Remove haskell-enumerator (Bug#943702) (fd68437a) · Commits · Debian Haskell Group / DHG_packages

p/haskell-enumerator/debian/changelog

deleted100644 → 0

+0 −130

Original line number	Diff line number	Diff line
		haskell-enumerator (0.4.20-10) unstable; urgency=medium

		* Patch to build with ghc-8.4

		-- Dmitry Bogatov <KAction@gnu.org> Fri, 05 Oct 2018 00:56:15 +0000

		haskell-enumerator (0.4.20-9) unstable; urgency=medium

		* Remove build dependency on libghc-text-dev (provided by ghc-8.4.3)

		-- Ilias Tsitsimpis <iliastsi@debian.org> Mon, 01 Oct 2018 13:47:30 +0300

		haskell-enumerator (0.4.20-8) unstable; urgency=medium

		[ Clint Adams ]
		* Set Rules-Requires-Root to no.

		[ Ilias Tsitsimpis ]
		* Bump debhelper compat level to 10

		-- Ilias Tsitsimpis <iliastsi@debian.org> Sun, 30 Sep 2018 21:07:54 +0300

		haskell-enumerator (0.4.20-7) unstable; urgency=medium

		[ Ilias Tsitsimpis ]
		* Change Priority to optional. Since Debian Policy version 4.0.1,
		priority extra has been deprecated.
		* Use the HTTPS form of the copyright-format URL
		* Modify d/watch and Source field in d/copyright to use HTTPS
		* Declare compliance with Debian policy 4.1.1
		* Use salsa.debian.org URLs in Vcs-{Browser,Git} fields

		[ Clint Adams ]
		* Bump to Standards-Version 4.1.4.

		-- Clint Adams <clint@debian.org> Mon, 09 Apr 2018 20:04:49 -0400

		haskell-enumerator (0.4.20-6) unstable; urgency=medium

		* Upload to unstable as part of GHC 8 transition.

		-- Clint Adams <clint@debian.org> Thu, 27 Oct 2016 18:33:34 -0400

		haskell-enumerator (0.4.20-5) experimental; urgency=medium

		[ Dmitry Bogatov ]
		* Use secure (https) uri in Vcs-Git field in 'debian/control'
		* Bump standards version to 3.9.8 (no changes needed)
		* Convert `debian/copyright' to dep5 format

		[ Clint Adams ]
		* Temporarily build-depend on ghc 8.

		-- Clint Adams <clint@debian.org> Fri, 14 Oct 2016 15:52:20 -0400

		haskell-enumerator (0.4.20-4) unstable; urgency=medium

		* Switch Vcs-Git/Vcs-Browser headers to new location.

		-- Clint Adams <clint@debian.org> Thu, 03 Dec 2015 14:54:25 -0500

		haskell-enumerator (0.4.20-3) experimental; urgency=medium

		* Bump standards-version to 3.9.6
		* Depend on haskell-devscripts >= 0.10 to ensure that this package
		builds against GHC in experimental

		-- Joachim Breitner <nomeata@debian.org> Thu, 20 Aug 2015 10:27:34 +0200

		haskell-enumerator (0.4.20-2) unstable; urgency=medium

		* Upload to unstable

		-- Joachim Breitner <nomeata@debian.org> Mon, 27 Apr 2015 11:49:30 +0200

		haskell-enumerator (0.4.20-1) experimental; urgency=low

		* Add a proper description to -prof and -doc
		* Adjust watch file to new hackage layout
		* Depend on haskell-devscripts 0.9, found in experimental
		* Do not depend on transformers, which now comes with GHC
		* New upstream release

		-- Joachim Breitner <nomeata@debian.org> Sun, 21 Dec 2014 09:58:18 +0100

		haskell-enumerator (0.4.19-3) unstable; urgency=low

		* Enable compat level 9
		* Use substvars for Haskell description blurbs

		-- Joachim Breitner <nomeata@debian.org> Fri, 24 May 2013 12:50:33 +0200

		haskell-enumerator (0.4.19-2) experimental; urgency=low

		* Depend on haskell-devscripts 0.8.13 to ensure this packages is built
		against experimental
		* Bump standards version, no change

		-- Joachim Breitner <nomeata@debian.org> Sun, 14 Oct 2012 12:00:46 +0200

		haskell-enumerator (0.4.19-1) unstable; urgency=low

		* New upstream version.
		* Bump to Standards-Version 3.9.3.

		-- Clint Adams <clint@debian.org> Thu, 17 May 2012 10:06:19 -0400

		haskell-enumerator (0.4.18-1) unstable; urgency=low

		* New upstream version.

		-- Clint Adams <clint@debian.org> Sun, 05 Feb 2012 13:14:59 -0500

		haskell-enumerator (0.4.16-1) unstable; urgency=low

		* New upstream version.

		-- Clint Adams <clint@debian.org> Mon, 26 Dec 2011 09:56:56 -0500

		haskell-enumerator (0.4.14-1) unstable; urgency=low

		* New upstream version.

		-- Clint Adams <clint@debian.org> Tue, 30 Aug 2011 13:59:55 -0400

		haskell-enumerator (0.4.10-1) unstable; urgency=low

		* Initial release.

		-- Clint Adams <clint@debian.org> Sun, 29 May 2011 12:04:27 -0400

p/haskell-enumerator/debian/compat

deleted100644 → 0

+0 −1

Original line number	Diff line number	Diff line
		10

p/haskell-enumerator/debian/control

deleted100644 → 0

+0 −158

Original line number	Diff line number	Diff line
		Source: haskell-enumerator
		Maintainer: Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
		Uploaders: Clint Adams <clint@debian.org>
		Priority: optional
		Section: haskell
		Rules-Requires-Root: no
		Build-Depends:
		cdbs,
		debhelper (>= 10),
		ghc (>= 8.4.3),
		ghc-prof,
		haskell-devscripts (>= 0.13),
		Build-Depends-Indep: ghc-doc
		Standards-Version: 4.1.4
		Homepage: https://john-millikin.com/software/enumerator/
		Vcs-Browser: https://salsa.debian.org/haskell-team/DHG_packages/tree/master/p/haskell-enumerator
		Vcs-Git: https://salsa.debian.org/haskell-team/DHG_packages.git [p/haskell-enumerator]

		Package: libghc-enumerator-dev
		Architecture: any
		Depends: ${haskell:Depends}, ${misc:Depends}, ${shlibs:Depends}
		Recommends: ${haskell:Recommends}
		Suggests: ${haskell:Suggests}
		Provides: ${haskell:Provides}
		Description: high-performance left-fold enumerators${haskell:ShortBlurb}
		Typical buffer–based incremental I/O is based around a single loop,
		which reads data from some source (such as a socket or file),
		transforms it, and generates one or more outputs (such as a line
		count, HTTP responses, or modified file). Although efficient and
		safe, these loops are all single–purpose; it is difficult or
		impossible to compose buffer–based processing loops.
		.
		Haskell's concept of "lazy I/O" allows pure code to operate on data
		from an external source. However, lazy I/O has several shortcomings.
		Most notably, resources such as memory and file handles can be
		retained for arbitrarily long periods of time, causing unpredictable
		performance and error conditions.
		.
		Enumerators are an efficient, predictable, and safe alternative to
		lazy I/O. Discovered by Oleg Kiselyov, they allow large datasets to
		be processed in near–constant space by pure code. Although somewhat
		more complex to write, using enumerators instead of lazy I/O
		produces more correct programs.
		.
		This library contains an enumerator implementation for Haskell,
		designed to be both simple and efficient. Three core types are
		defined, along with numerous helper functions:
		.
		Iteratee: Data sinks, analogous to left folds. Iteratees consume
		a sequence of input values, and generate a single output value. Many
		iteratees are designed to perform side effects (such as printing to
		stdout), so they can also be used as monad transformers.
		.
		Enumerator: Data sources, which generate input sequences. Typical
		enumerators read from a file handle, socket, random number generator,
		or other external stream. To operate, enumerators are passed an
		iteratee, and provide that iteratee with input until either the
		iteratee has completed its computation, or EOF.
		.
		Enumeratee: Data transformers, which operate as both enumerators
		and iteratees. Enumeratees read from an outer enumerator, and
		provide the transformed data to an inner iteratee.
		.
		${haskell:Blurb}

		Package: libghc-enumerator-prof
		Architecture: any
		Depends: ${haskell:Depends}, ${misc:Depends}
		Recommends: ${haskell:Recommends}
		Suggests: ${haskell:Suggests}
		Provides: ${haskell:Provides}
		Description: high-performance left-fold enumerators${haskell:ShortBlurb}
		Typical buffer–based incremental I/O is based around a single loop,
		which reads data from some source (such as a socket or file),
		transforms it, and generates one or more outputs (such as a line
		count, HTTP responses, or modified file). Although efficient and
		safe, these loops are all single–purpose; it is difficult or
		impossible to compose buffer–based processing loops.
		.
		Haskell's concept of "lazy I/O" allows pure code to operate on data
		from an external source. However, lazy I/O has several shortcomings.
		Most notably, resources such as memory and file handles can be
		retained for arbitrarily long periods of time, causing unpredictable
		performance and error conditions.
		.
		Enumerators are an efficient, predictable, and safe alternative to
		lazy I/O. Discovered by Oleg Kiselyov, they allow large datasets to
		be processed in near–constant space by pure code. Although somewhat
		more complex to write, using enumerators instead of lazy I/O
		produces more correct programs.
		.
		This library contains an enumerator implementation for Haskell,
		designed to be both simple and efficient. Three core types are
		defined, along with numerous helper functions:
		.
		Iteratee: Data sinks, analogous to left folds. Iteratees consume
		a sequence of input values, and generate a single output value. Many
		iteratees are designed to perform side effects (such as printing to
		stdout), so they can also be used as monad transformers.
		.
		Enumerator: Data sources, which generate input sequences. Typical
		enumerators read from a file handle, socket, random number generator,
		or other external stream. To operate, enumerators are passed an
		iteratee, and provide that iteratee with input until either the
		iteratee has completed its computation, or EOF.
		.
		Enumeratee: Data transformers, which operate as both enumerators
		and iteratees. Enumeratees read from an outer enumerator, and
		provide the transformed data to an inner iteratee.
		.
		${haskell:Blurb}

		Package: libghc-enumerator-doc
		Architecture: all
		Section: doc
		Depends: ${haskell:Depends}, ${misc:Depends}
		Recommends: ${haskell:Recommends}
		Suggests: ${haskell:Suggests}
		Description: high-performance left-fold enumerators${haskell:ShortBlurb}
		Typical buffer–based incremental I/O is based around a single loop,
		which reads data from some source (such as a socket or file),
		transforms it, and generates one or more outputs (such as a line
		count, HTTP responses, or modified file). Although efficient and
		safe, these loops are all single–purpose; it is difficult or
		impossible to compose buffer–based processing loops.
		.
		Haskell's concept of "lazy I/O" allows pure code to operate on data
		from an external source. However, lazy I/O has several shortcomings.
		Most notably, resources such as memory and file handles can be
		retained for arbitrarily long periods of time, causing unpredictable
		performance and error conditions.
		.
		Enumerators are an efficient, predictable, and safe alternative to
		lazy I/O. Discovered by Oleg Kiselyov, they allow large datasets to
		be processed in near–constant space by pure code. Although somewhat
		more complex to write, using enumerators instead of lazy I/O
		produces more correct programs.
		.
		This library contains an enumerator implementation for Haskell,
		designed to be both simple and efficient. Three core types are
		defined, along with numerous helper functions:
		.
		Iteratee: Data sinks, analogous to left folds. Iteratees consume
		a sequence of input values, and generate a single output value. Many
		iteratees are designed to perform side effects (such as printing to
		stdout), so they can also be used as monad transformers.
		.
		Enumerator: Data sources, which generate input sequences. Typical
		enumerators read from a file handle, socket, random number generator,
		or other external stream. To operate, enumerators are passed an
		iteratee, and provide that iteratee with input until either the
		iteratee has completed its computation, or EOF.
		.
		Enumeratee: Data transformers, which operate as both enumerators
		and iteratees. Enumeratees read from an outer enumerator, and
		provide the transformed data to an inner iteratee.
		.
		${haskell:Blurb}

p/haskell-enumerator/debian/copyright

deleted100644 → 0

+0 −35

Original line number	Diff line number	Diff line
		Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
		Upstream-Name: enumerator
		Upstream-Contact: John Millikin <jmillikin@gmail.com>
		Source: https://hackage.haskell.org/package/enumerator

		Files: *
		Copyright: 2010-2011 John Millikin <jmillikin@gmail.com>
		2011 Mikhail Vorozhtsov
		License: MIT

		Files: debian/*
		Copyright: held by the contributors mentioned in debian/changelog
		License: MIT

		License: MIT
		Permission is hereby granted, free of charge, to any person
		obtaining a copy of this software and associated documentation
		files (the "Software"), to deal in the Software without
		restriction, including without limitation the rights to use,
		copy, modify, merge, publish, distribute, sublicense, and/or sell
		copies of the Software, and to permit persons to whom the
		Software is furnished to do so, subject to the following
		conditions:
		.
		The above copyright notice and this permission notice shall be
		included in all copies or substantial portions of the Software.
		.
		THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
		EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
		OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
		NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
		HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
		WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
		FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		OTHER DEALINGS IN THE SOFTWARE.

p/haskell-enumerator/debian/patches/patch-to-build-with-ghc-8.4.patch

deleted100644 → 0

+0 −14

Original line number	Diff line number	Diff line
		Index: haskell-enumerator/lib/Data/Enumerator/Internal.hs
		===================================================================
		--- haskell-enumerator.orig/lib/Data/Enumerator/Internal.hs
		+++ haskell-enumerator/lib/Data/Enumerator/Internal.hs
		@@ -71,6 +71,9 @@ instance Monad Stream where
		Chunks xs >>= f = mconcat (fmap f xs)
		EOF >>= _ = EOF

		+instance Semigroup (Stream a) where
		+ (<>) = mappend
		+
		instance Monoid (Stream a) where
		mempty = Chunks mempty
		mappend (Chunks xs) (Chunks ys) = Chunks (xs ++ ys)