Paths
other items defined
module Kind
General purpose kinds
other items defined
type any = [ `InstanceVariable | `Module | `ModuleType | `Method | `Field | `Label | `Type | `Exception | `Class | `Page | `ClassType | `Value | `Constructor | `Extension ]
Any possible referent
type signature = [ `Module | `ModuleType ]
A referent that can contain signature items
type class_signature = [ `Class | `ClassType ]
A referent that can contain class signature items
type datatype = [ `Type ]
A referent that can contain datatype items
type page = [ `Page ]
A referent that can contain page items
type parent = [ `Module | `ModuleType | `Type | `Class | `ClassType ]
A referent that can contain other items
type label_parent = [ `Module | `ModuleType | `Type | `Class | `Page | `ClassType ]
Identifier kinds
The kind of an identifier directly corresponds to the kind of its referent.
type identifier = any
type identifier_module = [ `Module ]
type identifier_module_type = [ `ModuleType ]
type identifier_type = [ `Type ]
type identifier_constructor = [ `Constructor ]
type identifier_field = [ `Field ]
type identifier_extension = [ `Extension ]
type identifier_exception = [ `Exception ]
type identifier_value = [ `Value ]
type identifier_class = [ `Class ]
type identifier_class_type = [ `ClassType ]
type identifier_method = [ `Method ]
type identifier_instance_variable = [ `InstanceVariable ]
type identifier_label = [ `Label ]
type identifier_page = [ `Page ]
Path kinds
There are four kinds of OCaml path:
module
module type
type
class type
These kinds do not directly correspond to the kind of their referent (e.g. a type path may refer to a class definition).
type path = [ `Module | `ModuleType | `Type | `Class | `ClassType ]
type path_module = [ `Module ]
type path_module_type = [ `ModuleType ]
type path_type = [ `Type | `Class | `ClassType ]
type path_class_type = [ `Class | `ClassType ]
Fragment kinds
There are two kinds of OCaml path fragment:
module
type
These kinds do not directly correspond to the kind of their referent (e.g. a type path fragment may refer to a class definition).
type fragment = [ `Module | `Type | `Class | `ClassType ]
type fragment_module = [ `Module ]
type fragment_type = [ `Type | `Class | `ClassType ]
Reference kinds
There is one reference kind for each kind of referent. However, the kind of a reference does not refer to the kind of its referent, but to the kind with which the reference was annotated.
This means that reference kinds do not correspond directly to the kind of their referent because we used more relaxed rules when resolving a reference. For example, a reference annotated as being to a constructor can be resolved to the definition of an exception (which is a sort of constructor).
type reference_module = [ `Module ]
type reference_module_type = [ `ModuleType ]
type reference_type = [ `Type | `Class | `ClassType ]
type reference_constructor = [ `Exception | `Constructor | `Extension ]
type reference_field = [ `Field ]
type reference_extension = [ `Exception | `Extension ]
type reference_exception = [ `Exception ]
type reference_value = [ `Value ]
type reference_class = [ `Class ]
type reference_class_type = [ `Class | `ClassType ]
type reference_method = [ `Method ]
type reference_instance_variable = [ `InstanceVariable ]
type reference_label = [ `Label ]
type reference_page = [ `Page ]
module Identifier
This module does not have a toplevel documentation block.