~ package:pipes

(>~) with the arguments flipped
Compose loop bodies
(~>) :: Functor m => (a -> Producer b m r) -> (b -> Effect       m ()) -> (a -> Effect       m r)
(~>) :: Functor m => (a -> Producer b m r) -> (b -> Producer   c m ()) -> (a -> Producer   c m r)
(~>) :: Functor m => (a -> Pipe   x b m r) -> (b -> Consumer x   m ()) -> (a -> Consumer x   m r)
(~>) :: Functor m => (a -> Pipe   x b m r) -> (b -> Pipe     x c m ()) -> (a -> Pipe     x c m r)
The following diagrams show the flow of information:
a                    .--->   b                              a
|                   /        |                              |
+-----|-----+            /   +-----|-----+                 +------|------+
|     v     |           /    |     v     |                 |      v      |
|           |          /     |           |                 |             |
x ==>    f    ==> b   ---'   x ==>    g    ==> c     =     x ==>   f ~> g  ==> c
|           |                |           |                 |             |
|     |     |                |     |     |                 |      |      |
+-----|-----+                +-----|-----+                 +------|------+
v                            v                              v
r                            ()                             r
For a more complete diagram including bidirectional flow, see "Pipes.Core#respond-diagram".
Equivalent to (>>~) with the arguments flipped
(~>) with the arguments flipped
(draw >~ p) loops over p replacing each await with draw
(>~) :: Functor m => Effect       m b -> Consumer b   m c -> Effect       m c
(>~) :: Functor m => Consumer a   m b -> Consumer b   m c -> Consumer a   m c
(>~) :: Functor m => Producer   y m b -> Pipe     b y m c -> Producer   y m c
(>~) :: Functor m => Pipe     a y m b -> Pipe     b y m c -> Pipe     a y m c
The following diagrams show the flow of information:
+-----------+                 +-----------+                 +-------------+
|           |                 |           |                 |             |
|           |                 |           |                 |             |
a ==>    f    ==> y   .--->   b ==>    g    ==> y     =     a ==>   f >~ g  ==> y
|           |     /           |           |                 |             |
|     |     |    /            |     |     |                 |      |      |
+-----|-----+   /             +-----|-----+                 +------|------+
v        /                    v                              v
b   ----'                     c                              c
For a more complete diagram including bidirectional flow, see "Pipes.Core#request-diagram".
Equivalent to (>~>) with the arguments flipped
(p >>~ f) pairs each respond in p with a request in f. Point-ful version of (>~>)
Compose two proxies blocked while requesting data, creating a new proxy blocked while requesting data
(f >~> g) x = f x >>~ g
(>~>) is the composition operator of the push category.