Documentation

Flatten a stream of streams to a single stream.

>>> concat = Stream.concatMap id

Pre-release

Right fold, lazy for lazy monads and pure streams, and strict for strict monads.

Please avoid using this routine in strict monads like IO unless you need a strict right fold. This is provided only for use in lazy monads (e.g. Identity) or pure streams. Note that with this signature it is not possible to implement a lazy foldr when the monad m is strict. In that case it would be strict in its accumulator and therefore would necessarily consume all its input.

>>> foldr f z = Stream.foldrM (\a b -> f a <$> b) (return z)

Note: This is similar to Fold.foldr' (the right fold via left fold), but could be more efficient.

>>> mapM f = Stream.sequence . fmap f

Apply a monadic function to each element of the stream and replace it with the output of the resulting action.

>>> s = Stream.fromList ["a", "b", "c"]
>>> Stream.fold Fold.drain $ Stream.mapM putStr s
abc

This is functional equivalent of an imperative loop.

Loop the supplied stream (first argument) around each element of the input stream (second argument) generating tuples. This is an argument flipped version of cross.

Construct a stream from a list of pure values.

Definitions:

>>> toList = Stream.foldr (:) []
>>> toList = Stream.fold Fold.toList

Convert a stream into a list in the underlying monad. The list can be consumed lazily in a lazy monad (e.g. Identity). In a strict monad (e.g. IO) the whole list is generated and buffered before it can be consumed.

Warning! working on large lists accumulated as buffers in memory could be very inefficient, consider using Streamly.Data.Array instead.

Note that this could a bit more efficient compared to Stream.fold Fold.toList, and it can fuse with pure list consumers.

Decompose a stream into its head and tail. If the stream is empty, returns Nothing. If the stream is non-empty, returns Just (a, ma), where a is the head of the stream and ma its tail.

Properties:

>>> Nothing <- Stream.uncons Stream.nil
>>> Just ("a", t) <- Stream.uncons (Stream.cons "a" Stream.nil)

This can be used to consume the stream in an imperative manner one element at a time, as it just breaks down the stream into individual elements and we can loop over them as we deem fit. For example, this can be used to convert a streamly stream into other stream types.

All the folds in this module can be expressed in terms of uncons, however, this is generally less efficient than specific folds because it takes apart the stream one element at a time, therefore, does not take adavantage of stream fusion.

foldBreak is a more general way of consuming a stream piecemeal.

>>> :{
uncons xs = do
    r <- Stream.foldBreak Fold.one xs
    return $ case r of
        (Nothing, _) -> Nothing
        (Just h, t) -> Just (h, t)
:}

End the stream as soon as the predicate fails on an element.

Take first n elements from the stream and discard the rest.

Inlined definition. Without the inline "seriallyparsertake" benchmark degrades and parseMany does not fuse. Even using "inline" at the callsite does not help.

Map a stream producing function on each element of the stream and then flatten the results into a single stream.

>>> concatMap f = Stream.concat . fmap f
>>> concatMap f = Stream.concatMapM (return . f)
>>> concatMap f = Stream.unfoldEach (Unfold.lmap f Unfold.fromStream)

See argument flipped version concatFor for more detailed documentation.

NOTE: We recommend using unfoldEach or unfoldCross instead of concatMap especially in performance critical code. unfoldEach is much faster than concatMap and matches its expressive power in terms of generating dependent inner streams, there is one important distinction though: the nesting structure when using unfoldEach is fixed statically in the code. In contrast, concatMap allows dynamic and arbitrary nesting through monadic composition. This means that deeply nested or programmatically determined levels of nesting are easier to express and compose with concatMap, though often at the cost of performance and fusion.

WARNING! O(n^2) time complexity wrt number of streams. Suitable for statically fusing a small number of streams. Use the O(n) complexity StreamK.zipWith otherwise.

Stream a is evaluated first, followed by stream b, the resulting elements a and b are then zipped using the supplied zip function and the result c is yielded to the consumer.

If stream a or stream b ends, the zipped stream ends. If stream b ends first, the element a from previous evaluation of stream a is discarded.

>>> s1 = Stream.fromList [1,2,3]
>>> s2 = Stream.fromList [4,5,6]
>>> Stream.fold Fold.toList $ Stream.zipWith (+) s1 s2
[5,7,9]

Fold a stream using the supplied left Fold and reducing the resulting expression strictly at each step. The behavior is similar to foldl'. A Fold can terminate early without consuming the full stream. See the documentation of individual Folds for termination behavior.

Definitions:

>>> fold f = fmap fst . Stream.foldBreak f
>>> fold f = Stream.parse (Parser.fromFold f)

Example:

>>> Stream.fold Fold.sum (Stream.enumerateFromTo 1 100)
5050

Right associative/lazy pull fold. foldrM build final stream constructs an output structure using the step function build. build is invoked with the next input element and the remaining (lazy) tail of the output structure. It builds a lazy output expression using the two. When the "tail structure" in the output expression is evaluated it calls build again thus lazily consuming the input stream until either the output expression built by build is free of the "tail" or the input is exhausted in which case final is used as the terminating case for the output structure. For more details see the description in the previous section.

Example, determine if any element is odd in a stream:

>>> s = Stream.fromList (2:4:5:undefined)
>>> step x xs = if odd x then return True else xs
>>> Stream.foldrM step (return False) s
True

>>> import Control.Monad (join)
>>> foldrM f z = join . Stream.foldr f z

A stream consists of a step function that generates the next step given a current state, and the current state.

Like zipWith but using a monadic zipping function.

Convert an Unfold into a stream by supplying it an input seed.

>>> s = Stream.unfold Unfold.replicateM (3, putStrLn "hello")
>>> Stream.fold Fold.drain s
hello
hello
hello

WARNING! O(n^2) time complexity wrt number of streams. Suitable for statically fusing a small number of streams. Use the O(n) complexity StreamK.append otherwise.

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

>>> s1 = Stream.fromList [1,2]
>>> s2 = Stream.fromList [3,4]
>>> Stream.fold Fold.toList $ s1 `Stream.append` s2
[1,2,3,4]

A stream is a succession of Steps. A Yield produces a single value and the next state of the stream. Stop indicates there are no more values in the stream.

Create a singleton stream from a pure value.

>>> fromPure a = a `Stream.cons` Stream.nil
>>> fromPure = pure
>>> fromPure = Stream.fromEffect . pure

Convert a direct style step encoded StreamD to a CPS encoded StreamK

Like fold but also returns the remaining stream. The resulting stream would be nil if the stream finished before the fold.

Fold resulting in either breaking the stream or continuation of the fold. Instead of supplying the input stream in one go we can run the fold multiple times, each time supplying the next segment of the input stream. If the fold has not yet finished it returns a fold that can be run again otherwise it returns the fold result and the residual stream.

Internal

A stream that terminates without producing any output, but produces a side effect.

>>> nilM action = Stream.before action Stream.nil
>>> Stream.fold Fold.toList (Stream.nilM (print "nil"))
"nil"
[]

Pre-release

Like cons but fuses an effect instead of a pure value.

Convert a CPS encoded StreamK to direct style step encoded StreamD

Apply a terminating Fold repeatedly on a stream and emit the results in the output stream. If the last fold is empty, it's result is not emitted. This means if the input stream is empty the result is also an empty stream. See foldManyPost for an alternate behavior which always results in a non-empty stream even if the input stream is empty.

Definition:

>>> foldMany f = Stream.parseMany (Parser.fromFold f)

Example, empty stream, omits the empty fold value:

>>> f = Fold.take 2 Fold.toList
>>> fmany = Stream.fold Fold.toList . Stream.foldMany f
>>> fmany $ Stream.fromList []
[]

Example, omits the last empty fold value:

>>> fmany $ Stream.fromList [1..4]
[[1,2],[3,4]]

Example, last fold non-empty:

>>> fmany $ Stream.fromList [1..5]
[[1,2],[3,4],[5]]

Note that using a closed fold e.g. Fold.take 0, would result in an infinite stream on a non-empty input stream.

>>> takeEndBy_ f = Stream.takeWhile (not . f)

Like foldMany but for the Refold type. The supplied action is used as the initial value for each refold.

Internal

Group the input stream into groups of n elements each and then fold each group using the provided fold function.

Definition:

>>> groupsOf n f = Stream.foldMany (Fold.take n f)

Usage:

>>> Stream.toList $ Stream.groupsOf 2 Fold.toList (Stream.enumerateFromTo 1 10)
[[1,2],[3,4],[5,6],[7,8],[9,10]]

This can be considered as an n-fold version of take where we apply take repeatedly on the leftover stream until the stream exhausts.

Definitions:

>>> drain = Stream.fold Fold.drain
>>> drain = Stream.foldrM (\_ xs -> xs) (return ())

Run a stream, discarding the results.

Create a singleton stream from a monadic action.

>>> fromEffect m = m `Stream.consM` Stream.nil
>>> fromEffect = Stream.sequence . Stream.fromPure

>>> Stream.fold Fold.drain $ Stream.fromEffect (putStrLn "hello")
hello

Same as takeWhile but with a monadic predicate.

Definition:

>>> crossWith f m1 m2 = fmap f m1 `Stream.crossApply` m2

Note that the second stream is evaluated multiple times.

Also see "Streamly.Data.Unfold.crossWith" for fast fusible static cross product option.

Given a Stream m a and Stream m b generate a stream with all possible combinations of the tuple (a, b).

Definition:

>>> cross = Stream.crossWith (,)

The second stream is evaluated multiple times. If that is not desired it can be cached in an Array and then generated from the array before calling this function. Caching may also improve performance if the stream is expensive to evaluate.

Time: O(m x n)

Pre-release

Like cross but interleaves the outer and inner loops fairly. See fairConcatFor for more details.

unfoldEach unfold stream uses unfold to map the input stream elements to streams and then flattens the generated streams into a single output stream.

Like concatMap but uses an Unfold for stream generation. Unlike concatMap this can fuse the Unfold code with the inner loop and therefore provide many times better performance.

>>> concatMap f = Stream.unfoldEach (Unfold.lmap f Unfold.fromStream)

Here is an example of a two level nested loop much faster than concatMap based nesting.

>>> :{
outerLoop =
  flip Stream.mapM (Stream.fromList [1,2,3]) $ \x -> do
      liftIO $ putStrLn (show x)
      return x
innerUnfold = Unfold.carry $ Unfold.lmap (const [4,5,6]) Unfold.fromList
innerLoop =
     flip Unfold.mapM innerUnfold $ \(x, y) -> do
         when (x == 1) $ liftIO $ putStrLn (show y)
         pure $ (x, y)
:}

>>> Stream.toList $ Stream.unfoldEach innerLoop outerLoop
1
4
5
6
2
3
[(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]

Flatten a stream generated by an effect i.e. concat the effect monad with the stream monad.

>>> concatEffect = Stream.concat . Stream.fromEffect
>>> concatEffect eff = Stream.concatMapM (\() -> eff) (Stream.fromPure ())

See also: concat, sequence

Map a stream producing monadic function on each element of the stream and then flatten the results into a single stream. Since the stream generation function is monadic, unlike concatMap, it can produce an effect at the beginning of each iteration of the inner loop.

See unfoldEach for a faster alternative.

Map a stream generating function on each element of a stream and concatenate the results. This is the same as the bind function of the monad instance. It is just a flipped concatMap but more convenient to use for nested use case, feels like an imperative for loop. It is in fact equivalent to concat . for.

>>> concatFor = flip Stream.concatMap

A concatenating for loop:

>>> :{
Stream.toList $
    Stream.concatFor (Stream.fromList [1,2,3]) $ \x ->
      Stream.fromPure x
:}
[1,2,3]

Use unfoldEach instead of concatFor where possible, unfoldEach is much faster due to fusion.

Nested concatenating for loops:

>>> :{
Stream.toList $
    Stream.concatFor (Stream.fromList [1,2,3]) $ \x ->
     Stream.concatFor (Stream.fromList [4,5,6]) $ \y ->
      Stream.fromPure (x, y)
:}
[(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]

If total iterations are kept the same, each increase in the nesting level increases the cost by roughly 2 times.

For significantly faster multi-level nesting, prefer using the better fusible, applicative-like crossWith over concatFor where possible.

concatFor is monad-like: it allows expressing dependencies between the outer and the inner loops of the nesting, it means that the stream generated by the inner loop is dynamically governed by the outer loop. This expressive power comes at a significant performance cost.

NOTE: We recommend using unfoldEach or unfoldCross instead of concatFor especially in performance critical code. unfoldEach is much faster than concatFor and matches its expressive power in terms of generating dependent inner streams, there is one important distinction though: the nesting structure when using unfoldEach is fixed statically in the code. In contrast, concatFor allows dynamic and arbitrary nesting through monadic composition. This means that deeply nested or programmatically determined levels of nesting are easier to express and compose with concatFor, though often at the cost of performance and fusion.

Like concatFor but maps an effectful function. It allows conveniently mixing monadic effects with streams.

>>> import Control.Monad.IO.Class (liftIO)
>>> :{
Stream.toList $
    Stream.concatForM (Stream.fromList [1,2,3]) $ \x -> do
      liftIO $ putStrLn (show x)
      pure $ Stream.fromPure x
:}
1
2
3
[1,2,3]

Nested concatentating for loops:

>>> :{
Stream.toList $
    Stream.concatForM (Stream.fromList [1,2,3]) $ \x -> do
      liftIO $ putStrLn (show x)
      pure $ Stream.concatForM (Stream.fromList [4,5,6]) $ \y -> do
        when (x == 1) $ liftIO $ putStrLn (show y)
        pure $ Stream.fromPure (x, y)
:}
1
4
5
6
2
3
[(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]

Compare two streams for equality

Compare two streams lexicographically.

unfoldEach unfold stream uses unfold to map the input stream elements to streams and then flattens the generated streams into a single output stream.

Like concatMap but uses an Unfold for stream generation. Unlike concatMap this can fuse the Unfold code with the inner loop and therefore provide many times better performance.

>>> concatMap f = Stream.unfoldEach (Unfold.lmap f Unfold.fromStream)

Here is an example of a two level nested loop much faster than concatMap based nesting.

>>> :{
outerLoop =
  flip Stream.mapM (Stream.fromList [1,2,3]) $ \x -> do
      liftIO $ putStrLn (show x)
      return x
innerUnfold = Unfold.carry $ Unfold.lmap (const [4,5,6]) Unfold.fromList
innerLoop =
     flip Unfold.mapM innerUnfold $ \(x, y) -> do
         when (x == 1) $ liftIO $ putStrLn (show y)
         pure $ (x, y)
:}

>>> Stream.toList $ Stream.unfoldEach innerLoop outerLoop
1
4
5
6
2
3
[(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]

A newtype wrapper for the Stream type with a cross product style monad instance.

A Monad bind behaves like a for loop:

>>> :{
Stream.fold Fold.toList $ Stream.unNested $ do
    x <- Stream.Nested $ Stream.fromList [1,2]
    -- Perform the following actions for each x in the stream
    return x
:}
[1,2]

Nested monad binds behave like nested for loops:

>>> :{
Stream.fold Fold.toList $ Stream.unNested $ do
    x <- Stream.Nested $ Stream.fromList [1,2]
    y <- Stream.Nested $ Stream.fromList [3,4]
    -- Perform the following actions for each x, for each y
    return (x, y)
:}
[(1,3),(1,4),(2,3),(2,4)]

Append a stream to a fold lazily to build an accumulator incrementally.

Example, to continue folding a list of streams on the same sum fold:

>>> streams = [Stream.fromList [1..5], Stream.fromList [6..10]]
>>> f = Prelude.foldl Stream.foldAddLazy Fold.sum streams
>>> Stream.fold f Stream.nil
55

>>> foldAdd = flip Fold.addStream

Apply a stream of functions to a stream of values and flatten the results.

Note that the second stream is evaluated multiple times.

>>> crossApply = Stream.crossWith id

Like fairCrossWith but with monadic function argument.

Like crossWith but interleaves the outer and inner loops fairly. See fairConcatFor for more details.

Loop by unfold. Unfold a value into a stream and nest it with the input stream. This is much faster than loop due to stream fusion.

Generates a cross product of two streams and then unfolds each tuple.

A two level nested loop much faster than concatMap based nesting.

>>> :{
outerLoop =
  flip Stream.mapM (Stream.fromList [1,2,3]) $ \x -> do
      liftIO $ putStrLn (show x)
      return x
innerLoop =
  flip Stream.mapM (Stream.fromList [4,5,6]) $ \y -> do
      -- liftIO $ putStrLn (show y)
      return y
innerUnfold =
  flip Unfold.mapM Unfold.identity $ \(x,y) -> do
     when (x == 1) $ liftIO $ putStrLn (show y)
     pure $ (x, y)
:}

>>> Stream.toList $ Stream.unfoldCross innerUnfold outerLoop innerLoop
1
4
5
6
2
3
[(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]

Note: unfoldEach may generate faster code, so use that when possible. Also see "Streamly.Data.Unfold.cross" for fast fusible static cross product option.

Same as concatIterate but more efficient due to stream fusion.

Example, list a directory tree using DFS:

>>> f = Unfold.either (Dir.eitherReaderPaths id) Unfold.nil
>>> input = Stream.fromEffect (Left <$> Path.fromString ".")
>>> ls = Stream.unfoldIterate f input

Pre-release

Like unfoldIterate but uses breadth first style traversal.

Pre-release

Like bfsUnfoldIterate but processes the children in reverse order, therefore, may be slightly faster.

Pre-release

Generate a stream from an initial state, scan and concat the stream, generate a stream again from the final state of the previous scan and repeat the process.

Traverse the stream in depth first style (DFS). Map each element in the input stream to a stream and flatten, recursively map the resulting elements as well to a stream and flatten until no more streams are generated.

Example, list a directory tree using DFS:

>>> f = either (Just . Dir.readEitherPaths id) (const Nothing)
>>> input = Stream.fromEffect (Left <$> Path.fromString ".")
>>> ls = Stream.concatIterate f input

This is equivalent to using concatIterateWith StreamK.append.

Pre-release

Similar to concatIterate except that it traverses the stream in breadth first style (BFS). First, all the elements in the input stream are emitted, and then their traversals are emitted.

Example, list a directory tree using BFS:

>>> f = either (Just . Dir.readEitherPaths id) (const Nothing)
>>> input = Stream.fromEffect (Left <$> Path.fromString ".")
>>> ls = Stream.bfsConcatIterate f input

Pre-release

Same as concatIterateBfs except that the traversal of the last element on a level is emitted first and then going backwards up to the first element (reversed ordering). This may be slightly faster than concatIterateBfs.

Like foldMany but evaluates the fold even if the fold did not receive any input, therefore, always results in a non-empty output even on an empty stream (default result of the fold).

Example, empty stream, compare with foldMany:

>>> f = Fold.take 2 Fold.toList
>>> fmany = Stream.fold Fold.toList . Stream.foldManyPost f
>>> fmany $ Stream.fromList []
[[]]

Example, last empty fold is included, compare with foldMany:

>>> fmany $ Stream.fromList [1..4]
[[1,2],[3,4],[]]

Example, last fold non-empty, same as foldMany:

>>> fmany $ Stream.fromList [1..5]
[[1,2],[3,4],[5]]

Pre-release

Apply fold f1 infix separated by fold f2.

Unimplemented

Like foldIterateM but using the Refold type instead. This could be much more efficient due to stream fusion.

Internal

Binary BFS style reduce, folds a level entirely using the supplied fold function, collecting the outputs as next level of the tree, then repeats the same process on the next level. The last elements of a previously folded level are folded first.

N-Ary BFS style iterative fold, if the input stream finished before the fold then it returns Left otherwise Right. If the fold returns Left we terminate.

Unimplemented

Like splitEndBy but generates a stream of (index, len) tuples marking the places where the predicate matches in the stream.

>>> Stream.toList $ Stream.indexEndBy (== '/') $ Stream.fromList "/home/harendra"
[(0,1),(1,5),(6,8)]

Pre-release

Like splitEndBy_ but generates a stream of (index, len) tuples marking the places where the predicate matches in the stream.

>>> Stream.toList $ Stream.indexEndBy_ (== '/') $ Stream.fromList "/home/harendra"
[(0,0),(1,4),(6,8)]

Pre-release

Like splitEndBy_ but generates a stream of (index, len) tuples marking the places where the predicate matches in the stream.

>>> Stream.toList $ Stream.indexEndBy_ (== '/') $ Stream.fromList "/home/harendra"
[(0,0),(1,4),(6,8)]

Pre-release

Binary BFS style reduce, folds a level entirely using the supplied fold function, collecting the outputs as next level of the tree, then repeats the same process on the next level. The last elements of a previously folded level are folded first.

Same as concatIterate but more efficient due to stream fusion.

Example, list a directory tree using DFS:

>>> f = Unfold.either (Dir.eitherReaderPaths id) Unfold.nil
>>> input = Stream.fromEffect (Left <$> Path.fromString ".")
>>> ls = Stream.unfoldIterate f input

Pre-release

Like unfoldIterate but uses breadth first style traversal.

Pre-release

Like bfsUnfoldIterate but processes the children in reverse order, therefore, may be slightly faster.

Pre-release

Traverse the stream in depth first style (DFS). Map each element in the input stream to a stream and flatten, recursively map the resulting elements as well to a stream and flatten until no more streams are generated.

Example, list a directory tree using DFS:

>>> f = either (Just . Dir.readEitherPaths id) (const Nothing)
>>> input = Stream.fromEffect (Left <$> Path.fromString ".")
>>> ls = Stream.concatIterate f input

This is equivalent to using concatIterateWith StreamK.append.

Pre-release

Similar to concatIterate except that it traverses the stream in breadth first style (BFS). First, all the elements in the input stream are emitted, and then their traversals are emitted.

Example, list a directory tree using BFS:

>>> f = either (Just . Dir.readEitherPaths id) (const Nothing)
>>> input = Stream.fromEffect (Left <$> Path.fromString ".")
>>> ls = Stream.bfsConcatIterate f input

Pre-release

Same as concatIterateBfs except that the traversal of the last element on a level is emitted first and then going backwards up to the first element (reversed ordering). This may be slightly faster than concatIterateBfs.

Generate an infinite stream by repeating a pure value.

>>> repeat = Stream.iterate id
>>> repeat x = Stream.repeatM (pure x)

Build a stream by unfolding a pure step function step starting from a seed s. 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 > 2
        then Nothing
        else Just (b, b + 1)
in Stream.toList $ Stream.unfoldr f 0
:}
[0,1,2]

Generate an infinite stream with x as the first element and each successive element derived by applying the function f on the previous element.

>>> Stream.toList $ Stream.take 5 $ Stream.iterate (+1) 1
[1,2,3,4,5]

>>> replicate n = Stream.take n . Stream.repeat
>>> replicate n x = Stream.replicateM n (pure x)

Generate a stream of length n by repeating a value n times.

>>> replicateM n = Stream.sequence . Stream.replicate n

Generate a stream by performing a monadic action n times.

WARNING! O(n^2) time complexity wrt number of elements. Use the O(n) complexity StreamK.cons unless you want to statically fuse just a few elements.

Fuse a pure value at the head of an existing stream::

>>> s = 1 `Stream.cons` Stream.fromList [2,3]
>>> Stream.toList s
[1,2,3]

Definition:

>>> cons x xs = return x `Stream.consM` xs

Generate a singleton event at or after the specified absolute time. Note that this is different from a threadDelay, a threadDelay starts from the time when the action is evaluated, whereas if we use AbsTime based timeout it will immediately expire if the action is evaluated too late.

Unimplemented

times returns a stream of time value tuples with clock of 10 ms granularity. The first component of the tuple is an absolute time reference (epoch) denoting the start of the stream and the second component is a time relative to the reference.

>>> f = Fold.drainMapM (\x -> print x >> threadDelay 1000000)
>>> Stream.fold f $ Stream.take 3 $ Stream.times
(AbsTime (TimeSpec {sec = ..., nsec = ...}),RelTime64 (NanoSecond64 ...))
(AbsTime (TimeSpec {sec = ..., nsec = ...}),RelTime64 (NanoSecond64 ...))
(AbsTime (TimeSpec {sec = ..., nsec = ...}),RelTime64 (NanoSecond64 ...))

Note: This API is not safe on 32-bit machines.

Pre-release

A stream that terminates without producing any output or side effect.

>>> Stream.toList Stream.nil
[]

>>> repeatM act = Stream.iterateM (const act) act
>>> repeatM = Stream.sequence . Stream.repeat

Generate a stream by repeatedly executing a monadic action forever.

>>> :{
repeatAction =
       Stream.repeatM (threadDelay 1000000 >> print 1)
     & Stream.take 10
     & Stream.fold Fold.drain
:}

Generate an infinite stream with the first element generated by the action m and each successive element derived by applying the monadic function f on the previous element.

>>> :{
Stream.iterateM (\x -> print x >> return (x + 1)) (return 0)
    & Stream.take 3
    & Stream.toList
:}
0
1
[0,1,2]

Convert a list of monadic actions to a Stream

Keep reading Storable elements from an immutable Ptr onwards.

Unsafe: The caller is responsible for safe addressing.

Pre-release

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 > 2
        then return Nothing
        else return (Just (b, b + 1))
in Stream.toList $ Stream.unfoldrM f 0
:}
[0,1,2]

Types that can be enumerated as a stream. The operations in this type class are equivalent to those in the Enum type class, except that these generate a stream instead of a list. Use the functions in Streamly.Internal.Data.Stream.Enumeration module to define new instances.