What's the purpose of `id` function in the FSharp.Core?

Solution 1:

When working with higher-order functions (i.e. functions that return other functions and/or take other functions as parameters), you always have to provide something as parameter, but there isn't always an actual data transformation that you'd want to apply.

For example, the function Seq.collect flattens a sequence of sequences, and takes a function that returns the "nested" sequence for each element of the "outer" sequence. For example, this is how you might get the list of all grandchildren of a UI control of some sort:

let control = ...
let allGrandChildren = control.Children |> Seq.collect (fun c -> c.Children)

But a lot of times, each element of the sequence will already be a sequence by itself - for example, you may have a list of lists:

let l = [ [1;2]; [3;4]; [5;6] ]

In this case, the parameter function that you pass to Seq.collect needs to just return the argument:

let flattened = [ [1;2]; [3;4]; [5;6] ] |> Seq.collect (fun x -> x)

This expression fun x -> x is a function that just returns its argument, also known as "identity function".

let flattened = [ [1;2]; [3;4]; [5;6] ] |> Seq.collect id

Its usage crops up so often when working with higher-order functions (such as Seq.collect above) that it deserves a place in the standard library.

Another compelling example is Seq.choose - a function that filters a sequence of Option values and unwraps them at the same time. For example, this is how you might parse all strings as numbers and discard those that can't be parsed:

let tryParse s = match System.Int32.TryParse s with | true, x -> Some x | _ -> None
let strings = [ "1"; "2"; "foo"; "42" ]
let numbers = strings |> Seq.choose tryParse  // numbers = [1;2;42]

But what if you're already given a list of Option values to start with? The identity function to the rescue!

let toNumbers optionNumbers =
   optionNumbers |> Seq.choose id

Solution 2:

It's useful for certain higher order functions (functions that take functions as arguments) so that you can pass id as the argument instead of writing out the lambda (fun x -> x).

[[1;2]; [3]] |> List.collect id  // [1; 2; 3]

Solution 3:

It can be extremely useful when working with options.

I have written a small idiomatic JSON-Helper, indicating all optional fields as Option, throwing errors, if a string is passed as null, if not of type 'string option'.

Now there is a function providing a boxed output value, which can be

1. 'a -> any type but no option
2. 'b -> 'x option

In order to box the value correctly, I use

val |> if isOption then fnOptTransform else id

So I'm applying the high order function fnOptTransform, and by calling id otherwise, avoid the ugliness of coding a separate lambda (I try to avoid it, where I can..). Found it useful.