|
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 ) |