Patterns

## 6.6 Patterns

pattern | ::= | value-name
| ∣ | `_`
| ∣ | constant
| ∣ | pattern `as` value-name
| ∣ | `(` pattern `)`
| ∣ | `(` pattern `:` typexpr `)`
| ∣ | pattern `|` pattern
| ∣ | constr pattern
| ∣ | ```tag-name pattern
| ∣ | `#`typeconstr-name
| ∣ | pattern { `,` pattern }
| ∣ | `{` field `=` pattern { `;` field `=` pattern } `}`
| ∣ | `[` pattern { `;` pattern } `]`
| ∣ | pattern `::` pattern
| ∣ | `[|` pattern { `;` pattern } `|]`
| ∣ | `lazy` pattern

The table below shows the relative precedences and associativity of operators and non-closed pattern constructions. The constructions with higher precedences come first.

Operator | Associativity
Constructor application | –
`::` | right
`,` | –
`|` | left
`as` | –

Patterns are templates that allow selecting data structures of a given shape, and binding identifiers to components of the data structure. This selection operation is called pattern matching; its outcome is either “this value does not match this pattern”, or “this value matches this pattern, resulting in the following bindings of names to values”.

#### Variable patterns

A pattern that consists in a value name matches any value, binding the name to the value. The pattern `_` also matches any value, but does not bind any name.

Patterns are linear: a variable cannot appear several times in a given pattern. In particular, there is no way to test for equality between two parts of a data structure using only a pattern (but `when` guards can be used for this purpose).

#### Constant patterns

A pattern consisting in a constant matches the values that are equal to this constant.

#### Alias patterns

The pattern pattern1 `as` value-name matches the same values as pattern1. If the matching against pattern1 is successful, the name name is bound to the matched value, in addition to the bindings performed by the matching against pattern1.

#### Parenthesized patterns

The pattern `(` pattern1 `)` matches the same values as pattern1. A type constraint can appear in a parenthesized pattern, as in `(` pattern1 `:` typexpr `)`. This constraint forces the type of pattern1 to be compatible with typexpr.

#### “Or” patterns

The pattern pattern1 `|` pattern2 represents the logical “or” of the two patterns pattern1 and pattern2. A value matches pattern1 `|` pattern2 either if it matches pattern1 or if it matches pattern2. The two sub-patterns pattern1 and pattern2 must bind exactly the same identifiers to values having the same types. Matching is performed from left to right. More precisely, in case some value v matches pattern1 `|` pattern2, the bindings performed are those of pattern1 when v matches pattern1. Otherwise, value v matches pattern2 whose bindings are performed.

#### Variant patterns

The pattern constr pattern1 matches all variants whose constructor is equal to constr, and whose argument matches pattern1.

The pattern pattern1 `::` pattern2 matches non-empty lists whose heads match pattern1, and whose tails match pattern2.

The pattern `[` pattern1 `;` … `;` patternn `]` matches lists of length n whose elements match pattern1 …patternn, respectively. This pattern behaves like pattern1 `::` … `::` patternn `::` `[]`.

#### Polymorphic variant patterns

The pattern ``tag-name` pattern1 matches all polymorphic variants whose tag is equal to tag-name, and whose argument matches pattern1.

#### Variant abbreviation patterns

If the type [`('a,'b,...)`] typeconstr = `[`tag`1 typexpr1 `|` … `|` ``tag`n typexprn`]` is defined, then the pattern #typeconstr is a shorthand for the or-pattern `(`tag`1`(_` `:` typexpr1`)` `|` … `|` ``tag`n`(_` `:` typexprn`))`. It matches all values of type #typeconstr.

#### Tuple patterns

The pattern pattern1 `,` … `,` patternn matches n-tuples whose components match the patterns pattern1 through patternn. That is, the pattern matches the tuple values (v1, …, vn) such that patterni matches vi for i = 1,… , n.

#### Record patterns

The pattern `{` field1 `=` pattern1 `;` … `;` fieldn `=` patternn `}` matches records that define at least the fields field1 through fieldn, and such that the value associated to fieldi matches the pattern patterni, for i = 1,… , n. The record value can define more fields than field1 …fieldn; the values associated to these extra fields are not taken into account for matching.

#### Array patterns

The pattern `[|` pattern1 `;` … `;` patternn `|]` matches arrays of length n such that the i-th array element matches the pattern patterni, for i = 1,… , n.