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∣ 09∣ _∣ ' }  
 
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)  
  \ (09) (09) (09)  
  \x (09∣ AF∣ af) (09∣ AF∣ af)

String literals

string-literal::= " { string-character } "  
 
string-character::= regular-char-str  
  escape-sequence

Naming labels

label-name ::= (a … z∣ _) { letter∣ 09∣ _∣ ' } 
 
label ::= ~ label-name :  
 
optlabel ::= ? label-name :

Prefix and infix symbols

infix-symbol::= (= ∣  < ∣  > ∣  @ ∣  ^ ∣  | ∣  & ∣  + ∣  - ∣  * ∣  / ∣  $ ∣  %) { operator-char }  
 
prefix-symbol::= (! ∣  ? ∣  ~) { 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  
 
label-name::= lowercase-ident  
 
tag-name::= 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::= value-name  
  module-path .  value-name  
 
constr::= constr-name  
  module-path .  constr-name  
 
typeconstr::= typeconstr-name  
  extended-module-path .  typeconstr-name  
 
field::= field-name  
  module-path .  field-name  
 
module-path::= module-name  
  module-path .  module-name  
 
extended-module-path::= module-name  
  extended-module-path .  module-name  
  extended-module-path (  extended-module-path )  
 
modtype-path::= modtype-name  
  extended-module-path .  modtype-name  
 
class-path::= class-name  
  module-path .  class-name

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  { | tag-spec } ]  
  [> [ tag-spec ]  { | tag-spec } ]  
  [< [ | ] tag-spec-full  { | tag-spec-full }  [ > { `tag-name }+ ] ]  
 
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  
  []  
  ()  
  `tag-name

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 } |]  
  lazy pattern
 
extensions for records:
  { field  (= pattern)?  { ; (field =  pattern)? }  ( ; _ )? }  

6.7  Expressions

expr::= value-path  
  constant  
  ( expr )  
  begin expr end  
  ( expr :  typexpr )  
  expr ,  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  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 =  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  
  inst-var-name  
  inst-var-name <-  expr  
  ( expr :>  typexpr )  
  ( expr :  typexpr :>  typexpr )  
  {< inst-var-name =  expr  { ; inst-var-name =  expr } >}  
  assert expr  
  lazy expr  
 
extensions for method bodies:
  inst-var-name <-  expr  
  {< [ inst-var-name =  expr  { ; inst-var-name =  expr } ] >}  
extensions for local opens:
  let open module-path in  expr  
  module-path .(  expr )  
extensions for records:
  { field  (= expr)?  { ; field  (= expr)? } }  
  { expr with  field  (= expr?)  { ; field  (= expr)? } }  
extensions for first-class modules:
  (module module-expr :  package-type)  
 
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=  expr  
 
extensions for polymorphic type annotations:
  value-name :  poly-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 explicit type variables:
  ( 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 (row) types:
  = private typexpr
 
type-representation::= = constr-decl  { | constr-decl }  
  = { field-decl  { ; field-decl } }  
 
extensions for private variants/records:
  = private constr-decl  { | constr-decl }  
  = private { field-decl  { ; field-decl } }
 
type-params::= type-param  
  ( type-param  { , type-param } )  
 
type-param::= ' ident  
  + ' ident  
  - ' ident  
 
constr-decl::= constr-name  
  constr-name of  typexpr  { * typexpr }  
 
field-decl::= field-name :  poly-typexpr  
  mutable field-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::= class-body-type  
   [[?]label-name:]  typexpr ->  class-type  
 
class-body-type::= object [( typexpr )]  {class-field-specend  
   class-path  
   [ typexpr  {, typexpr]  class-path  
 
class-field-spec::= inherit class-type  
   val [mutable] [virtualinst-var-name :  typexpr  
   method [privatemethod-name :  poly-typexpr  
   method [privatevirtual 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 [( pattern  [: typexpr)]  { class-field } end  
 
class-field::= inherit class-expr  [as value-name]  
   val [mutableinst-var-name  [: typexpr=  expr  
   val [mutablevirtual inst-var-name :  typexpr  
   method [privatemethod-name  {parameter}  [: typexpr=  expr  
   method [privatemethod-name :  poly-typexpr =  expr  
   method [privatevirtual method-name :  poly-typexpr  
   constraint typexpr =  typexpr  
   initializer expr  
 
extensions for explicit class fields:
   inherit! class-expr  [as value-name]  
   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 specification

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 module type-recovery:
  module type of module-expr
 
mod-constraint::= type [type-parameters]  typeconstr =  typexpr  
  module module-path =  extended-module-path  
 
extensions for signature substitution:
  type [type-parameters]  typeconstr-name :=  [type-parameters]  typeconstr  
  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 }

6.11  Module expressions (module implementations)

module-expr::= module-path  
  struct { definition  [;;] ∣  expr ;; 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)  
 
 
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 }  

6.12  Compilation units

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

Chapter 7  Language extensions

7.1  Integer literals for types int32, int64 and nativeint

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

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  Explicit naming of type variables

parameter::= ...  
  ( type typeconstr-name )  
 

7.14  First-class modules

typexpr::= ...  
  (module package-type)  
 
module-expr::= ...  
  (val expr :  package-type)  
 
expr::= ...  
  (module module-expr :  package-type)  
 
package-type::= modtype-path  
  modtype-path with  package-type-constraint  { and package-type-constraint }  
 
package-type-constraint::= type typeconstr-name =  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-parameters]  typeconstr-name :=  [type-parameters]  typeconstr  
  module module-name :=  extended-module-path  
 

7.17  Explicit overriding in class definitions

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

Chapter 9  The toplevel system (ocaml)

toplevel-input::=toplevel-phrase } ;;  
 
toplevel-phrase::= definition  
  expr  
  # ident  directive-argument  
 
directive-argument::= є  
  string-literal  
  integer-literal  
  value-path  
 

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