foldr'

foldr' is a variant of foldr that performs strict reduction from right to left, i.e. starting with the right-most element. The input structure must be finite, otherwise foldr' runs out of space (diverges). If you want a strict right fold in constant space, you need a structure that supports faster than O(n) access to the right-most element, such as Seq from the containers package. This method does not run in constant space for structures such as lists that don't support efficient right-to-left iteration and so require O(n) space to perform right-to-left reduction. Use of this method with such a structure is a hint that the chosen structure may be a poor fit for the task at hand. If the order in which the elements are combined is not important, use foldl' instead.
foldr' is a variant of foldr that begins list reduction from the last element and evaluates the accumulator strictly as it unwinds the stack back to the beginning of the list. The input list must be finite, otherwise foldr' runs out of space (diverges). Note that if the function that combines the accumulated value with each element is strict in the accumulator, other than a possible improvement in the constant factor, you get the same <math> space cost as with just foldr. If you want a strict right fold in constant space, you need a structure that supports faster than <math> access to the right-most element, such as Seq from the containers package. Use of this function is a hint that the [] structure may be a poor fit for the task at hand. If the order in which the elements are combined is not important, use foldl' instead.
>>> foldr' (+) [1..4]  -- Use foldl' instead!
10

>>> foldr' (&&) [True, False, True, True] -- Use foldr instead!
False

>>> foldr' (||) [False, False, True, True] -- Use foldr instead!
True
foldr' is like foldr, but strict in the accumulator.
foldr' is a strict variant of foldr
foldr' is like foldr, but strict in the accumulator.
foldr' is like foldr, but strict in the accumulator.
O(n) A strict version of foldr. foldr' evaluates as a right-to-left traversal using constant stack space.
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.
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.
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.
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) Right fold with a strict accumulator.
O(n) Right fold with a strict accumulator.
O(n) Pure right fold with strict accumulator.
O(n) Pure right fold with strict accumulator.
O(n) Right fold with a strict accumulator.
O(n) Pure right fold with strict accumulator.
O(n) Right fold with a strict accumulator.
O(n) Pure right fold with strict accumulator.
O(n) Right fold with a strict accumulator.
O(n) Pure right fold with strict accumulator.
Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator). Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.