pipes-1.0: pipes.cabal

Name: pipes
Version: 1.0
Cabal-Version: >=1.10.1
Build-Type: Simple
License: GPL
License-File: LICENSE
Copyright: 2012 Gabriel Gonzalez
Author: Gabriel Gonzalez
Maintainer: Gabriel439@gmail.com
Stability: Experimental
Bug-Reports: mailto:Gabriel439@gmail.com
Synopsis: Compositional pipelines
Description:
  \"Iteratees done right\".  This library implements
  iteratees\/enumerators\/enumeratees simply and elegantly, but uses different
  naming conventions.
  .
  Advantages over traditional iteratee implementations:
  .
  * /Simpler semantics/: There is only one data type ('Pipe'), two primitives
    ('await' and 'yield'), and only one way to compose 'Pipe's ('.').  In fact,
    this library introduces no new operators, using only its 'Monad' and
    'Category' instances to implement all behavior.
  .
  * /Clearer naming conventions/: Enumeratees are called 'Pipe's, Enumerators
    are 'Producer's, and Iteratees are 'Consumer's.  'Producer's and 'Consumer's
    are just type synonyms for 'Pipe's with either the input or output end
    closed.
  .
  * /Pipes are Categories/: You compose them using ordinary composition.
    There are actually two 'Category' instances: one for 'Lazy' composition and
    one for 'Strict' composition.  Both instances satisfy the 'Category' laws.
  .
  * /Intuitive/: Pipe composition is easier to reason about because it is a true
    'Category'.  Composition works seamlessly and you don't have to worry about
    restarting iteratees, feeding new input, etc.  \"It just works\".
  .
  * /"Vertical" concatenation works flawlessly on everything/: ('>>')
    concatenates 'Pipe's, but since everything is a 'Pipe', you can use it to
    concatenate 'Producer's, 'Consumer's, and even intermediate 'Pipe' stages.
    Vertical Concatenation always works the way you expect, picking up where the
    previous 'Pipe' left off.
  .
  * /Symmetric implementation/: Most iteratee libraries are either
    enumerator-driven or iteratee-driven.  'Pipe's are implemented
    symmetrically, which is why they can be composed with either 'Lazy'
    ('Consumer'-driven) or 'Strict' ('Producer'-driven) semantics.
  .
  Check out "Control.Pipe" for a copious introduction (in the spirit of the
  @iterIO@ library) and "Control.Pipe.Common" for the actual implementation.
  .
  This library does not yet provide convenience 'Pipe's for common operations,
  but they are forthcoming.  However, there are several examples in the
  documentation to get you started and I encourage you to write your own to see
  how easy they are to write.
Category: Control, Enumerator
Tested-With: GHC ==7.0.3
Source-Repository head
    Type: git
    Location: https://github.com/Gabriel439/Haskell-Pipes-Library

Library
    Build-Depends: base >= 4 && < 5, mtl
    Exposed-Modules: Control.Pipe, Control.Pipe.Common
    GHC-Options: -O2
    Default-Language: Haskell2010