Previous Next Contents

5.6   Patterns

pattern ::= value-name
  | _
  | constant
  | pattern as  value-name
  | ( pattern )
  | ( pattern :  typexpr )
  | pattern |  pattern
  | ncconstr  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 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 :: [].

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 { label1 =  pattern1 ; ... ;  labeln =  patternn } matches records that define at least the labels label1 through labeln, and such that the value associated to labeli match the pattern patterni, for i = 1,... , n. The record value can define more labels than label1 ...labeln; the values associated to these extra labels are not taken into account for matching.



Previous Next Contents