---

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₁ as  value-name matches the same values as pattern₁. If the matching against pattern₁ is successful, the name name 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 pattern, 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₁ and pattern₂. A value matches pattern₁ |  pattern₂ either if it matches pattern₁ or if it matches pattern₂. The two sub-patterns pattern₁ and pattern₂ 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₁ |  pattern₂, the bindings performed are those of pattern₁ when v matches pattern₁. Otherwise, value v matches pattern₂ whose bindings are performed.

Variant patterns

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

The pattern pattern₁ ::  pattern₂ matches non-empty lists whose heads match pattern₁, and whose tails match 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 :: [].

Polymorphic variant patterns

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

Variant abbreviation patterns

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

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

Array patterns

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

---