Match expressions and pattern matching

Blank patterns

Ablank patternhas the form_.It matches any expression without creating a variable binding.

For example:

_ = 42
"Always matches"
⧨
"Always matches"

Literal patterns

Aliteral patternis a literalBoolean,Nat,Int,Char,orText.A literal pattern matches if the scrutinee has that exact value.

For example:

match 2 Nat.+ 2 with
  4 -> "Matches"
  _ -> "Doesn't match"
⧨
"Matches"

Variable patterns

Avariable patternis aregular identifierand matches any expression. The expression that it matches will be bound to that identifier as a variable in the match body.

For example:

match 1 + 1 with
  x -> x + 1

As-patterns

Anas-patternhas the formv@pwherevis aregular identifierandpis a pattern. This pattern matches ifpmatches, and the variablevwill be bound in the body to the value matchingp.

For example, this expression evaluates to3:

matchExpression : Nat

matchExpression : Nat
matchExpression =
  use Nat +
  match 1 + 1 with
    x@4 ->
      use Nat *
      x * 2
    y@2 -> y + 1
    _   -> 22

Constructor patterns

Aconstructor patternhas the form `C p1 p2 … pn'' whereCis the name of a data constructor in scope, andp1throughpnare patterns such thatnis thearityofC.Note thatnmay be zero. This pattern matches if the scrutinee reduces to a fully applied invocation of the data constructorCand the patternsp1throughpnmatch the arguments to the constructor.

For example, this expression usesSomeandNone,the constructors of theOptionaltype, to return the 3rd element of the listxsif present or0if there was no 3rd element.

xs = [0, 2, 3, 4, 5]
match List.at 3 xs with
  None   -> 0
  Some x -> x
⧨
4

List patterns

Alist patternmatches aList tfor some typetand has one of three forms:

1. head List.+: tailmatches a list with at least one element. The patternheadis matched against the first element of the list andtailis matched against the suffix of the list with the first element removed.
2. init :+ lastmatches a list with at least one element. The patterninitis matched against the prefix of the list with the last element removed, andlastis matched against the last element of the list.
3. Aliteral list patternhas the form[p1, p2, … pn]wherep1throughpnare patterns. The patternsp1throughpnare matched against the elements of the list. This pattern only matches if the length of the scrutinee is the same as the number of elements in the pattern. The pattern[]matches the empty list.
4. part1 List.++ part2matches a list which composed of the concatenation ofpart1andpart2.At least one ofpart1orpart2must be a pattern with a known list length, otherwise it's unclear where the list is being split. For instance,[x, y] List.++ restis okay as isstart List.++ [x, y],but justa ++ bis not allowed.

Examples:

first : [a] -> Optional a
first = cases
  h +: _ -> Some h
  []     -> None
last : [a] -> Optional a
last = cases
  _ :+ l -> Some l
  []     -> None
exactlyOne : [a] -> Boolean
exactlyOne = cases
  [_] -> true
  _   -> false
lastTwo : [a] -> Optional (a, a)
lastTwo = cases
  start ++ [a, a2] -> Some (a, a2)
  _                -> None
firstTwo : [a] -> Optional (a, a)
firstTwo = cases
  [a, a2] ++ rest -> Some (a, a2)
  _               -> None

Tuple patterns

Atuple patternhas the form(p1, p2, … pn)wherep1throughpnare patterns. The pattern matches if the scrutinee is a tuple of the samearityas the pattern andp1throughpnmatch against the elements of the tuple. The pattern(p)is the same as the patternp,and the pattern()matches the literal value()of the trivial type {()} (both pronounced “unit”).

For example, this expression evaluates to `4`:

(a, _, c) = (1, 2, 3)
a Nat.+ c
⧨
4

Guard patterns

Aguard patternhas the formp | gwherepis a pattern andgis a Boolean expression that may reference any variables bound inp.The pattern matches ifpmatches andgevaluates totrue.

For example, the following expression evaluates to6:

match 1 + 2 with
  x
    | x == 4     -> 0
    | x + 1 == 4 -> 6
  _              -> 42