Streamly.Internal.Data.Stream.Serial

For SerialT streams:

(<>) = Streamly.Prelude.serial                       -- Semigroup
(>>=) = flip . Streamly.Prelude.concatMapWith Streamly.Prelude.serial -- Monad

A single Monad bind behaves like a for loop:

>>> :{IsStream.toList $ do     x <- IsStream.fromList [1,2] -- foreach x in stream     return x:}[1,2]

Nested monad binds behave like nested for loops:

>>> :{IsStream.toList $ do    x <- IsStream.fromList [1,2] -- foreach x in stream    y <- IsStream.fromList [3,4] -- foreach y in stream    return (x, y):}[(1,3),(1,4),(2,3),(2,4)]

Since: 0.2.0 (Streamly)

A serial IO stream of elements of type a. See SerialT documentation for more details.

Since: 0.2.0 (Streamly)

For WSerialT streams:

(<>) = Streamly.Prelude.wSerial                       -- Semigroup
(>>=) = flip . Streamly.Prelude.concatMapWith Streamly.Prelude.wSerial -- Monad

Note that <> is associative only if we disregard the ordering of elements in the resulting stream.

A single Monad bind behaves like a for loop:

>>> :{IsStream.toList $ IsStream.fromWSerial $ do     x <- IsStream.fromList [1,2] -- foreach x in stream     return x:}[1,2]

Nested monad binds behave like interleaved nested for loops:

>>> :{IsStream.toList $ IsStream.fromWSerial $ do    x <- IsStream.fromList [1,2] -- foreach x in stream    y <- IsStream.fromList [3,4] -- foreach y in stream    return (x, y):}[(1,3),(2,3),(1,4),(2,4)]

It is a result of interleaving all the nested iterations corresponding to element 1 in the first stream with all the nested iterations of element 2:

>>> import Streamly.Prelude (wSerial)>>> IsStream.toList $ IsStream.fromList [(1,3),(1,4)] `IsStream.wSerial` IsStream.fromList [(2,3),(2,4)][(1,3),(2,3),(1,4),(2,4)]

The W in the name stands for wide or breadth wise scheduling in contrast to the depth wise scheduling behavior of SerialT.

Since: 0.2.0 (Streamly)

An interleaving serial IO stream of elements of type a. See WSerialT documentation for more details.

Since: 0.2.0 (Streamly)

Interleaves two streams, yielding one element from each stream alternately. When one stream stops the rest of the other stream is used in the output stream.

This gives exponential priority to earlier streams than the ones joining later. Because of exponential weighting it can be used with concatMapWith.

Not fused

Generate an infinite stream by repeating a pure value.

Build a stream by unfolding a monadic step function starting from a seed. The step function returns the next element in the stream and the next seed value. When it is done it returns Nothing and the stream ends. For example,

let f b =
        if b > 3
        then return Nothing
        else print b >> return (Just (b, b + 1))
in drain $ unfoldrM f 0

 0
 1
 2
 3

Pre-release

The fromList function constructs the structure l from the given list of Item l

The toList function extracts a list of Item l from the structure l. It should satisfy fromList . toList = id.

map = fmap

Same as fmap.

> S.toList $ S.map (+1) $ S.fromList [1,2,3]
[2,3,4]