Scheme where the same order of arguments is used for combining functions to both foldl and ). Another technical point is that, in the case of left folds using lazy evaluation, the new initial parameter is not being evaluated before the recursive call is made. This can lead to stack overflows when one reaches the end of the list and tries to evaluate the resulting potentially gigantic expression. For this reason, such languages often provide a stricter variant of left folding which forces the evaluation of the initial parameter before making the recursive call. In Haskell this is the foldl' (note the apostrophe, pronounced 'prime') function in the Data.List library (one needs to be aware of the fact though that forcing a value built with a lazy data constructor won't force its constituents automatically by itself). Combined with tail recursion, such folds approach the efficiency of loops, ensuring constant space operation, when lazy evaluation of the final result is impossible or undesirable. Examples Using a Haskell interpreter, the structural transformations which fold functions perform can be illustrated by constructing a string: λ> foldr (\x y -> concat ["(",x,"+",y,")"]) "0" (map show [1..13]) "(1+(2+(3+(4+(5+(6+(7+(8+(9+(10+(11+(12+(13+0)))))))))))))" λ> foldl (\x y -> concat ["(",x,"+",y,")"]) "0" (map show [1..13]) "(((((((((((((0+1)+2)+3)+4)+5)+6)+7)+8)+9)+10)+11)+12)+13)" λ> foldt (\x y -> concat ["(",x,"+",y,")"]) "0" (map show [1..13]) "(((((1+2)+(3+4))+((5+6)+(7+8)))+(((9+10)+(11+12))+13))+0)" λ> foldi (\x y -> concat ["(",x,"+",y,")"]) "0" (map show [1..13]) "(1+((2+3)+(((4+5)+(6+7))+((((8+9)+(10+11))+(12+13))+0))))" Infinite tree-like folding is demonstrated e.g., in recursive primes production by unbounded sieve of Eratosthenes in Haskell: primes = 2 : _Y ((3 :) . minus [5,7..] . foldi (\(x:xs) ys -> x : union xs ys) [] . map (\p-> [p*p, p*p+2*p..])) _Y g = g (_Y g) -- = g . g . g . g . ... where the function union operates on ordered lists in a local manner to efficiently produce their set union, and minus their set difference. A finite prefix of primes is concisely defined as a folding of set difference operation over the lists of enumerated multiples of integers, as primesTo n = foldl1 minus [[2*x,3*x..n] | x <- [1..n]] For finite lists, e.g., merge sort (and its duplicates-removing variety, nubsort) could be easily defined using tree-like folding as mergesort xs = foldt merge [] [[x] | x <- xs] nubsort xs = foldt union [] [[x] | x <- xs] with the function merge a duplicates-preserving variant of union. Functions head and last