 | Stream-0.2.1: A library for manipulating infinite lists. | Contents | Index |
|
|
|
|
|
| Description |
| Streams are infinite lists. Most operations on streams are
completely analogous to the definition in Data.List.
|
|
| Synopsis |
|
|
|
|
| The type of streams
|
|
| data Stream a |
| An infinite sequence.
| | Constructors | |  Instances | |
|
|
| Basic functions
|
|
| (<:>) :: a -> Stream a -> Stream a |
| The <:> operator is an infix version of the Cons
constructor.
|
|
| head :: Stream a -> a |
| Extract the first element of the sequence.
|
|
| tail :: Stream a -> Stream a |
| Extract the sequence following the head of the stream.
|
|
| inits :: Stream a -> Stream [a] |
| The inits function takes a stream xs and returns all the
finite prefixes of xs.
|
|
| tails :: Stream a -> Stream (Stream a) |
| The tails function takes a stream xs and returns all the
suffixes of xs.
|
|
| Stream transformations
|
|
| map :: (a -> b) -> Stream a -> Stream b |
| Apply a function uniformly over all elements of a sequence.
|
|
| intersperse :: a -> Stream a -> Stream a |
| intersperse y xs creates an alternating stream of
elements from xs and y.
|
|
| Building streams
|
|
| iterate :: (a -> a) -> a -> Stream a |
iterate f x function produces the infinite sequence
of repeated applications of f to x.
iterate f x = [x, f x, f (f x), ..]
|
|
| repeat :: a -> Stream a |
| repeat x returns a constant stream, where all elements are
equal to x.
|
|
| cycle :: [a] -> Stream a |
cycle xs returns the infinite repetition of xs:
cycle [1,2,3] = Cons 1 (Cons 2 (Cons 3 (Cons 1 (Cons 2 ...
|
|
| unfold :: (c -> (a, c)) -> c -> Stream a |
| The unfold function is similar to the unfold for lists. Note
there is no base case: all streams must be infinite.
|
|
| Extracting sublists
|
|
| take :: Int -> Stream a -> [a] |
take n xs returns the first n elements of xs.
Beware: passing a negative integer as the first argument will
cause an error.
|
|
| drop :: Int -> Stream a -> Stream a |
drop n xs drops the first n elements off the front of
the sequence xs.
Beware: passing a negative integer as the first argument will
cause an error.
|
|
| splitAt :: Int -> Stream a -> ([a], Stream a) |
The splitAt function takes an integer n and a stream xs
and returns a pair consisting of the prefix of xs of length
n and the remaining stream immediately following this prefix.
Beware: passing a negative integer as the first argument will
cause an error.
|
|
| takeWhile :: (a -> Bool) -> Stream a -> [a] |
| takeWhile p xs returns the longest prefix of the stream
xs for which the predicate p holds.
|
|
| dropWhile :: (a -> Bool) -> Stream a -> Stream a |
dropWhile p xs returns the suffix remaining after
takeWhile p xs.
Beware: this function may diverge if every element of xs
satisfies p, e.g. dropWhile even (repeat 0) will loop.
|
|
| span :: (a -> Bool) -> Stream a -> ([a], Stream a) |
| span p xs returns the longest prefix of xs that satisfies
p, together with the remainder of the stream.
|
|
| break :: (a -> Bool) -> Stream a -> ([a], Stream a) |
| The break p function is equivalent to span not . p.
|
|
| filter :: (a -> Bool) -> Stream a -> Stream a |
filter p xs, removes any elements from xs that do not satisfy p.
Beware: this function may diverge if there is no element of
xs that satisfies p, e.g. filter odd (repeat 0) will loop.
|
|
| partition :: (a -> Bool) -> Stream a -> (Stream a, Stream a) |
The partition function takes a predicate p and a stream
xs, and returns a pair of streams. The first stream corresponds
to the elements of xs for which p holds; the second stream
corresponds to the elements of xs for which p does not hold.
Beware: One of the elements of the tuple may be undefined. For
example, fst (partition even (repeat 0)) == repeat 0; on the
other hand snd (partition even (repeat 0)) is undefined.
|
|
| Sublist predicates
|
|
| isPrefixOf :: Eq a => [a] -> Stream a -> Bool |
| The isPrefix function returns True if the first argument is
a prefix of the second.
|
|
| Indexing streams
|
|
| (!!) :: Stream a -> Int -> a |
xs !! n returns the element of the stream xs at index
n. Note that the head of the stream has index 0.
Beware: passing a negative integer as the first argument will cause
an error.
|
|
| Zipping and unzipping streams
|
|
| zip :: Stream a -> Stream b -> Stream (a, b) |
| The zip function takes two streams and returns a list of
corresponding pairs.
|
|
| zipWith :: (a -> b -> c) -> Stream a -> Stream b -> Stream c |
| The zipWith function generalizes zip. Rather than tupling
the functions, the elements are combined using the function
passed as the first argument to zipWith.
|
|
| unzip :: Stream (a, b) -> (Stream a, Stream b) |
| The unzip function is the inverse of the zip function.
|
|
| Functions on streams of characters
|
|
| words :: Stream Char -> Stream String |
The words function breaks a stream of characters into a
stream of words, which were delimited by white space.
Beware: if the stream of characters xs does not contain white
space, accessing the tail of words xs will loop.
|
|
| unwords :: Stream String -> Stream Char |
| The unwords function is an inverse operation to words. It
joins words with separating spaces.
|
|
| lines :: Stream Char -> Stream String |
The lines function breaks a stream of characters into a list
of strings at newline characters. The resulting strings do not
contain newlines.
Beware: if the stream of characters xs does not contain
newline characters, accessing the tail of lines xs will loop.
|
|
| unlines :: Stream String -> Stream Char |
| The unlines function is an inverse operation to lines. It
joins lines, after appending a terminating newline to each.
|
|
| Converting to and from an infinite list
|
|
| listToStream :: [a] -> Stream a |
The listToStream converts an infinite list to a
stream.
Beware: Passing a finite list, will cause an error.
|
|
| streamToList :: Stream a -> [a] |
| The streamToList converts a stream into an infinite list.
|
|
| Produced by Haddock version 0.8 |