This module defines Source and Sink types and pipe functions that create them. The method get on Source abstracts away Control.Concurrent.SCC.Coroutine.await, and the method put on Sink is a higher-level abstraction of Control.Concurrent.SCC.Coroutine.yield. With this arrangement, a single coroutine can yield values to multiple sinks and await values from multiple sources with no need to change the Control.Concurrent.SCC.Coroutine.Coroutine functor; the only requirement is for each funtor of the sources and sinks the coroutine uses to be an Control.Concurrent.SCC.Coroutine.AncestorFunctor of the coroutine's functor. For example, coroutine zip that takes two sources and one sink would be declared like this:

 zip :: forall m a1 a2 a3 d x y. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d)
        => Source m a1 x -> Source m a2 y -> Sink m a3 (x, y) -> Coroutine d m ()

Sources, sinks, and coroutines communicating through them are all created using the pipe function or one of its variants. They effectively split the current coroutine into a producer-consumer coroutine pair. The producer gets a new Sink to write to and the consumer a new Source to read from, in addition to all the streams that are visible in the original coroutine. The following function, for example, uses the zip coroutine above to add together the values from two Integer sources:

 add :: forall m a1 a2 a3 d. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d)
        => Source m a1 Integer -> Source m a2 Integer -> Sink m a3 Integer -> Coroutine d m ()
 add source1 source2 sink = do pipe
                                  (pairSink-> zip source1 source2 pairSink)            -- producer coroutine
                                  (pairSource-> pourMap (uncurry (+)) pairSource sink) -- consumer coroutine
                               return ()