7.6  Patterns

See also the following language extensions: lazy patterns, local opens, first-class modules, attributes and extension nodes.

The table below shows the relative precedences and associativity of operators and non-closed pattern constructions. The constructions with higher precedences come first.

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 be bound several times by 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 value-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 typexpr.

“Or” patterns

The pattern pattern₁ |  pattern₂ represents the logical “or” of the two patterns pattern₁ and pattern₂. A value matches pattern₁ |  pattern₂ if it matches pattern₁ or 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₁ , … ,  pattern_n ) matches all variants whose constructor is equal to constr, and whose arguments match pattern₁ …  pattern_n. It is a type error if n is not the number of arguments expected by the constructor.

The pattern constr _ matches all variants whose constructor is constr.

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₁.

Polymorphic variant abbreviation patterns

If the type [('a,'b,…)] typeconstr = [ ` tag-name<sub>1</sub>  typexpr<sub>1</sub> | … | ` tag-name_n  typexpr_n] is defined, then the pattern #typeconstr is a shorthand for the following or-pattern: ( `tag-name<sub>1</sub>(_ :  typexpr<sub>1</sub>) | … | ` tag-name_n(_ :  typexpr_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. A single identifier field_k stands for field_k =  field_k , and a single qualified identifier module-path .  field_k stands for module-path .  field_k =  field_k . 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. Optionally, a record pattern can be terminated by ; _ to convey the fact that not all fields of the record type are listed in the record pattern and that it is intentional. Optional type constraints can be added field by field with { field₁ :  typexpr₁ =  pattern₁ ;… ; field_n :  typexpr_n =  pattern_n } to force the type of field_k to be compatible with typexpr_k.

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.

Range patterns

The pattern ' c ' .. ' d ' is a shorthand for the pattern

where c₁, c₂, …, c_n are the characters that occur between c and d in the ASCII character set. For instance, the pattern '0'..'9' matches all characters that are digits.

Exception patterns

(Introduced in OCaml 4.02)

A new form of exception pattern, exception pattern, is allowed only as a toplevel pattern under a match...with pattern-matching (other occurrences are rejected by the type-checker).

Cases with such a toplevel pattern are called “exception cases”, as opposed to regular “value cases”. Exception cases are applied when the evaluation of the matched expression raises an exception. The exception value is then matched against all the exception cases and re-raised if none of them accept the exception (as with a try...with block). Since the bodies of all exception and value cases are outside the scope of the exception handler, they are all considered to be in tail-position: if the match...with block itself is in tail position in the current function, any function call in tail position in one of the case bodies results in an actual tail call.

A pattern match must contain at least one value case. It is an error if all cases are exceptions, because there would be no code to handle the return of a value.