Revised
From Gallium
The revised syntax is an alternative syntax for OCaml. Its purpose is to be simpler, more regular, more logical than the normal syntax, and fix some problems which sometimes result in bugs not always easy to find.
This chapter presents the changes from regular OCaml syntax.
Contents |
The revised syntax and 3.10
There is new direction chosen for the revised syntax in 3.10. If you want learn about the revised syntax from scratch please starts at the next section.
We want to being closer to the original syntax when it's possible. So when possible we introduce some constructions closer to the original syntax called "preferred style", but kept the backward compatibility as most as possible.
List of changes
A tour of the revised syntax for OCaml
If you want learn about the revised syntax from scratch you'd better put attention mainly on changes marked "preferred style".
Top-level phrases
- 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.
- The declaration of a global variable is introduced by the keyword value, let being reserved to the construction let..in:
Regular syntax | Revised syntax |
---|---|
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.
Regular syntax | Revised syntax |
---|---|
val x : int;; | value x : int; |
Imperative constructions
- In the preferred style there is just some parentheses more.
- However the revised syntax also have sequences introduced by the keyword do followed by { and terminated by } (it is possible to put a semicolon after the last expression):
Regular syntax | Revised syntax (preferred style) | Revised syntax |
---|---|---|
e1; e2; e3; e4 | (e1; e2; e3; e4) | do { e1; e2; e3; e4 } |
- The body of for and while has the same syntax:
Regular syntax or Revised preferred style | Revised syntax |
---|---|
while e1 do | while e1 do { |
e2; e3; e4 | e2; e3; e4 |
done | } |
Tuples and lists
- Parentheses are mandatory in tuples:
Regular syntax | Revised syntax |
---|---|
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:
Regular syntax | Revised syntax |
---|---|
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.
Irrefutable patterns
There is a notion of "irrefutable patterns" used by some syntactic constructions. Matching against these patterns never fails. An "irrefutable pattern" is either:
- A variable.
- The wildcard _.
- The constructor ().
- A tuple with irrefutable patterns.
- A record with irrefutable patterns.
- An irrefutable pattern with a type constraint.
Note that the term "irrefutable" does not apply to all patterns which never fail: constructors alone in their type declarations, except (), are not said "irrefutable".