vector-0.6.0.1: Efficient ArraysSource codeContentsIndex
Data.Vector.Fusion.Stream
Portabilitynon-portable
Stabilityexperimental
MaintainerRoman 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
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 Source
Result of taking a single step in a stream
Constructors
Yield a sa new element and a new seed
Skip sjust a new seed
Doneend of stream
type Stream = Stream IdSource
The type of pure streams
type MStream = StreamSource
Alternative name for monadic streams
In-place markers
inplace :: (forall m. Monad m => Stream m a -> Stream m b) -> Stream a -> Stream bSource
Size hints
size :: Stream a -> SizeSource
Size hint of a Stream
sized :: Stream a -> Size -> Stream aSource
Attach a Size hint to a Stream
Length information
length :: Stream a -> IntSource
Length of a Stream
null :: Stream a -> BoolSource
Check if a Stream is empty
Construction
empty :: Stream aSource
Empty Stream
singleton :: a -> Stream aSource
Singleton Stream
cons :: a -> Stream a -> Stream aSource
Prepend an element
snoc :: Stream a -> a -> Stream aSource
Append an element
replicate :: Int -> a -> Stream aSource
Replicate a value to a given length
generate :: Int -> (Int -> a) -> Stream aSource
Generate a stream from its indices
(++) :: Stream a -> Stream a -> Stream aSource
Concatenate two Streams
Accessing individual elements
head :: Stream a -> aSource
First element of the Stream or error if empty
last :: Stream a -> aSource
Last element of the Stream or error if empty
(!!) :: Stream a -> Int -> aSource
Element at the given position
Substreams
sliceSource
::
=> Intstarting index
-> Intlength
-> Stream a
-> Stream a
Extract a substream of the given length starting at the given position.
init :: Stream a -> Stream aSource
All but the last element
tail :: Stream a -> Stream aSource
All but the first element
take :: Int -> Stream a -> Stream aSource
The first n elements
drop :: Int -> Stream a -> Stream aSource
All but the first n elements
Mapping
map :: (a -> b) -> Stream a -> Stream bSource
Map a function over a Stream
concatMap :: (a -> Stream b) -> Stream a -> Stream bSource
unbox :: Stream (Box a) -> Stream aSource
Zipping
indexed :: Stream a -> Stream (Int, a)Source
Pair each element in a Stream with its index
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 cSource
Zip two Streams with the given function
zipWith3 :: (a -> b -> c -> d) -> Stream a -> Stream b -> Stream c -> Stream dSource
Zip three Streams with the given function
zipWith4 :: (a -> b -> c -> d -> e) -> Stream a -> Stream b -> Stream c -> Stream d -> Stream eSource
zipWith5 :: (a -> b -> c -> d -> e -> f) -> Stream a -> Stream b -> Stream c -> Stream d -> Stream e -> Stream fSource
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Stream a -> Stream b -> Stream c -> Stream d -> Stream e -> Stream f -> Stream gSource
zip :: Stream a -> Stream b -> Stream (a, b)Source
zip3 :: Stream a -> Stream b -> Stream c -> Stream (a, b, c)Source
zip4 :: Stream a -> Stream b -> Stream c -> Stream d -> Stream (a, b, c, d)Source
zip5 :: Stream a -> Stream b -> Stream c -> Stream d -> Stream e -> Stream (a, b, c, d, e)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 aSource
Drop elements which do not satisfy the predicate
takeWhile :: (a -> Bool) -> Stream a -> Stream aSource
Longest prefix of elements that satisfy the predicate
dropWhile :: (a -> Bool) -> Stream a -> Stream aSource
Drop the longest prefix of elements that satisfy the predicate
Searching
elem :: Eq a => a -> Stream a -> BoolSource
Check whether the Stream contains an element
notElem :: Eq a => a -> Stream a -> BoolSource
Inverse of elem
find :: (a -> Bool) -> Stream a -> Maybe aSource
Yield Just the first element matching the predicate or Nothing if no such element exists.
findIndex :: (a -> Bool) -> Stream a -> Maybe IntSource
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 -> aSource
Left fold
foldl1 :: (a -> a -> a) -> Stream a -> aSource
Left fold on non-empty Streams
foldl' :: (a -> b -> a) -> a -> Stream b -> aSource
Left fold with strict accumulator
foldl1' :: (a -> a -> a) -> Stream a -> aSource
Left fold on non-empty Streams with strict accumulator
foldr :: (a -> b -> b) -> b -> Stream a -> bSource
Right fold
foldr1 :: (a -> a -> a) -> Stream a -> aSource
Right fold on non-empty Streams
Specialised folds
and :: Stream Bool -> BoolSource
or :: Stream Bool -> BoolSource
Unfolding
unfoldr :: (s -> Maybe (a, s)) -> s -> Stream aSource
Unfold
unfoldrN :: Int -> (s -> Maybe (a, s)) -> s -> Stream aSource
Unfold at most n elements
Scans
prescanl :: (a -> b -> a) -> a -> Stream b -> Stream aSource
Prefix scan
prescanl' :: (a -> b -> a) -> a -> Stream b -> Stream aSource
Prefix scan with strict accumulator
postscanl :: (a -> b -> a) -> a -> Stream b -> Stream aSource
Suffix scan
postscanl' :: (a -> b -> a) -> a -> Stream b -> Stream aSource
Suffix scan with strict accumulator
scanl :: (a -> b -> a) -> a -> Stream b -> Stream aSource
Haskell-style scan
scanl' :: (a -> b -> a) -> a -> Stream b -> Stream aSource
Haskell-style scan with strict accumulator
scanl1 :: (a -> a -> a) -> Stream a -> Stream aSource
Scan over a non-empty Stream
scanl1' :: (a -> a -> a) -> Stream a -> Stream aSource
Scan over a non-empty Stream with a strict accumulator
Enumerations
enumFromStepN :: Num a => a -> a -> Int -> Stream aSource
Yield a Stream of the given length containing the values x, x+y, x+y+y etc.
enumFromTo :: Enum a => a -> a -> Stream aSource

Enumerate values

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

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

Enumerate values with a given step.

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

Conversions
toList :: Stream a -> [a]Source
Convert a Stream to a list
fromList :: [a] -> Stream aSource
Create a Stream from a list
fromListN :: Int -> [a] -> Stream aSource

Create a Stream from the first n elements of a list

 fromListN n xs = fromList (take n xs)
unsafeFromList :: Size -> [a] -> Stream aSource
liftStream :: Monad m => Stream a -> Stream m aSource
Convert a pure stream to a monadic stream
Monadic combinators
mapM :: Monad m => (a -> m b) -> Stream a -> Stream m bSource
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
zipWithM :: Monad m => (a -> b -> m c) -> Stream a -> Stream b -> Stream m cSource
zipWithM_ :: Monad m => (a -> b -> m c) -> Stream a -> Stream b -> m ()Source
filterM :: Monad m => (a -> m Bool) -> Stream a -> Stream m aSource
Yield a monadic stream of elements that satisfy the monadic predicate
foldM :: Monad m => (a -> b -> m a) -> a -> Stream b -> m aSource
Monadic fold
fold1M :: Monad m => (a -> a -> m a) -> Stream a -> m aSource
Monadic fold over non-empty stream
foldM' :: Monad m => (a -> b -> m a) -> a -> Stream b -> m aSource
Monadic fold with strict accumulator
fold1M' :: Monad m => (a -> a -> m a) -> Stream a -> m aSource
Monad fold over non-empty stream with strict accumulator
eq :: Eq a => Stream a -> Stream a -> BoolSource
Check if two Streams are equal
cmp :: Ord a => Stream a -> Stream a -> OrderingSource
Lexicographically compare two Streams
Produced by Haddock version 2.4.2