vector-0.10.9.1: Efficient Arrays

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

Data.Vector.Fusion.Stream

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

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 infixr 5

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 infixl 9

Element at the given position

(!?) :: Stream a -> Int -> Maybe a infixl 9

Element at the given position or `Nothing` if out of bounds

# Substreams

slice

Arguments

:: 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 infix 4

Check whether the `Stream` contains an element

notElem :: Eq a => a -> Stream a -> Bool infix 4

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

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

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

# 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