[Pkg-haskell-commits] darcs: haskell-enumerator: Add a proper description to -prof and -doc

[Joachim Breitner]

Sat May 25 21:41:08 UTC 2013  Joachim Breitner <mail at joachim-breitner.de>
  * Add a proper description to -prof and -doc 
  Ignore-this: 1eee76329ce77f3dc8a6958459c5e061

    M ./changelog +6
    M ./control -2 +78

Sat May 25 21:41:08 UTC 2013  Joachim Breitner <mail at joachim-breitner.de>
  * Add a proper description to -prof and -doc 
  Ignore-this: 1eee76329ce77f3dc8a6958459c5e061
diff -rN -u old-haskell-enumerator//changelog new-haskell-enumerator//changelog
--- old-haskell-enumerator//changelog	2013-05-25 21:41:12.119068062 +0000
+++ new-haskell-enumerator//changelog	2013-05-25 21:41:12.119068062 +0000
@@ -1,3 +1,9 @@
+haskell-enumerator (0.4.19-4) UNRELEASED; urgency=low
+
+  * Add a proper description to -prof and -doc 
+
+ -- Joachim Breitner <nomeata at debian.org>  Sat, 25 May 2013 23:40:58 +0200
+
 haskell-enumerator (0.4.19-3) unstable; urgency=low
 
   * Enable compat level 9
diff -rN -u old-haskell-enumerator//control new-haskell-enumerator//control
--- old-haskell-enumerator//control	2013-05-25 21:41:12.114095627 +0000
+++ new-haskell-enumerator//control	2013-05-25 21:41:12.123049926 +0000
@@ -29,8 +29,6 @@
 Suggests: ${haskell:Suggests}
 Provides: ${haskell:Provides}
 Description: high-performance left-fold enumerators${haskell:ShortBlurb}
- ${haskell:Blurb}
- .
  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
@@ -68,6 +66,8 @@
  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
@@ -77,6 +77,44 @@
 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
@@ -86,4 +124,42 @@
 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}