Data.Text.Fusion.Common

Common stream fusion functionality for text.

Creation and elimination

singleton :: Char -> Stream Char

streamList :: [a] -> Stream a

unstreamList :: Stream a -> [a]

Basic interface

cons :: Char -> Stream Char -> Stream Char

O(n) Adds a character to the front of a Stream Char.

snoc :: Stream Char -> Char -> Stream Char

O(n) Adds a character to the end of a stream.

append :: Stream Char -> Stream Char -> Stream Char

O(n) Appends one Stream to the other.

head :: Stream Char -> Char

O(1) Returns the first character of a Text, which must be non-empty. Subject to array fusion.

uncons :: Stream Char -> Maybe (Char, Stream Char)

O(1) Returns the first character and remainder of a 'Stream Char', or Nothing if empty. Subject to array fusion.

last :: Stream Char -> Char

O(n) Returns the last character of a 'Stream Char', which must be non-empty.

tail :: Stream Char -> Stream Char

O(1) Returns all characters after the head of a Stream Char, which must be non-empty.

init :: Stream Char -> Stream Char

O(1) Returns all but the last character of a Stream Char, which must be non-empty.

null :: Stream Char -> Bool

O(1) Tests whether a Stream Char is empty or not.

lengthI :: Integral a => Stream Char -> a

O(n) Returns the number of characters in a text.

Transformations

map :: (Char -> Char) -> Stream Char -> Stream Char

O(n) map f xs is the Stream Char obtained by applying f to each element of xs.

intercalate :: Stream Char -> [Stream Char] -> Stream Char

intersperse :: Char -> Stream Char -> Stream Char

O(n) Take a character and place it between each of the characters of a 'Stream Char'.

Folds

foldl :: (b -> Char -> b) -> b -> Stream Char -> b

foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a Stream, reduces the Stream using the binary operator, from left to right.

foldl' :: (b -> Char -> b) -> b -> Stream Char -> b

A strict version of foldl.

foldl1 :: (Char -> Char -> Char) -> Stream Char -> Char

foldl1 is a variant of foldl that has no starting value argument, and thus must be applied to non-empty Streams.

foldl1' :: (Char -> Char -> Char) -> Stream Char -> Char

A strict version of foldl1.

foldr :: (Char -> b -> b) -> b -> Stream Char -> b

foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a stream, reduces the stream using the binary operator, from right to left.

foldr1 :: (Char -> Char -> Char) -> Stream Char -> Char

foldr1 is a variant of foldr that has no starting value argument, and thus must be applied to non-empty streams. Subject to array fusion.

Special folds

concat :: [Stream Char] -> Stream Char

O(n) Concatenate a list of streams. Subject to array fusion.

concatMap :: (Char -> Stream Char) -> Stream Char -> Stream Char

Map a function over a stream that results in a stream and concatenate the results.

any :: (Char -> Bool) -> Stream Char -> Bool

O(n) any p xs determines if any character in the stream xs satisifes the predicate p.

all :: (Char -> Bool) -> Stream Char -> Bool

O(n) all p xs determines if all characters in the Text xs satisify the predicate p.

maximum :: Stream Char -> Char

O(n) maximum returns the maximum value from a stream, which must be non-empty.

minimum :: Stream Char -> Char

O(n) minimum returns the minimum value from a Text, which must be non-empty.

Construction

Scans

scanl :: (Char -> Char -> Char) -> Char -> Stream Char -> Stream Char

Accumulating maps

mapAccumL :: (a -> b -> (a, b)) -> a -> Stream b -> Stream b

O(n) Like a combination of map and foldl. Applies a function to each element of a stream, passing an accumulating parameter from left to right, and returns a final stream.

Note: Unlike the version over lists, this function does not return a final value for the accumulator, because the nature of streams precludes it.

Generation and unfolding

replicate :: Int -> Char -> Stream Char

unfoldr :: (a -> Maybe (Char, a)) -> a -> Stream Char

O(n), where n is the length of the result. The unfoldr function is analogous to the List unfoldr. unfoldr builds a stream from a seed value. The function takes the element and returns Nothing if it is done producing the stream or returns Just (a,b), in which case, a is the next Char in the string, and b is the seed value for further production.

unfoldrNI :: Integral a => a -> (b -> Maybe (Char, b)) -> b -> Stream Char

O(n) Like unfoldr, unfoldrNI builds a stream from a seed value. However, the length of the result is limited by the first argument to unfoldrNI. This function is more efficient than unfoldr when the length of the result is known.

Substrings

Breaking strings

take :: Integral a => a -> Stream Char -> Stream Char

O(n) take n, applied to a stream, returns the prefix of the stream of length n, or the stream itself if n is greater than the length of the stream.

drop :: Integral a => a -> Stream Char -> Stream Char

O(n) drop n, applied to a stream, returns the suffix of the stream of length n, or the empty stream if n is greater than the length of the stream.

takeWhile :: (Char -> Bool) -> Stream Char -> Stream Char

takeWhile, applied to a predicate p and a stream, returns the longest prefix (possibly empty) of elements that satisfy p.

dropWhile :: (Char -> Bool) -> Stream Char -> Stream Char

dropWhile p xs returns the suffix remaining after takeWhile p xs.

Predicates

isPrefixOf :: Eq a => Stream a -> Stream a -> Bool

O(n) The isPrefixOf function takes two Streams and returns True iff the first is a prefix of the second.

Searching

elem :: Char -> Stream Char -> Bool

O(n) elem is the stream membership predicate.

filter :: (Char -> Bool) -> Stream Char -> Stream Char

O(n) filter, applied to a predicate and a stream, returns a stream containing those characters that satisfy the predicate.

Indexing

find :: (Char -> Bool) -> Stream Char -> Maybe Char

O(n) The find function takes a predicate and a stream, and returns the first element in matching the predicate, or Nothing if there is no such element.

indexI :: Integral a => Stream Char -> a -> Char

O(n) Stream index (subscript) operator, starting from 0.

findIndexI :: Integral a => (Char -> Bool) -> Stream Char -> Maybe a

The findIndexI function takes a predicate and a stream and returns the index of the first element in the stream satisfying the predicate.

findIndicesI :: Integral a => (Char -> Bool) -> Stream Char -> [a]

The findIndicesI function takes a predicate and a stream and returns all indices of the elements in the stream satisfying the predicate.

elemIndexI :: Integral a => Char -> Stream Char -> Maybe a

O(n) The elemIndexI function returns the index of the first element in the given stream which is equal to the query element, or Nothing if there is no such element.

elemIndicesI :: Integral a => Char -> Stream Char -> [a]

O(n) The elemIndicesI function returns the index of every element in the given stream which is equal to the query element.

countI :: Integral a => Char -> Stream Char -> a

O(n) The count function returns the number of times the query element appears in the given stream.

Zipping and unzipping

zipWith :: (a -> a -> b) -> Stream a -> Stream a -> Stream b

zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function.