Control.Foldl.Text

Apply a strict left Fold to lazy text

Apply a strict monadic left FoldM to lazy text

Get the first character of a text stream or return Nothing if the stream is empty

Get the last character of a text stream or return Nothing if the text stream is empty

Returns True if the text stream is empty, False otherwise

Return the length of the text stream in characters

(any predicate) returns True if any character satisfies the predicate, False otherwise

(all predicate) returns True if all characters satisfy the predicate, False otherwise

Computes the maximum character

Computes the minimum character

(elem c) returns True if the text stream has a character equal to c, False otherwise

(notElem c) returns False if the text stream has a character equal to c, True otherwise

(find predicate) returns the first character that satisfies the predicate or Nothing if no character satisfies the predicate

(index n) returns the nth character of the text stream, or Nothing if the stream has an insufficient number of characters

(elemIndex c) returns the index of the first character that equals c, or Nothing if no character matches

(findIndex predicate) returns the index of the first character that satisfies the predicate, or Nothing if no character satisfies the predicate

(count c) returns the number of times c appears

Combine all the strict Text chunks to build a lazy Text

Efficient representation of a left fold that preserves the fold's step function, initial accumulator, and extraction function

This allows the Applicative instance to assemble derived folds that traverse the container only once

A 'Fold a b' processes elements of type a and results in a value of type b.

Like Fold, but monadic.

A 'FoldM m a b' processes elements of type a and results in a monadic value of type m b.

The Foldable class represents data structures that can be reduced to a summary value one element at a time. Strict left-associative folds are a good fit for space-efficient reduction, while lazy right-associative folds are a good fit for corecursive iteration, or for folds that short-circuit after processing an initial subsequence of the structure's elements.

Instances can be derived automatically by enabling the DeriveFoldable extension. For example, a derived instance for a binary tree might be:

{-# LANGUAGE DeriveFoldable #-}
data Tree a = Empty
            | Leaf a
            | Node (Tree a) a (Tree a)
    deriving Foldable

A more detailed description can be found in the Overview section of Data.Foldable#overview.

For the class laws see the Laws section of Data.Foldable#laws.

A space efficient, packed, unboxed Unicode text type.