Mastering F#

F# projects follow a top-to-bottom structuring of program files. Unlike C# or VB.NET, this is the very first thing to understand to organize files and folders with F#.

You will learn by adding some files to the hello world project, as follows:

With F#, you can not write projects (.fsproj) containing module files (.fs), but also scripts (.fsx). These are single-file projects that are useful to write short programs, automation tasks, and so on.

With F# Script File, we will get the following features:

To access the F# Interactive window from the menu, navigate to View | Other Windows | F# Interactive.

Use the F# script files to quickly check a piece of code. We will now check this feature by writing a square root and a Fibonacci function. Add the following functions to a script file:

    let sqr x = x * x 
    let rec fib n = 
        if n < 2 then 1 
        else fib (n - 2) + fib (n - 1) 

After adding the preceding code snippet in the script file, perform the following steps:

There are some idioms that you will need to be familiar with when using F# Script File or the F# Interactive mode.

#load "sample.fs"   
#load "sample.fsx"   

#I @"C:\Program Files   (x86)\Reference    Assemblies\Microsoft\Framework\.NETFramework\v4.0"   

#I @"C:\Program Files   (x86)\Reference    Assemblies\Microsoft\Framework\.NETFramework\v4.0"   
#r "presentationcore.dll"   

FSI interactive shell is a simple console app that is bundled with the F# installation. To open FSI, perform the following steps:

In F#, and other similar functional languages, functions actually have only one input and output. When we declare a function with multiple arguments, we are actually building functions that return other functions until the desired output is obtained. In the following code snippet, the two functions are effectively identical:

> let sum = fun x y z -> x + y + z;; 
val sum : x:int -> y:int -> z:int -> int  
> let sum' = fun x -> fun y -> fun z -> x + y + z;; 
val sum' : x:int -> y:int -> z:int -> int  

The application of lesser arguments than the arity (the total number of arguments a function can accept) is called a partial application.

> let sum a b = a + b;; 
> let incr_by_ten = sum 10;; 
> incr_by_ten 5;; 
val it : int = 15 

Partial functions also help in writing concise code with F# pipeline operators, as shown in the following code:

    let res1 = List.map (fun x -> x + x) [2; 4; 6] 
    let res2 = List.filter (fun x -> x > 5) res1 

The preceding code can be rewritten in a more expressive way using the pipe (|>) operator:

    [2; 4; 6] |> List.map (fun x -> x + x) |> List.filter (fun x -> x > 5) 

For C# and VB.NET users, this is much like the continuation style programming with LINQ functions. In LINQ, you will normally pipeline a sequence of function calls, as follows:

    var listOfItems = someItems.Select(x => x.Name).OrderBy(x => x); 

However, for this the type returned by the first method needs to implement the method we want to call next. This is not a limitation when using the pipe operator.

In functional languages, recursion is used to express repetition or looping. For example, the Fibonacci sequence generator can be written as follows:

    let rec fib n = 
        if n < 2 then 1     
        else fib (n - 2) + fib (n - 1) 

We use the rec keyword to define a function as recursive. This is necessary to help the F# type checker infer the types of the function signature.

Every time a function is called recursively, a new routine is added to the call stack. As the call stack is limited, we must be careful not to overflow it. To prevent this, the compiler of F# and most functional programming languages implements an optimization called tail-call, which basically compiles down to a while loop. To enable this optimization, we will need to make sure the recursive call is the last expression in the function.

    // tail-recursion 
    let factorial x = 
        // Keep track of both x and an accumulator value (acc) 
        let rec tailRecursiveFactorial x acc = 
            if x <= 1 then 
                // use the accumulator that has the final result 
                acc 
            else 
                // pass the accumulator + original value again to the recursive method 
                tailRecursiveFactorial (x - 1) (acc * x) 
        tailRecursiveFactorial x 1 

As functions are first-class citizens in functional languages, we can pass them as arguments to other functions. When a function takes another function as an argument, we it a higher-order function. Let's consider the following example:

> let apply x f = f x 
val map : x:'a -> f:('a -> 'b) -> 'b 
> let sqr x = x * x 
val sqr : x:int -> int 
> let f = apply 5 sqr;; 
val f : int = 25

The preceding code snippets perform the following functions:

Higher-order functions are very important to write composable and reusable code. Earlier, we saw List.map. Many of the functions in the Collections modules (List, Array, and Seq) accept functions as arguments so we can adapt their behavior to our needs.