Pattern Matching in F#

Pattern matching is one of the most useful constructs in F#. Pattern matching operates on some value, matching the form of that value and altering control flow thus causing a corresponding expression to be evaluated . Lets take a look at a simple example:

let actor name = match name with | "Tom Cruise" -> "He is crazy" | _ -> "Not crazy";;

The LHS (left hand side) should look pretty familiar. Here we've defined a function called actor that takes one argument, name. On the RHS we've got the pattern matching construct using the match...with syntax. Here we're matching on the argument to the function, name. The computation of the matching is sequential so first it attempts to match the string "Tom Cruise". If the name value is "Tom Cruise" it will return the string "He is Crazy". If it does not match that string it will move on to the next pattern. In this case the next pattern is the wildcard pattern which matches everything.

For fun lets try and remove our wildcard pattern and see how the compiler/interpreter likes that:

let actor name = match name with
                        | "Tom Cruise" -> "He is crazy";;

warning: Incomplete pattern match.

As you can see, a warning was generated letting us know that our pattern match is not exhaustive. By exhaustive we mean that not all possible inputs will be matched. I wonder what happens when we try and call this function using a string we can't match on:

actor "Corey Feldman";;

Exception of type 'Microsoft.FSharp.Core.MatchFailureException' was thrown

Uh oh. What happens here is that our pattern was modified by the compiler to have a default path that generates a MatchFailureException exception. So when we called our function with a string it could match the exception was thrown. As you can see, it's good practice to define your pattern match expressions to be exhaustive.

Guarding your patterns

Guarding rules are another tool you can use when dealing with pattern matching. A guarding rule appears after your pattern and is executed if that pattern matches. The guarding rule is simply a conditional expression that if true, will evaluate the expression corresponding to that pattern. If the rule evaluates to false, control will flow to the next pattern. Below we extend the previous example to use a guarding rule:

let actor name isIceMan = match name with
                                        | "Tom Cruise" when not isIceMan -> "He is crazy"
                                        | _ -> "Not crazy";;

Now we've added the additional isIceMan argument to the function. We've also added a guarding rule to the first pattern to check whether the bool value isIceMan is true or false. If it's false the first pattern matches and the function returns "He is crazy". If it's true then we move on and try to match on the next pattern. Here's how we might use this function:

> actor "Tom Cruise" true;;
val it : string = "Not crazy"
> actor "Tom Cruise" false;;
val it : string = "He is crazy"

Lets try another pattern that's a little more difficult. Lets say that we have a list of integers and we want to return the first value in the list if it's even. If it's not, then we want to return the last value in the list if it's even. If neither of them are even we want to return 0. How could we do that? First things first, lets create a little recursive function that will walk through our list and return the last value:

let rec lastElement list = if (List.length list <= 1) then List.hd list else lastElement (List.tl list);;

Pretty simple huh? Our recursive function will return the first element in the list if the length of the list is one or less. If it's not, then it will call itself with the tail of the list. The List.tl function (tail) will return a list of everything but the first element in the list. So we'll keep removing one element until the list only has one element left, which is the last element in the original list.

Now that we have our function for getting the last element lets try our pattern:

let contrivedExample list = match list with
                                        | _ when List.hd list % 2 = 0 -> List.hd list
                                        | _ when lastElement list % 2 = 0 -> lastElement list
                                        | _ -> 0;;

Pretty simple huh? Our first pattern checks the head of the list and the second pattern uses our recursive function to check the last element. If neither is even, we return zero.