$ ocamlc -pp camlp4r foo.ml

            $ ocaml
            #load "camlp4r.cma";;

• In revised syntax, simple semicolons end the items of structures, signatures and objects. These semicolons are mandatory. The double semicolon is no more a token. There is no ambiguity with the sequence, which has a special construction (see further).
  
  
• 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;

• A structure item is actually ended by the beginning of the next structure item; it means that all structure items must start with a keyword; otherwise there is an ambiguity. For example, you cannot write:

  
       print_string "hello, world"
       print_newline ()
  

  because it is interpreted as a call to print_string with 3 parameters (and typing error). The advocated solution is to write:

  
       let _ = print_string "hello, world"
       let _ = print_newline ()
  

  Mmm....
  
  
• But this solution does not work interactively: in the toplevel, you cannot ask people to type the beginning of the next sentence to see the result of the current one. Therefore the double semicolon still remains! The property that we write in the toplevel like in source files has been lost.
  
  
• In structures and objects, the fact that you don't end the structure items and object items make the programs more difficult to read. If you write a short object or structure item in one only line, it is very difficult to see where the items start and end.

• 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	}

  
  
  
• The ``lets'' apply up to the end of the sequences.

     [ a; b; c ]

     if condition then
        a-simple-statement;
     statement-2;
     statement-3;

     if condition then
        let v = expr in
        a-simple-statement;
     statement-2;
     statement-3;

     if condition then
        let v = expr in
        a-simple-statement;
        statement-2;
        statement-3;

• 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 always 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.

     [ x; y; z :: t ]

     x :: y :: z :: t

• 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 by brackets: an open bracket ``['' before the first case, and a close bracket ``]'' after the last case:

  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 normal and revised syntaxes:

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

  Notice that in revised syntax, both fun [ x -> x ] and fun x -> x are correct. The currified pattern matching can be done with ``fun'' without brackets, 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 syntax:

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

  
  
  
• It is possible to use a construction ``where'', it is a reversed ``let'', but one can write only one bind:

       e where x = y
  

     match ... with
       case1 ->
         match ... with
           case11 -> ...
         | case12 -> ...
     | case2 -> ...

     fun _ -> assert False

     let x :: y = a in b

     match a with x :: y -> b | ...

          let a =
             b where c = d
          and e = f in ...

          let a =
             b where c = d and e = f
          in ...

             loop 0 where rec loop i = ...

             let loop i = ... in loop 0

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

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

  
  
  
• The ``ref'' type is used as if its field label was 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

            match x with Ref x -> x
            match x with Ref x -> x <- y

            x.contents
            x.contents <- y

• The type constructors are before their type parameters, which are written with the currified form:

  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 constructors 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 currified:

  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 currified, 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};

            fun (x : [ A | B ]) -> ...
            type t = { lab : [ A | B ] }
            type u = [ C of { lab : ...} ]

            fun C (x, y) -> (x, y)

            fun C x -> x

            fun [ C x y -> (x, y) ]

     camlp4o pr_r.cmo file.ml

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

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

  
  
  
• The boolean operations ``or'' and ``and'' must be written only 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 when needed.
  
  
• 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.
  
  
• 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;
  

    if a then
      if b then c
    else d

• 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 []
  

          [<:expr< xx >>; <:expr< yy >>]

          parser [< '('a' | 'b') >] -> ...

          parser [< ' ('a' | 'b') >] -> ...