Repeatedly apply an "unfolding" function to a given initial state, yielding the first item in the tuple as output and updating the state as the second item in the tuple. Goes on forever. See unfoldMaybe for a version that stops.

Repeatedly apply a function to a given starting value and yield each result forever.

>>> runPipePure $ iterate succ 0
      .| take 5
      .| sinkList

1,2,3,4,5

This doesn't yield the original starting value. However, you can yield it iterate after:

>>> runPipePure $ (yield 0 >> iterate succ 0)
      .| take 5
      .| sinkList

0,1,2,3,4,5

Repeatedly yield a given item forever.

A version of unfold that can terminate and end by returning Nothing.

A version of unfoldMaybe that can choose the "result" value by passing it in as Left.

A version of iterate that can choose to terminate and stop by returning Nothing.

A version of iterateMaybe that can specify a result value by providing it in the Left.

Yield every item in a foldable container.

Yield a given item a certain number of times.

Repeat a monadic action forever, yielding each output.

Remember that each item will only be "executed" when something downstream requests output.

Repeat a monadic action, yielding the item in the Just every time. As soon as it sees Nothing, stop producing forever.

Remember that each item will only be "executed" when something downstream requests output.

Like repeatMaybeM, but allow specification of a final result type.

Repeat a monadic action a given number of times, yielding each result, and then stop producing forever.

Remember that each item will only be "executed" when something downstream requests output.

Source from a given I/O handle, yielding each line drawn as a string. To draw raw bytes, use sourceHandle.

This stop as soon as end-of-file is reached, or an empty line is seen.

Source from each line received from stdin. This stops as soon as end-of-file is reached, or an empty line is seen.

Source from a given I/O handle, yielding bytestrings as they are pulled. If you want to retrieve each line as a string, see sourceHandleLines.

Source from stdin, yielding bytestrings as they are drawn. If you want to retrieve each line as a string, see stdinLines.

Process every incoming item with a pure function, and yield its output.

Map a monadic function to process every input, and yield its output.

Execute a monadic function to process every input, passing through the original value back downstream.

Since: 0.2.1.0

Like foldl, but yields every accumulator value downstream.

>>> runPipePure $ sourceList [1..10]
      .| scan (+) 0
      .| sinkList
[1,3,6,10,15,21,28,36,45,55]
@

Map a pure "stateful" function over each incoming item. Give a function to update the state and return an output and an initial state.

Let a given number of items pass through the stream uninhibited, and then stop producing forever.

This is most useful if you sequence a second conduit after it.

>>> runPipePure $ sourceList [1..8]
      .| (do take 3 .| map (*2)         -- double the first 3 items
             map negate                 -- negate the rest
         )
      .| sinkList
[2,4,6,-4,-5,-6,-7,-8]

Let elements pass until an element is received that does not satisfy the predicate, then stop producing forever.

Like take, is most useful if you sequence a second conduit after it.

Only allow values satisfying a predicate to pass.

Map a function returning a container onto every incoming item, and yield all of the outputs from that function.

Take an input of containers and output each of their elements successively.

Yield consecutive pairs of values.

>>> runPipePure $ sourceList [1..5]
      .| pairs
      .| sinkList
[(1,2),(2,3),(3,4),(4,5)]

Yield consecutive runs of at most n of values, starting with an empty sequence.

To get only "full" sequences, pipe with filter.

>>> runPipePure $ sourceList [1..6]
      .| consecutive 3
      .| map toList
      .| sinkList
[[],[1],[1,2],[1,2,3],[2,3,4],[3,4,5],[4,5,6]]

>>> runPipePure $ sourceList [1..6]
      .| consecutive 3
      .| filter ((== 3) . Seq.length)
      .| map toList
      .| sinkList
[[1,2,3],[2,3,4],[3,4,5],[4,5,6]]

Ignore a certain amount of items from the input stream, and then stop producing forever.

This is most useful if you sequence a second consumer after it:

>>> runPipePure $ sourceList [1..8]
      .| (drop 3 >> 'sinkList')
[4,5,6,7,8]

Ignore items from an input stream as long as they match a predicate. Afterwards, stop producing forever.

Like for drop, is most useful of you sequence a second consumer after it.

Right-fold every input into an accumulated value.

Essentially this builds up a giant continuation that will be run all at once on the final result.

Left-fold every input into an accumulated value.

Essentially this maintains a state and modifies that state with every input, using the given accumulating function.

Fold every incoming item according to a monoidal projection, and return the result once finished.

This can be used to implement many useful consumers, like ones that find the sum or the maximum item:

sum :: Num i => Pipe i o u m i
sum = getSum $ foldMap Sum

maximum :: Ord i => Pipe i o u m (Maybe i)
maximum = fmap getMax $ foldMap (Just . Max)

Fold every incoming item monoidally, and return the result once finished.

Consume an entire input stream and ignore all of its outputs.

Sink every incoming item into a list.

Note that this keeps the entire list in memory until it is all eventually read.

Get the last item emitted by a stream.

To get the first item ("head"), use await or awaitSurely.

Sink into a given I/O handle, writing each input to the handle.

A sink into stdout.

A sink into stderr.