|
This appendix contains the grammar rules for the Ocaml programming language (extracted from Chapter 6 and 7), the toplevel system (from Chapter 9) and the debugger (see Chapter 16). I also included statistics about the ocaml meta symbols.
ident | ::= | (letter| _) { letter| 0...9| _| ' } |
letter | ::= | A ... Z | a ... z |
integer-literal | ::= | [-] (0...9) { 0...9| _ } |
| | [-] (0x| 0X) (0...9| A...F| a...f) { 0...9| A...F| a...f| _ } | |
| | [-] (0o| 0O) (0...7) { 0...7| _ } | |
| | [-] (0b| 0B) (0...1) { 0...1| _ } |
int32-literal | ::= | integer-literal l |
int64-literal | ::= | integer-literal L |
nativeint-literal | ::= | integer-literal n |
float-literal | ::= | [-] (0...9) { 0...9| _ } [. { 0...9| _ }] [(e| E) [+| -] (0...9) { 0...9| _ }] |
char-literal | ::= | ' regular-char ' |
| | ' escape-sequence ' | |
escape-sequence | ::= | \ (\ | " | ' | n | t | b | r) |
| | \ (0...9) (0...9) (0...9) | |
| | \x (0...9| A...F| a...f) (0...9| A...F| a...f) |
string-literal | ::= | " { string-character } " |
string-character | ::= | regular-char-str |
| | escape-sequence |
label | ::= | ~ (a ... z) { letter| 0...9| _| ' } : |
optlabel | ::= | ? (a ... z) { letter| 0...9| _| ' } : |
infix-symbol | ::= | (= | < | > | @ | ^ | | | & | + | - | * | / | $ | %) { operator-char } |
prefix-symbol | ::= | (! | ? | ~) { operator-char } |
operator-char | ::= | ! | $ | % | & | * | + | - | . | / | : | < | = | > | ? | @ | ^ | | | ~ |
linenum-directive | ::= | # {0 ... 9}+ |
| | # {0 ... 9}+ " { string-character } " |
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 |
typexpr | ::= | ' ident |
| | _ | |
| | ( typexpr ) | |
| | [[?]label-name:] 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 | |
poly-typexpr | ::= | typexpr |
| | { ' ident }+ . typexpr | |
method-type | ::= | method-name : poly-typexpr |
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 |
constant | ::= | integer-literal |
| | float-literal | |
| | char-literal | |
| | string-literal | |
| | constr | |
| | false | |
| | true | |
| | [] | |
| | () | |
| | `tag-name |
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 } |] |
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 } } | |
Extensions for private types: | ||
| | = 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 | |
field-decl | ::= | field-name : poly-typexpr |
| | mutable field-name : poly-typexpr | |
type-constraint | ::= | constraint ' ident = typexpr |
exception-definition | ::= | exception constr-name [of typexpr] |
| | exception constr-name = constr |
class-type | ::= | |
| | class-body-type | |
| | [[?]label-name:] 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 : poly-typexpr | |
| | method [private] virtual method-name : poly-typexpr | |
| | constraint typexpr = typexpr |
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 [: typexpr] = expr | |
| | method [private] method-name {parameter} [: typexpr] = expr | |
| | method [private] method-name : poly-typexpr = expr | |
| | method [private] virtual method-name : poly-typexpr | |
| | constraint typexpr = typexpr | |
| | initializer expr |
expr | ::= | ... |
| | inst-var-name <- expr | |
| | {< [ inst-var-name = expr { ; inst-var-name = expr } ] >} |
class-definition | ::= | class class-binding { and class-binding } |
class-binding | ::= | [virtual] [[ type-parameters ]] class-name {parameter} [: class-type] = class-expr |
type-parameters | ::= | ' ident { , ' ident } |
class-specification | ::= | class class-spec { and class-spec } |
class-spec | ::= | [virtual] [[ type-parameters ]] class-name : class-type |
classtype-definition | ::= | class type classtype-def { and classtype-def } |
classtype-def | ::= | [virtual] [[ type-parameters ]] class-name = class-body-type |
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 module-type | |
Extensions for recursive modules: | ||
| | module rec module-name : module-type { and module-name: module-type } | |
mod-constraint | ::= | type [type-parameters] typeconstr = typexpr |
| | module module-path = extended-module-path |
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 | |
Extensions for recursive modules: | ||
| | module rec module-name : module-type = module-expr { and module-name: module-type = module-expr } |
unit-interface | ::= | { specification [;;] } |
unit-implementation | ::= | { definition [;;] } |
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 |
debug-expr | ::= | lowercase-ident |
| | { capitalized-ident . } lowercase-ident | |
| | * | |
| | $ integer | |
| | debug-expr . lowercase-ident | |
| | debug-expr .( integer ) | |
| | debug-expr .[ integer ] | |
| | ! debug-expr | |
| | ( debug-expr ) |