6.6 Patterns
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 pattern1 as value-name matches the same values as
pattern1. If the matching against pattern1 is successful,
the name name 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 pattern, 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.
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 ( :: ) ( pattern1 , pattern2 ).
The pattern [ pattern1 ; ... ; patternn ] matches lists
of length n whose elements match pattern1 ...patternn,
respectively. This pattern behaves like
pattern1 :: ... :: patternn :: [].
Polymorphic variant patterns
The pattern `tag-name pattern1 matches all polymorphic variants
whose tag is equal to tag-name, and whose argument matches
pattern1.
Variant abbreviation patterns
If the type [('a,'b,...)] typeconstr = [`tag1 t1 |
... | `tagn tn] is defined, then the pattern #typeconstr
is a shorthand for the or-pattern (`tag1(_ : t1) |
... | `tagn(_ : tn)). It matches all values of type
#typeconstr.
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 { field1 = pattern1 ; ... ; fieldn =
patternn } matches records that define at least the fields
field1 through fieldn, and such that the value associated to
fieldi match the pattern patterni, for i = 1,... , n.
The record value can define more fields than field1 ...fieldn; the values associated to these extra fields are not taken
into account for matching.