Pattern-Matching on

Lesson 8: Refutable vs Irrefutable Patterns — Where they apply

Thu, 08 Aug 2024 12:40:00 +0000

I remember the first time the Rust compiler told me “refutable pattern in local binding.” I stared at the error for five minutes, Googled “refutable pattern Rust,” read the explanation, and thought: “That’s… actually a really good distinction that no other language makes explicit.”

Every pattern in Rust is either refutable or irrefutable. Understanding which is which — and where each is allowed — clears up a whole class of confusing compiler errors.

Lesson 7: The Visitor Pattern via Enums — When trait objects won't cut it

Mon, 05 Aug 2024 20:15:00 +0000

I spent a week once trying to make trait objects work for an AST walker. Every new operation meant a new trait, a new impl block for every node type, and a growing pile of boilerplate. When I rewrote the whole thing with an enum and match, the code shrank by 60% and got faster. Not every problem needs dynamic dispatch.

The Problem: Open vs. Closed Hierarchies

In object-oriented languages, the visitor pattern exists because class hierarchies are “open” — anyone can add new subclasses, so you can’t write a switch over all possible types. You need double dispatch through interfaces.

Lesson 6: State Machines with Enums — Compile-time guarantees

Fri, 02 Aug 2024 07:20:00 +0000

Three years ago, I debugged a payment processing system where an order could go from “refunded” back to “shipped.” Nobody intended for that to happen. The state machine was implemented with a status string and a bunch of if/else checks scattered across eight files. One developer added a shortcut. Review missed it. Customers got refund emails followed by shipping confirmations.

If the state machine had been in the type system, that shortcut wouldn’t have compiled.

Lesson 5: Enums Carrying Data — Modeling real domains

Tue, 30 Jul 2024 09:55:00 +0000

The worst bug I ever shipped came from a status field that was a string. It could be “active”, “Active”, “ACTIVE”, “active “, or — my personal favorite — “acitve”. Six months of data with a typo nobody caught because strings don’t have a compiler checking them.

Rust enums would have made that bug impossible.

The Problem With Primitive Obsession

In most languages, developers reach for strings, integers, and booleans to represent domain concepts. A user’s role is a string. An order status is an integer. A payment method is… also a string. This is called “primitive obsession” and it’s responsible for an entire category of bugs:

Lesson 4: Or Patterns, @ Bindings, and Rest Patterns — The full syntax

Sat, 27 Jul 2024 14:10:00 +0000

I was reviewing a PR last year where someone had written twelve match arms for an enum — four groups of three variants that all did the same thing. Each group was identical code, copy-pasted three times. I left a one-line comment: “or patterns.” The whole match collapsed from 36 lines to 12.

Most Rust developers learn the basics of match early and never dig into the full pattern syntax. That’s a shame, because there are three features that eliminate a ton of redundancy: or patterns, @ bindings, and rest patterns.

Lesson 3: Match Guards and Bindings — Fine-grained control

Thu, 25 Jul 2024 08:30:00 +0000

A few months back I was writing a rate limiter. The logic was simple: if the request is from an internal IP and the rate is under the limit, allow it. If it’s external and under a different limit, allow it. Otherwise, reject. I started with nested if statements inside match arms and ended up with something that looked like a plate of spaghetti. Then I rewrote it with match guards and the whole function collapsed to six clean lines.

Lesson 2: Destructuring — Structs, tuples, enums, nested

Mon, 22 Jul 2024 16:45:00 +0000

I used to write code like point.x, point.y, point.z over and over in the same function. Three fields, three accesses, repeated twelve times. Then I learned destructuring and realized I’d been doing the equivalent of opening a package, looking at each item individually, and putting it back before looking at the next one.

Destructuring is opening the package and grabbing everything at once.

The Problem With Field-by-Field Access

When you work with compound types — structs, tuples, enums with data — you constantly need to pull values out of them. In most languages, this means dot access or method calls, and you end up with verbose code that obscures the actual logic:

Lesson 1: match — Exhaustive by design

Sat, 20 Jul 2024 11:23:00 +0000

I shipped a Python service once that had a match statement handling four message types. Three months later, the team added a fifth type. Nobody updated the match. The default branch silently swallowed the new messages, and we lost two days of analytics data before anyone noticed.

Rust’s match wouldn’t have let that happen.

The Problem With Non-Exhaustive Matching

Most languages treat pattern matching (or switch/case) as a convenience. You list the cases you care about, slap a default at the bottom, and move on. The problem is that code evolves. New variants get added, old assumptions break, and that default case quietly covers up bugs.