Previous Contents

Ocaml Grammar overview

This appendix contains all grammar rules extracted from Chapter 6 and Chapter 7. Below there are also the grammar rules for the toplevel system (see Chapter 9) and for the the debugger (see Chapter 15).

6.1 Lexical conventions

Identifiers

ident ::= (letter| _) { letter| 0...9| _| ' }
letter ::= A ... Z | a ... z

Integer literals

integer-literal ::= [-] { 0...9 }+
  | [-] (0x| 0X) { 0...9| A...F| a...f }+
  | [-] (0o| 0O) { 0...7 }+
  | [-] (0b| 0B) { 0...1 }+

Floating-point literals

float-literal ::= [-] { 0...9 }+ [. { 0...9 }] [(e| E) [+| -] { 0...9 }+]

Character literals

char-literal ::= ' regular-char '
  | ' \ (\ | ' | n | t | b | r) '
  | ' \ (0...9) (0...9) (0...9) '

String literals

string-literal ::= " { string-character } "
string-character ::= regular-char
  | \ (\ | " | n | t | b | r)
  | \ (0...9) (0...9) (0...9)

Naming labels

label ::= ~ (a ... z) { letter| 0...9| _| ' } :
optlabel ::= ? (a ... z) { letter| 0...9| _| ' } :

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-symbol | * | = | or | & | :=
cconstr-name ::= capitalized-ident
  | false
  | true
  | [ ]
  | ( )
ncconstr-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 .  lowercase-ident
cconstr ::= cconstr-name
  | module-path .  capitalized-ident
ncconstr ::= ncconstr-name
  | module-path .  capitalized-ident
typeconstr ::= typeconstr-name
  | extended-module-path .  lowercase-ident
field ::= field-name
  | module-path .  lowercase-ident
module-path ::= module-name
  | module-path .  capitalized-ident
extended-module-path ::= module-name
  | extended-module-path .  capitalized-ident
  | extended-module-path (  extended-module-path )
modtype-path ::= modtype-name
  | extended-module-path .  ident
class-path ::= class-name
  | module-path .  lowercase-ident

6.4 Type expressions

typexpr ::= ' ident
  | _
  | ( typexpr )
  | [[?]ident:]  typexpr ->  typexpr
  | typexpr  { * typexpr }+
  | typeconstr
  | typexpr  typeconstr
  | ( typexpr  { , typexpr } )  typeconstr
  | typexpr as '  ident
  | [ variant-type ]
  | < [..] >
  | < method-type  { ; method-type }  [; ..] >
  | # class-path
  | typexpr #  class-path
  | ( typexpr  { , typexpr } ) #  class-path
  | # typeconstr-path  [ tag-list ]
  | typexpr #  typeconstr-path  [ tag-list ]
  | ( typexpr  { , typexpr } ) #  typeconstr-path  [ tag-list ]
method-type ::= method-name :  typexpr
tag-list ::= [> {`tag-name}+ ]

Variant types

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

6.5. Constants

constant ::= integer-literal
  | float-literal
  | char-literal
  | string-literal
  | cconstr
  | `tag-name

6.3. Patterns

pattern ::= value-name
  | _
  | constant
  | pattern as  value-name
  | ( pattern )
  | ( pattern :  typexpr )
  | pattern |  pattern
  | ncconstr  pattern
  | `tag-name  pattern
  | #typeconstr-name
  | pattern  { , pattern }
  | { field =  pattern  { ; field =  pattern } }
  | [ pattern  { ; pattern } ]
  | pattern ::  pattern

6.7. Expressions

expr ::= value-path
  | constant
  | ( expr )
  | begin expr end
  | ( expr :  typexpr )
  | expr ,  expr  { , expr }
  | ncconstr  expr
  | `tag-name  expr
  | expr ::  expr
  | [ expr  { ; expr } ]
  | [| expr  { ; expr } |]
  | { 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 [rec] let-binding  { and let-binding } in  expr
  | new class-path
  | expr #  method-name
  | ( expr :>  typexpr )
  | ( expr :  typexpr :>  typexpr )
  | {< inst-var-name =  expr  { ; inst-var-name =  expr } >}
 

Extensions in method definitions
  | inst-var-name <-  expr
  | {< [ inst-var-name =  expr  { ; inst-var-name =  expr } ] >}
 

extensions for streams and stream parsers
expr ::= ...
  | [< >]
  | [< stream-component  { ; stream-component } >]
  | parser [pattern]  stream-matching
  | match expr with parser  [pattern]  stream-matching
 
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  [: typexpr] =  expr
  | value-name  { parameter }+  [: 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] )
infix-op ::= infix-symbol
  | * | = | or | &

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
type-representation ::= = constr-decl  { | constr-decl }
  | = { field-decl  { ; field-decl } }
type-params ::= type-param
  | ( type-param  { , type-param } )
type-param ::= ' ident
  | + ' ident
  | - ' ident
constr-decl ::= cconstr-name
  | ncconstr-name of  typexpr
field-decl ::= field-name :  typexpr
  | mutable field-name :  typexpr
type-constraint ::= constraint ' ident =  typexpr

6.8.2 Exception definitions
exception-definition ::= exception constr-decl
  | exception cconstr-name =  cconstr
  | exception ncconstr-name =  ncconstr

6.9. Classes

6.9.1 Class types

class-type ::=  
  | class-body-type
  | [[?]label] typexpr ->  class-type
class-body-type ::= object [( typexpr )]  {class-field-spec} end
  | class-path
  | [ typexpr  {, typexpr} ]  class-path
class-field-spec ::= inherit class-type
  | val [mutable] inst-var-name :  typexpr
  | method [private] method-name :  typexpr
  | method [private] virtual method-name :  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 [rec] let-binding  {and let-binding} in  class-expr
  | object [( pattern  [: typexpr] )]  { class-field } end
class-field ::= inherit class-expr  [as value-name]
  | val [mutable] inst-var-name =  expr
  | method [private] method-name  {pattern} =  expr
  | method [private] virtual method-name :  typexpr
  | constraint typexpr =  typexpr
  | initializer expr

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  { pattern }  [: 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.9. 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 )
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 modtype-path
mod-constraint ::= type [type-parameters]  typeconstr =  typexpr
  | module module-path =  extended-module-path

Module expressions (module implementations)
module-expr ::= module-path
  | struct { definition  [;;] } end
  | functor ( module-name :  module-type ) ->  module-expr
  | module-expr (  module-expr )
  | ( module-expr )
  | ( module-expr :  module-type )
definition ::= let [rec] let-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

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

7.1 Streams and stream parsers
expr ::= ...
  | [< >]
  | [< stream-component  { ; stream-component } >]
  | parser [pattern]  stream-matching
  | match expr with parser  [pattern]  stream-matching
stream-component ::= ' expr
  | expr
stream-matching ::= stream-pattern  [pattern] ->  expr  { | stream-pattern  [pattern] ->  expr }
stream-pattern ::= [< >]
  | [< stream-pat-comp  { ; stream-pat-comp  [ ?? expr ] }>]
stream-pat-comp ::= ' pattern  [ when expr ]
  | pattern =  expr
  | ident

9. The toplevel system (ocaml)
toplevel-input ::= { toplevel-phrase } ;;
toplevel-phrase ::= toplevel-definition
  | expr
  | # ident  directive-argument
toplevel-definition ::= let [rec] let-binding  { and let-binding }
  | external value-name :  typexpr =  external-declaration
  | type-definition
  | exception-definition
  | module module-name  [ : module-type ] =  module-expr
  | module type modtype-name =  module-type
  | open module-path
directive-argument ::= nothing
  | string-literal
  | integer-literal
  | value-path

Expressions in the Debugger
debug-expr ::= lowercase-ident
  | { capitalized-ident . }  lowercase-ident
  | *
  | $ integer
  | debug-expr .  lowercase-ident
  | debug-expr .(  integer )
  | debug-expr .[  integer ]
  | ! debug-expr
  | ( debug-expr )

Previous Contents