**Packages**- base
- bytestring
- text
- containers

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

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.

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.

foldr1 is a variant of foldr that has no starting value argument, and thus must be applied to non-empty lists.

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

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

'foldr\'' is a strict variant of foldr

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

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.

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

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

The unfoldr function is a `dual' to foldr: while foldr reduces a list to a summary value, unfoldr builds a list from a seed value. The function takes the element and returns Nothing if it is done producing the list or returns Just (a,b), in which case, a is a prepended to the list and b is used as the next element in a recursive call. For example,
> iterate f == unfoldr (\x -> Just (x, f x))
In some cases, unfoldr can undo a foldr operation:
> unfoldr f' (foldr f z xs) == xs
if the following holds:
> f' (f x y) = Just (x,y)
> f' z = Nothing
A simple use of unfoldr:
> unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
> [10,9,8,7,6,5,4,3,2,1]

Create a Builder that encodes a sequence generated from a seed value using a BoundedPrim for each sequence element.

Builds a sequence from a seed value. Takes time linear in the number of generated elements. *WARNING:* If the number of generated elements is infinite, this method will not terminate.