Control.Foldl.ByteString

Apply a strict left Fold to a lazy bytestring

Apply a strict monadic left FoldM to a lazy bytestring

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

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

Returns True if the byte stream is empty, False otherwise

Return the length of the byte stream in bytes

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

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

Computes the maximum byte

Computes the minimum byte

(elem w8) returns True if the byte stream has a byte equal to w8, False otherwise

(notElem w8) returns False if the byte stream has a byte equal to w8, True otherwise

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

(index n) returns the nth byte of the byte stream, or Nothing if the stream has an insufficient number of bytes

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

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

count w8 returns the number of times w8 appears

Combine all the strict ByteString chunks to build a lazy ByteString

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 representation of a Word8 vector, supporting many efficient operations.

A ByteString contains 8-bit bytes, or by using the operations from Data.ByteString.Char8 it can be interpreted as containing 8-bit characters.

8-bit unsigned integer type