The Seq.fold function takes three arguments:
1. A function that takes two arguments, an accumulator and an item from a sequence, and returns an updated accumulator.
2. The initial value for the accumulator.
3. A sequence of items.
Returns: A single, aggregated value.

The Seq.unfold function takes two arguments:
1. A function that takes one arguments, an accumulator, and returns a tuple, consisting of a value to be inserted into the sequence and an updated accumulator.
2. The initial value for the accumulator.
Returns: A new sequence of values generated from the function (1) above.

let the_num = 600851475143L;;
let isFactor (numerator : int64) (denominator : int64) = (numerator % denominator = 0L);;
let get_factors (n : int64) = List.sort [for x in 1L .. int64(ceil(sqrt(float n))) do if ((isFactor n x) && (x <> 1L)) then yield x; yield (n / x)];;
let isPrime (n : int64) = (List.length (get_factors n)) = 0;;
let the_factors = the_num |> get_factors |> List.rev;;
let prime, notprime = List.partition isPrime the_factors;;
List.head prime;;

let fibs = (1,2) |> Seq.unfold (fun (a,b) -> if a < 4000000 then Some(a, (b, a+b)) else None);;
let sum acc itm = if (itm % 2 = 0) then acc + itm else acc;;
let answer = List.fold sum 0 (Seq.toList fibs);;

In this problem, I need to gather all the Fibonacci numbers that do not exceed four-million, then filter out the odd ones and sum the result.

First, I generate a sequence of Fibonacci numbers using the Seq.unfold function. It has two parameters: A function which will calculate the next value in the sequence, and the initial value supplied to that function. The function has a return type of option. This is why the Some/None keywords are used. If a value is present we use Some(value), else None which is like null. Once a None or null is encountered, the sequence will end. In the Some function, it returns a tuple. The first part of the tuple is what will go into the sequence, the second part is the updated values being fed back into the function. Notice that I said that the Seq.unfold function has two parameters, but only one argument is being passed in, so where is the other argument? Well, it actually is specified before the function call. The tuple (1,2) is followed by the pipe-forward operator. This takes that tuple and supplies it to the last parameter of the function that it proceeds, in this case, the Seq.unfold function.

Second, I create a summation function. It takes an accumulator and the next item in a list. As each item runs through the function, the accumulator gets larger and larger, but only if the item in question is even. If the item is odd, then the accumulator remains unchanged.

Finally, all of the pieces get put together. I use the List.fold function, passing in the summation function, the initial value of the accumulator, and the list of Fibonacci numbers less than four million. All of the values in the list have been folded or aggregated into a single value: the sum.

List.fold (fun acc itm -> acc + itm) 0 [for x in 1..999 do if (x % 3 = 0) || (x % 5 = 0) then yield x];;

The List.fold function takes three arguments:
1. A function. This function takes two arguments, the first is an accumulator or the aggregated value, the second argument is an item being supplied from a list.
2. The accumulator’s (see above) starting value.
3. A list.

In the above code, I’m creating a list using list comprehension syntax. It is iterating from 1 to 999 and checks if each number is divisible by either 3 or 5. If it is, then it gets added to the list. After the list gets created, it gets fed into the lambda function (anonymous). The 0, zero, is the starting value for the accumulator. As each number in the list gets fed to the lambda the total value gets larger and larger until the list has exhausted all the values. The fold function then terminates, returning the accumulator, which in this case is the sum of all the numbers 1 to 999 that are factors of either 3 or 5.