A Sink can be used to yield output from any nested Coroutine computation whose functor provably descends from the functor a. It's the write-only end of a communication channel created by pipe.

A Source can be used to read input into any nested Coroutine computation whose functor provably descends from the functor a. It's the read-only end of a communication channel created by pipe.

Class of functors that can be lifted.

The pipe function splits the computation into two concurrent parts, producer and consumer. The producer is given a Sink to put values into, and consumer a Source to get those values from. Once producer and consumer both complete, pipe returns their paired results.

The pipeP function is equivalent to pipe, except it runs the producer and the consumer in parallel.

A generic version of pipe. The first argument is used to combine two computation steps.

A disconnected sink that consumes and ignores all data put into it.

Function get tries to get a single value from the given Source argument. The intervening Coroutine computations suspend all the way to the pipe function invocation that created the source. The function returns Nothing if the argument source is empty.

Invokes its first argument with the value it gets from the source, if there is any to get.

Tries to get a minimal, i.e., prime, prefix from the given Source argument. The intervening Coroutine computations suspend all the way to the pipe function invocation that created the source. The function returns mempty if the argument source is empty.

Function peek acts the same way as get, but doesn't actually consume the value from the source; sequential calls to peek will always return the same value.

This function puts a value into the given Sink. The intervening Coroutine computations suspend up to the pipe invocation that has created the argument sink.

Like put, but returns a Bool that determines if the sink is still active.

Converts a Sink on the ancestor functor a into a sink on the descendant functor d.

Converts a Source on the ancestor functor a into a source on the descendant functor d.

Copies all data from the source argument into the sink argument. The result indicates if there was any chunk to copy.

Copies all data from the source argument into the sink argument, like pour but ignoring the result.

tee is similar to pour except it distributes every input value from its source argument into its both sink arguments.

Every value put into a teeSink result sink goes into its both argument sinks: put (teeSink s1 s2) x is equivalent to put s1 x >> put s2 x. The putChunk method returns the list of values that couldn't fit into the second sink.

getAll consumes and returns all data generated by the source.

putAll puts an entire list into its sink argument. If the coroutine fed by the sink dies, the remainder of the argument list is returned.

This method puts a portion of the producer's output into the Sink. The intervening Coroutine computations suspend up to the pipe invocation that has created the argument sink. The method returns the suffix of the argument that could not make it into the sink because of the sibling coroutine's death.

Consumes inputs from the source as long as the parser accepts it.

Consumes input from the source as long as the reader accepts it.

Consumes values from the source as long as each satisfies the predicate, then returns their list.

Consumes values from the source until one of them satisfies the predicate or the source is emptied, then returns the pair of the list of preceding values and maybe the one value that satisfied the predicate. The latter is not consumed.

Like pour, copies data from the source to the sink, but only as long as it satisfies the predicate.

Parses the input data using the given parser and copies the results to output.

Like pour, copies data from the source to the sink, but only as long as it satisfies the predicate.

Like pour, copies data from the source to the sink, but only until one value satisfies the predicate. That value is returned rather than copied.

A sink mark-down transformation: the marks get removed off each chunk.

A sink mark-up transformation: every chunk going into the sink is accompanied by the given value.

An equivalent of map that works on a Sink instead of a list. The argument function is applied to every value vefore it's written to the sink argument.

mapStream is like pour that applies the function f to each argument before passing it into the sink.

mapMaybeStream is to mapStream like mapMaybe is to map.

concatMapStream is to mapStream like concatMap is to map.

Like mapStream except it runs the argument function on whole chunks read from the input.

Like mapAccumStream except it runs the argument function on whole chunks read from the input.

Similar to foldl, but reads the values from a Source instead of a list.

mapAccumStream is similar to mapAccumL except it reads the values from a Source instead of a list and writes the mapped values into a Sink instead of returning another list.

concatMapAccumStream is a love child of concatMapStream and mapAccumStream: it threads the accumulator like the latter, but its argument function returns not a single value, but a list of values to write into the sink.

Equivalent to partition. Takes a Source instead of a list argument and partitions its contents into the two Sink arguments.

mapMStream is similar to mapM. It draws the values from a Source instead of a list, writes the mapped values to a Sink, and returns a Coroutine.

mapMStream_ is similar to mapM_ except it draws the values from a Source instead of a list and works with Coroutine instead of an arbitrary monad.

Like mapMStream_ except it runs the argument function on whole chunks read from the input.

An equivalent of filterM. Draws the values from a Source instead of a list, writes the filtered values to a Sink, and returns a Coroutine.

foldMStream is similar to foldM except it draws the values from a Source instead of a list and works with Coroutine instead of an arbitrary monad.

A variant of foldMStream that discards the final result value.

unfoldMStream is a version of unfoldr that writes the generated values into a Sink instead of returning a list.

unmapMStream_ is opposite of mapMStream_; it takes a Sink instead of a Source argument and writes the generated values into it.

Like unmapMStream_ but writing whole chunks of generated data into the argument sink.

zipWithMStream is similar to zipWithM except it draws the values from two Source arguments instead of two lists, sends the results into a Sink, and works with Coroutine instead of an arbitrary monad.

parZipWithMStream is equivalent to zipWithMStream, but it consumes the two sources in parallel.