Ways of Creating Single Case Discriminated Unions in F#

There are quite a few ways of creating single case discriminated unions in F# and this makes them popular for wrapping primatives. In this post, I will go through a number of the approaches that I have seen. The inspiration for this post is Twitter threads from the likes of @McCrews, @asp_net and @jordan_n_marr. It is in no way exhaustive but should give you plenty of ideas.

Basics

We start with a simple single case discriminated union:

type CustomerId = CustomerId of Guid

To create a CustomerId and deconstruct it to get the value, we can do the following:

let id = CustomerId (Guid.NewGuid())
let (CustomerId value) = id

We can add a private modifier to it which means that we do not have access to the constructor and cannot create a CustomerId outside of the module the type is defined in:

type CustomerId = private CustomerId of Guid

// Problem outside of current module
let id = CustomerId (Guid.NewGuid())
let (CustomerId value) = id

type CustomerId = private CustomerId of Guid

module CustomerId =
    let New() = CustomerId (Guid.NewGuid())
    let Value (CustomerId value) = id

We can now create a CustomerId and extract the value from it like this:

let id = CustomerId.New()
let value = CustomerId.Value id

type CustomerId = private CustomerId of Guid
    with
        member this.Value =
            let (CustomerId value) = this
            value
        static member New() = CustomerId (Guid.NewGuid())

This now makes extracting the value much cleaner:

let id = CustomerId.New()
let value = id.Value

If you think that the two lines for the Value function are one too many, we can write it in one line. This is the first version using the in keyword:

type CustomerId = private CustomerId of Guid
    with
        member this.Value = let (CustomerId value) = this in value
        static member New() = CustomerId (Guid.NewGuid())

It doesn't impact how we create and extract the data:

let id = CustomerId.New()
let value = id.Value

Another way is to use an anonymous function:

type CustomerId = private CustomerId of Guid
    with
        member this.Value = this |> fun (CustomerId value) -> value
        static member New() = CustomerId (Guid.NewGuid())

Again the usage is the same as before:

let id = CustomerId.New()
let value = id.Value

Having a separate New function means that we could add logic to ensure that it cannot be created with an invalid value. If you don't need that, we can remove the private access modifier and the New function:

type CustomerId = CustomerId of Guid with member this.Value = this |> fun (CustomerId value) -> value

Usage then looks like this:

let id = CustomerId (Guid.NewGuid())
let value = id.Value

Alternate Solution

After I'd posted this article, @Savlambda suggested an alternate approach using an active pattern:

module Identifier =
    type CustomerId = private CustomerId of Guid
        with
            static member New() = CustomerId (Guid.NewGuid())

    let (|CustomerId|) (CustomerId value) = value

Using the new module looks like this:

module OtherModule =
    open Identifier

    let id = CustomerId.New()
    let (CustomerId value) = id

type CustomerId = { CustomerId : Guid }

Creation and value extraction look like this:

let id = { CustomerId = Guid.NewGuid() }
let value = id.CustomerId

That's not too different! We can even add member functions to record types:

type CustomerId = { CustomerId : Guid }
    with 
        member this.Value = this.CustomerId
        static member New() = { CustomerId = Guid.NewGuid() }

This means that we can create and extract the value in exactly the same way that we did with single case discriminated unions:

let id = CustomerId.New()
let value = id.Value