• A simple semicolon ends the sentences, in structures and in signatures. The double semicolon is not a token. There is no ambiguity with the sequence, which has a special construction (see 6.2).
  
  
• The declaration of a global variable is introduced by the keyword ``value'', ``let'' being reserved to the construction ``let..in'':

  OCaml	Revised
  let x = 23;;	value x = 23;
  let x = 23 in x + 7;;	let x = 23 in x + 7;

  
  
  
• In interfaces, one must use ``value'', too, instead of ``val''.

  OCaml	Revised
  val x : int;;	value x : int;

• The sequence is introduced by the keyword ``do'' followed by ``{'' and terminated by ``}'' (it is possible to put a semicolon after the last expression):

  OCaml	Revised
  e1; e2; e3; e4	do { e1; e2; e3; e4 }

  
  
  
• The body of ``for'' and ``while'' has the same syntax:

  OCaml	Revised
  while e1 do	while e1 do {
  e2; e3; e4	e2; e3; e4
  done	}

• Parentheses are mandatory in tuples:

  OCaml	Revised
  1, "hello", World	(1, "hello", World)

  
  
  
• Lists are always enclosed with ``['' and ``]''. Their syntax is:

  list	::=	[ elem-list opt-cons ]
  elem-list	::=	expression ; elem-list | expression
  opt-cons	::=	:: expression | (*empty*)

  A list is a sequence of expressions separated by semicolons, optionally ended by a ``::'' and an expression, the whole being enclosed by brackets. Examples:

  OCaml	Revised
  x::y	[x::y]
  [x; y; z]	[x; y; z]
  x::y::z::t	[x::[y::[z::t]]]
  x::y::z::t	[x; y; z :: t]

  Note the two ways to write the last case.

• A variable.
• The wildcard ``_''.
• The constructor ``()''.
• A tuple with irrefutable patterns.
• A record with irrefutable patterns.
• An irrefutable pattern with a type constraint.

• The keyword ``function'' no longer exists. One must use only ``fun''.
  
  
• The pattern matchings, in constructions with ``fun'', ``match'' and ``try'' are closed with brackets: an open bracket ``['' before the first case, and a close bracket ``]'' after the last one:

  OCaml	Revised
  match e with	match e with
  p1 -> e1	[ p1 -> e1
  | p2 -> e2;;	| p2 -> e2 ];
  fun x -> x;;	fun [x -> x];

  But if there is only one case and if the pattern is irrefutable, the brackets are not mandatory. These examples work identically in OCaml and in revised syntax:

  OCaml	Revised
  fun x -> x	fun x -> x
  fun {foo=(y, _)} -> y	fun {foo=(y, _)} -> y

  The curryfied pattern matching can be done with ``fun'', but only with irrefutable patterns:

  OCaml	Revised
  fun x (y, z) -> t	fun x (y, z) -> t
  fun x y (C z) -> t	fun x y -> fun [C z -> t]

  
  
  
• It is possible to write the empty function, raising the exception ``Match_failure'' whichever parameter is applied, the empty ``match'', raising ``Match_failure'' after having evaluated its expression, and the empty ``try'', equivalent to its expression without try:

      fun []
      match e with []
      try e with []
  

  
  
  
• The patterns after ``let'' and ``value'' must be irrefutable. The following OCaml expression:

      let f (x::y) = ...
  

  must be written in Revised:

      let f = fun [ [x::y] -> ...
  

  
  
  
• The construction ``where'' is back, but one can write only one bind: e where x = y but not: e where x = y and z = t

• The instruction ``<-'' is written ``:='':

  OCaml	Revised
  x.f <- y	x.f := y

  
  
  
• The ``ref'' type is declared as a record type with one field named ``val'', instead of ``contents''. The operator ``!'' does not exist any more, and references are assigned like the other mutables:

  OCaml	Revised
  x := !x + y	x.val := x.val + y

• The type constructors are before their type parameters, which are curryfied:

  OCaml	Revised
  int list	list int
  ('a, bool) Hashtbl.t	Hashtbl.t 'a bool
  type 'a foo =	type foo 'a =
  'a list list;;	list (list 'a);

  
  
  
• The abstract types are represented by a unbound type variable:

  OCaml	Revised
  type 'a foo;;	type foo 'a = 'b;
  type bar;;	type bar = 'a;

  
  
  
• Parentheses are mandatory in tuples of types:

  OCaml	Revised
  int * bool	(int * bool)

  
  
  
• In declaration of a concrete type, brackets must enclose the constructor declarations:

  OCaml	Revised
  type t = A of i | B;;	type t = [ A of i | B ];

  
  
  
• It is possible to make the empty type, without constructor:

      type foo = [];
  

  
  
  
• There is a syntax difference between data constructors with several parameters and data constructors with one parameter of type tuple.
  
  The declaration of a data constructor with several parameters is done by separating the types with ``and''. In expressions and patterns, this constructor parameters must be curryfied:

  OCaml	Revised
  type t = C of t1 * t2;;	type t = [ C of t1 and t2 ];
  C (x, y);;	C x y;

  
  
  The declaration of a data constructor with one parameter of type tuple is done by using a tuple type. In expressions and patterns, the parameter has not to be curryfied, since it is alone:

  OCaml	Revised
  type t = D of (t1 * t2);;	type t = [ D of (t1 * t2) ];
  D (x, y);;	D (x, y);

  
  
  
• The predefined constructors ``True'' and ``False'' start with an uppercase letter.
  
  
• In record types, the keyword ``mutable'' must appear after the colon:

  OCaml	Revised
  type t = {mutable x : t1};;	type t = {x : mutable t1};

     camlp4o pr_r.cmo file.ml

• The ``else'' is mandatory in the ``if'' instruction:

  OCaml	Revised
  if a then b	if a then b else ()

  
  
  
• The boolean operations ``or'' and ``and'' must be only written with ``||'' and ``&&'':

  OCaml	Revised
  a or b & c	a || b && c
  a || b && c	a || b && c

  
  
  
• No more ``begin end'' construction. One must use parentheses.
  
  
• The operators as functions are written with an backslash:

  OCaml	Revised
  (+)	\+
  (mod)	\mod

• The operators with special characters are not automatically infix. To define infixes, use the syntax extensions (chapter 5).
  
  
• It is possible to group together several declarations either in an interface or in an implementation by enclosing them between ``declare'' and ``end''. Example in an interface:

     declare
       type foo = [ Foo of int | Bar ];
       value f : foo -> int;
     end;
  

  This can be useful when extending the language structure or signature items with a construction generating several items.

• The streams and the stream patterns are bracketed with ``[:'' and ``:]'' instead of ``[<'' and ``>]''.
  
  
• The stream component ``terminal'' is written with a backquote instead of a quote:

  OCaml	Revised
  [< '1; '2; s; '3 >]	[: `1; `2; s; `3 :]

  
  
  
• The cases of parsers are bracketed with ``['' and ``]'', like for ``fun'', ``match'' and ``try''. If there is one case, the brackets are not mandatory:

  OCaml	Revised
  parser	parser
  [< 'Foo >] -> e	[ [: `Foo :] -> e
  | [< p = f >] -> f	| [: p = f :] -> f ]
  parser [< 'x >] -> x	parser [ [: `x :] -> x ]
  parser [< 'x >] -> x	parser [: `x :] -> x

  
  
  
• It is possible to write the empty parser raising the exception ``Stream.Failure'' whichever parameter is applied, and the empty stream matching always raising ``Stream.Failure'':

      parser []
      match e with parser []