United Kingdom: +44 (0)208 088 8978

Using the Option module in F#

Dragos takes a look at the Option module

We're hiring Software Developers

Click here to find out more


In Object-Oriented Programming, it is not uncommon to encounter null values, which can lead to null reference errors. Despite the existence of extensive code to mitigate these errors, they still persist in C# code bases.

On the other hand, in functional programming, null values are not typically utilized. Thanks to immutability, we can rely on values to always contain something. In cases where null values are expected at the boundaries of our system or when we anticipate the absence of a value, we have effective mechanisms to handle such situations.

The secret weapon F# uses for dealing with null value is the option type which is basically a Discriminated Union:

type Option<'T> =
    | Some of 'T
    | None

A breakdown:

  • Option<'T>: This declares the Option type, a discriminated union.
  • Some of 'T: This case represents a value that is present. It wraps a value of type 'T using the Some constructor where T is our payload.
  • None: This case represents the absence of a value. It signifies that no value is present.

Note: T represents a generic type

To access the payload of an Option type in F#, there are a couple of approaches. One of the simplest ways is by utilizing pattern matching.

let printGreeting (name: string option) =
    match name with
    | Some n -> printfn "Hello, %s!" n
    | None -> printfn "Hello, anonymous!"

let name1 = Some "Alice"
let name2 = None

printGreeting name1 // Output: Hello, Alice!
printGreeting name2 // Output: Hello, anonymous!

Option module

The Option module in F# provides a variety of functions that assist in accessing and handling Option values.


The Option.defaultValue function provides a convenient way to specify a default value and use it when accessing an Option. If the Option value is None, the default value is returned instead.

The argument order in Option.defaultValue might seem unconventional at first, with the default value as the first argument and the Option as the second argument. However, this design decision aligns well with F#'s pipeline-friendly programming style, allowing for smooth integration in code pipelines.

let getUserAgeFromDB (userName:string) =
    match userName with
    | "John" -> Some 25
    | _ -> None

let getUserAge userName = 
    |> getUserAgeFromDB
    |> Option.defaultValue 18

let aliceAge = getUserAge "Alice"
let bobAge = getUserAge "Bob"

printfn "Alice's age: %d" aliceAge // Output: Alice's age: 25
printfn "Bob's age: %d" bobAge // Output: Bob's age: 18 (default value)


A familiar syntax, it allows us to print out the payload or write to a file. It only performs on Some values otherwise it doesn't do anything.

let printEmail (email: string) =
    printfn "Sending email to %s" email

let emailOption : string option = Some "alice@example.com"
emailOption |> Option.iter printEmail


Option.map applies a function to the underlying value of the option if has Some and it will still return as Some followed by the modified value, otherwise return None.

Some "hello" |> Option.map (fun greeting -> greeting.ToUpper()) // Some "Hello"

Handling pre-existing nulls

If you are already being given null values like "Some null", there are a few options to handle them effectively. One approach is creating a function designed to handle these null values.

For instance, you can define a function in F# to handle null values as follows:

type SafeString (s: string) = 
        if s = null then
            raise <| System.ArgumentException()
    member __.Value = s
    override __.ToString() = s

This example was taken Stylish F# 6 by Kit Easton

Option.ofObj Option.ofNullable

The Option module in F# offers useful functions to handle null values. One such function is Option.ofObj, which allows you to wrap an existing value in an option type. When using Option.ofObj, if the value provided is not null, it will be encapsulated within the Some case, signifying the presence of a value. However, if the value is null, the function will return None, indicating the absence of a value.

Option.ofObj "Hello" // Some "Hello"

Option.ofObj null // None

Similarly, if you're working with instances of System.Nullable, you can use Option.ofNullable to convert them into an option type.

Option.ofNullable (System.Nullable(96)) // Some 96

Option.ofNullable (System.Nullable()) // None

Option.toObj Option.toNullable

We can reverse the process and transform the None option into null

Option.toObj will convert an option to a null value if the input was None or it just extract the value from Some

(None: string option) |> Option.toObj // null
Some "text" |> Option.toObj // text

And Option.toNullable makes into a System.Nullable

(None: int option) |> Option.toNullable // evaluates to new System.Nullable<int>()
Some 42 |> Option.toNullable // evaluates to new System.Nullable(42)


In this blog post, we've taken a brief look at some common functions within the Option module for handling option values. It provided a short overview, but there is much more to explore. In future posts, I plan to delve deeper into advanced concepts such as Option.bind and ValueOption, providing a more in-depth understanding.

In the meantime, I highly recommend checking out Kit Eason's book, "Stylish F# 6". It offers comprehensive coverage of working with options and other advanced topics in F#. I found it to be an incredibly educational resource, and it will undoubtedly provide you with valuable insights.