## 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` } `|]`

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 `pattern`1 `as` `value-name` matches the same values as `pattern`1. If the matching against `pattern`1 is successful, the name `name` is bound to the matched value, in addition to the bindings performed by the matching against `pattern`1.

#### Parenthesized patterns

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

#### “Or” patterns

The pattern `pattern`1 `|` `pattern`2 represents the logical “or” of the two patterns `pattern`1 and `pattern`2. A value matches `pattern`1 `|` `pattern`2 either if it matches `pattern`1 or if it matches `pattern`2. The two sub-patterns `pattern`1 and `pattern`2 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 `pattern`1 `|` `pattern`2, the bindings performed are those of `pattern`1 when `v` matches `pattern`1. Otherwise, value `v` matches `pattern`2 whose bindings are performed.

#### Variant patterns

The pattern `constr` `pattern`1 matches all variants whose constructor is equal to `constr`, and whose argument matches `pattern`1.
The pattern `pattern`1 `::` `pattern`2 matches non-empty lists whose heads match `pattern`1, and whose tails match `pattern`2.
The pattern `[` `pattern`1 `;` … `;` `pattern`n `]` matches lists of length n whose elements match `pattern`1 ...`pattern`n, respectively. This pattern behaves like `pattern`1 `::` … `::` `pattern`n `::` `[]`.

#### Polymorphic variant patterns

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

#### Variant abbreviation patterns

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

#### Tuple patterns

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

#### Record patterns

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

#### Array patterns

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