Expressions

expr:
      value-path
   |  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-symbol expr
   |  expr infix-op expr
   |  expr . label
   |  expr . label <- expr
   |  expr .( expr )
   |  expr .( expr ) <- expr
   |  expr .[ expr ]
   |  expr .[ expr ] <- 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 pattern-matching
   |  function pattern-matching
   |  fun multiple-matching
   |  try expr with pattern-matching
   |  let [rec] let-binding {and let-binding} in expr
   |  new class-path
   |  expr # method-name
   |  ( expr :> typexpr )
   |  ( expr : typexpr :> typexpr )
   |  {< inst-var-name = expr {; inst-var-name = expr} >}

pattern-matching:
      pattern [when expr] -> expr {| pattern [when expr] -> expr}

multiple-matching:
      {pattern}+ [when expr] -> expr



let-binding:
      pattern = expr
   |  value-name {pattern}+ [: typexpr] = expr

infix-op:
      infix-symbol
   |  * | = | or | &

The table below shows the relative precedences and associativity of operators and non-closed constructions. The constructions with higher precedence come first. For infix and prefix symbols, we write ``*...'' to mean ``any symbol starting with *''.

Construction or operator	Associativity
prefix-symbol	--
. .( .[	--
function application	left
constructor application	--
- -. (prefix)	--
**...	right
*... /... %... mod	left
+... -...	left
::	right
@ ^	right
comparisons (= == < etc.), all other infix symbols	left
not	--
& &&	left
or ||	left
,	--
<- :=	right
if	--
;	right
let match fun function try	--

Basic expressions

Constants

Expressions consisting in a constant evaluate to this constant.

Value paths

Expressions consisting in an access path evaluate to the value bound to this path in the current evaluation environment. The path can be either a value name or an access path to a value component of a module.

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.

Parenthesized expressions can also contain coercions ( expr [: type] :> type ) (see subsection 5.8 below).

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.

Function definition

Two syntactic forms are provided to define functions. The first form is introduced by the keyword function:

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

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

The other form of function definition is introduced by the keyword fun:

fun pattern₁...pattern_n -> expr

function pattern₁ ->...function pattern_n -> expr

Guards in pattern-matchings

Cases of a pattern matching (in the function, fun, match and try constructs) can include guard expressions, which are arbitrary boolean expressions that must evaluate to true for the match case to be selected. Guards occur just before the -> token and are introduced by the when keyword:

function pattern1 [when cond1] -> expr1
       | ...
       | patternN [when condN] -> exprN

Local definitions

The let and let rec constructs bind value names 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

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

let ident pattern₁...pattern_m = expr

Recursive definitions of names 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 are just value names, as in:

let rec name₁ = fun...and...and name_n = fun...in expr

The behavior of other forms of let rec definitions is implementation-dependent. The current implementation also supports a certain class of recursive definitions of non-functional values, such as

let rec name₁ = 1 :: name₂ and name₂ = 2 :: name₁ in expr

Control structures

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 name = 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 name is successively bound to the values n, n+1, ..., p-1, p. The loop body is never evaluated if n > p.

The expression for name = expr₁ downto expr₂ do expr₃ done evaluates similarly, except that name is successively bound to the values n, n-1, ..., 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 ( :: ) 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₂ ) 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₃ 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 value of the whole expression is ().

Strings

The expression expr₁ .[ expr₂ ] returns the value of character number expr₂ in the string denoted by expr₁. The first character has number 0; the last character has number n-1, where n is the length of the string. The exception Invalid_argument is raised if the access is out of bounds.

The expression expr₁ .[ expr₂ ] <- expr₃ modifies in-place the string denoted by expr₁, replacing character number expr₂ by the value of expr₃. The exception Invalid_argument is raised if the access is out of bounds. The value of the whole expression is ().

Operators

Symbols from the class infix-symbols, as well as the keywords *, =, or and &, can appear in infix position (between two expressions). Symbols from the class prefix-symbols can appear in prefix position (in front of an expression).

Infix and prefix symbols do not have a fixed meaning: they are simply interpreted as applications of functions bound to the names corresponding to the symbols. The expression prefix-symbol expr is interpreted as the application ( prefix-symbol ) expr. Similarly, the expression expr₁ infix-symbol expr₂ is interpreted as the application ( infix-symbol ) expr₁ expr₂.

The table below lists the symbols defined in the initial environment and their initial meaning. (See the description of the standard library module Pervasive in chapter 16 for more details). Their meaning may be changed at any time using let ( infix-op ) name₁ name₂ =...

Operator	Initial meaning
+	Integer addition.
- (infix)	Integer subtraction.
- (prefix)	Integer negation.
*	Integer multiplication.
/	Integer division. Raise Division_by_zero if second argument is zero. The result is unspecified if either argument is negative.
mod	Integer modulus. Raise Division_by_zero if second argument is zero. The result is unspecified if either argument is negative.
land	Bitwise logical ``and'' on integers.
lor	Bitwise logical ``or on integers.
lxor	Bitwise logical ``exclusive or'' on integers.
lsl	Bitwise logical shift left on integers.
lsr	Bitwise logical shift right on integers.
asr	Bitwise arithmetic shift right on integers.
+.	Floating-point addition.
-. (infix)	Floating-point subtraction.
-. (prefix)	Floating-point negation.
*.	Floating-point multiplication.
/.	Floating-point division.
**	Floating-point exponentiation.
@	List concatenation.
^	String concatenation.
!	Dereferencing (return the current contents of a reference).
:=	Reference assignment (update the reference given as first argument with the value of the second argument).
=	Structural equality test.
<>	Structural inequality test.
==	Physical equality test.
!=	Physical inequality test.
<	Test ``less than''.
<=	Test ``less than or equal''.
>	Test ``greater than''.
>=	Test ``greater than or equal''

Objects

Object creation

The expression new class-path denotes a function that takes some initialization arguments and returns a new object of class class-path.

Message sending

The expression expr # method-name invokes the method method-name of the object denoted by expr.

Coercion

The type of an object can be coerced (weakened) to a supertype. The expression ( expr :> typexpr ) coerces the expression expr to type typexpr. The expression ( expr : typexpr₁ :> typexpr₂ ) coerces the expression expr from type typexpr₁ to type typexpr₂. The former operator will sometimes fail to coerce an expression expr from a type t₁ to a type t₂ even if type t₁ is a subtype of type t₂. In this case, the latter operator should be used.

In a class definition, coercion to the type this class defines is the identity, as this type abbreviation is not yet completely defined.

Object duplication

An object can be duplicated using the library function Oo.copy (see section 17.17). Inside a method, the expression {< inst-var-name = expr {; inst-var-name = expr} >} returns a copy of self with the given instance variables replaced by the values of the associated expressions; other instance variables have the same value in the returned object as in self.