Folding

Now is the perfect time to revisit the factorial function that I used at the beginning of this chapter when covering tail recursion. Let's take a sequence of bigint numbers from 1I to a value n represented by the following expression:

Seq.init (n + 1) bigint.op_Implicit |> Seq.skip 1 

Does the factorial(n) function represent nothing else but a product of the factors, each being a member of the preceding sequence? Sure, it can be seen (and implemented) as such. Let me create this implementation in the best traditions of the imperative programming style as shown here (Ch7_3.fsx):

let ``folding factorial (seq)`` n = 
  let fs = Seq.init (n + 1) bigint.op_Implicit |> Seq.skip 1 
  use er = fs.GetEnumerator() 
  let mutable acc = 1I 
  while er.MoveNext() do 
    acc <- acc * er.Current 
  acc 

Expressed in plain words, this implementation can be laid out in the following manner:

• Take a mutable value that will serve as a result accumulator

• Enumerate the sequence of factors

• For each...