The following demonstration of F# was all performed in the interactive window installed with the F# add-in:

One of the interesting keywords I noticed in f# was the rec keyword. This keyword allows you to do recursion. To do recursion in C# or most other languages would be something like:

int factorial (int n)
{
if (n == 1)
return 1;

return factorial(n-1) * n;
}

in F# the equivalent looks like this:

let rec factorial n = if n>1 then
n * (n-1 |> factorial) else 1;;

Let's try to grok what it is saying here

let rec factorial n =

tells us we are defining a recursive function called factorial that takes one parameter n. Note that we don't need to define int, F# figures it out!

if n > 1 then (n-1 |> factorial)

this statement says that if n is greater than one, call the factorial function with parameter n - 1.

n-1 |> factorial

is similar to the lambda ( =>) in LINQ in that we are passing the parameter n - 1 back into the factorial function.

To call our F# function in the interactive window for 5! we just say

factorial 5;;

This returns

val it : int = 120

if we want to subtract 5! - 3! we can type into the window:

factorial 5 - factorial 3;;

The result shows:

val it : int = 114

We can also define a function to do the subtraction by passing a tuple to the function called (x,y). A tuple is a list of values that can be automatically typed for you by F#. Below is our subtract function defined.

let subtract (x,y) = x - y;;

Passing the tuple (factorial 5, factorial 3) to our subtract function

subtract (factorial 5, factorial 3);;

returns

val it : int = 114

I know this looks like we are passing parameters, but we are really passing a tuple. We can get the same result piping the tuple

(factorial 5, factorial 3)

to our subtract function:

(factorial 5, factorial 3) |> subtract;;

which returns the same result

val it : int = 114

It's a little confusing at first, but I think you'll find you get the hang of it after a while. For algorithmic programming, life just got a lot simpler with F#.