This repository has been archived by the owner on Nov 19, 2023. It is now read-only.
forked from Gabriella439/pipes
/
pipes-core.cabal
82 lines (80 loc) · 3.21 KB
/
pipes-core.cabal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
Name: pipes-core
Version: 0.1.1
Cabal-Version: >=1.10.1
Build-Type: Simple
License: BSD3
License-File: LICENSE
Copyright: 2012 Gabriel Gonzalez, 2012 Paolo Capriotti
Author: Gabriel Gonzalez, Paolo Capriotti
Maintainer: p.capriotti@gmail.com
Stability: Experimental
Homepage: https://github.com/pcapriotti/pipes-core
Bug-Reports: https://github.com/pcapriotti/pipes-core/issues
Synopsis: Compositional pipelines
Description:
This library offers an abstraction similar in scope to
iteratees\/enumerators\/enumeratees, but with different characteristics and
naming conventions.
.
This package is a fork of the original pipes package by Gabriel Gonzalez.
See <https://github.com/pcapriotti/pipes-core/wiki/pipes-core-vs-pipes> for a
comparison between the two packages.
.
Differences with traditional iteratees:
.
* /Simpler semantics/: There is only one data type ('Pipe'), two basic
primitives ('await' and 'yield'), and only one way to compose 'Pipe's
('>+>'). In fact, ('>+>') is just convenient syntax for the composition
operator in 'Category'. Most pipes can be implemented just using the
'Monad' instance and composition.
.
* /Different 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 form a Category/: that means that composition is associative, and
that there is an identity 'Pipe'.
.
* /"Vertical" concatenation works on every 'Pipe'/: ('>>'), concatenates
'Pipe's. Since everything is a 'Pipe', you can use it to concatenate
'Producer's, 'Consumer's, and even intermediate 'Pipe' stages. Vertical
concatenation can be combined with composition to create elaborate
combinators, without the need of executing pipes in \"passes\" or resuming
partially executed pipes.
.
Check out "Control.Pipe" for a copious introduction (in the spirit of the
@iterIO@ library), and "Control.Pipe.Combinators" for some basic combinators
and 'Pipe' examples.
Category: Control, Enumerator
Tested-With: GHC ==7.0.3
Source-Repository head
Type: git
Location: https://github.com/pcapriotti/pipes-core
Library
Build-Depends: base >= 4 && < 5
, transformers (>= 0.2 && < 0.4)
, categories (== 1.0.*)
, void (== 0.5.*)
, lifted-base (== 0.1.*)
, monad-control (== 0.3.*)
Exposed-Modules: Control.Pipe
, Control.Pipe.Category
, Control.Pipe.Combinators
, Control.Pipe.Common
, Control.Pipe.Exception
, Control.Pipe.Monoidal
, Control.Category.Multiplicative
Default-Language: Haskell2010
test-suite tests
type: exitcode-stdio-1.0
hs-source-dirs: tests
main-is: Tests.hs
build-depends: base >= 4 && < 5
, QuickCheck == 2.4.*
, test-framework == 0.6.*
, test-framework-quickcheck2 == 0.2.*
, test-framework-th-prime == 0.0.*
, transformers >= 0.2 && < 0.4
, pipes-core == 0.1.*
Default-Language: Haskell2010