To run examples in this module:

`>>>`

`import qualified Streamly.Prelude as Stream`

For `SerialT`

streams:

(<>) =`serial`

--`Semigroup`

(>>=) = flip .`concatMapWith`

`serial`

--`Monad`

A single `Monad`

bind behaves like a `for`

loop:

`>>>`

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

Nested monad binds behave like nested `for`

loops:

`>>>`

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

*Since: 0.2.0 (Streamly)*

*Since: 0.8.0*

serial :: IsStream t => t m a -> t m a -> t m a infixr 6 Source #

Appends two streams sequentially, yielding all elements from the first stream, and then all elements from the second stream.

`>>>`

`import Streamly.Prelude (serial)`

`>>>`

`stream1 = Stream.fromList [1,2]`

`>>>`

`stream2 = Stream.fromList [3,4]`

`>>>`

[1,2,3,4]`Stream.toList $ stream1 `serial` stream2`

This operation can be used to fold an infinite lazy container of streams.

*Since: 0.2.0 (Streamly)*

*Since: 0.8.0*

fromSerial :: IsStream t => SerialT m a -> t m a Source #

For `WSerialT`

streams:

(<>) =`wSerial`

--`Semigroup`

(>>=) = flip .`concatMapWith`

`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:

`>>>`

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

Nested monad binds behave like interleaved nested `for`

loops:

`>>>`

Stream.toList $ Stream.fromWSerial $ do x <- Stream.fromList [1,2] -- foreach x in stream y <- Stream.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)`

`>>>`

[(1,3),(2,3),(1,4),(2,4)]`Stream.toList $ Stream.fromList [(1,3),(1,4)] `wSerial` Stream.fromList [(2,3),(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)*

*Since: 0.8.0*

wSerial :: IsStream t => t m a -> t m a -> t m a infixr 6 Source #

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.

`>>>`

`import Streamly.Prelude (wSerial)`

`>>>`

`stream1 = Stream.fromList [1,2]`

`>>>`

`stream2 = Stream.fromList [3,4]`

`>>>`

[1,3,2,4]`Stream.toList $ Stream.fromWSerial $ stream1 `wSerial` stream2`

Note, for singleton streams `wSerial`

and `serial`

are identical.

Note that this operation cannot be used to fold a container of infinite streams but it can be used for very large streams as the state that it needs to maintain is proportional to the logarithm of the number of streams.

*Since: 0.2.0 (Streamly)*

*Since: 0.8.0*

wSerialFst :: IsStream t => t m a -> t m a -> t m a Source #

Like `wSerial`

but stops interleaving as soon as the first stream stops.

*Since: 0.7.0*

wSerialMin :: IsStream t => t m a -> t m a -> t m a Source #

Like `wSerial`

but stops interleaving as soon as any of the two streams
stops.

*Since: 0.7.0*

fromWSerial :: IsStream t => WSerialT m a -> t m a Source #

unfoldrM :: (IsStream t, Monad m) => (b -> m (Maybe (a, b))) -> b -> t m a Source #

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*

type InterleavedT = WSerialT Source #

Deprecated: Please use `WSerialT`

instead.

*Since: 0.1.0*

interleaving :: IsStream t => WSerialT m a -> t m a Source #

streamly-0.8.0**Streamly.Internal.Data.Stream.Serial**