Categories

# F# Friday – Pattern Matching, Part 4: Active Patterns

Active patterns and partial active patterns round out the F# developer’s toolbox for pattern matching.

### These Patterns Are Highly Active

An active pattern allows you to define a set of named cases that you can use in your pattern matching expressions. The active recognizer, the type of function that defines active patterns, encapsulates pattern matching logic and associates it with the case name(s). The advantage is that you can give a readable name to a case that effectively communicates the nature of the match, but hide some of the clutter that can threaten the readability of your code.

A classic example is determining whether an integer is even or odd. Now you could do that this way:

```match n % 2 with
| 0 -> n, "even"
| _ -> n, "odd"
```

Now `n % 2` is a simple expression, and its use common enough in computer science that most of us recognize right away, whenever we see it, “Oh, right, even or odd.” But there is just the slightest context switch between thinking mathematically and thinking conceptually, i.e., determining intent. And that context switch slows us down. A more complex expression can slow us down even more.

Compare the above (admittedly simple) match expression to what you can do with an active pattern. First, define the active pattern this way:

```let (|Even|Odd|) n =
match n % 2 with
| 0 -> Even
| _ -> Odd
```

Where you usually give a name to the function, you now have a set of pipe-delimited names between what are known as banana clips `(| |)`. Those names are case names that you will be able to use in match expressions. Finally, in the body of the active recognizer, you define a return path for each case name.

Now after defining the active pattern, you can use it in a match expression like this:

```let oddOrEven n =
match n with
| Even -> n, "even"
| Odd -> n, "odd"

seq { 1..10 }
|> Seq.map oddOrEven
|> Seq.iter (printfn "%O")
// (1, odd)
// (2, even)
// (3, odd)
// (4, even)
// (5, odd)
// (6, even)
// (7, odd)
// (8, even)
// (9, odd)
// (10, even)
```

Look at the difference in readability. There is no context switch. It reads much smoother than the original match expression. You can see that `oddOrEven` takes a value, `n`, and returns a result based on whether `n` is even or odd. You don’t have to leave the realm of the conceptual to think mathematically and then turn right back around to think conceptually again.

A point of emphasis: When defining an active pattern, you need to cover all the bases and define a return condition for every case. (In that regard, an active pattern is something like an algebraic data type.) That is easy for the even/odd test: There are only two cases.

But what if there are several cases? Take the wavelengths of colors in the spectrum of visible light. Each color corresponds to a range of wavelengths:

Color Wavelength Ranges
Color Wavelength
Red 620–750 nm
Orange 590–620 nm
Yellow 570–590 nm
Green 495–570 nm
Blue 450–495 nm
Violet 380–450 nm

No problem, right? Just define a quick little active pattern:

```let (|Red|Orange|Yellow|Green|Blue|Violet|) λ =
match λ with
| x when 620 <= x && x < 750 -> Red
| x when 590 <= x && x < 620 -> Orange
| x when 570 <= x && x < 590 -> Yellow
| x when 495 <= x && x < 570 -> Green
| x when 450 <= x && x < 495 -> Blue
| x when 380 <= x && x < 450 -> Violet
```

But wait! The compiler tells you, “Incomplete pattern matches on this expression.” That is because there is radiation outside the visible spectrum; `λ` could be greater than 750 nm or less than 380 nm. You therefore need a catch-all case to cover the values that are outside the explicit cases:

```let (|Red|Orange|Yellow|Green|Blue|Violet|Invisible|) λ =
match λ with
| x when 620 <= x && x < 750 -> Red
| x when 590 <= x && x < 620 -> Orange
| x when 570 <= x && x < 590 -> Yellow
| x when 495 <= x && x < 570 -> Green
| x when 450 <= x && x < 495 -> Blue
| x when 380 <= x && x < 450 -> Violet
| _ -> Invisible
```

Now you can use the active pattern like this:

```let colorOfLight λ =
match λ with
| Red -> (sprintf "%d nm" λ), "red"
| Orange -> (sprintf "%d nm" λ), "orange"
| Yellow -> (sprintf "%d nm" λ), "yellow"
| Green -> (sprintf "%d nm" λ), "green"
| Blue -> (sprintf "%d nm" λ), "blue"
| Violet -> (sprintf "%d nm" λ), "violet"
| Invisible -> (sprintf "%d nm" λ), "invisible"

seq [800; 700; 600; 580; 500; 475; 400; 350]
|> Seq.map colorOfLight
|> Seq.iter (printfn "%O")
// (800 nm, invisible)
// (700 nm, red)
// (600 nm, orange)
// (580 nm, yellow)
// (500 nm, green)
// (475 nm, blue)
// (400 nm, violet)
// (350 nm, invisible)
```

One final word before moving on: There is a limit to the number of cases in an active pattern. It can contain no more than seven cases. Your spectrum-of-light active pattern just so happens to go right up to that limit. If, for instance, you had needed to account for an indigo band of wavelengths between blue and violet, you would have had to take a different approach.

### Active In Part

A partial active pattern is similar to an active pattern, but it does not cover the entire input domain. If the input meets the criteria sought, you return the case name in a `Some`. If not, you return a `None`.

Perhaps you are a clerk in a department store. You recommend that customers who are at least 6′ (72 inches) tall and have at least a 40-inch waist go to the Big & Tall section. Others you greet according to their proportions.

First, define a `Measurements` type:

```type Measurements = {
Height : int
Waist : int
}
```

Then define partial active patterns: one to detect whether a customer meets the “big” criterion and another to detect whether he meets the “tall” criterion.

```let (|Big|_|) (m : Measurements) =
if m.Waist >= 40 then Some Big else None
let (|Tall|_|) (m : Measurements) =
if m.Height >= 72 then Some Tall else None
```

Now that you have the patterns defined, you can use them in a match expression:

```let sizeUp m =
match m with
| Big & Tall ->
"Let me show you to the big & tall section"
| Big ->
"Big fella, ain'tcha?"
| Tall ->
"How's the weather up there?"
| _ ->
"May I help you, sir?"
```

Notice how you can use partial active patterns together and by themselves. Now you run some customers through the `sizeUp` function:

```let me = { Height = 76; Waist = 36 }
let shrimp = { Height = 58; Waist = 28 }
let hoss = { Height = 80; Waist = 46 }
let tubby = { Height = 63; Waist = 42 }

seq [me; shrimp; hoss; tubby]
|> Seq.map sizeUp
|> Seq.iter (printfn "%s")
// How's the weather up there?
// May I help you, sir?
// Let me show you to the big & tall section
// Big fella, ain'tcha?
```

### Parameterizing on the Fly

Finally, active patterns may accept more than just the one parameter they test against. They can accept additional parameters in order to configure or modify their behavior.

You have a list of test scores, and you want to convert each to a letter grade. You can start by defining the partial active pattern `AtLeast` that takes a number, `n`, and returns a match only if evaluated against a `score` that is greater than or equal to `n`:

```let (|AtLeast|_|) n score =
if score >= n then Some AtLeast else None
```

Now build a `grade` function using `AtLeast`:

```let grade =
function
| AtLeast 90 -> "A"
| AtLeast 80 -> "B"
| AtLeast 70 -> "C"
| AtLeast 60 -> "D"
| _ -> "F"
```

Just a reminder that order matters in match expressions. If you had put the `AtLeast 60` match case before the `AtLeast 90` match case, then `AtLeast 90` would never match. `AtLeast 60` would always match first.

Evaluating a list of scores is now straightforward:

```seq [95; 31; 72; 67; 89]
|> Seq.map (fun n -> n, grade n)
|> Seq.iter (printfn "%O")
// (95, A)
// (31, F)
// (72, C)
// (67, D)
// (89, B)
```

## One reply on “F# Friday – Pattern Matching, Part 4: Active Patterns”

[…] F# Friday – Pattern Matching, Part 4: Active Patterns – Brad Collins […]

This site uses Akismet to reduce spam. Learn how your comment data is processed.