F# introduction for my coworkers
A quick, dirty, and mostly wrong introduction to F#

Use Ionide. This is probably the easiest to use, although I’ve not used it myself.

F# tooling has shipped with Visual Studio for some time, but it might have to be enabled in the installer depending on the workload you chose when installing. You can download the latest version from within VS. See documentation on the fsharp.org page for more information.

For any non-trivial projects that also has a mix of C# projects, this is probably the way to go. You might be able to use Visual Studio Code for parts of the development.

F# works well with a Read Eval Print Loop (REPL), and this is available through editors or on the command-line by calling fsi.exe (or fsharpi depending on your OS). This is useful for looking at types and experiment with the language. By just writing the name of a function, you’ll see the type:

$ fsharpi

F# Interactive for F# 4.0 (Open Source Edition)
Freely distributed under the Apache 2.0 Open Source License

For help type #help;;

> (|>);;
val it : ('a -> ('a -> 'b) -> 'b) = <fun:it@1>
> #quit;;

- Exit...

Here we see that the function |> has the type 'a -> ('a -> 'b) -> 'b. Don’t worry, we’ll get to all this. Using the REPL to look at type signatures and experiment.

fsharpi can also run scripts.

printfn "Hello, World!"

$ fsharpi hello.fsx
Hello, World!

Although using the REPL is great, using it from within an editor with nice integration for executing parts of scripts is more convenient and what I do in my daily work.

Use fsharp-mode. The Spacemacs distribution with the FSharp layer works well. This is my setup of choice for much of my experimentation.

This introduction is written in emacs, using the Spacemacs distribution with evil-mode, fsharp-mode, org-mode and org-babel.

I’ve not yet tried using F# from vim.

F# is whitespace sensitive much like Python or Haskell. Indentation indicates a scope, and a line break is the end of a statement.

Bindings is available to everything in the scope that follows and that shadowing is allowed.

I recommend turning on indentation highlighting in your editor to make the scope more visually distinct. I also like using more blank lines in such languages to easily visually distinct newlines within functions from newlines between functions.

  // we define p as 1
  let p = 1
  // then we create a submodule
  module SomeModule =
      // we redefine p, but we use the old p in its definition
      let p = p + 1 // 2
      // here we define a function
      let someFunction () =
          // that defines a new p using the previous p in its definition
          let p = p + 1 // 3
          // and we finally return this last p
          p + 1 // 4

  sprintf "Top: %d, SomeModule: %d, someFunction: %d" p SomeModule.p (SomeModule.someFunction ())

Top: 1, SomeModule: 2, someFunction: 4

PS: I don’t encourage using lots of shadowing.

FP is known for having a lightweight syntax, and as functions is the most elementary building block, they are made especially lightweight.

Passing function arguments is just separated with namespaces. Given a function f : 'a -> 'b -> 'c, you should call it as f 1 2 rather than f(1, 2). The latter means a different thing in F#, and will be actually send a tuple much like f(Tuple.Create(1,2)), which is not what we meant.

' is a perfectly valid symbol, and is often used when there are small differences in a function – you’ll be creating a lots of functions, and naming everyone would be very difficult.

It’s also possible to create names that contain other special characters:

let f' x = x

let ``[Function] *with /a -- _special_ "name"`` x = x

let f' x = x

let ``[Function] *with /a -- _special_ "name"`` x = x;;
val f': x: 'a -> 'a
val ``[Function] *with /a -- _special_ "name"`` : x: 'a -> 'a

You might be used to writing tests with names like WhenCallingSomeFunction_WithSomeSpecialState_ThrowsException. In F#, this would be

let ``When calling SomeFunction with some special state throws exception`` () = ()

let ``When calling SomeFunction with some special state throws exception`` () = ();;
val ``When calling SomeFunction with some special state throws exception`` :
  unit -> unit

This will make it a lot simpler to read test results.

Creating new types easy and safe, so you’ll probably create a lot of types. Types in F# will have structural equality by default, so you don’t have to override Equals or GetHashCode. Together with simple syntax, this encourage programming with types. Reading the types is a bit different than C# though.

The basic syntax is theSymbol : firstParam -> secondParam -> result. I’ll never write names like this when explaining something, so let’s talk about f : a -> b -> c instead. The arrow in the type signature is right associative, so this should be read as f : a -> (b -> c), which looks very wrong at first sight. The reason for this is that every function in F# only takes a single argument and returns a single value! A function taking two arguments is actually a function taking one argument, returning a new function taking another argument. The following is equivalent:

let f a b = a + b
let g a = fun b -> a + b
let h = fun a b -> a + b

let f a b = a + b
let g a = fun b -> a + b
let h = fun a b -> a + b;;

As you’ll see from the types, this is exactly the same. This becomes important later when we talk more about functions. Notice that the parameters are no longer just a, but they have a type attached after : as with the function. Types can also be written inline as follows.

let f a b = a + b
let g (a:int) (b:int) = a + b
let h : int -> int -> int = fun a b -> a + b
let i (a:int) (b:int) : int = a + b
let j a b = (a + b) : int

let f a b = a + b
let g (a:int) (b:int) = a + b
let h : int -> int -> int = fun a b -> a + b
let i (a:int) (b:int) : int = a + b
let j a b = (a + b) : int;;
val i: a: int -> b: int -> int

Notice that there are many ways we can attach types to the signatures, but the compiler is quite smart in reasoning about the types.

Generic parameters will be prefixed with ':

let f x = x

let f x = x;;

Whenever you see _, it means “I don’t care” or “match everything”. Look at the following definitions that will extract the first or second element of a tuple:

let fst (a, _) = a
let snd (_, b) = b

let fst (a, _) = a
let snd (_, b) = b;;
val fst: a: 'a * 'b -> 'a
val snd: 'a * b: 'b -> 'b

It’s not possible to look at _ or otherwise use the value, and many values can be thrown away in the same scope – this doesn’t bind something to the _ symbol. It matches anything, and throws away the result. The alert reader might notice that I write f : a -> a rather than f : 'a -> 'a. This is because I’m lazy and I think it’s pretty clear from the context that I don’t mean a data type named a. When I write the former, I mean the latter.

Another different thing about F# is that every symbol must be defined before use. This is like C, except that you don’t have forward declaration at your disposal. For this reason, files have to be ordered, and the symbols within the files has to be ordered. When I first started, I thought it would be really difficult to structure projects this way, but it’s actually both quite natural and haven’t resulted in any difficulties for me. But it does mean that you need to look in a project file in order to see the correct order of the files to compile. In return you know that the most general stuff is at the top in the first file, and your main function will be at the bottom of the last file.

There is an escape-hatch, and, to compile multiple symbols as a unit and thus enabling recursion between them.

Several things that are statements in C# is expressions in F#. In C# you might write something like the following

int res;
if (true /*some condition*/) {
  res = 1;
} else {
  res = 2;
}

// Do something with res

In F#, if is an expression, and you would rather write

let res = if true then 1 else 2

1

The last expression will be the result. This is true for all expressions.

F#, as many other functional languages, explicitly handles absence of values with a custom type rather than with an (for common architectures) invalid memory location that will trigger an error in the OS. In F#, this type is called Option. It looks and behaves much like .NETs Nullable.

As F# has good .NET integration, we can still get null values from other libraries, and it’s also possible to construct them ourselves if we want. But in general, nulls doesn’t really pose a problem as in C#. Using Option to model the possible absence of values is highly encouraged as it forces us to explicitly handle the cases when a value is missing. It’s fully possible to create F# programs that doesn’t use nulls or explodes at runtime.

Consider the following F# snippet

// Person is a record, and can never be null
type Person = { name : string }

// As Person cannot be null, getName cannot trigger an exception
let getName (p : Person) = p.name

// We need to explicitly state that something might be missing
// and handle the case where it's missing
let getNameOrDefault (maybePerson : Option<Person>) =
  match maybePerson with
  | Some person -> person.name
  | None -> "John Doe"

type Person = { name : string }


let getName (p : Person) = p.name



let getNameOrDefault (maybePerson : Option<Person>) =
  match maybePerson with
  | Some person -> person.name
  | None -> "John Doe";;
type Person =
  { name: string }
val getName: p: Person -> string
val getNameOrDefault: maybePerson: Option<Person> -> string

Nulls are popularly known as the billion dollar mistake, and I have no doubt this is a very kind underestimate. It might seem tedious to always be checking for nulls, but in practice you code in a different style such that this is just a big safety net that saves a lot of time even in the short run.

I would be surprised if there are not a lot of questions after reading this walk-through. Download the program, experiment with it using an editor with a REPL, and continue reading this guide for a more thorough explanation of some of the features. Once you’ve read the rest of this guide, you should be able to read and write a simple program like this.

A lot of the power of having functions as first-class citizens is the ability to create larger functions by composing several smaller functions together. Remember that passing a single argument to a function taking more than one parameter will create a new function.

Before we get into composition, it’s useful to look into the syntax and basic features.

(>>)

(>>);;
val it: (('a -> 'b) -> ('b -> 'c) -> 'a -> 'c)

This is a very generic function as you can see by the 'a parameters. A type name which starts with ' is a generic parameter, meaning it can take any type as an argument. These types can be more than just a single type. For instance, an 'a can be (x -> y) -> Option<z> or something even more complex. Try the id function with different kinds of arguments to see how it works.

('a -> 'b) can be read as “A function taking anything as an argument, returning anything else”. What’s important is that it might have a different type as input and output. 'b could also be the same as 'a if you really like. When mapping values in a list, you might return a value of the same type, and thus have 'b = 'a:

List.map ((+) 1) [1; 2]

In order to compose functions, the output of the first has to match the input of the second. Remember that -> is right associative, so the function signature can be read as (a -> b) -> (b -> c) -> (a -> c). This can be read as “Given a function from a to b and a function from b to c, I’ll construct a function from a to c”. >> is the flipped version of \(\circ\). So f >> g is the same as \(g \circ f\). If you like the more mathy way of writing your composition, you can rather write g << f, but personally, I like reading code left to right.

let readUser () = System.Console.ReadLine ()
let createGreeting user = sprintf "Hello %s" user

let user = readUser ()
let greeting = createGreeting user

let greetUser = readUser >> createGreeting

The first is the imperative way of first calling one function, storing the result, then using the result in a second call and so on. The last line will create a function that does both. In our number guessing game, we use this composition several places.

Let’s define >> ourselves.

let (>>) f g a = g (f a)

let (>>) f g a = g (f a);;
val (>>) : f: ('a -> 'b) -> g: ('b -> 'c) -> a: 'a -> 'c

Another useful function is |>:

(|>)

(|>);;
val it: ('a -> ('a -> 'b) -> 'b)

This makes it simple to chain a result through a set of functions where each function has as input the previous result

let isEven x = (x % 2) = 0
let a =
  1
  |> isEven
  |> not

let b =
  2
  |> isEven
  |> not

let isEven x = (x % 2) = 0
let a =
  1
  |> isEven
  |> not

let b =
  2
  |> isEven
  |> not;;
val isEven: x: int -> bool

Defining it ourselves is easy

let (|>) x f = f x

let (|>) x f = f x;;
val (|>) : x: 'a -> f: ('a -> 'b) -> 'b

Given the simplicity of the implementation, it’s amazing how useful it is in practice. The above two constructs lets you easily replace your Linq needs in F# either by chaining data directly through your process using |>, or creating a more generic function using >>:

[10..200]
|> Seq.map ((+) 1)
|> Seq.filter (fun x -> x % 2 = 1)
|> Seq.skipWhile (fun x -> x < 100)
|> Seq.take 3

seq [101; 103; 105]

Yet another is one that deconstructs a tuple while it goes

("Hello", "World!")
||> printfn "First: %s, Second: %s"

("Hello", "World!")
||> printfn "First: %s, Second: %s";;
First: Hello, Second: World!

All these have similar functions composing the other way: <<, <| etc.

We have already looked at partial application. Any time you apply an argument to a function, you create a new function with one less parameter. When the last parameter is bound, the function is called.

As function parameters are bound left to right, it’s important to put the most “static” parameters first, and the data you wish to operate over last. This way you can create a new function by configuring an existing function.

  let filterMap f m =
    Seq.filter f
    >> Seq.map m

  let myFunction =
      filterMap
        (fun x -> x > 0)
        (fun x -> -x)

  myFunction [-5 .. 5] |> List.ofSeq

fold (also called reduce) is a very useful abstraction that we need examine more closely.

Seq.fold

Seq.fold;;
val it: (('a -> 'b -> 'a) -> 'a -> seq<'b> -> 'a)

'a is our state, and 'b is our element. We need a function that takes the state so far, an element from the sequence, and returns a new state. It’s often used to aggregate values as with sum, but as long as we conform with the types, it can do pretty much everything. It might be useful to see a couple of examples.

This implements average by using a tuple containing the number of items and the running total as a tuple.

  let avg =
    Seq.fold (fun (c, t) v ->
        (c+1, t+v)
    ) (0, 0)
    >> fun (c, t) -> t/c

  avg [50..100]

75

Reversing a sequence

let rev = Seq.fold (fun xs x -> x :: xs) []
rev [1 ..5] // returns [5; 4; 3; 2; 1]

Picking the last element

let uncurry f a b = f (a, b)
let tryLast = Seq.fold (uncurry (snd >> Some)) None
let a = tryLast []
let b = tryLast [1; 2]

let uncurry f a b = f (a, b)
let tryLast = Seq.fold (uncurry (snd >> Some)) None
let a = tryLast []
let b = tryLast [1; 2];;
val uncurry: f: ('a * 'b -> 'c) -> a: 'a -> b: 'b -> 'c
val tryLast: (int list -> Option<int>)

Here we count the number of equal elements in a list, and returns a new list with a tuple containing the item and count ordered by the count.

  module Option =
      let getOr x = function | Some v -> v | None -> x

  let byCount =
    Seq.fold (fun s k ->
      Map.tryFind k s
      |> Option.map ((+) 1)
      |> Option.getOr 1
      |> fun v -> Map.add k v s
    ) Map.empty
    >> Map.toSeq
    >> Seq.sortByDescending snd
    >> Seq.toList

  byCount  [1; 2; 1; 1; 1; 2; 3]

The usecases are many. Whenever you need to work on a sequence of elements, you can usually solve it using fold, though it does take some practice both to read them, notice that you can use it, and write it. But by the time you’ve mastered folds, or at least gotten more proficient with them, you’ll miss them when you only have loops available.

type T = A of int
let f (A v) = v + 10
let a = f (A 0)

type T = A of int
let f (A v) = v + 10
let a = f (A 0);;
type T = | A of int

let swap (a, b) = (b, a)
let (a, b) = swap ("Hello", 24)

let swap (a, b) = (b, a)
let (a, b) = swap ("Hello", 24);;
val swap: a: 'a * b: 'b -> 'b * 'a

function exists because we’re lazy and would rather not specify an argument when it doesn’t help with clarity.

let f x = match x with | Some v -> v | None -> 10
let g = function | Some v -> v | None -> 10

let f x = match x with | Some v -> v | None -> 10
let g = function | Some v -> v | None -> 10;;

We used this in our number guessing game earlier

let answer = 10

let withFunction =
  [1]
  |> Seq.exists ((=) answer)
  |> function
      | true  -> "Correct"
      | false -> sprintf "The answer was %d" answer

let withMatch =
  [1]
  |> Seq.exists ((=) answer)
  |> fun x ->
      match x with
      | true  -> "Correct"
      | false -> sprintf "The answer was %d" answer

10

function only let’s us avoid a bit of boilerplate as it replaces fun x -> match x with with just function.