Do option types collapse?

Question

Here is an option type in F#:

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

Suppose I have an Option of an Option:

type Option2<'a> =
   | O of Option<'a>
   | None

Does it get collapsed down to just one Option?

Answer 1

No, F# has a nominal type system. Structurally equivalent types are not compatible. So even if you had Option and Option2 exactly the same (except the name), these types would be different. Your case is different, similar to asking whether a list of ints and a list of lists of ints are the same.

let hasOptionType (_ : Option<_>) = ()
let hasOption2Type (_ : Option2<_>) = ()

let o = Option.None
let o2 = Option2.None

hasOptionType o
//hasOption2Type o // does not compile
//hasOptionType o2 // does not compile
hasOption2Type o2

You can have type aliases though that work both ways:

type IntOption = Option<int>

let isOptionOfInt (_ : Option<int>) = ()
let isIntOption (_ : IntOption) = ()

let i = IntOption.None
let i2 = Option<int>.None

isOptionOfInt i
isOptionOfInt i2
isIntOption i
isIntOption i2

Answer 2

Your question is a little confusing because you talk about an Option of an Option, but then show a type which is your own Option2 type containing an Option.

I'm going to assume your question is really this: Does Some (Some x) collapse down to Some x?

The answer to that is no. That collapsing would implicitly change the type and you would lose some of the type safety that Option provides. And the distinction between the collapsed and non-collapsed versions may be important. Take this example.

match List.tryHead [Some 1; None; Some 2] with
| Some (Some x) -> sprintf "The first item exists with a value of %i" x
| Some None     -> "The first item exists but it has no value"
| None          -> "The list was empty"

The List.tryHead function returns the first element of the list, or None if the list is empty. We are passing it a list of Option<int> so it returns an Option<Option<int>>

We are able to match on the return values to cover all the different possible cases of that return type. This may be useful if you want to handle those cases differently.

But we still have the ability to treat Some None and None as equivalent:

match List.tryHead [Some 1; None; Some 2] with
| Some (Some x) -> sprintf "The first item exists with a value of %i" x
| _             -> "No value found"