Streaming.Linear.Internal.Many

The type

Data.List.unzip     :: [(a,b)] -> ([a],[b])

might lead us to expect

Streaming.unzip :: Stream (Of (a,b)) m r -> Stream (Of a) m (Stream (Of b) m r)

which would not stream, since it would have to accumulate the second stream (of bs). Of course, Data.List unzip doesn't stream either.

This unzip does stream, though of course you can spoil this by using e.g. toList:

>>> let xs = Prelude.map (x -> (x, Prelude.show x)) [1..5 :: Int]

>>> S.toList $ S.toList $ S.unzip (S.each' xs)
["1","2","3","4","5"] :> ([1,2,3,4,5] :> ())

>>> Prelude.unzip xs
([1,2,3,4,5],["1","2","3","4","5"])

Note the difference of order in the results. It may be of some use to think why. The first application of toList was applied to a stream of integers:

>>> :t S.unzip $ S.each' xs
S.unzip $ S.each' xs :: Control.Monad m => Stream (Of Int) (Stream (Of String) m) ()

Like any fold, toList takes no notice of the monad of effects.

toList :: Control.Monad m => Stream (Of a) m r %1-> m (Of [a] r)

In the case at hand (since I am in ghci) m = Stream (Of String) IO. So when I apply toList, I exhaust that stream of integers, folding it into a list:

>>> :t S.toList $ S.unzip $ S.each' xs
S.toList $ S.unzip $ S.each' xs
 :: Control.Monad m => Stream (Of String) m (Of [Int] ())

When I apply toList to this, I reduce everything to an ordinary action in IO, and return a list of strings:

>>> S.toList $ S.toList $ S.unzip (S.each' xs)
["1","2","3","4","5"] :> ([1,2,3,4,5] :> ())

unzip can be considered a special case of either unzips or expand:

 unzip = unzips . maps (((a,b) :> x) -> Compose (a :> b :> x))
 unzip = expand $ p ((a,b) :> abs) -> b :> p (a :> abs)

The remainder of zipping two streams

The (liberal) remainder of zipping three streams. This has the downside that the possibility of three remainders is allowed, though it will never occur.

zip zips two streams exhausing the remainder of the longer stream and consuming its effects.

zipR zips two streams keeping the remainder if there is one.

zipWithR zips two streams applying a function along the way, keeping the remainder of zipping if there is one. Note. If two streams have the same length, but one needs to perform some effects to obtain the end-of-stream result, that stream is treated as a residual.

Like zipR but with three streams.

Like zipR but with three streams.

Like zipWith but with three streams

Like zipWithR but with three streams.

Merge two streams of elements ordered with their Ord instance.

The return values of both streams are returned.

>>> S.print $ merge (each [1,3,5]) (each [2,4])
1
2
3
4
5
((), ())

Merge two streams, ordering them by applying the given function to each element before comparing.

The return values of both streams are returned.

Merge two streams, ordering the elements using the given comparison function.

The return values of both streams are returned.