- data Pipe i o m r
- type Source m a = Pipe Void a m ()
- type Sink i m r = Pipe i Void m r
- type Conduit i m o = Pipe i o m ()
- pipeClose :: Monad m => Pipe i o m r -> m r
- pipe :: Monad m => Pipe a b m () -> Pipe b c m r -> Pipe a c m r
- pipeResume :: Monad m => Pipe a b m () -> Pipe b c m r -> Pipe a c m (Pipe a b m (), r)
- runPipe :: Monad m => Pipe Void Void m r -> m r
- sinkToPipe :: Monad m => Sink i m r -> Pipe i o m r
- await :: Pipe i o m (Maybe i)
- yield :: Monad m => o -> Pipe i o m ()
- hasInput :: Pipe i o m Bool
- transPipe :: Monad m => (forall a. m a -> n a) -> Pipe i o m r -> Pipe i o n r
The underlying datatype for all the types in this package. In has four type parameters:
- i is the type of values for this
Pipe's input stream.
- o is the type of values for this
Pipe's output stream.
- m is the underlying monad.
- r is the result type.
Note that o and r are inherently different. o is the type of the
stream of values this
Pipe will produce and send downstream. r is the
final output of this
Pipes can be composed via the
pipe function. To do so, the output type
of the left pipe much match the input type of the left pipe, and the result
type of the left pipe must be unit
(). This is due to the fact that any
result produced by the left pipe must be discarded in favor of the result of
the right pipe.
|HaveOutput (Pipe i o m r) (m r) o|
Provide new output to be sent downstream. This constructor has three
records: the next
|NeedInput (i -> Pipe i o m r) (Pipe i o m r)|
Request more input from upstream. The first record takes a new input
value and provides a new
|Done (Maybe i) r|
Processing with this
|PipeM (m (Pipe i o m r)) (m r)|
Require running of a monadic action to get the next
Pipe which provides a stream of output values, without consuming any
input. The input parameter is set to
() instead of
Void since there is
no way to statically guarantee that the
NeedInput constructor will not be
Source is not used to produce a final result, and thus the result
parameter is set to
() as well.
Pipe which consumes a stream of input values and produces a final
result. It cannot produce any output values, and thus the output parameter
is set to
Void. In other words, it is impossible to create a
constructor for a
Pipe which consumes a stream of input values and produces a stream of
output values. It does not produce a result value, and thus the result
parameter is set to
Perform any close actions available for the given
Compose a left and right pipe together into a complete pipe. The left pipe will be automatically closed when the right pipe finishes, and any leftovers from the right pipe will be discarded.
This is in fact a wrapper around
pipeResume. This function closes the left
Pipe returns by
pipeResume and returns only the result.
pipe, but retain both the new left pipe and the leftovers from
the right pipe. The two components are combined together into a single pipe
and returned, together with the result of the right pipe.
Note: we're biased towards checking the right side first to avoid pulling extra data which is not needed. Doing so could cause data loss.
Run a complete pipeline until processing completes.
Sink has a
Void type parameter for the output, which makes it
difficult to compose with
Conduits. This function replaces
that parameter with a free variable. This function is essentially
only modifies the types, not the actions performed.
Wait for a single input value from upstream, and remove it from the
Nothing if no more data is available.
Check if input is available from upstream. Will not remove the data from the stream.