expr 
::= 
valuepath 

 
constant 

 
( expr ) 

 
begin expr end 

 
( expr : typexpr ) 

 
expr , expr { , expr } 

 
constr expr 

 
`tagname expr 

 
expr :: expr 

 
[ expr { ; expr } ] 

 
[ expr { ; expr } ] 

 
{ field = expr { ; field = expr } } 

 
{ expr with field = expr { ; field = expr } } 

 
expr { argument }^{+} 

 
prefixsymbol expr 

 
expr infixop expr 

 
expr . field 

 
expr . field < 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 patternmatching 

 
function patternmatching 

 
fun multiplematching 

 
try expr with patternmatching 

 
let [rec] letbinding { and letbinding } in expr 

 
new classpath 

 
object [( pattern [: typexpr] )] { classfield } end 

 
expr # methodname 

 
instvarname 

 
instvarname < expr 

 
( expr :> typexpr ) 

 
( expr : typexpr :> typexpr ) 

 
{< instvarname = expr { ; instvarname = expr } >} 

 
assert expr 

 
lazy expr 
argument 
::= 
expr 

 
~ labelname 

 
~ labelname : expr 

 
? labelname 

 
? labelname : expr 
patternmatching 
::= 
[  ] pattern [when expr] > expr
{  pattern [when expr] > expr } 
multiplematching 
::= 
{ parameter }^{+} [when expr] > expr 
letbinding 
::= 
pattern = expr 

 
valuename { parameter } [: typexpr] = expr 
parameter 
::= 
pattern 

 
~ labelname 

 
~ ( labelname [: typexpr] ) 

 
~ labelname : pattern 

 
? labelname 

 
? ( labelname [: typexpr] [= expr] ) 

 
? labelname : pattern 

 
? labelname : ( pattern [: typexpr] [= expr] ) 
The table below shows the relative precedences and associativity of
operators and nonclosed 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 
prefixsymbol 
 
. .( .[ 
 
function application, constructor application, assert, lazy 
left 
 . (prefix) 
 
**... 
right 
*... /... %... mod 
left 
+... ... 
left 
:: 
right 
@... ^... 
right 
comparisons (= == < etc.), all other infix symbols 
left 
& && 
left 
or  
left 
, 
 
< := 
right 
if 
 
; 
right 
let match fun function try 
 
Expressions consisting in a constant evaluate to this constant.
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
and ( ... ) for the other grouping situations.
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 6.7.5 below).
Function application is denoted by juxtaposition of (possibly labeled)
expressions. The expression expr argument_{1} ... argument_{n}
evaluates the expression expr and those appearing in argument_{1}
to argument_{n}. The expression expr must evaluate to a
functional value f, which is then applied to the values of
argument_{1}, ..., argument_{n}.
The order in which the expressions expr, argument_{1}, ...,
argument_{n} are evaluated is not specified.
Arguments and parameters are matched according to their respective
labels. Argument order is irrelevant, except among arguments with the
same label, or no label.
If a parameter is specified as optional (label prefixed by ?) in the
type of expr, the corresponding argument will be automatically
wrapped with the constructor Some, except if the argument itself is
also prefixed by ?, in which case it is passed as is.
If a nonlabeled argument is passed, and its corresponding parameter
is preceded by one or several optional parameters, then these
parameters are defaulted, i.e. the value None will be
passed for them.
All other missing parameters (without corresponding argument), both
optional and nonoptional, will be kept, and the result of the
function will still be a function of these missing parameters to the
body of f.
As a special case, if the function has a known arity, all the
arguments are unlabeled, and their number matches the number of
nonoptional parameters, then labels are ignored and nonoptional
parameters are matched in their definition order. Optional arguments
are defaulted.
In all cases but exact match of order and labels, without optional
parameters, the function type should be known at the application
point. This can be ensured by adding a type constraint. Principality
of the derivation can be checked in the principal mode.
Two syntactic forms are provided to define functions. The first form
is introduced by the keyword function:
function 
pattern_{1} 
> 
expr_{1} 
 
... 
 
pattern_{n} 
> 
expr_{n} 
This expression evaluates to a functional value with one argument.
When this function is applied to a value v, this value is
matched against each pattern pattern_{1} to pattern_{n}.
If one of these matchings succeeds, that is, if the value v
matches the pattern pattern_{i} for some i,
then the expression expr_{i} associated to the selected pattern
is evaluated, and its value becomes the value of the function
application. The evaluation of expr_{i} takes place in an
environment enriched by the bindings performed during the matching.
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 parameter_{1} ... parameter_{n} > expr
This expression is equivalent to:
fun parameter_{1} > ... fun parameter_{n} > expr
Functions of the form fun optlabel ( pattern = expr_{0} ) >
expr are equivalent to
fun optlabel x >
let pattern =
match x with Some x > x  None > expr_{0}
in expr 
where x is a fresh variable. When expr_{0} will be evaluated is left
unspecified.
After these two transformations, expressions are of the form
fun [label_{1}] pattern_{1} > ... fun [label_{n}] pattern_{n} > expr
If we ignore labels, which will only be meaningful at function
application, this is equivalent to
function pattern_{1} > ... function pattern_{n} > expr
That is, the fun expression above evaluates to a curried function
with n arguments: after applying this function n times to the
values v_{1} ... v_{m}, the values will be matched
in parallel against the patterns pattern_{1} ... pattern_{n}.
If the matching succeeds, the function returns the value of expr in
an environment enriched by the bindings performed during the matchings.
If the matching fails, the exception Match_failure is raised.
Guards in patternmatchings 

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 
pattern_{1} [when cond_{1}] 
> 
expr_{1} 
 
... 
 
pattern_{n} [when cond_{n}] 
> 
expr_{n} 
Matching proceeds as described before, except that if the value
matches some pattern pattern_{i} which has a guard cond_{i}, then the
expression cond_{i} is evaluated (in an environment enriched by the
bindings performed during matching). If cond_{i} evaluates to true,
then expr_{i} is evaluated and its value returned as the result of the
matching, as usual. But if cond_{i} evaluates to false, the matching
is resumed against the patterns following pattern_{i}.
The let and let rec constructs bind value names locally.
The construct
let pattern_{1} = expr_{1} and ... and pattern_{n} = expr_{n} in expr
evaluates expr_{1} ... expr_{n} in some unspecified order, then matches
their values against the patterns pattern_{1} ... pattern_{n}. If the
matchings succeed, expr is evaluated in the environment enriched by
the bindings performed during matching, and the value of expr is
returned as the value of the whole let expression. If one of the
matchings fails, the exception Match_failure is raised.
An alternate syntax is provided to bind variables to functional
values: instead of writing
let ident = fun parameter_{1} ... parameter_{m} > expr
in a let expression, one may instead write
let ident parameter_{1} ... parameter_{m} = expr
Recursive definitions of names are introduced by let rec:
let rec pattern_{1} = expr_{1} and ... and pattern_{n} = expr_{n}
in expr
The only difference with the let construct described above is
that the bindings of names to values performed by the
patternmatching are considered already performed when the expressions
expr_{1} to expr_{n} are evaluated. That is, the expressions expr_{1}
to expr_{n} can reference identifiers that are bound by one of the
patterns pattern_{1}, ..., pattern_{n}, and expect them to have the
same value as in expr, the body of the let rec construct.
The recursive definition is guaranteed to behave as described above if
the expressions expr_{1} to expr_{n} are function definitions
(fun ... or function ...), and the patterns pattern_{1}
... pattern_{n} are just value names, as in:
let rec name_{1} = fun ...
and ...
and name_{n} = fun ...
in expr
This defines name_{1} ... name_{n} as mutually recursive functions
local to expr.
The behavior of other forms of let rec definitions is
implementationdependent. The current implementation also supports
a certain class of recursive definitions of nonfunctional values,
as explained in section 7.3.
The expression expr_{1} ; expr_{2} evaluates expr_{1} first, then
expr_{2}, and returns the value of expr_{2}.
The expression if expr_{1} then expr_{2} else expr_{3} evaluates to
the value of expr_{2} if expr_{1} evaluates to the boolean true,
and to the value of expr_{3} if expr_{1} evaluates to the boolean
false.
The else expr_{3} part can be omitted, in which case it defaults to
else ().
The expression
match 
expr 
with 
pattern_{1} 
> 
expr_{1} 
 
... 
 
pattern_{n} 
> 
expr_{n} 
matches the value of expr against the patterns pattern_{1} to
pattern_{n}. If the matching against pattern_{i} succeeds, the
associated expression expr_{i} is evaluated, and its value becomes the
value of the whole match expression. The evaluation of
expr_{i} takes place in an environment enriched by the bindings
performed during matching. If several patterns match the value of
expr, the one that occurs first in the match expression is
selected. If none of the patterns match the value of expr, the
exception Match_failure is raised.
The expression expr_{1} && expr_{2} evaluates to true if both
expr_{1} and expr_{2} evaluate to true; otherwise, it evaluates to
false. The first component, expr_{1}, is evaluated first. The
second component, expr_{2}, is not evaluated if the first component
evaluates to false. Hence, the expression expr_{1} && expr_{2} behaves
exactly as
if expr_{1} then expr_{2} else false.
The expression expr_{1}  expr_{2} evaluates to true if one of
expr_{1} and expr_{2} evaluates to true; otherwise, it evaluates to
false. The first component, expr_{1}, is evaluated first. The
second component, expr_{2}, is not evaluated if the first component
evaluates to true. Hence, the expression expr_{1}  expr_{2} behaves
exactly as
if expr_{1} then true else expr_{2}.
The boolean operator & is synonymous for &&. The boolean operator
or is synonymous for .
The expression while expr_{1} do expr_{2} done repeatedly
evaluates expr_{2} while expr_{1} evaluates to true. The loop
condition expr_{1} 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_{1} to expr_{2} do expr_{3} done
first evaluates the expressions expr_{1} and expr_{2} (the boundaries)
into integer values n and p. Then, the loop body expr_{3} is
repeatedly evaluated in an environment where name is successively
bound to the values
n, n+1, ..., p1, p.
The loop body is never evaluated if n > p.
The expression for name = expr_{1} downto expr_{2} do expr_{3} done
evaluates similarly, except that name is successively bound to the values
n, n1, ..., p+1, p.
The loop body is never evaluated if n < p.
In both cases, the whole for expression evaluates to the unit
value ().
The expression
try 
expr 
with 
pattern_{1} 
> 
expr_{1} 
 
... 
 
pattern_{n} 
> 
expr_{n} 
evaluates the expression expr and returns its value if the
evaluation of expr does not raise any exception. If the evaluation
of expr raises an exception, the exception value is matched against
the patterns pattern_{1} to pattern_{n}. If the matching against
pattern_{i} succeeds, the associated expression expr_{i} is evaluated,
and its value becomes the value of the whole try expression. The
evaluation of expr_{i} takes place in an environment enriched by the
bindings performed during matching. If several patterns match the value of
expr, the one that occurs first in the try expression is
selected. If none of the patterns matches the value of expr, the
exception value is raised again, thereby transparently ``passing
through'' the try construct.
6.7.3 
Operations on data structures 

The expression expr_{1} , ... , expr_{n} evaluates to the
ntuple of the values of expressions expr_{1} to expr_{n}. The
evaluation order for the subexpressions is not specified.
The expression constr expr evaluates to the variant value whose
constructor is constr, and whose argument is the value of expr.
For lists, some syntactic sugar is provided. The expression
expr_{1} :: expr_{2} stands for the constructor ( :: )
applied to the argument ( expr_{1} , expr_{2} ), and therefore
evaluates to the list whose head is the value of expr_{1} and whose tail
is the value of expr_{2}. The expression [ expr_{1} ; ... ;
expr_{n} ] is equivalent to expr_{1} :: ... :: expr_{n} ::
[], and therefore evaluates to the list whose elements are the
values of expr_{1} to expr_{n}.
The expression `tagname expr evaluates to the variant value whose
tag is tagname, and whose argument is the value of expr.
The expression { field_{1} = expr_{1} ; ... ; field_{n} =
expr_{n} } evaluates to the record value
{ field_{1} = v_{1} ; ... ; field_{n} = v_{n} },
where v_{i} is the value of expr_{i} for i = 1,... , n.
The fields field_{1} to field_{n} must all belong to the same record
types; all fields 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_{1} to expr_{n} are evaluated is not
specified.
The expression
{ expr with field_{1} = expr_{1} ; ... ; field_{n} = expr_{n} }
builds a fresh record with fields field_{1} ... field_{n} equal to
expr_{1} ... expr_{n}, and all other fields having the same value as
in the record expr. In other terms, it returns a shallow copy of
the record expr, except for the fields field_{1} ... field_{n},
which are initialized to expr_{1} ... expr_{n}.
The expression expr_{1} . field evaluates expr_{1} to a record
value, and returns the value associated to field in this record
value.
The expression expr_{1} . field < expr_{2} evaluates expr_{1} to a record
value, which is then modified inplace by replacing the value
associated to field in this record by the value of
expr_{2}. This operation is permitted only if field has been
declared mutable in the definition of the record type. The whole
expression expr_{1} . field < expr_{2} evaluates to the unit value
().
The expression [ expr_{1} ; ... ; expr_{n} ] evaluates to
a nelement array, whose elements are initialized with the values of
expr_{1} to expr_{n} respectively. The order in which these
expressions are evaluated is unspecified.
The expression expr_{1} .( expr_{2} ) returns the value of element
number expr_{2} in the array denoted by expr_{1}. The first element
has number 0; the last element has number n1, where n is the
size of the array. The exception Invalid_argument is raised if the
access is out of bounds.
The expression expr_{1} .( expr_{2} ) < expr_{3} modifies inplace
the array denoted by expr_{1}, replacing element number expr_{2} by
the value of expr_{3}. The exception Invalid_argument is raised if
the access is out of bounds. The value of the whole expression is ().
The expression expr_{1} .[ expr_{2} ] returns the value of character
number expr_{2} in the string denoted by expr_{1}. The first character
has number 0; the last character has number n1, where n is the
length of the string. The exception Invalid_argument is raised if the
access is out of bounds.
The expression expr_{1} .[ expr_{2} ] < expr_{3} modifies inplace
the string denoted by expr_{1}, replacing character number expr_{2} by
the value of expr_{3}. The exception Invalid_argument is raised if
the access is out of bounds. The value of the whole expression is ().
Symbols from the class infixsymbols, as well as the keywords
*, =, or and &, can appear in infix position (between two
expressions). Symbols from the class prefixsymbols
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 prefixsymbol expr is
interpreted as the application ( prefixsymbol )
expr. Similarly, the expression expr_{1} infixsymbol expr_{2} is
interpreted as the application ( infixsymbol ) expr_{1} expr_{2}.
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 20 for more
details). Their meaning may be changed at any time using
let ( infixop ) name_{1} name_{2} = ...
Operator 
Initial meaning 
+ 
Integer addition. 
 (infix) 
Integer subtraction. 
 (prefix) 
Integer negation. 
* 
Integer multiplication. 
/ 
Integer division.
Raise Division_by_zero if second argument is zero. 
mod 
Integer modulus. Raise
Division_by_zero if second argument is zero. 
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. 
+. 
Floatingpoint addition. 
. (infix) 
Floatingpoint subtraction. 
. (prefix) 
Floatingpoint negation. 
*. 
Floatingpoint multiplication. 
/. 
Floatingpoint division. 
** 
Floatingpoint 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''. 
When classpath evaluates to a class body, new classpath
evaluates to an object containing the instance variables and
methods of this class.
When classpath evaluates to a class function, new classpath
evaluates to a function expecting the same number of arguments and
returning a new object of this class.
Immediate object creation 

Creating directly an object through the object classbody end
construct is operationally equivalent to defining locally a class
myclass = object classbody end see sections
6.9.2 and following for the syntax of classbody
and immediately creating a single object from it by new myclass.
The typing of immediate objects is slightly different from explicitely
defining a class in two respects. First, the inferred object type may
contain free type variables. Second, since the class body of an
immediate object will never be extended, its self type can be unified
with a closed object type.
The expression expr # methodname invokes the method
methodname of the object denoted by expr.
If methodname is a polymorphic method, its type should be known at
the invocation site. This is true for instance if expr is the name
of a fresh object (let ident = new classpath ... ) or if
there is a type constraint. Principality of the derivation can be
checked in the principal mode.
Accessing and modifying instance variables 

The instance variables of a class are visible only in the body of the
methods defined in the same class or a class that inherits from the
class defining the instance variables. The expression instvarname
evaluates to the value of the given instance variable. The expression
instvarname < expr assigns the value of expr to the instance
variable instvarname, which must be mutable. The whole expression
instvarname < expr evaluates to ().
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_{1} :> typexpr_{2} ) coerces the
expression expr from type typexpr_{1} to type typexpr_{2}.
The former operator will sometimes fail to coerce an expression expr
from a type t_{1} to a type t_{2} even if type t_{1} is a subtype of type
t_{2}: in the current implementation it only expands two levels of
type abbreviations containing objects and/or variants, keeping only
recursion when it is explicit in the class type. In case of failure,
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.
An object can be duplicated using the library function Oo.copy
(see
Module Oo). Inside a method, the expression
{< instvarname = expr { ; instvarname = 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.