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

Parenthesized patterns

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

``Or'' patterns

The pattern pattern₁ | pattern₂ represents the logical ``or'' of the two patterns pattern<sub>1</sub> and pattern<sub>2</sub>. A value matches pattern<sub>1</sub> | pattern<sub>2</sub> either if it matches pattern<sub>1</sub> or if it matches pattern<sub>2</sub>. The two sub-patterns pattern<sub>1</sub> and pattern<sub>2</sub> 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 pattern₁ matches all variants whose constructor is equal to ncconstr, and whose argument matches pattern₁.

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

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

Tuple patterns

The pattern pattern₁ ,..., pattern_n matches n-tuples whose components match the patterns pattern₁ through pattern_n. That is, the pattern matches the tuple values (v₁,...,v_n) such that pattern_i matches v_i for i = 1, ..., n.

Record patterns

The pattern { label₁ = pattern₁ ;...; label_n = pattern_n } matches records that define at least the labels label₁ 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₁ ... label_n; the values associated to these extra labels are not taken into account for matching.