6.3 | Names

Identifiers are used to give names to several classes of language objects and refer to these objects by name later:

- value names (syntactic class `value-name`),
- value constructors (constant -- class `cconstr-name` -- or non-constant -- class `ncconstr-name`),
- labels (`label-name`),
- variant tags (`tag-name`),
- type constructors (`typeconstr-name`),
- record fields (`field-name`),
- class names (`class-name`),
- method names (`method-name`),
- instance variable names (`inst-var-name`),
- module names (`module-name`),
- module type names (`modtype-name`).

These nine name spaces are distinguished both by the context and by the capitalization of the identifier: whether the first letter of the identifier is in lowercase (written `lowercase-ident` below) or in uppercase (written `capitalized-ident`). Underscore is considered a lowercase letter for this purpose.

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`

As shown above, prefix and infix symbols as well as some keywords can be used as value names, provided they are written between parentheses. Keywords such as '::' and 'false' are also constructor names. The capitalization rules are summarized in the table below.

Name space | Case of first letter
Values | lowercase
Constructors | uppercase
Labels | lowercase
Variant tag | uppercase
Type constructors | lowercase
Record fields | lowercase
Classes | lowercase
Methods | lowercase
Modules | uppercase
Module types | any

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`

A named object can be referred to either by its name (following the usual static scoping rules for names) or by an access path `prefix` `.` `name`, where `prefix` designates a module and `name` is the name of an object defined in that module. The first component of the path, `prefix`, is either a simple module name or an access path `name`1 `.` `name`2 ..., in case the defining module is itself nested inside other modules. For referring to type constructors or module types, the `prefix` can also contain simple functor applications (as in the syntactic class `extended-module-path` above), in case the defining module is the result of a functor application.
Label names, tag names, method names and instance variable names need not be qualified: the former three are global labels, while the latter are local to a class.