F# Option Cheat Sheet

From what I have seen, pattern matching is overused in F#, especially when dealing with options. It is not hard to spot code like this in F# codebases:

1
match x with
2
| Some a -> Some <| f a
3
| None -> None

Here is what is wrong with this style of code:

1. The intent is not immediately obvious; the abstraction level is too low.
2. It is verbose.
3. Pattern matching does not compose.

We can alleviate all of these drawbacks by using higher-order functions that abstract over common option patterns.

For example, with the higher-order function map, the above code can be written more concisely as:

1
x |> map f

Tony Morris once blogged an Option cheat sheet for Scala. What follows is an F# translation of the same idea, with a couple of additional functions.

Several of the following functions are already part of F#‘s Option module. You should add the rest to your repertoire by extending the Option module. Alternatively, you can use FSharpx, which provides most of these functions, along with many others.

1
// map : ('a -> 'b) -> 'a option -> 'b option
2
let map f =
3
  function
4
  | Some a -> Some <| f a
5
  | None -> None
6

7
// filter : ('a -> bool) -> 'a option -> 'a option
8
let filter cond =
9
  function
10
  | Some a as s when cond a -> s
11
  | _ -> None
12

13
// iter : ('a -> unit) -> 'a option -> unit
14
let iter f =
15
  function
16
  | Some a -> f a
17
  | None -> ()
18

19
// fold : ('a -> 'b) -> 'b -> 'a option -> 'b
20
let fold f g =
21
  function
22
  | Some a -> f a
23
  | None -> g
24

25
// bind : ('a -> 'b option) -> 'a option -> 'b option
26
let bind f =
27
  function
28
  | Some a -> f a
29
  | None -> None
30

31
// flatten : 'a option option -> 'a option
32
let flatten =
33
  function
34
  | Some a -> a
35
  | None -> None
36

37
// getOrElse : 'a -> 'a option -> 'a
38
let getOrElse d =
39
  function
40
  | Some a -> a
41
  | None -> d
42

43
// orElse : 'a option -> 'a option -> 'a option
44
let orElse b a =
45
  match a with
46
  | Some _ -> a
47
  | None -> b
48

49
// isSome : 'a option -> bool
50
let isSome =
51
  function
52
  | Some _ -> true
53
  | None -> false
54

55
// isNone : 'a option -> bool
56
let isNone =
57
  function
58
  | Some _ -> false
59
  | None -> true
60

61
// forall : ('a -> bool) -> 'a option -> bool
62
let forall cond =
63
  function
64
  | Some a -> cond a
65
  | None -> true
66

67
// exists : ('a -> bool) -> 'a option -> bool
68
let exists cond =
69
  function
70
  | Some a -> cond a
71
  | None -> false
72

73
// toList : 'a option -> 'a list
74
let toList =
75
  function
76
  | Some a -> a :: []
77
  | None -> []
78

79
// lift2 : ('a -> 'b -> 'c) -> 'a option -> 'b option -> 'c option
80
let lift2 f x y =
81
  match x with
82
  | None -> None
83
  | Some x' ->
84
      match y with
85
      | None -> None
86
      | Some y' -> Some <| f x' y'
87

88
// lift3 : ('a -> 'b -> 'c -> 'd) -> 'a option -> 'b option ->
89
// 'c option -> 'd option
90
let lift3 f x y z =
91
  match x with
92
  | None -> None
93
  | Some x' ->
94
      match y with
95
      | None -> None
96
      | Some y' ->
97
          match z with
98
          | None -> None
99
          | Some z' -> Some <| f x' y' z'

Here is some code I wrote not too long ago. The original was in Scala; here it is translated to F#. The task is this: you receive an HTTP POST request. The required parameter values come in the URI, and you receive one file as an attachment. If all of these arguments are present and well-formed, you compute something and return it.

This is what the code looks like with higher-order functions over option:

1
let customerCode =
2
  headers |> Map.tryFind "customer_code"
3

4
let sheetNr =
5
  headers |> Map.tryFind "sheet_nr" |> Option.bind Int32.parse
6

7
let file =
8
  headers
9
  |> Map.tryFind "attached_file"
10
  |> Option.bind (flip Map.tryFind attachments)
11

12
let result =
13
  Option.lift3 parseFile file customerCode sheetNr
14

15
respond <|
16
  match result with
17
  | Some (Choice1Of2 parsedValue) -> (200, parsedValue)
18
  | Some (Choice2Of2 errors) -> (400, toJson errors)
19
  | None -> (400, "Bad params")

In the above code, headers and attachments are assumed to have the types Map<string, string> and Map<string, File> respectively. Int32.parse is a safe string-to-integer conversion function from FSharpx with the type string -> int option. parseFile has the type File -> string -> int -> Choice<string, string list>. lift3 lifts it to the type File option -> string option -> int option -> Choice<string, string list> option. flip is another function from FSharpx, used for flipping function arguments; it turns 'a -> 'b -> 'c into 'b -> 'a -> 'c. respond is assumed to be a function for sending back the response, with the type (int, string) -> unit.

Now, my example above also happens to use pattern matching. Yes, there are justifiable use cases for pattern matching on option. This is when you should use it:

1. When each case requires elaborate handling. The higher-order-function equivalent would be fold, but it looks uglier if the function being passed is anything more than a one-liner.
2. When you are dealing with object graphs more than one level deep, for example matching over Choice<'a, 'b> option.
3. When matching over multiple options, for example int option * int option.

Everywhere else, higher-order functions usually make for more readable code.

Special thanks to Mauricio Scheffer for reviewing the draft and suggesting improvements.