Use of folding in defining functions

The idea of folding is a powerful one. The fold functions (foldr and foldl in the Haskell base library) come from a family of functions called Higher-Order Functions (for those who don't know - these are functions which take functions as parameters or return functions as their output).

This allows for greater code clarity as the intention of the program is more clearly expressed. A function written using fold functions strongly indicates that there is an intention to iterate over the list and apply a function repeatedly to obtain an output. Using the standard recursive method is fine for simple programs but when complexity increases it can become difficult to understand quickly what is happening.

Greater code re-use can be achieved with folding due to the nature of passing in a function as the parameter. If a program has some behaviour that is affected by the passing of a Boolean or enumeration value then this behaviour can be abstracted away into a separate function. The separate function can then be used as an argument to fold. This achieves greater flexibility and simplicity (as there are 2 simpler functions versus 1 more complex function).

Higher-Order Functions are also essential for Monads.

Credit to the comments for this question as well for being varied and informative.

Higher-order functions like foldr, foldl, map, zipWith, &c. capture common patterns of recursion so you can avoid writing manually recursive definitions. This makes your code higher-level and more readable: instead of having to step through the code and infer what a recursive function is doing, the programmer can reason about compositions of higher-level components.

For a somewhat extreme example, consider a manually recursive calculation of standard deviation:

standardDeviation numbers = step1 numbers
  where

    -- Calculate length and sum to obtain mean
    step1 = loop 0 0
      where
        loop count sum (x : xs) = loop (count + 1) (sum + x) xs
        loop count sum [] = step2 sum count numbers

    -- Calculate squared differences with mean
    step2 sum count = loop []
      where
        loop diffs (x : xs) = loop ((x - (sum / count)) ^ 2 : diffs) xs
        loop diffs [] = step3 count diffs

    -- Calculate final total and return square root
    step3 count = loop 0
      where
        loop total (x : xs) = loop (total + x) xs
        loop total [] = sqrt (total / count)

(To be fair, I went a little overboard by also inlining the summation, but this is roughly how it may typically be done in an imperative language—manually looping.)

Now consider a version using a composition of calls to standard functions, some of which are higher-order:

standardDeviation numbers          -- The standard deviation
  = sqrt                           -- is the square root
  . mean                           -- of the mean
  . map (^ 2)                      -- of the squares
  . map (subtract                  -- of the differences
      (mean numbers))              --   with the mean
  $ numbers                        -- of the input numbers
  where                            -- where
    mean xs                        -- the mean
      = sum xs                     -- is the sum
      / fromIntegral (length xs)   -- over the length.

This more declarative code is also, I hope, much more readable—and without the heavy commenting, could be written neatly in two lines. It’s also much more obviously correct than the low-level recursive version.

Furthermore, sum, map, and length can all be implemented in terms of folds, as well as many other standard functions like product, and, or, concat, and so on. Folding is an extremely common operation on not only lists, but all kinds of containers (see the Foldable typeclass), because it captures the pattern of computing something incrementally from all elements of a container.

A final reason to use folds instead of manual recursion is performance: thanks to laziness and optimisations that GHC knows how to perform when you use fold-based functions, the compiler may fuse a series of folds (maps, &c.) together into a single loop at runtime.