**foldl** -bytestring

foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:
> foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
The list must be finite.
*O(n)* foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a Text, reduces the Text using the binary operator, from left to right. Subject to fusion.
*O(n)*. Fold the elements in the set using the given left-associative binary operator, such that foldl f z == foldl f z . toAscList.
For example,
> toDescList set = foldl (flip (:)) [] set
*O(n)*. Fold the values in the map using the given left-associative binary operator, such that foldl f z == foldl f z . elems.
For example,
> elems = reverse . foldl (flip (:)) []
> let f len a = len + (length a)
> foldl f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
*O(n)*. Fold the values in the map using the given left-associative binary operator, such that foldl f z == foldl f z . elems.
For example,
> elems = reverse . foldl (flip (:)) []
> let f len a = len + (length a)
> foldl f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
*O(n)*. Fold the elements in the set using the given left-associative binary operator, such that foldl f z == foldl f z . toAscList.
For example,
> toDescList set = foldl (flip (:)) [] set
This library provides strict left folds that stream in constant memory, and you can combine folds using Applicative style to derive new folds. Derived folds still traverse the container just once and are often as efficient as hand-written folds.
Version 1.0.0

foldl1 is a variant of foldl that has no starting value argument, and thus must be applied to non-empty lists.
A strict version of foldl.
Fold over the elements of a structure, associating to the left, but strictly.

Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.

*O(n)* A strict version of foldl. Subject to fusion.
*O(n)*. A strict version of foldl. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
*O(n)*. A strict version of foldl. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
*O(n)*. A strict version of foldl. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
*O(n)*. A strict version of foldl. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
*O(n)* A variant of foldl that has no starting value argument, and thus must be applied to a non-empty Text. Subject to fusion.
Show more results