Streamly.Internal.Data.Stream.StreamD.Type

The stream type

data Step s a

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.

Constructors

Yield a s

Skip s

Stop

Instances

Functor (Step s)

Defined in Streamly.Internal.Data.Stream.StreamD.Step

Methods

fmap :: (a -> b) -> Step s a -> Step s b

(<$) :: a -> Step s b -> Step s a

data Stream m a

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

Constructors

forall s. UnStream (State Stream m a -> s -> m (Step s a)) s

Bundled Patterns

pattern Stream :: (State Stream m a -> s -> m (Step s a)) -> s -> Stream m a

Instances

MonadTrans Stream

Defined in Streamly.Internal.Data.Stream.StreamD.Type

Methods

lift :: Monad m => m a -> Stream m a

Monad m => Monad (Stream m)

Defined in Streamly.Internal.Data.Stream.StreamD.Type

Methods

(>>=) :: Stream m a -> (a -> Stream m b) -> Stream m b

(>>) :: Stream m a -> Stream m b -> Stream m b

return :: a -> Stream m a

Functor m => Functor (Stream m)

Defined in Streamly.Internal.Data.Stream.StreamD.Type

Methods

fmap :: (a -> b) -> Stream m a -> Stream m b

(<$) :: a -> Stream m b -> Stream m a

Applicative f => Applicative (Stream f)

Defined in Streamly.Internal.Data.Stream.StreamD.Type

Methods

pure :: a -> Stream f a

(<*>) :: Stream f (a -> b) -> Stream f a -> Stream f b

liftA2 :: (a -> b -> c) -> Stream f a -> Stream f b -> Stream f c

(*>) :: Stream f a -> Stream f b -> Stream f b

(<*) :: Stream f a -> Stream f b -> Stream f a

MonadThrow m => MonadThrow (Stream m)

Defined in Streamly.Internal.Data.Stream.StreamD.Type

Methods

throwM :: Exception e => e -> Stream m a

Primitives

nilM :: Applicative m => m b -> Stream m a

An empty Stream with a side effect.

consM :: Applicative m => m a -> Stream m a -> Stream m a

uncons :: Monad m => Stream m a -> m (Maybe (a, Stream m a))

Does not fuse, has the same performance as the StreamK version.

From Unfold

unfold :: Applicative m => Unfold m a b -> a -> Stream m b

Convert an Unfold into a Stream by supplying it a seed.

From Values

fromPure :: Applicative m => a -> Stream m a

Create a singleton Stream from a pure value.

fromEffect :: Applicative m => m a -> Stream m a

Create a singleton Stream from a monadic action.

From Containers

fromList :: Applicative m => [a] -> Stream m a

Convert a list of pure values to a Stream

Conversions From/To

fromStreamK :: Applicative m => Stream m a -> Stream m a

Convert a CPS encoded StreamK to direct style step encoded StreamD

toStreamK :: Monad m => Stream m a -> Stream m a

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

Running a Fold

fold :: Monad m => Fold m a b -> Stream m a -> m b

fold_ :: Monad m => Fold m a b -> Stream m a -> m (b, Stream m a)

foldOn :: Monad m => Fold m a b -> Stream m a -> Fold m a b

Right Folds

foldrT :: (Monad m, Monad (t m), MonadTrans t) => (a -> t m b -> t m b) -> t m b -> Stream m a -> t m b

foldrM :: Monad m => (a -> m b -> m b) -> m b -> Stream m a -> m b

foldrMx :: Monad m => (a -> m x -> m x) -> m x -> (m x -> m b) -> Stream m a -> m b

foldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b

foldrS :: Monad m => (a -> Stream m b -> Stream m b) -> Stream m b -> Stream m a -> Stream m b

Left Folds

foldl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> m b

foldlM' :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> m b

foldlx' :: Monad m => (x -> a -> x) -> x -> (x -> b) -> Stream m a -> m b

foldlMx' :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> Stream m a -> m b

Special Folds

drain :: Monad m => Stream m a -> m ()

Run a streaming composition, discard the results.

To Containers

toList :: Monad m => Stream m a -> m [a]

Multi-stream folds

eqBy :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool

cmpBy :: Monad m => (a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering

Compare two streams lexicographically

Transformations

map :: Monad m => (a -> b) -> Stream m a -> Stream m b

mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b

Map a monadic function over a Stream

take :: Applicative m => Int -> Stream m a -> Stream m a

takeWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a

takeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a

takeEndBy :: Monad m => (a -> Bool) -> Stream m a -> Stream m a

takeEndByM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a

Nesting

data ConcatMapUState o i

Constructors

ConcatMapUOuter o

ConcatMapUInner o i

unfoldMany :: Monad m => Unfold m a b -> Stream m a -> Stream m b

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

concatMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b

concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b

data FoldMany s fs b a

Constructors

FoldManyStart s

FoldManyFirst fs s

FoldManyLoop s fs

FoldManyYield b (FoldMany s fs b a)

FoldManyDone

data FoldManyPost s fs b a

Constructors

FoldManyPostStart s

FoldManyPostLoop s fs

FoldManyPostYield b (FoldManyPost s fs b a)

FoldManyPostDone

foldMany :: Monad m => Fold m a b -> Stream m a -> Stream m b

Apply a fold multiple times until the stream ends. If the stream is empty the output would be empty.

foldMany f = parseMany (fromFold f)

A terminating fold may terminate even without accepting a single input. So we run the fold's initial action before evaluating the stream. However, this means that if later the stream does not yield anything we have to discard the fold's initial result which could have generated an effect.

foldManyPost :: Monad m => Fold m a b -> Stream m a -> Stream m b

Like foldMany but with the following differences:

• If the stream is empty the default value of the fold would still be emitted in the output.
• At the end of the stream if the last application of the fold did not receive any input it would still yield the default fold accumulator as the last value.

refoldMany :: Monad m => Refold m x a b -> m x -> Stream m a -> Stream m b

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

Internal

chunksOf :: Monad m => Int -> Fold m a b -> Stream m a -> Stream m b