Copyright | (c) Roman Leshchinskiy 2008-2010 |
---|---|

License | BSD-style |

Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au> |

Stability | experimental |

Portability | non-portable |

Safe Haskell | None |

Language | Haskell2010 |

Monadic stream combinators.

- data Stream m a = forall s . Stream (s -> m (Step s a)) s
- data Step s a where
- data SPEC :: *
- 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 :: Monad m => Stream m a -> m a
- last :: Monad m => Stream m a -> m a
- (!!) :: 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 :: Monad m => Stream m a -> Stream m a
- tail :: 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)
- eq :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool
- cmp :: (Monad m, Ord a) => Stream m a -> Stream m a -> 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
- 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 :: 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' :: 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 :: 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
- 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

# Documentation

Monadic streams

Result of taking a single step in a stream

data SPEC :: *

SPEC is used by GHC in the `SpecConstr`

pass in order to inform
the compiler when to be particularly aggressive. In particular, it
tells GHC to specialize regardless of size or the number of
specializations. However, not all loops fall into this category.

Libraries can specify this by using `SPEC`

data type to inform which
loops should be aggressively specialized.

# Length

# Construction

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

Yield a `Stream`

of values obtained by performing the monadic action the
given number of times

# Accessing elements

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

Element at the given position or `Nothing`

if out of bounds

# Substreams

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

# Mapping

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

Map a monadic function over a `Stream`

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

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 Source

Transform a `Stream`

to use a different monad

# Zipping

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

Pair each element in a `Stream`

with its index

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

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 -> Stream m c Source

Zip two `Stream`

s 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 Source

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

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 Source

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 Source

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

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

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 Source

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 Source

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

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) Source

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) Source

# Comparisons

cmp :: (Monad m, Ord a) => Stream m a -> Stream m a -> m Ordering Source

Lexicographically compare two `Stream`

s

# Filtering

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

Drop elements which do not satisfy the predicate

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

Drop elements which do not satisfy the monadic predicate

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

Longest prefix of elements that satisfy the predicate

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

Longest prefix of elements that satisfy the monadic predicate

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

Drop the longest prefix of elements that satisfy the predicate

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

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 Source

Check whether the `Stream`

contains an element

# Folding

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

Left fold with a monadic operator

foldl1M :: Monad m => (a -> a -> m a) -> Stream m a -> m a Source

Left fold over a non-empty `Stream`

with a monadic operator

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

Left fold with a strict accumulator

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

Left fold with a strict accumulator and a monadic operator

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

Left fold over a non-empty `Stream`

with a strict accumulator

foldl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> m a Source

Left fold over a non-empty `Stream`

with a strict accumulator and a
monadic operator

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

Right fold with a monadic operator

foldr1M :: Monad m => (a -> a -> m a) -> Stream m a -> m a Source

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

# Specialised folds

# Unfolding

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

Unfold with a monadic function

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

Unfold at most `n`

elements with a monadic functions

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

Apply function n times to value. Zeroth element is original value.

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

Apply monadic function n times to value. Zeroth element is original value.

# Scans

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

Prefix scan with a monadic operator

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

Prefix scan with strict accumulator

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

Prefix scan with strict accumulator and a monadic operator

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

Suffix scan with a monadic operator

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

Suffix scan with strict accumulator

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

Suffix scan with strict acccumulator and a monadic operator

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

Haskell-style scan with a monadic operator

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

Haskell-style scan with strict accumulator

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

Haskell-style scan with strict accumulator and a monadic operator

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

Scan over a non-empty `Stream`

with a monadic operator

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

Scan over a non-empty `Stream`

with a strict accumulator

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

Scan over a non-empty `Stream`

with a strict accumulator and a monadic
operator

# Enumerations

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

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 Source

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 Source

Enumerate values with a given step.

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

instead.