Series composition. Compose two pipes such that the output of the second pipe is attached to the input of the first pipe.
Stream.toList $ Stream.pipe (Pipe.map (+1) >>> Pipe.map (+1)) $ Stream.fromList [1..5::Int][3,4,5,6,7]
Modulestreamly-core-0.3.1Haskell2010
Streamly.Internal.Data.Pipe
There are three fundamental types that make up a stream pipeline:
Stream: sources
Scan: transformations
Fold: sinks
Streams are sources or producers of values, multiple sources can be merged into a single source but a source cannot be split into multiple stream sources. Folds are sinks or consumers, a stream can be split and distributed to multiple folds but the results cannot be merged back into a stream source again. Scans are simple one-to-one transformations with filtering. One element cannot be transformed to multiple elements.
The Pipe type is a super type of all the above, it is the most complex type. All of these can be represented by a pipe. A pipe can act as a source or a sink or a transformation, dynamically. A stream source can be split and distributed to multiple pipes each pipe can apply its own transform on the stream and the results can be merged back into a single pipe. Pipes can be attached to a source to produce a source or they can be attached to a fold to produce a fold, or multiple pipes can be merged or zipped into a single pipe.
import qualified Streamly.Internal.Data.Pipe as Pipe- 2 types
- 11 values
- Packagestreamly-core-0.3.1
- Exports13
- LanguageHaskell2010
- LicenceBSD-3-Clause
- SourcePipe.hs
A filtering pipe using a pure predicate.
Stream.toList $ Stream.pipe (Pipe.filter odd) $ Stream.fromList [1..5::Int][1,3,5]
A filtering pipe using a monadic predicate.
Create a singleton pipe from a fold.
Pipes do not support finalization yet. This does not finalize the fold when the stream stops before the fold terminates. So cannot be used on folds that require such finalization.
> Stream.toList $ Stream.pipe (Pipe.fromFold Fold.sum) $ Stream.fromList [1..5::Int]- 15
Produces the stream on consuming ().
An identity pipe producing the same output as input.
identity = Pipe.map Prelude.idStream.toList $ Stream.pipe (Pipe.identity) $ Stream.fromList [1..5::Int][1,2,3,4,5]
A pipe representing mapping of a pure function.
Stream.toList $ Stream.pipe (Pipe.map (+1)) $ Stream.fromList [1..5::Int][2,3,4,5,6]
A pipe representing mapping of a monadic action.
Stream.toList $ Stream.pipe (Pipe.mapM print) $ Stream.fromList [1..5::Int]12345[(),(),(),(),()]
Pipes do not support finalization yet. This does not finalize the fold when the stream stops before the fold terminates. So cannot be used on folds that require finalization.
Stream.toList $ Stream.pipe (Pipe.scanFold Fold.sum) $ Stream.fromList [1..5::Int][1,3,6,10,15]
Parallel composition. Distribute the input across two pipes and merge their outputs.
Stream.toList $ Stream.pipe (Pipe.teeMerge Pipe.identity (Pipe.map (\x -> x * x))) $ Stream.fromList [1..5::Int][1,1,2,4,3,9,4,16,5,25]
Represents a stateful transformation over an input stream of values of
type a to outputs of type b in Monad m.
The constructor is Pipe consume produce initial.
Instances3Category, Functor, Semigroup
Monad m => Category (Pipe m)Defined in streamly-core-0.3.1 · Streamly.Internal.Data.Pipe.Type"." composes the pipes in series.
Functor m => Functor (Pipe m a)Defined in streamly-core-0.3.1 · Streamly.Internal.Data.Pipe.Typefmap maps a pure function on a scan output.
Example1 expression Stream.toList $ Stream.pipe (fmap (+1) Pipe.identity) $ Stream.fromList [1..5::Int][2,3,4,5,6]
Monad m => Semigroup (Pipe m a b)Defined in streamly-core-0.3.1 · Streamly.Internal.Data.Pipe.Type<> composes the pipes in parallel.