A Sink is a special type of Fold that does not accumulate any value, but runs only effects. A Sink has no state to maintain therefore can be a bit more efficient than a Fold with () as the state, especially when Sinks are composed with other operations. A Sink can be upgraded to a Fold, but a Fold cannot be converted into a Sink.

Convert a Sink to a Fold. When you want to compose sinks and folds together, upgrade a sink to a fold before composing.

Distribute one copy each of the input to both the sinks.

                |-------Sink m a
---stream m a---|
                |-------Sink m a

> let pr x = Sink.drainM (putStrLn . ((x ++ " ") ++) . show)
> sink (Sink.tee (pr "L") (pr "R")) (S.enumerateFromTo 1 2)
L 1
R 1
L 2
R 2

Distribute copies of the input to all the sinks in a container.

                |-------Sink m a
---stream m a---|
                |-------Sink m a
                |
                      ...

> let pr x = Sink.drainM (putStrLn . ((x ++ " ") ++) . show)
> sink (Sink.distribute [(pr "L"), (pr "R")]) (S.enumerateFromTo 1 2)
L 1
R 1
L 2
R 2

This is the consumer side dual of the producer side sequence_ operation.

Demultiplex to multiple consumers without collecting the results. Useful to run different effectful computations depending on the value of the stream elements, for example handling network packets of different types using different handlers.

                            |-------Sink m a
-----stream m a-----Map-----|
                            |-------Sink m a
                            |
                                      ...

> let pr x = Sink.drainM (putStrLn . ((x ++ " ") ++) . show)
> let table = Data.Map.fromList [(1, pr "One"), (2, pr "Two")]
  in Sink.sink (Sink.demux id table) (S.enumerateFromTo 1 100)
One 1
Two 2

Split elements in the input stream into two parts using a monadic unzip function, direct each part to a different sink.

                          |-------Sink m b
-----Stream m a----(b,c)--|
                          |-------Sink m c

> let pr x = Sink.drainM (putStrLn . ((x ++ " ") ++) . show)
  in Sink.sink (Sink.unzip return (pr "L") (pr "R")) (S.fromPure (1,2))
L 1
R 2

Same as unzipM but with a pure unzip function.

Map a pure function on the input of a Sink.

Map a monadic function on the input of a Sink.

Filter the input of a Sink using a pure predicate function.

Filter the input of a Sink using a monadic predicate function.

Drain all input, running the effects and discarding the results.

drainM f = lmapM f drain

Drain all input after passing it through a monadic function.