-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | A library for manipulating infinite lists.
--
-- This package implements functions, analogous to those from Data.List,
-- to create and manipulate infinite lists: data Stream a = Cons a
-- (Stream a). It provides alternative definitions for those Prelude
-- functions that make sense on such streams. Note that this package has
-- (almost) nothing to do with the work on Stream Fusion by Duncan
-- Coutts, Roman Leshchinskiy, and Don Stewart.
@package Stream
@version 0.2.6
-- | Streams are infinite lists. Most operations on streams are completely
-- analogous to the definition in Data.List.
module Data.Stream
-- | An infinite sequence.
--
-- Beware: If you use any function from the Eq or
-- Ord class two compare to equal streams, these functions will
-- diverge.
data Stream a
Cons :: a -> (Stream a) -> Stream a
-- | The <:> operator is an infix version of the
-- Cons constructor.
(<:>) :: a -> Stream a -> Stream a
-- | Extract the first element of the sequence.
head :: Stream a -> a
-- | Extract the sequence following the head of the stream.
tail :: Stream a -> Stream a
-- | The inits function takes a stream xs and returns all
-- the finite prefixes of xs.
inits :: Stream a -> Stream ([a])
-- | The tails function takes a stream xs and returns all
-- the suffixes of xs.
tails :: Stream a -> Stream (Stream a)
-- | Apply a function uniformly over all elements of a sequence.
map :: (a -> b) -> Stream a -> Stream b
-- | intersperse y xs creates an alternating
-- stream of elements from xs and y.
intersperse :: a -> Stream a -> Stream a
-- | Interleave two Streams xs and ys, alternating
-- elements from each list.
--
--
-- @[x1,x2,...] `interleave` [y1,y2,...] == [x1,y1,x2,y2,...]@
--
interleave :: Stream a -> Stream a -> Stream a
-- | scanl yields a stream of successive reduced values from the |
-- left:
--
--
-- scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
--
scanl :: (a -> b -> a) -> a -> Stream b -> Stream a
-- | scanl1 is a variant of scanl that has no starting value
-- argument:
--
--
-- scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
--
scanl1 :: (a -> a -> a) -> Stream 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), ..]
--
iterate :: (a -> a) -> a -> Stream a
-- | repeat x returns a constant stream, where all elements
-- are equal to x.
repeat :: 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 ...
--
cycle :: [a] -> Stream a
-- | The unfold function is similar to the unfold for lists. Note there is
-- no base case: all streams must be infinite.
unfold :: (c -> (a, c)) -> c -> Stream a
-- | take n xs returns the first n
-- elements of xs.
--
-- Beware: passing a negative integer as the first argument will
-- cause an error.
take :: Int -> Stream a -> [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.
drop :: Int -> Stream 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.
splitAt :: Int -> Stream a -> ([a], Stream a)
-- | takeWhile p xs returns the longest prefix of
-- the stream xs for which the predicate p holds.
takeWhile :: (a -> Bool) -> Stream a -> [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.
dropWhile :: (a -> Bool) -> Stream a -> Stream a
-- | span p xs returns the longest prefix of
-- xs that satisfies p, together with the remainder of
-- the stream.
span :: (a -> Bool) -> Stream a -> ([a], Stream a)
-- | The break p function is equivalent to span
-- not . p.
break :: (a -> Bool) -> Stream a -> ([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.
filter :: (a -> Bool) -> 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.
partition :: (a -> Bool) -> Stream a -> (Stream a, Stream a)
-- | The isPrefix function returns True if the first
-- argument is a prefix of the second.
isPrefixOf :: (Eq a) => [a] -> Stream a -> Bool
-- | 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.
(!!) :: Stream a -> Int -> a
-- | The zip function takes two streams and returns a list of
-- corresponding pairs.
zip :: Stream a -> Stream b -> Stream (a, b)
-- | The zipWith function generalizes zip. Rather than
-- tupling the functions, the elements are combined using the function
-- passed as the first argument to zipWith.
zipWith :: (a -> b -> c) -> Stream a -> Stream b -> Stream c
-- | The unzip function is the inverse of the zip function.
unzip :: Stream (a, b) -> (Stream a, Stream b)
-- | 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.
words :: Stream Char -> Stream String
-- | The unwords function is an inverse operation to words.
-- It joins words with separating spaces.
unwords :: Stream String -> Stream Char
-- | 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.
lines :: Stream Char -> Stream String
-- | The unlines function is an inverse operation to lines.
-- It joins lines, after appending a terminating newline to each.
unlines :: Stream String -> Stream Char
-- | The listToStream converts an infinite list to a stream.
--
-- Beware: Passing a finite list, will cause an error.
listToStream :: [a] -> Stream a
-- | The streamToList converts a stream into an infinite list.
streamToList :: Stream a -> [a]
instance (Eq a) => Eq (Stream a)
instance (Ord a) => Ord (Stream a)
instance (Show a) => Show (Stream a)
instance (Arbitrary a) => Arbitrary (Stream a)
instance Monad Stream
instance Applicative Stream
instance Functor Stream