Moduletext-2.1.3Haskell2010

Data.Text.Internal.Fusion.Common

Warning: this is an internal module, and does not have a stable API or name. Functions in this module may not check or enforce preconditions expected by public modules. Use at your own risk!

This module provides a common stream fusion interface for text. The stream interface allows us to write text pipelines which do not allocate intermediate text values. For example, we could guarantee no intermediate text is allocated by writing the following:

  getNucleotides :: Text -> Text
  getNucleotides =
        unstream
      . filter isNucleotide
      . toLower
      . stream
    where
      isNucleotide chr =
        chr == 'a' ||
        chr == 'c' ||
        chr == 't' ||
        chr == 'g'

54 values

Packagetext-2.1.3
Exports54
LanguageHaskell2010
LicenceBSD-2-Clause
SourceCommon.hs

Creation and elimination

4 declarations

valuesingleton :: Char -> Stream Char

O(1) Convert a character into a Stream

Properties

unstream . singleton = singleton

valuestreamList :: [a] -> Stream a

O(n) Convert a list into a Stream.

Properties

unstream . streamList = pack

valueunstreamList :: Stream a -> [a]

O(n) Convert a Stream into a list.

Properties

unstreamList . stream = unpack

valuestreamCString# :: Addr# -> Stream Char

Stream the UTF-8-like packed encoding used by GHC to represent constant strings in generated code.

This encoding uses the byte sequence "xc0x80" to represent NUL, and the string is NUL-terminated.

Properties

 unstream . streamCString# addr# = unpackCString# addr#

Basic interface

12 declarations

valuecons :: Char -> Stream Char -> Stream Char

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

Properties

 unstream . cons c . stream = cons c

valuesnoc :: Stream Char -> Char -> Stream Char

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

Properties

 unstream . snoc c . stream = snoc c

valueappend :: Stream Char -> Stream Char -> Stream Char

O(n) Appends one Stream to the other.

Properties

 unstream (append (stream t1) (stream t2)) = append t1 t2

valuehead :: HasCallStack => Stream Char -> Char

O(1) Returns the first character of a Stream Char, which must be non-empty. This is a partial function, consider using uncons.

Properties

 head . stream = head

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

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

Properties

 Data.Functor.fmap fst . uncons . stream = Data.Functor.fmap fst . uncons

 Data.Functor.fmap (unstream . snd) . uncons . stream = Data.Functor.fmap snd . uncons

valuelast :: HasCallStack => Stream Char -> Char

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

Properties

 last . stream = last

valuetail :: HasCallStack => Stream Char -> Stream Char

O(1) Returns all characters after the head of a Stream Char, which must be non-empty. This is a partial function, consider using uncons.

Properties

 Data.Text.Internal.unstream . tail . stream = tail

valueinit :: HasCallStack => Stream Char -> Stream Char

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

Properties

 Data.Text.Internal.unstream . init . stream = init

valuenull :: Stream Char -> Bool

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

Properties

 null . stream = null

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

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

valuecompareLengthI :: Integral a => Stream Char -> a -> Ordering

O(n) Compares the count of characters in a string to a number.

This function gives the same answer as comparing against the result of lengthI, but can short circuit if the count of characters is greater than the number or if the stream can't possibly be as long as the number supplied, and hence be more efficient.

valueisSingleton :: Stream Char -> Bool

O(n) Indicate whether a string contains exactly one element.

Properties

 isSingleton . stream = isSingleton

Transformations

3 declarations

valuemap :: (Char -> Char) -> Stream Char -> Stream Char

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

Properties

 Data.Text.Internal.unstream . map f . stream = map f

valueintercalate :: Stream Char -> [Stream Char] -> Stream Char

intercalate str strs inserts the stream str in between the streams strs and concatenates the result.

Properties

 intercalate s = concat . intersperse s

valueintersperse :: Char -> Stream Char -> Stream Char

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

Properties

 Data.Text.Internal.unstream . intersperse c . stream = intersperse c

Case conversion

With Unicode text, it is incorrect to use combinators like map toUpper to case convert each character of a string individually. Instead, use the whole-string case conversion functions from this module. For correctness in different writing systems, these functions may map one input character to two or three output characters.

valuetoCaseFold :: Stream Char -> Stream Char

O(n) Convert a string to folded case. This function is mainly useful for performing caseless (or case insensitive) string comparisons.

A string x is a caseless match for a string y if and only if:

toCaseFold x == toCaseFold y

The result string may be longer than the input string, and may differ from applying toLower to the input string. For instance, the Armenian small ligature men now (U+FB13) is case folded to the bigram men now (U+0574 U+0576), while the micro sign (U+00B5) is case folded to the Greek small letter letter mu (U+03BC) instead of itself.

valuetoLower :: Stream Char -> Stream Char

O(n) Convert a string to lower case, using simple case conversion. The result string may be longer than the input string. For instance, the Latin capital letter I with dot above (U+0130) maps to the sequence Latin small letter i (U+0069) followed by combining dot above (U+0307).

Properties

 Data.Text.Internal.unstream . toLower . stream = toLower

valuetoTitle :: Stream Char -> Stream Char

O(n) Convert a string to title case, using simple case conversion.

The first letter (as determined by isLetter) of the input is converted to title case, as is every subsequent letter that immediately follows a non-letter. Every letter that immediately follows another letter is converted to lower case.

The result string may be longer than the input string. For example, the Latin small ligature ﬂ (U+FB02) is converted to the sequence Latin capital letter F (U+0046) followed by Latin small letter l (U+006C).

This function is not idempotent. Consider lower-case letter ŉ (U+0149 LATIN SMALL LETTER N PRECEDED BY APOSTROPHE). Then toTitle "ŉ" = "ʼN": the first (and the only) letter of the input is converted to title case, becoming two letters. Now ʼ (U+02BC MODIFIER LETTER APOSTROPHE) is a modifier letter and as such is recognised as a letter by isLetter, so toTitle "ʼN" = "'n".

Note: this function does not take language or culture specific rules into account. For instance, in English, different style guides disagree on whether the book name "The Hill of the Red Fox" is correctly title cased—but this function will capitalize every word.

Properties

 Data.Text.Internal.unstream . toTitle . stream = toTitle

valuetoUpper :: Stream Char -> Stream Char

O(n) Convert a string to upper case, using simple case conversion. The result string may be longer than the input string. For instance, the German eszett (U+00DF) maps to the two-letter sequence SS.

Properties

 Data.Text.Internal.unstream . toUpper . stream = toUpper

Justification

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

Folds

7 declarations

valuefoldl :: (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.

Properties

 foldl f z0 . stream = foldl f z0

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

A strict version of foldl.

Properties

 foldl' f z0 . stream = foldl' f z0

valuefoldl1 :: HasCallStack => (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.

Properties

 foldl1 f . stream = foldl1 f

valuefoldl1' :: HasCallStack => (Char -> Char -> Char) -> Stream Char -> Char

A strict version of foldl1.

Properties

 foldl1' f . stream = foldl1' f

valuefoldr :: (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.

Properties

 foldr f z0 . stream = foldr f z0

valuefoldr1 :: HasCallStack => (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.

Properties

 foldr1 f . stream = foldr1 f

valuefoldlM' :: Monad m => (b -> Char -> m b) -> b -> Stream Char -> m b

A monadic version of foldl.

Properties

 foldlM' f z0 . stream = foldlM' f z0

Special folds

valueconcat :: [Stream Char] -> Stream Char

O(n) Concatenate a list of streams.

Properties

unstream . concat . Data.Functor.fmap stream  = concat

valueconcatMap :: (Char -> Stream Char) -> Stream Char -> Stream Char

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

Properties

unstream . concatMap (Data.Text.Fusion.stream . f) . stream = concatMap f

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

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

Properties

any f . Data.Text.Fusion.stream = any f

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

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

Properties

all f . Data.Text.Fusion.stream = all f

valuemaximum :: HasCallStack => Stream Char -> Char

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

Properties

maximum . Data.Text.Fusion.stream = maximum

valueminimum :: HasCallStack => Stream Char -> Char

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

Properties

minimum . Data.Text.Fusion.stream = minimum

Construction

0 declarations

Scans

valuescanl :: (Char -> Char -> Char) -> Char -> Stream Char -> Stream Char

O(n) scanl is similar to foldl, but returns a stream of successive reduced values from the left. Conceptually, if we write the input stream as a list then we have:

scanl f z [x1, x2, ...] == [z, z 'f' x1, (z 'f' x1) 'f' x2, ...]

Properties

head (scanl f z xs) = z

last (scanl f z xs) = foldl f z xs

Generation and unfolding

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

O(n) replicateCharI n c is a Stream Char of length n with c the value of every element.

valuereplicateI :: Int64 -> Stream Char -> Stream Char

O(n*m) replicateI n t is a Stream Char consisting of the input t repeated n times.

valueunfoldr :: (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.

Properties

unstream . unfoldr f z = unfoldr f z

valueunfoldrNI :: 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.

Properties

unstream (unfoldrNI n f z) = unfoldrN n f z

Substrings

0 declarations

Breaking strings

valuetake :: 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.

Properties

unstream . take n . stream = take n

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

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

Properties

unstream . drop n . stream = drop n

valuetakeWhile :: (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.

Properties

unstream . takeWhile p . stream = takeWhile p

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

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

Properties

unstream . dropWhile p . stream = dropWhile p

Predicates

1 declaration

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

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

Properties

 isPrefixOf (stream t1) (stream t2) = isPrefixOf t1 t2

Searching

2 declarations

valueelem :: Char -> Stream Char -> Bool

O(n) elem is the stream membership predicate.

Properties

 elem c . stream = elem c

valuefilter :: (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.

Properties

 Data.Text.Internal.unstream . filter p . stream = filter p

Indexing

4 declarations

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

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

Properties

 findBy p . stream = find p

valueindexI :: (HasCallStack, Integral a) => Stream Char -> a -> Char

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

Properties

 indexI (stream t) n = index t n

valuefindIndexI :: 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.

Properties

findIndexI p . stream = findIndex p

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

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

Properties

countCharI c . stream = Data.Text.countChar c

Zipping and unzipping

1 declaration

valuezipWith :: (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.

Properties

 unstream (zipWith f (stream t1) (stream t2)) = zipWith f t1 t2