Is a pattern match the only way to get data associated with a union case?

Question

Let's say you have this union:

type Thing = 
| Eagle
| Elephant of int

And your code has a list of Elephants, as in

let l = [Elephant (1000); Elephant (1200)]

And you wanted to iterate over l, and print out the data associated with each Elephant. Is there a way to do so without using a pattern match?

Answer 1

In your example, you say that you have a list of elephants - which is true in this case - but the type of l is really a list of Thing values and so it can contain both elephants and eagles. This is why you need to use pattern matching - to handle all possible cases.

If you regularly need to use list that contain only elephants, then it might make sense to define a separate type of elephants. Something like:

type ElephantInfo = { Size : int }

type Thing = 
  | Elephant of ElephantInfo
  | Eagle

Now you can create a list of type list<ElephantInfo> which can contain just elephants and so you don't need pattern matching:

let l1 = [ {Size=1}; {Size=2} ]
for el in l1 do printfn "%d" el.Size

On the other hand, if you want to mix elephants and eagles, you'll create list<Thing> and then use pattern matching:

let l2 = [ Elephant {Size=1}; Eagle ]

Answer 2

You could do this:

l
|> List.collect (function Elephant x -> [x] | _ -> [])
|> List.iter (printfn "%i")

Prints

1000
1200

It still uses pattern matching, but it's fairly minimal.

Answer 3

You have of course the option of going full Ivory Tower (® Scott Wlaschin)

As in about:

type Thing = 
 | Eagle
 | Elephant of int

type MaybeElephantBuilder() =      
 member this.Bind(x, f) = 
  match x with
  | Eagle -> 0
  | Elephant a -> f a

 member this.Return(x) = x

let maybeElephant = new MaybeElephantBuilder()

let l = 
 [ Elephant(1000)
   Elephant(1200)
    ]

let printIt v = 
 let i = 
  maybeElephant { 
   let! elephantValue = v  
   return elephantValue
  }
 printfn "%d" i   

l |> Seq.iter printIt

It will even handle the stuff with the Eagles thrown in there!

Well...

Remove the non-Eagles and the code will fly...

let l = 
 [ Eagle
   Leadon
   Elephant(1000)
   Eagle
   Meisner
   Elephant(1200)
   Eagle
   Felder
    ]

l |> Seq.iter printIt

But no. Its not nice. Its not short. Its more for fun (if that!) than anything else. Its probably the worst misuse of F# computation expressions ever too!

And you will need pattern matching somewhere.

Thx Scott! And Petricek.

Computation Expression Zoo for real! ;-)

Answer 4

You can use reflection from Microsoft.FSharp.Reflection Namespace but it is much more cumbersome and slow.

Pattern matching is probably the easiest way to get data from discriminated union.

(Also you have a list of Things all its members happen to be of Elephant union case).

Answer 5

There's a way to place the pattern match into the header of the function (or a let binding). It is still a pattern match, though.

// This function takes a tuple:
// the first argument is a Thing,
// the second is "default" weight to be processed if the first one is NOT an Elephant
let processElephant (Elephant weight, _ | _, weight) =
    weight

let [<Literal>] NON_ELEPHANT_WEIGHT = -1

// usage:
let totalWeight =
    [Elephant (1000); Elephant (1200)]
    |> List.sumBy (fun el -> processElephant(el, NON_ELEPHANT_WEIGHT))

This question and its answers provide with more details.