# (a -> b -> c) -> b -> a -> c -text

flip f takes its (first) two arguments in the reverse order of f.
*Deprecated.* As of version 0.5, replaced by foldr.
*O(n)*. Fold the values in the map using the given right-associative binary operator. This function is an equivalent of foldr and is present for compatibility only.
*O(n)*. Fold the values in the map using the given right-associative binary operator, such that foldr f z == foldr f z . elems.
For example,
> elems map = foldr (:) [] map
> let f a len = len + (length a)
> foldr f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
*O(n)*. A strict version of foldr. 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)*. Fold the elements in the set using the given right-associative binary operator. This function is an equivalent of foldr and is present for compatibility only.
*Please note that fold will be deprecated in the future and removed.*
*O(n)*. Fold the elements in the set using the given right-associative binary operator, such that foldr f z == foldr f z . toAscList.
For example,
> toAscList set = foldr (:) [] set
*O(n)*. A strict version of foldr. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:
> foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
Fold over the elements of a structure, associating to the right, but strictly.

Fold over the elements of a structure, associating to the left, but strictly.

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.
A strict version of foldl.
*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)*. 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)*. 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)*. 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.
Consume the chunks of a lazy ByteString with a natural right fold.

Consume the chunks of a lazy ByteString with a strict, tail-recursive, accumulating left fold.

Show more results