Expressions

expr:
      ident
   |  variable
   |  constant
   |  ( expr )
   |  begin expr end
   |  ( expr : typexpr )
   |  expr , expr {, expr}
   |  ncconstr expr
   |  expr :: expr
   |  [ expr {; expr} ]
   |  [| expr {; expr} |]
   |  { label = expr {; label = expr} }
   |  expr expr
   |  prefix-op expr
   |  expr infix-op expr
   |  expr . label
   |  expr . label <- expr
   |  expr .( expr )
   |  expr .( expr ) <- expr
   |  expr & expr
   |  expr or expr
   |  if expr then expr [else expr]
   |  while expr do expr done
   |  for ident = expr (to | downto) expr do expr done
   |  expr ; expr
   |  match expr with simple-matching
   |  fun multiple-matching
   |  function simple-matching
   |  try expr with simple-matching
   |  let [rec] let-binding {and let-binding} in expr

simple-matching:
      pattern -> expr {| pattern -> expr}

multiple-matching:
      pattern-list -> expr {| pattern-list -> expr}

pattern-list:
      pattern {pattern}

let-binding:
      pattern = expr
   |  variable pattern-list = expr

prefix-op:
      - | -. | !

infix-op:
      + | - | * | / | mod | +. | -. | *. | /. | ** | @ | ^ | ! | :=
   |  = | <> | == | != | < | <= | > | >= | <. | <=. | >. | >=.

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

Construction or operator	Associativity
!	--
. .(	--
function application	left
constructor application	--
- -. (prefix)	--
**	right
mod	left
* *. / /.	left
+ +. - -.	left
::	right
@ ^	right
comparisons (= == < etc.)	left
not	--
&	left
or	left
,	--
<- :=	right
if	--
;	right
let match fun function try	--

Simple expressions

Constants

Expressions consisting in a constant evaluate to this constant.

Variables

Expressions consisting in a variable evaluate to the value bound to this variable in the current evaluation environment. The variable can be either a qualified identifier or a simple identifier. Qualified identifiers always denote global variables. Simple identifiers denote either a local variable, if the identifier is locally bound, or a global variable, whose full name is obtained by qualifying the simple identifier, as described in section 3.3.

Parenthesized expressions

The expressions ( expr ) and begin expr end have the same value as expr. Both constructs are semantically equivalent, but it is good style to use begin...end inside control structures:

        if ... then begin ... ; ... end else begin ... ; ... end

Parenthesized expressions can contain a type constraint, as in ( expr : type ). This constraint forces the type of expr to be compatible with type.

Function abstraction

The most general form of function abstraction is:

fun pattern11 ... pattern1M -> expr1
  | ...
  | patternN1 ... patternNM -> exprN

If several pattern rows match the arguments, the one that occurs first in the function definition is selected. If none of the pattern rows matches the argument, the exception Match_failure is raised.

If the function above is applied to less than m arguments, a functional value is returned, that represents the partial application of the function to the arguments provided. This partial application is a function that, when applied to the remaining arguments, matches all arguments against the pattern rows as described above. Matching does not start until all m arguments have been provided to the function; hence, partial applications of the function to less than m arguments never raise Match_failure.

All pattern rows in the function body must contain the same number of patterns. A variable must not be bound more than once in one pattern row.

Functions with only one argument can be defined with the function keyword instead of fun:

function pattern1 -> expr1
       | ...
       | patternN -> exprN

Function application

Function application is denoted by juxtaposition of expressions. The expression expr₁ expr₂...expr_n evaluates the expressions expr₁ to expr_n. The expression expr₁ must evaluate to a functional value, which is then applied to the values of expr₂,...,expr_n. The order in which the expressions expr₁,...,expr_n are evaluated is not specified.

Local definitions

The let and let rec constructs bind variables locally. The construct

let pattern₁ = expr₁ and...and pattern_n = expr_n in expr

An alternate syntax is provided to bind variables to functional values: instead of writing

ident = fun pattern₁...pattern_m -> expr

ident pattern₁...pattern_m = expr

pattern₁...pattern_m -> expr.

Recursive definitions of variables are introduced by let rec:

let rec pattern₁ = expr₁ and...and pattern_n = expr_n in expr

The recursive definition is guaranteed to behave as described above if the expressions expr₁ to expr_n are function definitions (fun... or function...), and the patterns pattern₁...pattern_n consist in a single variable, as in:

let rec ident₁ = fun...and...and ident_n = fun...in expr

Control constructs

Sequence

The expression expr₁ ; expr₂ evaluates expr₁ first, then expr₂, and returns the value of expr₂.

Conditional

The expression if expr₁ then expr₂ else expr₃ evaluates to the value of expr₂ if expr₁ evaluates to the boolean true, and to the value of expr₃ if expr₁ evaluates to the boolean false.

The else expr₃ part can be omitted, in which case it defaults to else ().

Case expression

The expression

match expr with
      pattern1 -> expr1
    | ...
    | patternN -> exprN

Boolean operators

The expression expr₁ & expr₂ evaluates to true if both expr₁ and expr₂ evaluate to true; otherwise, it evaluates to false. The first component, expr₁, is evaluated first. The second component, expr₂, is not evaluated if the first component evaluates to false. Hence, the expression expr₁ & expr₂ behaves exactly as

if expr₁ then expr₂ else false.

The expression expr₁ or expr₂ evaluates to true if one of expr₁ and expr₂ evaluates to true; otherwise, it evaluates to false. The first component, expr₁, is evaluated first. The second component, expr₂, is not evaluated if the first component evaluates to true. Hence, the expression expr₁ or expr₂ behaves exactly as

if expr₁ then true else expr₂.

Loops

The expression while expr₁ do expr₂ done repeatedly evaluates expr₂ while expr₁ evaluates to true. The loop condition expr₁ is evaluated and tested at the beginning of each iteration. The whole while...done expression evaluates to the unit value ().

The expression for ident = expr₁ to expr₂ do expr₃ done first evaluates the expressions expr₁ and expr₂ (the boundaries) into integer values n and p. Then, the loop body expr₃ is repeatedly evaluated in an environment where the local variable named ident is successively bound to the values n, n+1, \ldots, p-1, p. The loop body is never evaluated if n > p.

The expression for ident = expr₁ downto expr₂ do expr₃ done first evaluates the expressions expr₁ and expr₂ (the boundaries) into integer values n and p. Then, the loop body expr₃ is repeatedly evaluated in an environment where the local variable named ident is successively bound to the values n, n-1, \ldots, p+1, p. The loop body is never evaluated if n < p.

In both cases, the whole for expression evaluates to the unit value ().

Exception handling

The expression

try  expr
with pattern1 -> expr1
    | ...
    | patternN -> exprN

Operations on data structures

Products

The expression expr₁ ,..., expr_n evaluates to the n-tuple of the values of expressions expr₁ to expr_n. The evaluation order for the subexpressions is not specified.

Variants

The expression ncconstr expr evaluates to the variant value whose constructor is ncconstr, and whose argument is the value of expr.

For lists, some syntactic sugar is provided. The expression expr₁ :: expr₂ stands for the constructor prefix :: applied to the argument ( expr₁ , expr₂ ), and therefore evaluates to the list whose head is the value of expr₁ and whose tail is the value of expr₂. The expression [ expr₁ ;...; expr_n ] is equivalent to expr₁ ::...:: expr_n :: [], and therefore evaluates to the list whose elements are the values of expr₁ to expr_n.

Records

The expression { label₁ = expr₁ ;...; label_n = expr_n } evaluates to the record value { label₁ = v₁ ;...; label_n = v_n }, where v_i is the value of expr_i for i = 1, ..., n. The labels label₁ to label_n must all belong to the same record types; all labels belonging to this record type must appear exactly once in the record expression, though they can appear in any order. The order in which expr₁ to expr_n are evaluated is not specified.

The expression expr₁ . label evaluates expr₁ to a record value, and returns the value associated to label in this record value.

The expression expr₁ . label <- expr₂ evaluates expr₁ to a record value, which is then modified in-place by replacing the value associated to label in this record by the value of expr₂. This operation is permitted only if label has been declared mutable in the definition of the record type. The whole expression expr₁ . label <- expr₂ evaluates to the unit value ().

Arrays

The expression [| expr₁ ;...; expr_n |] evaluates to a n-element array, whose elements are initialized with the values of expr₁ to expr_n respectively. The order in which these expressions are evaluated is unspecified.

The expression expr₁ .( expr₂ ) is equivalent to the application vect_item expr₁ expr₂. In the initial environment, the identifier vect_item resolves to a built-in function that returns the value of element number expr₂ in the array denoted by expr₁. The first element has number 0; the last element has number n-1, where n is the size of the array. The exception Invalid_argument is raised if the access is out of bounds.

The expression expr₁ .( expr₂ ) <- expr₃ is equivalent to vect_assign expr₁ expr₂ expr₃. In the initial environment, the identifier vect_assign resolves to a built-in function that modifies in-place the array denoted by expr₁, replacing element number expr₂ by the value of expr₃. The exception Invalid_argument is raised if the access is out of bounds. The built-in function returns (). Hence, the whole expression expr₁ .( expr₂ ) <- expr₃ evaluates to the unit value ().

This behavior of the two constructs expr₁ .( expr₂ ) and expr₁ .( expr₂ ) <- expr₃ may change if the meaning of the identifiers vect_item and vect_assign is changed, either by redefinition or by modification of the list of opened modules. See the discussion below on operators.

Operators

The operators written infix-op in the grammar above can appear in infix position (between two expressions). The operators written prefix-op in the grammar above can appear in prefix position (in front of an expression).

The expression prefix-op expr is interpreted as the application ident expr, where ident is the identifier associated to the operator prefix-op in the table below. Similarly, the expression expr₁ infix-op expr₂ is interpreted as the application ident expr₁ expr₂, where ident is the identifier associated to the operator infix-op in the table below. The identifiers written ident above are then evaluated following the rules in section 3.8. In the initial environment, they evaluate to built-in functions whose behavior is described in the table. The behavior of the constructions prefix-op expr and expr₁ infix-op expr₂ may change if the meaning of the identifiers associated to prefix-op or infix-op is changed, either by redefinition of the identifiers, or by modification of the list of opened modules, through the #open and #close directives.

Operator	Associated ident	Behavior in the default environment
+	prefix +	Integer addition.
- (infix)	prefix -	Integer subtraction.
- (prefix)	minus	Integer negation.
*	prefix *	Integer multiplication.
/	prefix /	Integer division. Raise Division_by_zero if second argument is zero. The result is unspecified if either argument is negative.
mod	prefix mod	Integer modulus. Raise Division_by_zero if second argument is zero. The result is unspecified if either argument is negative.
+.	prefix +.	Floating-point addition.
-. (infix)	prefix -.	Floating-point subtraction.
-. (prefix)	minus_float	Floating-point negation.
*.	prefix *.	Floating-point multiplication.
/.	prefix /.	Floating-point division. Raise Division_by_zero if second argument is zero.
**	prefix **	Floating-point exponentiation.
@	prefix @	List concatenation.
^	prefix ^	String concatenation.
!	prefix !	Dereferencing (return the current contents of a reference).
:=	prefix :=	Reference assignment (update the reference given as first argument with the value of the second argument).
=	prefix =	Structural equality test.
<>	prefix <>	Structural inequality test.
==	prefix ==	Physical equality test.
!=	prefix !=	Physical inequality test.
<	prefix <	Test ``less than'' on integers.
<=	prefix <=	Test ``less than or equal '' on integers.
>	prefix >	Test ``greater than'' on integers.
>=	prefix >=	Test ``greater than or equal'' on integers.
<.	prefix <.	Test ``less than'' on floating-point numbers.
<=.	prefix <=.	Test ``less than or equal '' on floating-point numbers.
>.	prefix >.	Test ``greater than'' on floating-point numbers.
>=.	prefix >=.	Test ``greater than or equal'' on floating-point numbers.

The behavior of the +, -, *, /, mod, +., -., *. or /. operators is unspecified if the result falls outside of the range of representable integers or floating-point numbers, respectively. See chapter 14 for a more precise description of the behavior of the operators above.