Streamly.Internal.Data.Stream.StreamK

Continuation passing style (CPS) stream implementation. The symbol K below denotes a function as well as a Kontinuation.

import qualified Streamly.Internal.Data.Stream.StreamK as K

The stream type

newtype Stream m a

The type Stream m a represents a monadic stream of values of type a constructed using actions in monad m. It uses stop, singleton and yield continuations equivalent to the following direct style type:

data Stream m a = Stop | Singleton a | Yield a (Stream m a)

To facilitate parallel composition we maintain a local state in an SVar that is shared across and is used for synchronization of the streams being composed.

The singleton case can be expressed in terms of stop and yield but we have it as a separate case to optimize composition operations for streams with single element. We build singleton streams in the implementation of pure for Applicative and Monad, and in lift for MonadTrans.

Constructors

MkStream (forall r. State Stream m a -> (a -> Stream m a -> m r) -> (a -> m r) -> m r -> m r)

Instances

MonadTrans Stream

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

Methods

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

Monad m => Monad (Stream m)

Defined in Streamly.Internal.Data.Stream.StreamK.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

Monad m => Functor (Stream m)

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

Methods

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

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

Monad m => Applicative (Stream m)

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

Methods

pure :: a -> Stream m a

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

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

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

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

Semigroup (Stream m a)

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

Methods

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

sconcat :: NonEmpty (Stream m a) -> Stream m a

stimes :: Integral b => b -> Stream m a -> Stream m a

Monoid (Stream m a)

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

Methods

mempty :: Stream m a

mappend :: Stream m a -> Stream m a -> Stream m a

mconcat :: [Stream m a] -> Stream m a

Construction Primitives

mkStream :: (forall r. State Stream m a -> (a -> Stream m a -> m r) -> (a -> m r) -> m r -> m r) -> Stream m a

nil :: Stream m a

An empty stream.

> toList nil
[]

Since: 0.1.0

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

An empty stream producing a side effect.

> toList (nilM (print "nil"))
"nil"
[]

Pre-release

cons :: a -> Stream m a -> Stream m a infixr 5

Construct a stream by adding a pure value at the head of an existing stream. For serial streams this is the same as (return a) `consM` r but more efficient. For concurrent streams this is not concurrent whereas consM is concurrent. For example:

> toList $ 1 `cons` 2 `cons` 3 `cons` nil
[1,2,3]

Since: 0.1.0

(.:) :: a -> Stream m a -> Stream m a infixr 5

Operator equivalent of cons.

> toList $ 1 .: 2 .: 3 .: nil
[1,2,3]

Since: 0.1.1

Elimination Primitives

foldStream :: State Stream m a -> (a -> Stream m a -> m r) -> (a -> m r) -> m r -> Stream m a -> m r

Fold a stream by providing a State, stop continuation, a singleton continuation and a yield continuation. The stream will not use the SVar passed via State.

foldStreamShared :: State Stream m a -> (a -> Stream m a -> m r) -> (a -> m r) -> m r -> Stream m a -> m r

Fold a stream by providing an SVar, a stop continuation, a singleton continuation and a yield continuation. The stream would share the current SVar passed via the State.

Transformation Primitives

unShare :: Stream m a -> Stream m a

Detach a stream from an SVar

Deconstruction

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

Generation

Unfolds

unfoldr :: (b -> Maybe (a, b)) -> b -> Stream m a

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

Specialized Generation

repeat :: a -> Stream m a

Generate an infinite stream by repeating a pure value.

Pre-release

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

replicate :: Int -> a -> Stream m a

replicateM :: Monad m => Int -> m a -> Stream m a

fromIndices :: (Int -> a) -> Stream m a

fromIndicesM :: Monad m => (Int -> m a) -> Stream m a

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

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

Conversions

fromPure :: a -> Stream m a

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

fromFoldable :: Foldable f => f a -> Stream m a

fromFoldable = foldr cons nil

Construct a stream from a Foldable containing pure values:

Since: 0.2.0

fromList :: [a] -> Stream m a

foldr/build

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

Lazy right associative fold to a stream.

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

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

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

Elimination

General Folds

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

Lazy right associative fold.

foldr1 :: Monad m => (a -> a -> a) -> Stream m a -> m (Maybe a)

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

Lazy right fold with a monadic step function.

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

Right associative fold to an arbitrary transformer monad.

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

Strict left associative fold.

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

Like foldl' but with a monadic step function.

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

Lazy left fold to a stream.

foldlT :: (Monad m, Monad (s m), MonadTrans s) => (s m b -> a -> s m b) -> s m b -> Stream m a -> s m b

Lazy left fold to an arbitrary transformer monad.

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

Strict left fold with an extraction function. Like the standard strict left fold, but applies a user supplied extraction function (the third argument) to the folded value at the end. This is designed to work with the foldl library. The suffix x is a mnemonic for extraction.

Note that the accumulator is always evaluated including the initial value.

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

Like foldx, but with a monadic step function.

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

Specialized Folds

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

drain = foldl' (\_ _ -> ()) ()
drain = mapM_ (\_ -> return ())

null :: Monad m => Stream m a -> m Bool

head :: Monad m => Stream m a -> m (Maybe a)

tail :: Applicative m => Stream m a -> m (Maybe (Stream m a))

init :: Applicative m => Stream m a -> m (Maybe (Stream m a))

elem :: (Monad m, Eq a) => a -> Stream m a -> m Bool

notElem :: (Monad m, Eq a) => a -> Stream m a -> m Bool

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

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

last :: Monad m => Stream m a -> m (Maybe a)

Extract the last element of the stream, if any.

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

minimumBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> m (Maybe a)

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

maximumBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> m (Maybe a)

findIndices :: (a -> Bool) -> Stream m a -> Stream m Int

lookup :: (Monad m, Eq a) => a -> Stream m (a, b) -> m (Maybe b)

findM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe a)

find :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe a)

(!!) :: Monad m => Stream m a -> Int -> m (Maybe a)

Map and Fold

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

Apply a monadic action to each element of the stream and discard the output of the action.

Conversions

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

hoist :: (Monad m, Monad n) => (forall x. m x -> n x) -> Stream m a -> Stream n a

Transformation

By folding (scans)

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

scanlx' :: (x -> a -> x) -> x -> (x -> b) -> Stream m a -> Stream m b

Filtering

filter :: (a -> Bool) -> Stream m a -> Stream m a

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

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

drop :: Int -> Stream m a -> Stream m a

dropWhile :: (a -> Bool) -> Stream m a -> Stream m a

Mapping

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

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

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

Inserting

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

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

insertBy :: (a -> a -> Ordering) -> a -> Stream m a -> Stream m a

Deleting

deleteBy :: (a -> a -> Bool) -> a -> Stream m a -> Stream m a

Reordering

reverse :: Stream m a -> Stream m a

Map and Filter

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

Zipping

zipWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c

Zip two streams serially using a pure zipping function.

Since: 0.1.0

zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c

Zip two streams serially using a monadic zipping function.

Since: 0.1.0

Merging

mergeBy :: (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a

mergeByM :: Monad m => (a -> a -> m Ordering) -> Stream m a -> Stream m a -> Stream m a

Nesting

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

Perform a concatMap using a specified concat strategy. The first argument specifies a merge or concat function that is used to merge the streams generated by the map function. For example, the concat function could be serial, parallel, async, ahead or any other zip or merge function.

Since: 0.7.0

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

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

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

See concatPairsWith for documentation.

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

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

apSerialDiscardFst :: Stream m a -> Stream m b -> Stream m b

apSerialDiscardSnd :: Stream m a -> Stream m b -> Stream m a

Transformation comprehensions

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

Semigroup Style Composition

serial :: Stream m a -> Stream m a -> Stream m a infixr 6

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

Utilities

consM :: Monad m => m a -> Stream m a -> Stream m a infixr 5

withLocal :: MonadReader r m => (r -> r) -> Stream m a -> Stream m a

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