## Patterns

    pattern:
          ident
       |  _
       |  pattern as ident
       |  ( pattern )
       |  ( pattern : typexpr )
       |  pattern | pattern
       |  constant
       |  ncconstr pattern
       |  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 identifiers to values''.

#### Variable patterns

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

#### Alias patterns

The pattern pattern1 `as` ident matches the same values as pattern1. If the matching against pattern1 is successful, the identifier ident 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 patterns, as in `(` pattern1 `:` typexpr `)`. This constraint forces the type of pattern1 to be compatible with type.

#### ``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 contain no identifiers. Hence no bindings are returned by matching against an ``or'' pattern.

#### Constant patterns

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

#### Variant patterns

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

The pattern pattern1 `::` pattern2 matches non-empty lists whose heads match pattern1, and whose tails match pattern2. This pattern behaves like `prefix` `::` `(` pattern1 `,` pattern2 `)`.

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

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