Data.Vector.Fusion.Stream

| vector-0.7.0.1: Efficient Arrays | Contents | Index
Data.Vector.Fusion.Stream |
Portability | non-portable
Stability | experimental
Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au>
Contents
Types In-place markers Size hints Length information Construction Accessing individual elements Substreams Mapping Zipping Filtering Searching Folding Specialised folds Unfolding Scans Enumerations Conversions Monadic combinators
Description
Streams for stream fusion
Synopsis
data Step s a
= Yield a s
| Skip s
| Done
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
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
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
data Step s a
Result of taking a single step in a stream
Constructors
Yield a s | a new element and a new seed
Skip s | just a new seed
Done | end of stream
type Stream = Stream Id
The type of pure streams
type MStream = Stream
Alternative name for monadic streams
In-place markers
inplace :: (forall m. Monad m => Stream m a -> Stream m b) -> Stream a -> Stream b
Size hints
size :: Stream a -> Size
`Size` hint of a `Stream`
sized :: Stream a -> Size -> Stream a
Attach a `Size` hint to a `Stream`
Length information
length :: Stream a -> Int
Length of a `Stream`
null :: Stream a -> Bool
Check if a `Stream` is empty
Construction
empty :: Stream a
Empty `Stream`
singleton :: a -> Stream a
Singleton `Stream`
cons :: a -> Stream a -> Stream a
Prepend an element
snoc :: Stream a -> a -> Stream a
Append an element
replicate :: Int -> a -> Stream a
Replicate a value to a given length
generate :: Int -> (Int -> a) -> Stream a
Generate a stream from its indices
(++) :: Stream a -> Stream a -> Stream a
Concatenate two `Stream`s
Accessing individual elements
head :: Stream a -> a
First element of the `Stream` or error if empty
last :: Stream a -> a
Last element of the `Stream` or error if empty
(!!) :: Stream a -> Int -> a
Element at the given position
Substreams
slice
:: Int | starting index
-> Int | length
-> Stream a |
-> Stream a |
Extract a substream of the given length starting at the given position.
init :: Stream a -> Stream a
All but the last element
tail :: Stream a -> Stream a
All but the first element
take :: Int -> Stream a -> Stream a
The first `n` elements
drop :: Int -> Stream a -> Stream a
All but the first `n` elements
Mapping
map :: (a -> b) -> Stream a -> Stream b
Map a function over a `Stream`
concatMap :: (a -> Stream b) -> Stream a -> Stream b
flatten :: (a -> s) -> (s -> Step s b) -> Size -> Stream a -> Stream b
Create a `Stream` of values from a `Stream` of streamable things
unbox :: Stream (Box a) -> Stream a
Zipping
indexed :: Stream a -> Stream (Int, a)
Pair each element in a `Stream` with its index
indexedR :: Int -> Stream a -> Stream (Int, a)
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
Zip two `Stream`s with the given function
zipWith3 :: (a -> b -> c -> d) -> Stream a -> Stream b -> Stream c -> Stream d
Zip three `Stream`s with the given function
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)
Filtering
filter :: (a -> Bool) -> Stream a -> Stream a
Drop elements which do not satisfy the predicate
takeWhile :: (a -> Bool) -> Stream a -> Stream a
Longest prefix of elements that satisfy the predicate
dropWhile :: (a -> Bool) -> Stream a -> Stream a
Drop the longest prefix of elements that satisfy the predicate
Searching
elem :: Eq a => a -> Stream a -> Bool
Check whether the `Stream` contains an element
notElem :: Eq a => a -> Stream a -> Bool
Inverse of `elem`
find :: (a -> Bool) -> Stream a -> Maybe a
Yield `Just` the first element matching the predicate or `Nothing` if no such element exists.
findIndex :: (a -> Bool) -> Stream a -> Maybe Int
Yield `Just` the index of the first element matching the predicate or `Nothing` if no such element exists.
Folding
foldl :: (a -> b -> a) -> a -> Stream b -> a
Left fold
foldl1 :: (a -> a -> a) -> Stream a -> a
Left fold on non-empty `Stream`s
foldl' :: (a -> b -> a) -> a -> Stream b -> a
Left fold with strict accumulator
foldl1' :: (a -> a -> a) -> Stream a -> a
Left fold on non-empty `Stream`s with strict accumulator
foldr :: (a -> b -> b) -> b -> Stream a -> b
Right fold
foldr1 :: (a -> a -> a) -> Stream a -> a
Right fold on non-empty `Stream`s
Specialised folds
and :: Stream Bool -> Bool
or :: Stream Bool -> Bool
Unfolding
unfoldr :: (s -> Maybe (a, s)) -> s -> Stream a
Unfold
unfoldrN :: Int -> (s -> Maybe (a, s)) -> s -> Stream a
Unfold at most `n` elements
Scans
prescanl :: (a -> b -> a) -> a -> Stream b -> Stream a
Prefix scan
prescanl' :: (a -> b -> a) -> a -> Stream b -> Stream a
Prefix scan with strict accumulator
postscanl :: (a -> b -> a) -> a -> Stream b -> Stream a
Suffix scan
postscanl' :: (a -> b -> a) -> a -> Stream b -> Stream a
Suffix scan with strict accumulator
scanl :: (a -> b -> a) -> a -> Stream b -> Stream a
Haskell-style scan
scanl' :: (a -> b -> a) -> a -> Stream b -> Stream a
Haskell-style scan with strict accumulator
scanl1 :: (a -> a -> a) -> Stream a -> Stream a
Scan over a non-empty `Stream`
scanl1' :: (a -> a -> a) -> Stream a -> Stream a
Scan over a non-empty `Stream` with a strict accumulator
Enumerations
enumFromStepN :: Num a => a -> a -> Int -> Stream a
Yield a `Stream` of the given length containing the values `x`, `x+y`, `x+y+y` etc.
enumFromTo :: Enum a => a -> a -> Stream a
Enumerate values WARNING: This operations can be very inefficient. If at all possible, use `enumFromStepN` instead.
enumFromThenTo :: Enum a => a -> a -> a -> Stream a
Enumerate values with a given step. WARNING: This operations is very inefficient. If at all possible, use `enumFromStepN` instead.
Conversions
toList :: Stream a -> [a]
Convert a `Stream` to a list
fromList :: [a] -> Stream a
Create a `Stream` from a list
fromListN :: Int -> [a] -> Stream a
Create a `Stream` from the first `n` elements of a list
     fromListN n xs = fromList (take n xs)
unsafeFromList :: Size -> [a] -> Stream a
liftStream :: Monad m => Stream a -> Stream m a
Convert a pure stream to a monadic stream
Monadic combinators
mapM :: Monad m => (a -> m b) -> Stream a -> Stream m b
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 ()
Apply a monadic action to each element of the stream
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
Yield a monadic stream of elements that satisfy the monadic predicate
foldM :: Monad m => (a -> b -> m a) -> a -> Stream b -> m a
Monadic fold
fold1M :: Monad m => (a -> a -> m a) -> Stream a -> m a
Monadic fold over non-empty stream
foldM' :: Monad m => (a -> b -> m a) -> a -> Stream b -> m a
Monadic fold with strict accumulator
fold1M' :: Monad m => (a -> a -> m a) -> Stream a -> m a
Monad fold over non-empty stream with strict accumulator
eq :: Eq a => Stream a -> Stream a -> Bool
Check if two `Stream`s are equal
cmp :: Ord a => Stream a -> Stream a -> Ordering
Lexicographically compare two `Stream`s
Produced by Haddock version 2.7.2