## 5.6 Patterns

`pattern` | ::= | `value-name`
| | | `_`
| | | `constant`
| | | `pattern` `as` `value-name`
| | | `(` `pattern` `)`
| | | `(` `pattern` `:` `typexpr` `)`
| | | `pattern` `|` `pattern`
| | | `ncconstr` `pattern`
| | | `pattern` { `,` `pattern` }
| | | `{` `label` `=` `pattern` { `;` `label` `=` `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 contain no identifiers. Hence no bindings are returned by matching against an ``or'' pattern.

#### Variant patterns

The pattern `ncconstr` `pattern`1 matches all variants whose constructor is equal to `ncconstr`, 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. This pattern behaves like `(` `::` `)` `(` `pattern`1 `,` `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 `::` `[]`.

#### 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 `{` `label`1 `=` `pattern`1 `;` ... `;` `label`n `=` `pattern`n `}` matches records that define at least the labels `label`1 through `label`n, and such that the value associated to `label`i match the pattern `pattern`i, for i = 1,... , n. The record value can define more labels than `label`1 ...`label`n; the values associated to these extra labels are not taken into account for matching.