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 | Haskell98 |

Streams for stream fusion

- data Step s a
- type Stream = Stream Id
- type MStream = Stream
- inplace :: (forall m. Monad m => Stream m a -> Stream m b) -> Stream a -> Stream b
- size :: Stream a -> Size
- sized :: Stream a -> Size -> Stream a
- length :: Stream a -> Int
- null :: Stream a -> Bool
- empty :: Stream a
- singleton :: a -> Stream a
- cons :: a -> Stream a -> Stream a
- snoc :: Stream a -> a -> Stream a
- replicate :: Int -> a -> Stream a
- generate :: Int -> (Int -> a) -> Stream a
- (++) :: Stream a -> Stream a -> Stream a
- head :: Stream a -> a
- last :: Stream a -> a
- (!!) :: Stream a -> Int -> a
- (!?) :: Stream a -> Int -> Maybe a
- slice :: Int -> Int -> Stream a -> Stream a
- init :: Stream a -> Stream a
- tail :: Stream a -> Stream a
- take :: Int -> Stream a -> Stream a
- drop :: Int -> Stream a -> Stream a
- map :: (a -> b) -> Stream a -> Stream b
- concatMap :: (a -> Stream b) -> Stream a -> Stream b
- flatten :: (a -> s) -> (s -> Step s b) -> Size -> Stream a -> Stream b
- unbox :: Stream (Box a) -> Stream a
- indexed :: Stream a -> Stream (Int, a)
- indexedR :: Int -> Stream a -> Stream (Int, a)
- zipWith :: (a -> b -> c) -> Stream a -> Stream b -> Stream c
- zipWith3 :: (a -> b -> c -> d) -> Stream a -> Stream b -> Stream c -> Stream d
- zipWith4 :: (a -> b -> c -> d -> e) -> Stream a -> Stream b -> Stream c -> Stream d -> Stream e
- zipWith5 :: (a -> b -> c -> d -> e -> f) -> Stream a -> Stream b -> Stream c -> Stream d -> Stream e -> Stream f
- zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Stream a -> Stream b -> Stream c -> Stream d -> Stream e -> Stream f -> Stream g
- zip :: Stream a -> Stream b -> Stream (a, b)
- zip3 :: Stream a -> Stream b -> Stream c -> Stream (a, b, c)
- zip4 :: Stream a -> Stream b -> Stream c -> Stream d -> Stream (a, b, c, d)
- zip5 :: Stream a -> Stream b -> Stream c -> Stream d -> Stream e -> Stream (a, b, c, d, e)
- zip6 :: Stream a -> Stream b -> Stream c -> Stream d -> Stream e -> Stream f -> Stream (a, b, c, d, e, f)
- filter :: (a -> Bool) -> Stream a -> Stream a
- takeWhile :: (a -> Bool) -> Stream a -> Stream a
- dropWhile :: (a -> Bool) -> Stream a -> Stream a
- elem :: Eq a => a -> Stream a -> Bool
- notElem :: Eq a => a -> Stream a -> Bool
- find :: (a -> Bool) -> Stream a -> Maybe a
- findIndex :: (a -> Bool) -> Stream a -> Maybe Int
- foldl :: (a -> b -> a) -> a -> Stream b -> a
- foldl1 :: (a -> a -> a) -> Stream a -> a
- foldl' :: (a -> b -> a) -> a -> Stream b -> a
- foldl1' :: (a -> a -> a) -> Stream a -> a
- foldr :: (a -> b -> b) -> b -> Stream a -> b
- foldr1 :: (a -> a -> a) -> Stream a -> a
- and :: Stream Bool -> Bool
- or :: Stream Bool -> Bool
- unfoldr :: (s -> Maybe (a, s)) -> s -> Stream a
- unfoldrN :: Int -> (s -> Maybe (a, s)) -> s -> Stream a
- iterateN :: Int -> (a -> a) -> a -> Stream a
- prescanl :: (a -> b -> a) -> a -> Stream b -> Stream a
- prescanl' :: (a -> b -> a) -> a -> Stream b -> Stream a
- postscanl :: (a -> b -> a) -> a -> Stream b -> Stream a
- postscanl' :: (a -> b -> a) -> a -> Stream b -> Stream a
- scanl :: (a -> b -> a) -> a -> Stream b -> Stream a
- scanl' :: (a -> b -> a) -> a -> Stream b -> Stream a
- scanl1 :: (a -> a -> a) -> Stream a -> Stream a
- scanl1' :: (a -> a -> a) -> Stream a -> Stream a
- enumFromStepN :: Num a => a -> a -> Int -> Stream a
- enumFromTo :: Enum a => a -> a -> Stream a
- enumFromThenTo :: Enum a => a -> a -> a -> Stream a
- toList :: Stream a -> [a]
- fromList :: [a] -> Stream a
- fromListN :: Int -> [a] -> Stream a
- unsafeFromList :: Size -> [a] -> Stream a
- liftStream :: Monad m => Stream a -> Stream m a
- mapM :: Monad m => (a -> m b) -> Stream a -> Stream m b
- mapM_ :: Monad m => (a -> m b) -> Stream a -> m ()
- zipWithM :: Monad m => (a -> b -> m c) -> Stream a -> Stream b -> Stream m c
- zipWithM_ :: Monad m => (a -> b -> m c) -> Stream a -> Stream b -> m ()
- filterM :: Monad m => (a -> m Bool) -> Stream a -> Stream m a
- foldM :: Monad m => (a -> b -> m a) -> a -> Stream b -> m a
- fold1M :: Monad m => (a -> a -> m a) -> Stream a -> m a
- foldM' :: Monad m => (a -> b -> m a) -> a -> Stream b -> m a
- fold1M' :: Monad m => (a -> a -> m a) -> Stream a -> m a
- eq :: Eq a => Stream a -> Stream a -> Bool
- cmp :: Ord a => Stream a -> Stream a -> Ordering

# Types

Result of taking a single step in a stream

# In-place markers

# Size hints

# Length information

# Construction

# Accessing individual elements

(!?) :: Stream a -> Int -> 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

# Zipping

indexedR :: Int -> Stream a -> Stream (Int, a) Source

Pair each element in a `Stream`

with its index, starting from the right
and counting down

zipWith :: (a -> b -> c) -> Stream a -> Stream b -> Stream c Source

Zip two `Stream`

s with the given function

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

Zip three `Stream`

s with the given function

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

zipWith5 :: (a -> b -> c -> d -> e -> f) -> Stream a -> Stream b -> Stream c -> Stream d -> Stream e -> Stream f Source

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Stream a -> Stream b -> Stream c -> Stream d -> Stream e -> Stream f -> Stream g Source

zip6 :: Stream a -> Stream b -> Stream c -> Stream d -> Stream e -> Stream f -> Stream (a, b, c, d, e, f) Source

# Filtering

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

Drop elements which do not satisfy the predicate

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

Longest prefix of elements that satisfy the predicate

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

Drop the longest prefix of elements that satisfy the predicate

# Searching

# Folding

foldl1' :: (a -> a -> a) -> Stream a -> a Source

Left fold on non-empty `Stream`

s with strict accumulator

# Specialised folds

# Unfolding

iterateN :: Int -> (a -> a) -> a -> Stream a Source

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

# Scans

postscanl' :: (a -> b -> a) -> a -> Stream b -> Stream a Source

Suffix scan with strict accumulator

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

Haskell-style scan with strict accumulator

scanl1' :: (a -> a -> a) -> Stream a -> Stream a Source

Scan over a non-empty `Stream`

with a strict accumulator

# Enumerations

enumFromStepN :: Num a => a -> a -> Int -> Stream a Source

Yield a `Stream`

of the given length containing the values `x`

, `x+y`

,
`x+y+y`

etc.

enumFromTo :: Enum a => a -> a -> Stream a Source

Enumerate values

*WARNING:* This operations can be very inefficient. If at all possible, use
`enumFromStepN`

instead.

enumFromThenTo :: Enum a => a -> a -> a -> Stream a Source

Enumerate values with a given step.

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

instead.

# Conversions

fromListN :: Int -> [a] -> Stream a Source

Create a `Stream`

from the first `n`

elements of a list

fromListN n xs = fromList (take n xs)

unsafeFromList :: Size -> [a] -> Stream a Source

liftStream :: Monad m => Stream a -> Stream m a Source

Convert a pure stream to a monadic stream

# Monadic combinators

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

Apply a monadic action to each element of the stream, producing a monadic stream of results

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

Apply a monadic action to each element of the stream

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

Yield a monadic stream of elements that satisfy the monadic predicate

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

Monadic fold with strict accumulator