Haskell - foldl' in terms of foldr and performance issues

Question

While studying fold in depth with A tutorial on the universality and expressiveness of fold I found an amazing definition of foldl using foldr :

-- I used one lambda function inside another only to improve reading
foldl :: (b -> a -> b) -> b -> [a] -> b
foldl f z xs = foldr (\x g -> (\a -> g (f a x))) id xs z

After understanding what is going on, I thought I could even use foldr to define foldl' , which would be like this:

foldl' :: (b -> a -> b) -> b -> [a] -> b
foldl' f z xs = foldr (\x g -> (\a -> let z' = a `f` x in z' `seq` g z')) id xs z

Which is parallel to this:

foldl' :: (b -> a -> b) -> b -> [a] -> b
foldl' f z (x:xs) = let z' = z `f` x 
                    in seq z' $ foldl' f z' xs 
foldl' _ z _     = z

It seems that both of them are running in constant space (not creating thunks) in simple cases like this:

*Main> foldl' (+) 0 [1..1000000]
500000500000

May I consider both definitions of foldl' equivalent in terms of performance?

Answer 1

In GHC 7.10+, foldl and foldl' are both defined in terms of foldr . The reason that they weren't before is that GHC didn't optimize the foldr definition well enough to participate in foldr/build fusion. But GHC 7.10 introduced a new optimization specifically to allow foldr/build fusion to succeed while using foldl' or foldl' defined that way.

The big win here is that an expression like foldl' (+) 0 [1..10] can be optimized down to never allocating a (:) constructor at all. And we all know that the absolute fastest garbage collection is when there's no garbage to collect.

See http://www.joachim-breitner.de/publications/CallArity-TFP.pdf for information on the new optimization in GHC 7.10, and why it was necessary.