foldr package:rio

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.

Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).

Reduce this set by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).

Right-associative fold of a structure. In the case of lists, foldr, when 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)...)

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, foldr can produce a terminating expression from an infinite list. For a general Foldable structure this should be semantically identical to,

foldr f z = foldr f z . toList

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

O(n) foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a Text, reduces the Text using the binary operator, from right to left. Subject to fusion.

O(n) Right fold

O(n) Right fold

O(n) Right fold

O(n) Right fold

foldr' is like foldr, but strict in the accumulator.

Consume the chunks of a lazy ByteString with a natural right fold.

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.

foldr1' is a variant of foldr1, but is strict in the accumulator.

Fold over a Deque, starting at the end. Does not modify the Deque.

Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).

A variant of foldr that has no base case, and thus may only be applied to non-empty structures.

foldr1 f = foldr1 f . toList

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 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)"

O(n). A strict version of foldrWithKey. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.

foldrWithIndex is a version of foldr that also provides access to the index of each element.

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.

Consume the chunks of a lazy Text with a natural right fold.