Copyright	(c) Roman Leshchinskiy 2008-2010 Alexey Kuleshevich 2020-2022 Aleksey Khudyakov 2020-2022 Andrew Lelechenko 2020-2022
License	BSD-style
Maintainer	Haskell Libraries Team <libraries@haskell.org>
Stability	experimental
Portability	non-portable
Safe Haskell	Safe-Inferred
Language	Haskell2010

Data.Stream.Monadic

Contents

Box monad
Stream

Description

Monadic stream combinators.

Synopsis

data Box a = Box {
- unBox :: a
}
liftBox :: Monad m => Box a -> m a
data Stream m a = forall s. Stream (s -> m (Step s a)) s
data Step s a where
- Yield :: a -> s -> Step s a
- Skip :: s -> Step s a
- Done :: Step s a
data SPEC
- = SPEC
- | SPEC2
length :: Monad m => Stream m a -> m Int
null :: Monad m => Stream m a -> m Bool
empty :: Monad m => Stream m a
singleton :: Monad m => a -> Stream m a
cons :: Monad m => a -> Stream m a -> Stream m a
snoc :: Monad m => Stream m a -> a -> Stream m a
replicate :: Monad m => Int -> a -> Stream m a
replicateM :: Monad m => Int -> m a -> Stream m a
generate :: Monad m => Int -> (Int -> a) -> Stream m a
generateM :: Monad m => Int -> (Int -> m a) -> Stream m a
(++) :: Monad m => Stream m a -> Stream m a -> Stream m a
head :: (HasCallStack, Monad m) => Stream m a -> m a
last :: (HasCallStack, Monad m) => Stream m a -> m a
(!!) :: (HasCallStack, Monad m) => Stream m a -> Int -> m a
(!?) :: Monad m => Stream m a -> Int -> m (Maybe a)
slice :: Monad m => Int -> Int -> Stream m a -> Stream m a
init :: (HasCallStack, Monad m) => Stream m a -> Stream m a
tail :: (HasCallStack, Monad m) => Stream m a -> Stream m a
take :: Monad m => Int -> Stream m a -> Stream m a
drop :: Monad m => Int -> Stream m a -> Stream m a
map :: Monad m => (a -> b) -> Stream m a -> Stream m b
mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b
mapM_ :: Monad m => (a -> m b) -> Stream m a -> m ()
trans :: (Monad m, Monad m') => (forall z. m z -> m' z) -> Stream m a -> Stream m' a
unbox :: Monad m => Stream m (Box a) -> Stream m a
concatMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b
flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Stream m a -> Stream m b
indexed :: Monad m => Stream m a -> Stream m (Int, a)
indexedR :: Monad m => Int -> Stream m a -> Stream m (Int, a)
zipWithM_ :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> m ()
zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
zipWith3M :: Monad m => (a -> b -> c -> m d) -> Stream m a -> Stream m b -> Stream m c -> Stream m d
zipWith4M :: Monad m => (a -> b -> c -> d -> m e) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e
zipWith5M :: Monad m => (a -> b -> c -> d -> e -> m f) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f
zipWith6M :: Monad m => (a -> b -> c -> d -> e -> f -> m g) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f -> Stream m g
zipWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
zipWith3 :: Monad m => (a -> b -> c -> d) -> Stream m a -> Stream m b -> Stream m c -> Stream m d
zipWith4 :: Monad m => (a -> b -> c -> d -> e) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e
zipWith5 :: Monad m => (a -> b -> c -> d -> e -> f) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f
zipWith6 :: Monad m => (a -> b -> c -> d -> e -> f -> g) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f -> Stream m g
zip :: Monad m => Stream m a -> Stream m b -> Stream m (a, b)
zip3 :: Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m (a, b, c)
zip4 :: Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m (a, b, c, d)
zip5 :: Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m (a, b, c, d, e)
zip6 :: Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f -> Stream m (a, b, c, d, e, f)
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
filter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
uniq :: (Eq a, Monad m) => Stream m a -> Stream m a
mapMaybe :: Monad m => (a -> Maybe b) -> Stream m a -> Stream m b
mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream m a -> Stream m b
catMaybes :: Monad m => Stream m (Maybe 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
dropWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> 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
find :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe a)
findM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe a)
findIndex :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe Int)
findIndexM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe Int)
foldl :: Monad m => (a -> b -> a) -> a -> Stream m b -> m a
foldlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
foldl1 :: Monad m => (a -> a -> a) -> Stream m a -> m a
foldl1M :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a
foldM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
fold1M :: Monad m => (a -> a -> m a) -> Stream m a -> m a
foldl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> m a
foldlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
foldl1' :: Monad m => (a -> a -> a) -> Stream m a -> m a
foldl1M' :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a
foldM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
fold1M' :: Monad m => (a -> a -> m a) -> Stream m a -> m a
foldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b
foldrM :: Monad m => (a -> b -> m b) -> b -> Stream m a -> m b
foldr1 :: Monad m => (a -> a -> a) -> Stream m a -> m a
foldr1M :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a
and :: Monad m => Stream m Bool -> m Bool
or :: Monad m => Stream m Bool -> m Bool
concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b
unfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Stream m a
unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a
unfoldrN :: Monad m => Int -> (s -> Maybe (a, s)) -> s -> Stream m a
unfoldrNM :: Monad m => Int -> (s -> m (Maybe (a, s))) -> s -> Stream m a
unfoldrExactN :: Monad m => Int -> (s -> (a, s)) -> s -> Stream m a
unfoldrExactNM :: Monad m => Int -> (s -> m (a, s)) -> s -> Stream m a
iterateN :: Monad m => Int -> (a -> a) -> a -> Stream m a
iterateNM :: Monad m => Int -> (a -> m a) -> a -> Stream m a
prescanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
prescanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
prescanl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
prescanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
postscanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
postscanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
postscanl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
postscanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
scanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
scanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
scanl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
scanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a
scanl1 :: Monad m => (a -> a -> a) -> Stream m a -> Stream m a
scanl1M :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a
scanl1' :: Monad m => (a -> a -> a) -> Stream m a -> Stream m a
scanl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a
enumFromStepN :: (Num a, Monad m) => a -> a -> Int -> Stream m a
enumFromTo :: (Enum a, Monad m) => a -> a -> Stream m a
enumFromThenTo :: (Enum a, Monad m) => a -> a -> a -> Stream m a
toList :: Monad m => Stream m a -> m [a]
fromList :: Monad m => [a] -> Stream m a
fromListN :: Monad m => Int -> [a] -> Stream m a

Box monad

data Box a #

Box monad

Constructors

Box
Fields unBox :: a

Instances

Instances details

Applicative Box #
Instance details Defined in Data.Stream.Monadic Methods pure :: a -> Box a (<>) :: Box (a -> b) -> Box a -> Box b liftA2 :: (a -> b -> c) -> Box a -> Box b -> Box c (>) :: Box a -> Box b -> Box b (<*) :: Box a -> Box b -> Box a
Functor Box #
Instance details Defined in Data.Stream.Monadic Methods fmap :: (a -> b) -> Box a -> Box b (<$) :: a -> Box b -> Box a
Monad Box #
Instance details Defined in Data.Stream.Monadic Methods (>>=) :: Box a -> (a -> Box b) -> Box b (>>) :: Box a -> Box b -> Box b return :: a -> Box a

liftBox :: Monad m => Box a -> m a #

Stream

data Stream m a #

Monadic streams

Constructors

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

Instances

Instances details

Monad m => Functor (Stream m) #
Instance details Defined in Data.Stream.Monadic Methods fmap :: (a -> b) -> Stream m a -> Stream m b (<$) :: a -> Stream m b -> Stream m a

data Step s a where #

Result of taking a single step in a stream

Constructors

Yield :: a -> s -> Step s a
Skip :: s -> Step s a
Done :: Step s a

Instances

Instances details

Functor (Step s) #
Instance details Defined in Data.Stream.Monadic Methods fmap :: (a -> b) -> Step s a -> Step s b (<$) :: a -> Step s b -> Step s a

data SPEC #

Constructors

SPEC
SPEC2

Length

length :: Monad m => Stream m a -> m Int #

Length of a Stream

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

Check if a Stream is empty

Construction

empty :: Monad m => Stream m a #

Empty Stream

singleton :: Monad m => a -> Stream m a #

Singleton Stream

cons :: Monad m => a -> Stream m a -> Stream m a #

Prepend an element

snoc :: Monad m => Stream m a -> a -> Stream m a #

Append an element

replicate :: Monad m => Int -> a -> Stream m a #

Replicate a value to a given length

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

Yield a Stream of values obtained by performing the monadic action the given number of times

generate :: Monad m => Int -> (Int -> a) -> Stream m a #

generateM :: Monad m => Int -> (Int -> m a) -> Stream m a #

Generate a stream from its indices

(++) :: Monad m => Stream m a -> Stream m a -> Stream m a infixr 5 #

Concatenate two Streams

Accessing elements

head :: (HasCallStack, Monad m) => Stream m a -> m a #

First element of the Stream or error if empty

last :: (HasCallStack, Monad m) => Stream m a -> m a #

Last element of the Stream or error if empty

(!!) :: (HasCallStack, Monad m) => Stream m a -> Int -> m a infixl 9 #

Element at the given position

(!?) :: Monad m => Stream m a -> Int -> m (Maybe a) infixl 9 #

Element at the given position or Nothing if out of bounds

Substreams

slice #

Arguments

:: Monad m
=> Int	starting index
-> Int	length
-> Stream m a
-> Stream m a

Extract a substream of the given length starting at the given position.

init :: (HasCallStack, Monad m) => Stream m a -> Stream m a #

All but the last element

tail :: (HasCallStack, Monad m) => Stream m a -> Stream m a #

All but the first element

take :: Monad m => Int -> Stream m a -> Stream m a #

The first n elements

drop :: Monad m => Int -> Stream m a -> Stream m a #

All but the first n elements

Mapping

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

Map a function over a Stream

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

Map a monadic function over a Stream

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

Execute a monadic action for each element of the Stream

trans :: (Monad m, Monad m') => (forall z. m z -> m' z) -> Stream m a -> Stream m' a #

Transform a Stream to use a different monad

unbox :: Monad m => Stream m (Box a) -> Stream m a #

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

flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Stream m a -> Stream m b #

Create a Stream of values from a Stream of streamable things

Zipping

indexed :: Monad m => Stream m a -> Stream m (Int, a) #

Pair each element in a Stream with its index

indexedR :: Monad m => Int -> Stream m a -> Stream m (Int, a) #

Pair each element in a Stream with its index, starting from the right and counting down

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

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

Zip two Streams with the given monadic function

zipWith3M :: Monad m => (a -> b -> c -> m d) -> Stream m a -> Stream m b -> Stream m c -> Stream m d #

zipWith4M :: Monad m => (a -> b -> c -> d -> m e) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e #

zipWith5M :: Monad m => (a -> b -> c -> d -> e -> m f) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f #

zipWith6M :: Monad m => (a -> b -> c -> d -> e -> f -> m g) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f -> Stream m g #

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

zipWith3 :: Monad m => (a -> b -> c -> d) -> Stream m a -> Stream m b -> Stream m c -> Stream m d #

zipWith4 :: Monad m => (a -> b -> c -> d -> e) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e #

zipWith5 :: Monad m => (a -> b -> c -> d -> e -> f) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f #

zipWith6 :: Monad m => (a -> b -> c -> d -> e -> f -> g) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f -> Stream m g #

zip :: Monad m => Stream m a -> Stream m b -> Stream m (a, b) #

zip3 :: Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m (a, b, c) #

zip4 :: Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m (a, b, c, d) #

zip5 :: Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m (a, b, c, d, e) #

zip6 :: Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f -> Stream m (a, b, c, d, e, f) #

Comparisons

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

Check if two Streams are equal

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

Lexicographically compare two Streams

Filtering

filter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a #

Drop elements which do not satisfy the predicate

filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a #

Drop elements which do not satisfy the monadic predicate

uniq :: (Eq a, Monad m) => Stream m a -> Stream m a #

Drop repeated adjacent elements.

mapMaybe :: Monad m => (a -> Maybe b) -> Stream m a -> Stream m b #

mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream m a -> Stream m b #

Apply monadic function to each element and drop all Nothings

Since: 0.12.2.0

catMaybes :: Monad m => Stream m (Maybe a) -> Stream m a #

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

Longest prefix of elements that satisfy the predicate

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

Longest prefix of elements that satisfy the monadic predicate

dropWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a #

Drop the longest prefix of elements that satisfy the predicate

dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a #

Drop the longest prefix of elements that satisfy the monadic predicate

Searching

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

Check whether the Stream contains an element

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

Inverse of elem

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

Yield Just the first element that satisfies the predicate or Nothing if no such element exists.

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

Yield Just the first element that satisfies the monadic predicate or Nothing if no such element exists.

findIndex :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe Int) #

Yield Just the index of the first element that satisfies the predicate or Nothing if no such element exists.

findIndexM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe Int) #

Yield Just the index of the first element that satisfies the monadic predicate or Nothing if no such element exists.

Folding

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

Left fold

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

Left fold with a monadic operator

foldl1 :: Monad m => (a -> a -> a) -> Stream m a -> m a #

Left fold over a non-empty Stream

foldl1M :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a #

Left fold over a non-empty Stream with a monadic operator

foldM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a #

Same as foldlM

fold1M :: Monad m => (a -> a -> m a) -> Stream m a -> m a #

Same as foldl1M

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

Left fold with a strict accumulator

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

Left fold with a strict accumulator and a monadic operator

foldl1' :: Monad m => (a -> a -> a) -> Stream m a -> m a #

Left fold over a non-empty Stream with a strict accumulator

foldl1M' :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a #

Left fold over a non-empty Stream with a strict accumulator and a monadic operator

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

Same as foldlM'

fold1M' :: Monad m => (a -> a -> m a) -> Stream m a -> m a #

Same as foldl1M'

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

Right fold

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

Right fold with a monadic operator

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

Right fold over a non-empty stream

foldr1M :: (HasCallStack, Monad m) => (a -> a -> m a) -> Stream m a -> m a #

Right fold over a non-empty stream with a monadic operator

Specialised folds

and :: Monad m => Stream m Bool -> m Bool #

or :: Monad m => Stream m Bool -> m Bool #

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

Unfolding

unfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Stream m a #

Unfold

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

Unfold with a monadic function

unfoldrN :: Monad m => Int -> (s -> Maybe (a, s)) -> s -> Stream m a #

unfoldrNM :: Monad m => Int -> (s -> m (Maybe (a, s))) -> s -> Stream m a #

Unfold at most n elements with a monadic function.

unfoldrExactN :: Monad m => Int -> (s -> (a, s)) -> s -> Stream m a #

Unfold exactly n elements

Since: 0.12.2.0

unfoldrExactNM :: Monad m => Int -> (s -> m (a, s)) -> s -> Stream m a #

Unfold exactly n elements with a monadic function.

Since: 0.12.2.0

iterateN :: Monad m => Int -> (a -> a) -> a -> Stream m a #

O(n) Apply function $\max(n - 1, 0)$ times to an initial value, producing a stream of $\max(n, 0)$ values.

iterateNM :: Monad m => Int -> (a -> m a) -> a -> Stream m a #

O(n) Apply monadic function $\max(n - 1, 0)$ times to an initial value, producing a stream of $\max(n, 0)$ values.

Scans

prescanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a #

Prefix scan

prescanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a #

Prefix scan with a monadic operator

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

Prefix scan with strict accumulator

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

Prefix scan with strict accumulator and a monadic operator

postscanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a #

Suffix scan

postscanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a #

Suffix scan with a monadic operator

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

Suffix scan with strict accumulator

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

Suffix scan with strict acccumulator and a monadic operator

scanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a #

Haskell-style scan

scanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a #

Haskell-style scan with a monadic operator

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

Haskell-style scan with strict accumulator

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

Haskell-style scan with strict accumulator and a monadic operator

scanl1 :: Monad m => (a -> a -> a) -> Stream m a -> Stream m a #

Initial-value free scan over a Stream

scanl1M :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a #

Initial-value free scan over a Stream with a monadic operator

scanl1' :: Monad m => (a -> a -> a) -> Stream m a -> Stream m a #

Initial-value free scan over a Stream with a strict accumulator

scanl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a #

Initial-value free scan over a Stream with a strict accumulator and a monadic operator

Enumerations

enumFromStepN :: (Num a, Monad m) => a -> a -> Int -> Stream m a #

Yield a Stream of the given length containing the values x, x+y, x+y+y etc.

enumFromTo :: (Enum a, Monad m) => a -> a -> Stream m a #

Enumerate values

WARNING: This operation can be very inefficient. If at all possible, use enumFromStepN instead.

enumFromThenTo :: (Enum a, Monad m) => a -> a -> a -> Stream m a #

Enumerate values with a given step.

WARNING: This operation is very inefficient. If at all possible, use enumFromStepN instead.

Conversions

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

Convert a Stream to a list

fromList :: Monad m => [a] -> Stream m a #

Convert a list to a Stream

fromListN :: Monad m => Int -> [a] -> Stream m a #

Convert the first n elements of a list to a Bundle