**foldr** -base -text

foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a packed string, reduces the packed string using the binary operator, from right to left.
*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
foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a ByteString, reduces the ByteString using the binary operator, from right to left.
*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)*. 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)*. 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
'foldr\'' is a strict variant of foldr

*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\'' is like foldr, but strict in the accumulator.
*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)*. 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)*. 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.
foldr1 is a variant of foldr that has no starting value argument, and thus must be applied to non-empty ByteStrings
foldr1 is a variant of foldr that has no starting value argument, and thus must be applied to non-empty ByteStrings
foldr1 is a variant of foldr that has no starting value argument, and thus must be applied to non-empty ByteStrings An exception will be thrown in the case of an empty ByteString.
A strict variant of foldr1

'foldr1\'' is a variant of foldr1, but is strict in the accumulator.
Consume the chunks of a lazy ByteString with a natural right fold.

*O(n)*. Fold the keys and values in the map using the given right-associative binary operator, such that foldrWithKey f z == foldr (uncurry f) z . toAscList.
For example,
> keys map = foldrWithKey (\k x ks -> k:ks) [] map
> let f k a result = result ++ "(" ++ (show k) ++ ":" ++ a ++ ")"
> foldrWithKey f "Map: " (fromList [(5,"a"), (3,"b")]) == "Map: (5:a)(3:b)"
Show more results