Previous Up

Ocaml grammar overview

This appendix contains all grammar rules from this manual, including those for the toplevel and the debugger.

Page navigation


6.1  Lexical conventions

Identifiers

ident::= ( letter ∣  _ ) { letter ∣  0 … 9 ∣  _ ∣  ' }  
 
capitalized-ident::= (A … Z) { letter ∣  0 … 9 ∣  _ ∣  ' }  
 
lowercase-ident::= (a … z ∣  _) { letter ∣  0 … 9 ∣  _ ∣  ' }  
 
letter::= A … Z ∣  a … z

Integer literals

integer-literal::= [-] (09) { 09 ∣  _ }  
  [-] (0x∣ 0X) (09∣ AF∣ af) { 09∣ AF∣ af∣ _ }  
  [-] (0o∣ 0O) (07) { 07∣ _ }  
  [-] (0b∣ 0B) (01) { 01∣ _ }

Floating-point literals

float-literal::= [-] (09) { 09∣ _ } [. { 09∣ _ }] [(e∣ E) [+∣ -] (09) { 09∣ _ }]

Character literals

char-literal::= ' regular-char '  
  ' escape-sequence '  
 
escape-sequence::= \ ( \ ∣  " ∣  ' ∣  n ∣  t ∣  b ∣  r ∣  space )  
  \ (09) (09) (09)  
  \x (09∣ AF∣ af) (09∣ AF∣ af)

String literals

string-literal::= " { string-character } "  
 
string-character::= regular-string-char  
  escape-sequence  
  \ newline  { space ∣  tab }

Naming labels

label-name::= lowercase-ident  
 
label::= ~ label-name :  
 
optlabel::= ? label-name :

Prefix and infix symbols

infix-symbol::= (= ∣  < ∣  > ∣  @ ∣  ^ ∣  | ∣  & ∣  + ∣  - ∣  * ∣  / ∣  $ ∣  %) { operator-char }  
 
prefix-symbol::= ! { operator-char }  
  (? ∣  ~) { operator-char }+  
 
operator-char::= ! ∣  $ ∣  % ∣  & ∣  * ∣  + ∣  - ∣  . ∣  / ∣  : ∣  < ∣  = ∣  > ∣  ? ∣  @ ∣  ^ ∣  | ∣  ~

Line number directives

linenum-directive::= # {0 … 9}+  
  # {0 … 9}+ " { string-character } "

6.3  Names

Naming objects

value-name::= lowercase-ident  
  ( operator-name )  
 
operator-name::= prefix-symbol ∣  infix-op  
 
infix-op::= infix-symbol  
  * ∣  + ∣  - ∣  -. ∣  = ∣  != ∣  < ∣  > ∣  or ∣  || ∣  & ∣  && ∣  :=  
  mod ∣  land ∣  lor ∣  lxor ∣  lsl ∣  lsr ∣  asr  
 
constr-name::= capitalized-ident  
 
tag-name::= ident capitalized-ident  
 
typeconstr-name::= lowercase-ident  
 
field-name::= lowercase-ident  
 
module-name::= capitalized-ident  
 
modtype-name::= ident  
 
class-name::= lowercase-ident  
 
inst-var-name::= lowercase-ident  
 
method-name::= lowercase-ident

Referring to named objects

value-path::=module-path . ]  value-name  
 
constr::=module-path . ]  constr-name  
 
typeconstr::=extended-module-path . ]  typeconstr-name  
 
field::=module-path . ]  field-name  
 
modtype-path::=extended-module-path . ]  modtype-name  
 
class-path::=module-path . ]  class-name  
 
classtype-path::=extended-module-path . ]  class-name  
 
module-path::= module-name  { . module-name }  
 
extended-module-path::= extended-module-name  { . extended-module-name }  
 
extended-module-name::= module-name  { ( extended-module-path ) }

6.4  Type expressions

typexpr::= ' ident  
  _  
  ( typexpr )  
  [[?]label-name:]  typexpr ->  typexpr  
  typexpr  { * typexpr }+  
  typeconstr  
  typexpr  typeconstr  
  ( typexpr  { , typexpr } )  typeconstr  
  typexpr as '  ident  
  polymorphic-variant-type  
  < [..>  
  < method-type  { ; method-type }  [; ∣  ; ..>  
  # class-path  
  typexpr #  class-path  
  ( typexpr  { , typexpr } ) #  class-path  
 
extensions for first class modules:
  (module package-type)  
 
poly-typexpr::= typexpr  
  { ' ident }+ .  typexpr  
 
method-type::= method-name :  poly-typexpr

Polymorphic variant types

polymorphic-variant-type::= [ tag-spec-first  { | tag-spec } ]  
  [> [ tag-spec ]  { | tag-spec } ]  
  [< [|tag-spec-full  { | tag-spec-full }  [ > { `tag-name }+ ] ]  
 
tag-spec-first::= `tag-name  [ of typexpr ]  
  [ typexpr ] |  tag-spec  
 
tag-spec::= `tag-name  [ of typexpr ]  
  typexpr  
 
tag-spec-full::= `tag-name  [ of [&] typexpr  { & typexpr } ]  
  typexpr

6.5  Constants

constant::= integer-literal  
  float-literal  
  char-literal  
  string-literal  
  constr  
  false  
  true  
  ()  
  begin end  
  []  
  [||]  
  `tag-name
 
extensions for more integer literals:
  int32-literal  
  int64-literal  
  nativeint-literal  

6.6  Patterns

pattern::= value-name  
  _  
  constant  
  pattern as  value-name  
  ( pattern )  
  ( pattern :  typexpr )  
  pattern |  pattern  
  constr  pattern  
  `tag-name  pattern  
  #typeconstr-name  
  pattern  { , pattern }+  
  { field =  pattern  { ; field =  pattern }  [ ; ] }  
  [ pattern  { ; pattern }  [ ; ] ]  
  pattern ::  pattern  
  [| pattern  { ; pattern }  [ ; ] |]
 
extensions for range patterns:
  char-literal ..  char-literal
 
extensions for lazy evaluation:
  lazy pattern
 
extensions for record notations:
  { field  [= pattern]  { ; field  [= pattern] }  [; _ ] [;}  
 
extensions for first class modules:
  (module module-name  [: package-type])  

6.7  Expressions

expr::= value-path  
  constant  
  ( expr )  
  begin expr end  
  ( expr :  typexpr )  
  expr  {, expr}+  
  constr  expr  
  `tag-name  expr  
  expr ::  expr  
  [ expr  { ; expr }  [;]  
  [| expr  { ; expr }  [;|]  
  { field =  expr  { ; field =  expr }  [;}  
  { expr with  field =  expr  { ; field =  expr }  [;}  
  expr  { argument }+  
  prefix-symbol  expr  
  - expr  
  -. expr  
  expr  infix-op  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 value-name =  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 [reclet-binding  { and let-binding } in  expr  
  new class-path  
  object class-body end  
  expr #  method-name  
  ( expr :>  typexpr )  
  ( expr :  typexpr :>  typexpr )  
 
extensions for assertion checking:
  assert expr
 
extensions for method bodies:
  inst-var-name  
  inst-var-name <-  expr  
  {< [ inst-var-name =  expr  { ; inst-var-name =  expr }  [;] ] >}
 
extensions for lazy evaluation:
  lazy expr
 
extensions for local modules:
  let module module-name  { ( module-name :  module-type ) }  [ : module-type ]  =  module-expr in  expr
 
extensions for local opens:
  let open module-path in  expr  
  module-path .(  expr )
 
extensions for record notations:
  { field  [= expr]  { ; field  [= expr] }  [;}  
  { expr with  field  [= expr]  { ; field  [= expr] }  [;}
 
extensions for first class modules:
  (module module-expr  [: package-type])  
 
extensions for overriding in open statements:
  let open! module-path in  expr
 
extensions for bigarray access:
  expr .{  expr  { , expr } }  
  expr .{  expr  { , expr } } <-  expr
 
argument::= expr  
  ~ label-name  
  ~ label-name :  expr  
  ? label-name  
  ? label-name :  expr  
 
pattern-matching::=| ] pattern  [when expr->  expr  { | pattern  [when expr->  expr }  
 
multiple-matching::=parameter }+  [when expr->  expr  
 
let-binding::= pattern =  expr  
  value-name  { parameter }  [: typexpr]  [:> typexpr] =  expr  
 
extensions for explicit polymorphic type annotations:
  value-name :  poly-typexpr =  expr
 
extensions for locally abstract types:
  value-name : type  { typeconstr-name }+ .  typexpr =  expr  
 
parameter::= pattern  
  ~ label-name  
  ~ ( label-name  [: typexpr)  
  ~ label-name :  pattern  
  ? label-name  
  ? ( label-name  [: typexpr]  [= expr)  
  ? label-name :  pattern  
  ? label-name : (  pattern  [: typexpr]  [= expr)
 
extensions for locally abstract types:
  ( type typeconstr-name )

6.8  Type and exception definitions

6.8.1  Type definitions

type-definition::= type typedef  { and typedef }  
 
typedef::= [type-params]  typeconstr-name  type-information  
 
type-information::= [type-equation]  [type-representation]  { type-constraint }  
 
type-equation::= = typexpr  
 
extensions for private type abbreviations:
  = private typexpr
 
extensions for private row types:
  = private typexpr
 
type-representation::= = [|] constr-decl  { | constr-decl }  
  = { field-decl  { ; field-decl }  [;] }  
 
extensions for private variant and record types:
  = private [ | ] constr-decl  { | constr-decl }  
  = private { field-decl  { ; field-decl }  [ ; ] }
 
type-params::= type-param  
  ( type-param  { , type-param } )  
 
type-param::= [variance'  ident  
 
extensions for generalized algebraic datatypes:
  [variance_
 
variance::= +  
  -  
 
constr-decl::= (constr-name ∣  ()) [ of typexpr  { * typexpr } ]  
 
extensions for generalized algebraic datatypes:
  constr-name :  [ typexpr  { * typexpr } -> ]  typexpr  
 
field-decl::= [mutablefield-name :  poly-typexpr  
 
type-constraint::= constraint ' ident =  typexpr

6.8.2  Exception definitions

exception-definition::= exception constr-name  [ of typexpr  { * typexpr } ]  
  exception constr-name =  constr

6.9  Classes

6.9.1  Class types

class-type::= {[[?]label-name:]  typexpr ->}  class-body-type  
 
class-body-type::= object [( typexpr )]  {class-field-specend  
   [[ typexpr  {, typexpr]]  classtype-path  
 
class-field-spec::= inherit class-body-type  
   val [mutable] [virtualinst-var-name :  typexpr  
   val virtual mutable inst-var-name :  typexpr  
   method [private] [virtualmethod-name :  poly-typexpr  
   method virtual private method-name :  poly-typexpr  
   constraint typexpr =  typexpr

6.9.2  Class expressions

class-expr::= class-path  
   [ typexpr  {, typexpr]  class-path  
   ( class-expr )  
   ( class-expr :  class-type )  
   class-expr  {argument}+  
   fun {parameter}+ ->  class-expr  
   let [reclet-binding  {and let-bindingin  class-expr  
   object class-body end  
 
class-field::= inherit class-expr  [as value-name lowercase-ident]  
   val [mutableinst-var-name  [: typexpr=  expr  
   val [mutablevirtual inst-var-name :  typexpr  
   val virtual mutable inst-var-name :  typexpr  
   method [privatemethod-name  {parameter}  [: typexpr=  expr  
   method [privatemethod-name :  poly-typexpr =  expr  
   method [privatevirtual method-name :  poly-typexpr  
   method virtual private method-name :  poly-typexpr  
   constraint typexpr =  typexpr  
   initializer expr
 
extensions for locally abstract types:
  method [privatemethod-name : type  { typeconstr-name }+ .  typexpr =  expr  
  method! [privatemethod-name : type  { typeconstr-name }+ .  typexpr =  expr
 
extensions for explicit overriding in class definitions:
   inherit! class-expr  [as lowercase-ident]  
   val! [mutableinst-var-name  [: typexpr=  expr  
   method! [privatemethod-name  {parameter}  [: typexpr=  expr  
   method! [privatemethod-name :  poly-typexpr =  expr

Class body

class-body::=  [( pattern  [: typexpr)]  { class-field }

Method definition

expr::= …  
  inst-var-name <-  expr  
  {< [ inst-var-name =  expr  { ; inst-var-name =  expr }  [;] ] >}

6.9.3  Class definitions

class-definition::= class class-binding  { and class-binding }  
 
class-binding::= [virtual] [[ type-parameters ]]  class-name  {parameter}  [: class-type]  =  class-expr  
 
type-parameters::= ' ident  { , ' ident }

6.9.4  Class specifications

class-specification::= class class-spec  { and class-spec }  
 
class-spec::= [virtual] [[ type-parameters ]]  class-name :  class-type

6.9.5  Class type definitions

classtype-definition::= class type classtype-def  { and classtype-def }  
 
classtype-def::= [virtual] [[ type-parameters ]]  class-name =  class-body-type

6.10  Module types (module specifications)

module-type::= modtype-path  
  sig { specification  [;;] } end  
  functor ( module-name :  module-type ) ->  module-type  
  module-type with  mod-constraint  { and mod-constraint }  
  ( module-type )  
 
extensions for recovering the type of a module:
  module type of module-expr
 
mod-constraint::= type [type-params]  typeconstr  type-equation  
  module module-path =  extended-module-path  
 
extensions for substituting inside a signature:
  type [type-params]  typeconstr-name :=  [type-params]  typeconstr-name typexpr  
  module module-name :=  extended-module-path
 
specification::= val value-name :  typexpr  
  external value-name :  typexpr =  external-declaration  
  type-definition  
  exception constr-decl  
  class-specification  
  classtype-definition  
  module module-name :  module-type  
  module module-name  { ( module-name :  module-type ) } :  module-type  
  module type modtype-name  
  module type modtype-name =  module-type  
  open module-path  
  include module-type
 
extensions for recursive modules:
  module rec module-name :  module-type  { and module-name:  module-type }
 
extensions for overriding in open statements:
   open! module-path  

6.11  Module expressions (module implementations)

module-expr::= module-path  
  struct [ module-items ] end  
  functor ( module-name :  module-type ) ->  module-expr  
  module-expr (  module-expr )  
  ( module-expr )  
  ( module-expr :  module-type )  
 
extensions for first class modules:
  (val expr  [: package-type])  
 
module-items::= [;;] ( definition ∣  expr )  { [;;definition ∣  ;; expr }  [;;]  
 
definition::= let [reclet-binding  { and let-binding }  
  external value-name :  typexpr =  external-declaration  
  type-definition  
  exception-definition  
  class-definition  
  classtype-definition  
  module module-name  { ( module-name :  module-type ) }  [ : module-type ]  =  module-expr  
  module type modtype-name =  module-type  
  open module-path  
  include module-expr
 
extensions for recursive modules:
  module rec module-name :  module-type =  module-expr   { and module-name :  module-type =  module-expr }  
 
extensions for overriding in open statements:
   open! module-path  

6.12  Compilation units

unit-interface::= { specification  [;;] }  
 
unit-implementation::= [ module-items ]

Chapter 7  Language extensions

7.1  Integer literals for types int32, int64 and nativeint

constant::= ...  
  int32-literal  
  int64-literal  
  nativeint-literal  
 
int32-literal::= integer-literal l  
 
int64-literal::= integer-literal L  
 
nativeint-literal::= integer-literal n

7.4  Range patterns

pattern::= ...  
  char-literal ..  char-literal

7.5  Assertion checking

expr::= ...  
  assert expr

7.6  Lazy evaluation

expr::= ...  
  lazy expr
pattern::= ...  
  lazy pattern

7.7  Local modules

expr::= ...  
  let module module-name  { ( module-name :  module-type ) }  [ : module-type ]  =  module-expr in  expr

7.8  Recursive modules

definition::= ...  
  module rec module-name :  module-type =  module-expr   { and module-name :  module-type =  module-expr }  
 
specification::= ...  
  module rec module-name :  module-type  { and module-name:  module-type }

7.9  Private types

7.9.1  Private variant and record types

type-representation::= ...  
  = private [ | ] constr-decl  { | constr-decl }  
  = private { field-decl  { ; field-decl }  [ ; ] }

7.9.2  Private type abbreviations

type-equation::= ...  
  = private typexpr

7.9.3  Private row types

type-equation::= ...  
  = private typexpr

7.10  Local opens

expr::= ...  
  let open module-path in  expr  
  module-path .(  expr )

7.11  Record notations

pattern::= ...  
  { field  [= pattern]  { ; field  [= pattern] }  [; _ ] [;}  
 
expr::= ...  
  { field  [= expr]  { ; field  [= expr] }  [;}  
  { expr with  field  [= expr]  { ; field  [= expr] }  [;}

7.12  Explicit polymorphic type annotations

let-binding::= ...  
  value-name :  poly-typexpr =  expr

7.13  Locally abstract types

parameter::= ...  
  ( type typeconstr-name )
let-binding::= ...  
  value-name : type  { typeconstr-name }+ .  typexpr =  expr  
 
class-field::= ...  
  method [privatemethod-name : type  { typeconstr-name }+ .  typexpr =  expr  
  method! [privatemethod-name : type  { typeconstr-name }+ .  typexpr =  expr

7.14  First-class modules

typexpr::= ...  
  (module package-type)  
 
module-expr::= ...  
  (val expr  [: package-type])  
 
expr::= ...  
  (module module-expr  [: package-type])  
 
pattern::= ...  
  (module module-name  [: package-type])  
 
package-type::= modtype-path  
  modtype-path with  package-constraint  { and package-constraint }  
 
package-constraint::= type typeconstr =  typexpr

7.15  Recovering the type of a module

module-type::= ...  
  module type of module-expr

7.16  Substituting inside a signature

mod-constraint::= ...  
  type [type-params]  typeconstr-name :=  [type-params]  typeconstr-name typexpr  
  module module-name :=  extended-module-path

7.17  Explicit overriding in class definitions

class-field::= ...  
   inherit! class-expr  [as lowercase-ident]  
   val! [mutableinst-var-name  [: typexpr=  expr  
   method! [privatemethod-name  {parameter}  [: typexpr=  expr  
   method! [privatemethod-name :  poly-typexpr =  expr

7.18  Overriding in open statements

definition::= ...  
   open! module-path  
 
specification::= ...  
   open! module-path  
 
expr::= ...  
  let open! module-path in  expr

7.19  Generalized algebraic datatypes

constr-decl::= ...  
  constr-name :  [ typexpr  { * typexpr } -> ]  typexpr  
 
type-param::= ...  
  [variance_

7.20  Syntax for Bigarray access

expr::= ...  
  expr .{  expr  { , expr } }  
  expr .{  expr  { , expr } } <-  expr

Chapter 9  The toplevel system (ocaml)

toplevel-input::=definition }+ ;;  
  expr ;;  
  # ident  [ directive-argument ] ;;  
 
directive-argument::= string-literal  
  integer-literal  
  value-path  
  true ∣  false

Chapter 16  The debugger (ocamldebug)

16.7  Examining variable values

simple-expr::= lowercase-ident  
  { capitalized-ident . }  lowercase-ident  
  *  
  $ integer  
  simple-expr .  lowercase-ident  
  simple-expr .(  integer )  
  simple-expr .[  integer ]  
  ! simple-expr  
  ( simple-expr )

Previous Up