Tuple is one of the most common data types with the F# language and is simply a way of storing two or several values in one container.

The following code is an example of a tuple:

// pattern matching
let tuple = (1, 2)
let a, b = tuple
printfn "%d + %d = %d" a b (a + b) 

A tuple is immutable because once it's created, you cannot change the values without creating a new tuple.

Another important aspect of the tuple is how it maps to the out keyword of C#. Where the .NET framework supports out variables, it will be translated into a tuple in F#. The most common usage of the out keyword is the Try pattern, as follows:

// instead of bool.TryParse
// s -> bool choice
let parseBool s =
    match bool.TryParse(s) with
    // success, value
    | true, b  -> Some(b)
    | false, _ -> None 

The code maps the bool.TryParse functionality into the choice type, which becomes less prone to error as it forces you to handle the None case, and it only has three combinations of values instead of four, as with the tuple result.

This can be tested as follows:

[<Test>]
let ``should parse "true" as true`` () =
    parseBool "true" |> should equal (Some true)

[<Test>]
let ``should parse "false" as false`` () =
    parseBool "false" |> should equal (Some false)
    
[<Test>]
let ``cannot parse string gives none`` () =
    parseBool "FileNotFound" |> should equal None 

The list type is a very used collection type throughout F#, and it has very little in common with its mutable cousin: the System.Collections.Generic.List<T> type. Instead, it is more like a linked list with a closer resemblance to Lisp.

The following image shows the working of lists:

The immutable list of F# has the following properties:

This is enough to perform most computations that require collections. Here is an example of a common way to build lists with recursion:

// not very optimized way of getting factors of n
let factors n = 
    let rec _factors = function
    | 1 -> [1]
    | k when n % k = 0 -> k :: _factors (k - 1)
    | k -> _factors (k - 1)

    _factors (n / 2)

One strength of the list type is the built-in language features:

// create a list
> [1..5];;
val it : int list = [1; 2; 3; 4; 5]

// pattern matching
let a :: b :: _ = [1..5];;
val b : int = 2
val a : int = 1

// generate list
> [for i in 1..5 -> i * i];;
val it : int list = [1; 4; 9; 16; 25]

Another strength of the list type is the list module and its higher order functions. I will give an example here of a few higher order functions that are very powerful to use together with the list type.

The map is a higher order function that will let you apply a function to each element in the list:

// map example
let double = (*) 2
let numbers = [1..5] |> List.map double

// val numbers : int list = [2; 4; 6; 8; 10] 

The fold is a higher order function that will aggregate the list items with an accumulator value:

// fold example
let separateWithSpace = sprintf "%O %d"
let joined = [1..5] |> List.fold separateWithSpace "Joined:"

// val joined : string = "Joined: 1 2 3 4 5" 

The nice thing about the fold function is that you can apply it to two lists as well. This is nice when you want to compute a value between two lists.

The following image is an example of this, using two lists of numbers. The algorithm described is called Luhn and is used to validate Swedish social security numbers. The result of this calculation should always be 0 for the Social Security Number (SSN) to be valid:

Here is a perfect situation where you want to compute a value between two lists:

// fold2 example
let multiplier = [for i in [1..12] -> (i % 2) + 1] // 2; 1; 2; 1...
let multiply acc a b = acc + (a * b)
let luhn ssn = (List.fold2 multiply 0 ssn multiplier) % 10

let result = luhn [1; 9; 3; 8; 0; 8; 2; 0; 9; 0; 0; 5]

// val result : int = 0

The partition is an excellent higher order function to use when you need to split values in a list into separate lists:

// partition example
let overSixteen = fun x -> x > 16
let youthPartition = [10..23] |> List.partition overSixteen 

// val youthPartition : int list * int list =
//   ([17; 18; 19; 20; 21; 22; 23], [10; 11; 12; 13; 14; 15; 16])

The reduce is a higher order function that will not use an accumulator value through the aggregation like the fold function, but uses the computation of the first two values as a seed.

The following code shows the reduce function:

// reduce example
let lesser a b = if a < b then a else b
let min = [6; 34; 2; 75; 23] |> List.reduce lesser 

There are many more useful higher order functions in the List module that are free for you to explore.

Sequence in F# is the implementation of the .NET framework's IEnumerable interface. It lets you get one element at a time without any other information about the sequence. There is no knowledge about the size of the sequence.

The F# sequence is strongly typed and quite powerful when combined with the seq computational expression. It will let us create unlimited length lists just like the yield keyword in C#:

// For multiples of three print "Fizz" instead of the number
// and for multiples of five print "Buzz"
// for multiples of both write "Fizzbuzz"
let fizzbuzz =
    let rec _fizzbuzz n =
        seq {
            match n with
            | n when n % 15 = 0 -> yield "Fizzbuzz"
            | n when n % 3 = 0  -> yield "Fizz"
            | n when n % 5 = 0 -> yield "Buzz"
            | n -> yield n.ToString()
                
            yield! _fizzbuzz (n + 1)
        }

    _fizzbuzz 1 

I'm sure you recognize the classic recruitment test. This code will generate an infinite sequence of fizzbuzz output for as long as a new value is requested.

The test for this algorithm clearly shows the usage of sequences:

[<Test>]
let ``should verify the first 15 computations of the fizzbuzz sequence`` () =
    fizzbuzz 
        |> Seq.take 15 
        |> Seq.reduce (sprintf "%s %s") 
        |> should equal "1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 Fizzbuzz"