Concise pattern match on single case discriminated union in F#

Question

Say I have the following single case discriminated union:

type OrderId = OrderId of string

At some point I need the actual string. The way I've found for extracting it is:

let id = match orderId with OrderId x -> x

Is there a more concise way of doing this?

I understand that my use is a special case and the match makes sense in order to make sure you've covered the possibilities, just wondering if there's a way of doing something like:

let OrderId id = orderId

Answer 1

You're almost there. Parentheses are required in order that the compiler interprets a let-bound as pattern matching:

let (OrderId id) = orderId

If orderId is a parameter of a function, you can also use pattern matching directly there:

let extractId (OrderId id) = id

Answer 2

When you're using a discriminated union to hold a single value (which is a useful F# programming technique), then it might make sense to define it with a property for accessing the value:

type OrderId = 
  | OrderId of string 
  member x.Value = let (OrderId v) = x in v

The implementation of Value is using the pattern matching using let as posted by pad. Now, if you have a value orderId of type OrderId, you can just write:

let id = orderId.Value

However, the pattern matching using (OrderId id) is still quite useful, because property access will only work when the compiler already knows the type of orderId (so you would typically use pattern matching in function argument, but property access for other values).