Knowing 'When' to Switch: A Glimpse into the Future of Pattern Matching

An overview of the when statement: a flexible pattern matching structure in DeltaScript, and an alternative to switch

\ I have spent over a year working obsessively to bring my vision of the perfect pixel art editor to life. The fruit of my labor is Stipple Effect, a program that lets users write scripts for a variety of use cases, including transforming the project for display in the preview window in real-time:

\

\ I was very particular about how I wanted the script-writing process to feel for users: quick, clear, painless, iterative. To achieve that, I designed and implemented my own scripting language rather than embedding Lua or another established scripting language in my program.

\ The result is DeltaScript, a scripting language "sketelon" designed to be extended for specific application domains. Stipple Effect's scripting API is one such extension.

\ I released the language specification for DeltaScript v0.1.0 last week (Jan 16, 2025), so I figured now is the perfect time to write about one of the features I am most excited about.

:::info Note: This blog post is adapted from the original on my website. Read it there to see the proper syntax highlighting for DeltaScript code snippets.

:::

Why when?

DeltaScript was always supposed to be a high-level interpreted language. As such, I wanted the language to have powerful, flexible control flow structures that could express complex logic concisely and still be readable and maintainable.

\ One of my biggest frustrations as a programmer is the limitations and the implementation philosophy of the traditional switch statement: limited to literals in case labels, fallthrough, etc.

\ I do most of my programming in Java, and I must say, recent Java language versions have drastically extended the functionality of switch and turned it into a near-perfect pattern-matching structure. I wanted to do something similar for DeltaScript.

How when works

My when statement supports three different kinds of non-trivial cases:

• is - matches the control expression against one or more expressions, checking for equality
• matches - uses the special identifier _ to replace the control expression and defines a pattern in the form of a boolean expression
• passes - accepts a test function (predicate) of type (T -> bool), where T is the type of the control expression

\ These cases can be arranged inside a when statement in any order. Each case is checked in order until a case passes its check, at which point the case body is executed. There is no fallthrough; once the runtime execution identifies a successful match case and executes its body, the execution drops out of the when statement and executes the statement that follows it.

\ Consider this example:

(color c) { ~ string pfx = "The color is "; when (c) { matches _.alpha == 0 -> print(pfx + "transparent"); is #000000 -> print(pfx + "black"); is #ffffff -> print(pfx + "white"); matches _.r == _.g && _.r == _.b && opaque(_) -> print(pfx + "a shade of grey"); is #ff0000, #00ff00, #0000ff -> print(pfx + "an RGB primary color"); passes ::bright_opaque -> print("bright"); otherwise -> print(pfx + "not a match"); } } bright_opaque(color c -> bool) { int max = max([ c.r, c.g, c.b ]); return max == 0xff && opaque(c); } opaque(color c -> bool) -> c.alpha == 0xff

\ This logic cannot be expressed by a traditional switch statement. Expressing it with an if…else if would look like this:

\

(color c) { ~ string pfx = "The color is "; if (c.alpha == 0) print(pfx + "transparent"); else if (c == #000000) print(pfx + "black"); else if (c == #ffffff) print(pfx + "white"); else if (c.r == c.g && c.r == c.b && opaque(c)) print(pfx + "a shade of grey"); else if (c == #ff0000 || c == #00ff00 || c == #0000ff) print(pfx + "an RGB primary color"); else if (bright_opaque(c)) print("bright"); else print(pfx + "not a match"); } bright_opaque(color c -> bool) { int max = max([ c.r, c.g, c.b ]); return max == 0xff && opaque(c); } opaque(color c -> bool) -> c.alpha == 0xff

\ You can read the full semantics of the when statement in the language specification.

\ I'll leave you with this long-form example that shows off a few additional language features of interest:

\

() { string[] words = [ "Racecar", "Pilot", "Madam", "Able was I ere I saw Elba", "Nurses run", "Highway 61", "A man, a plan, a canal - Panama" ]; (string -> bool) no_whitespace_palindrome = (s -> palindrome(no_whitespace(s))); for (word in words) { when (word) { passes ::palindrome -> print("\"" + _ + "\" is a pure palindrome!"); passes no_whitespace_palindrome -> print("\"" + _ + "\" is a palindrome if whitespace is ignored"); passes (s -> palindrome(only_letters(s))) -> print("\"" + _ + "\" is a palindrome if whitespace and punctuation are ignored"); otherwise -> print("\"" + _ + "\" is not a palindrome"); } } } palindrome(string s -> bool) { string lc = lowercase(s); return lc == reverse(lc); } reverse(string s -> string) { string res = ""; for (c in s) res = c + res; return res; } lowercase(string s -> string) { string res = ""; for (c in s) { int unicode = (int) c; if (uppercase_letter(c)) res += (char) ((int) 'a' + (unicode - (int) 'A')) else res += c; } return res; } no_whitespace(string s -> string) { ~ char{} WHITESPACE = { ' ', '\t' '\n' }; string res = ""; for (c in s) if (!WHITESPACE.has(c)) res += c; return res; } only_letters(string s -> string) { string res = ""; for (c in s) if (uppercase_letter(c) || lowercase_letter(c)) res += c; return res; } uppercase_letter(char c -> bool) { int unicode = (int) c; return unicode >= (int) 'A' && unicode <= (int) 'Z'; } lowercase_letter(char c -> bool) { int unicode = (int) c; return unicode >= (int) 'a' && unicode <= (int) 'z'; }

\ This script produces the following output:

"Racecar" is a pure palindrome! "Pilot" is not a palindrome "Madam" is a pure palindrome! "Able was I ere I saw Elba" is a pure palindrome! "Nurses run" is a palindrome if whitespace is ignored "Highway 61" is not a palindrome "A man, a plan, a canal - Panama" is a palindrome if whitespace and punctuation are ignored

\