Chapter 6 The OCaml language

Foreword

This document is intended as a reference manual for the OCaml language. It lists the language constructs, and gives their precise syntax and informal semantics. It is by no means a tutorial introduction to the language: there is not a single example. A good working knowledge of OCaml is assumed.

No attempt has been made at mathematical rigor: words are employed with their intuitive meaning, without further definition. As a consequence, the typing rules have been left out, by lack of the mathematical framework required to express them, while they are definitely part of a full formal definition of the language.

Notations

The syntax of the language is given in BNF-like notation. Terminal symbols are set in typewriter font (like this). Non-terminal symbols are set in italic font (like that). Square brackets […] denote optional components. Curly brackets {…} denotes zero, one or several repetitions of the enclosed components. Curly brackets with a trailing plus sign {…}⁺ denote one or several repetitions of the enclosed components. Parentheses (…) denote grouping.

6 Patterns

pattern	::=	value-name
	∣	_
	∣	constant
	∣	pattern as value-name
	∣	( pattern )
	∣	( pattern : typexpr )
	∣	pattern \| pattern
	∣	constr pattern
	∣	`tag-name pattern
	∣	#typeconstr
	∣	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
.. (see section 7.4)	–
lazy (see section 7.6)	–
Constructor application, Tag application	right
::	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 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₁ typexpr₁ | … | ` tag-name_n typexpr_n] is defined, then the pattern #typeconstr is a shorthand for the following or-pattern: ( `tag-name₁(_ : typexpr₁) | … | ` 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. 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.

The present documentation is copyright Institut National de Recherche en Informatique et en Automatique (INRIA). A complete version can be obtained from this page.