A  | 
| alert [Warnings] | 
 | 
| alerts [Misc] | 
 | 
| arg_label [Asttypes] | 
 | 
| ast_kind [Pparse] | 
 | 
| attribute [Parsetree] | 
Attributes such as [@id ARG] and [@@id ARG]. 
 
 | 
| attributes [Parsetree] | 
 | 
| attrs [Ast_helper] | 
 | 
| auto_include_callback [Load_path] | 
The type of callback functions on for init ~auto_include 
 
 | 
B  | 
| binding_op [Parsetree] | 
 | 
| bound_map [Depend] | 
 | 
| buffer [CamlinternalMenhirLib.ErrorReports] | 
 | 
C  | 
| case [Parsetree] | 
 | 
| change [Diffing_with_keys.Define] | 
 | 
| change [Diffing_with_keys] | 
This specialized version of changes introduces two composite
    changes: Move and Swap 
 
 | 
| change [Diffing.Define] | 
The type of potential changes on a list. 
 
 | 
| change [Diffing] | 
 | 
| change_kind [Diffing] | 
The kind of changes which is used to share printing and styling
    across implementation 
 
 | 
| checkpoint [CamlinternalMenhirLib.EngineTypes.INCREMENTAL_ENGINE_START] | 
 | 
| checkpoint [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | 
 | 
| class_declaration [Parsetree] | 
 | 
| class_description [Parsetree] | 
 | 
| class_expr [Parsetree] | 
 | 
| class_expr_desc [Parsetree] | 
 | 
| class_field [Parsetree] | 
 | 
| class_field_desc [Parsetree] | 
 | 
| class_field_kind [Parsetree] | 
 | 
| class_infos [Parsetree] | 
Values of type class_expr class_infos represents: class c = ..., class ['a1,...,'an] c = ..., class virtual c = ...
   They are also used for "class type" declaration. 
 
 | 
| class_signature [Parsetree] | 
Values of type class_signature represents: object('selfpat) ... end, object ... end when pcsig_self
                         is Ptyp_any 
 
 | 
| class_structure [Parsetree] | 
 | 
| class_type [Parsetree] | 
 | 
| class_type_declaration [Parsetree] | 
 | 
| class_type_desc [Parsetree] | 
 | 
| class_type_field [Parsetree] | 
 | 
| class_type_field_desc [Parsetree] | 
 | 
| closed_flag [Asttypes] | 
 | 
| color [Misc.Color] | 
 | 
| column [Profile] | 
 | 
| component [Strongly_connected_components.S] | 
 | 
| composite_change [Diffing_with_keys.Define] | 
Composite changes and patches 
 
 | 
| constant [Parsetree] | 
 | 
| constant [Asttypes] | 
 | 
| constructor_arguments [Parsetree] | 
 | 
| constructor_declaration [Parsetree] | 
 | 
| constructor_usage_warning [Warnings] | 
 | 
| core_type [Parsetree] | 
 | 
| core_type_desc [Parsetree] | 
 | 
| crcs [Misc] | 
 | 
D  | 
| description [Warnings] | 
 | 
| diff [Diffing_with_keys.Define] | 
 | 
| diff [Diffing.Defs] | 
Detailed difference trace 
 
 | 
| directed_graph [Strongly_connected_components.S] | 
If (a -> set) belongs to the map, it means that there are edges
      from a to every element of set. 
 
 | 
| direction_flag [Asttypes] | 
 | 
| directive_argument [Parsetree] | 
 | 
| directive_argument_desc [Parsetree] | 
 | 
| docs [Docstrings] | 
 | 
| docstring [Docstrings] | 
 | 
E  | 
| element [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | 
 | 
| env [CamlinternalMenhirLib.EngineTypes] | 
 | 
| env [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | 
 | 
| env [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | 
 | 
| env_reader [Clflags] | 
 | 
| eq [Diffing.Defs] | 
 | 
| error [Pparse] | 
 | 
| error [Misc.Magic_number] | 
 | 
| error [Binutils] | 
 | 
| error [Syntaxerr] | 
 | 
| error [Location] | 
An error is a report which report_kind must be Report_error. 
 
 | 
| error [Lexer] | 
 | 
| error [Attr_helper] | 
 | 
| error_message [Build_path_prefix_map] | 
 | 
| expression [Parsetree] | 
 | 
| expression_desc [Parsetree] | 
 | 
| extension [Parsetree] | 
Extension points such as [%id ARG] and [%%id ARG]. 
 
 | 
| extension_constructor [Parsetree] | 
 | 
| extension_constructor_kind [Parsetree] | 
 | 
F  | 
| field_usage_warning [Warnings] | 
 | 
| file [Profile] | 
 | 
| filepath [Misc] | 
 | 
| functor_parameter [Parsetree] | 
 | 
H  | 
| head [CamlinternalMenhirLib.General] | 
 | 
I  | 
| include_declaration [Parsetree] | 
Values of type include_declaration represents include ME 
 
 | 
| include_description [Parsetree] | 
Values of type include_description represents include MT 
 
 | 
| include_infos [Parsetree] | 
 | 
| info [Misc.Magic_number] | 
 | 
| info [Docstrings] | 
 | 
| injectivity [Asttypes] | 
 | 
| inlining_arguments [Clflags] | 
 | 
| item [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | 
 | 
| iterator [Ast_iterator] | 
A iterator record implements one "method" per syntactic category,
    using an open recursion style: each method takes as its first
    argument the iterator to be applied to children in the syntax
    tree. 
 
 | 
K  | 
| kind [Misc.Magic_number] | 
 | 
L  | 
| label [Asttypes] | 
 | 
| label_declaration [Parsetree] | 
 | 
| left [Diffing_with_keys.Define] | 
 | 
| left [Diffing.Defs] | 
 | 
| letop [Parsetree] | 
 | 
| lid [Ast_helper] | 
 | 
| link_mode [Ccomp] | 
 | 
| loc [Warnings] | 
 | 
| loc [Location] | 
 | 
| loc [Asttypes] | 
 | 
| loc [Ast_helper] | 
 | 
| location_stack [Parsetree] | 
 | 
| log [Lazy_backtrack] | 
 | 
| longest_common_prefix_result [Misc.Stdlib.List] | 
 | 
| lr1state [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | 
 | 
| lr1state [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | 
 | 
| lr1state [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | 
 | 
M  | 
| map [Build_path_prefix_map] | 
 | 
| map_tree [Depend] | 
 | 
| mapper [Ast_mapper] | 
A mapper record implements one "method" per syntactic category,
    using an open recursion style: each method takes as its first
    argument the mapper to be applied to children in the syntax
    tree. 
 
 | 
| mismatch [Diffing_with_keys] | 
 | 
| modname [Misc] | 
 | 
| module_binding [Parsetree] | 
Values of type module_binding represents module X = ME 
 
 | 
| module_declaration [Parsetree] | 
Values of type module_declaration represents S : MT 
 
 | 
| module_expr [Parsetree] | 
 | 
| module_expr_desc [Parsetree] | 
 | 
| module_substitution [Parsetree] | 
Values of type module_substitution represents S := M 
 
 | 
| module_type [Parsetree] | 
 | 
| module_type_declaration [Parsetree] | 
Values of type module_type_declaration represents: S = MT,, S for abstract module type declaration,
     when pmtd_type is None. 
 
 | 
| module_type_desc [Parsetree] | 
 | 
| msg [Location] | 
 | 
| mutable_flag [Asttypes] | 
 | 
N  | 
| native_obj_config [Misc.Magic_number] | 
native object files have a format and magic number that depend
     on certain native-compiler configuration parameters. 
 
 | 
| nonterminal [CamlinternalMenhirLib.EngineTypes.TABLE] | 
 | 
| nonterminal [CamlinternalMenhirLib.IncrementalEngine.SYMBOLS] | 
 | 
O  | 
| object_field [Parsetree] | 
 | 
| object_field_desc [Parsetree] | 
 | 
| open_declaration [Parsetree] | 
Values of type open_declaration represents: open M.N, open M(N).O, open struct ... end 
 
 | 
| open_description [Parsetree] | 
Values of type open_description represents: open M.N, open M(N).O 
 
 | 
| open_infos [Parsetree] | 
 | 
| override_flag [Asttypes] | 
 | 
P  | 
| package_type [Parsetree] | 
As Parsetree.package_type typed values: (S, []) represents (module S),, (S, [(t1, T1) ; ... ; (tn, Tn)])
          represents (module S with type t1 = T1 and ... and tn = Tn). 
 
 | 
| pair [Build_path_prefix_map] | 
 | 
| parse_error [Misc.Magic_number] | 
 | 
| parse_result [Clflags.Float_arg_helper] | 
 | 
| parse_result [Clflags.Int_arg_helper] | 
 | 
| parse_result [Arg_helper.Make] | 
 | 
| parsed [Clflags.Float_arg_helper] | 
 | 
| parsed [Clflags.Int_arg_helper] | 
 | 
| parsed [Arg_helper.Make] | 
 | 
| patch [Diffing_with_keys.Define] | 
 | 
| patch [Diffing.Define] | 
A patch is an ordered list of changes. 
 
 | 
| path [Build_path_prefix_map] | 
 | 
| path_prefix [Build_path_prefix_map] | 
 | 
| pattern [Parsetree] | 
 | 
| pattern_desc [Parsetree] | 
 | 
| payload [Parsetree] | 
 | 
| position [CamlinternalMenhirLib.IncrementalEngine] | 
 | 
| private_flag [Asttypes] | 
 | 
| production [CamlinternalMenhirLib.EngineTypes.TABLE] | 
 | 
| production [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | 
 | 
| production [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | 
 | 
R  | 
| raw [Misc.Magic_number] | 
the type of raw magic numbers,
      such as "Caml1999A027" for the .cma files of OCaml 4.10 
 
 | 
| raw_kind [Misc.Magic_number] | 
the type of raw magic numbers kinds,
      such as "Caml1999A" for .cma files 
 
 | 
| rec_flag [Asttypes] | 
 | 
| ref_and_value [Misc] | 
 | 
| report [Location] | 
 | 
| report_kind [Location] | 
 | 
| report_printer [Location] | 
A printer for reports, defined using open-recursion. 
 
 | 
| reporting_information [Warnings] | 
 | 
| repr [Targetint] | 
 | 
| revised [CamlinternalMenhirLib.Convert] | 
 | 
| right [Diffing_with_keys.Define] | 
 | 
| right [Diffing.Defs] | 
 | 
| row_field [Parsetree] | 
 | 
| row_field_desc [Parsetree] | 
 | 
S  | 
| semantic_action [CamlinternalMenhirLib.EngineTypes.TABLE] | 
 | 
| semantic_value [CamlinternalMenhirLib.EngineTypes.INCREMENTAL_ENGINE_START] | 
 | 
| semantic_value [CamlinternalMenhirLib.EngineTypes.MONOLITHIC_ENGINE] | 
 | 
| semantic_value [CamlinternalMenhirLib.EngineTypes.TABLE] | 
 | 
| setting [Misc.Error_style] | 
 | 
| setting [Misc.Color] | 
 | 
| signature [Parsetree] | 
 | 
| signature_item [Parsetree] | 
 | 
| signature_item_desc [Parsetree] | 
 | 
| space_formatter [Pprintast] | 
 | 
| stack [CamlinternalMenhirLib.EngineTypes] | 
 | 
| stack [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | 
 | 
| state [Warnings] | 
 | 
| state [Diffing.Defs] | 
environment of a partial patch 
 
 | 
| state [CamlinternalMenhirLib.EngineTypes.INCREMENTAL_ENGINE_START] | 
 | 
| state [CamlinternalMenhirLib.EngineTypes.MONOLITHIC_ENGINE] | 
 | 
| state [CamlinternalMenhirLib.EngineTypes.TABLE] | 
 | 
| status [Terminfo] | 
 | 
| store [Local_store] | 
 | 
| str [Ast_helper] | 
 | 
| str_opt [Ast_helper] | 
 | 
| strategy [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | 
 | 
| stream [CamlinternalMenhirLib.General] | 
 | 
| structure [Parsetree] | 
 | 
| structure_item [Parsetree] | 
 | 
| structure_item_desc [Parsetree] | 
 | 
| style [Misc.Color] | 
 | 
| styles [Misc.Color] | 
 | 
| supplier [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | 
 | 
| symbol [CamlinternalMenhirLib.IncrementalEngine.SYMBOLS] | 
 | 
T  | 
| t [Warnings] | 
 | 
| t [Targetint] | 
The type of target integers. 
 
 | 
| t [Numbers.Int16] | 
 | 
| t [Numbers.Int8] | 
 | 
| t [Misc.LongString] | 
 | 
| t [Misc.Stdlib.Option] | 
 | 
| t [Misc.Stdlib.List] | 
 | 
| t [Load_path.Dir] | 
Represent one directory in the load path. 
 
 | 
| t [Lazy_backtrack] | 
 | 
| t [Identifiable.Tbl.T] | 
 | 
| t [Identifiable.S] | 
 | 
| t [Identifiable.Thing] | 
 | 
| t [Domainstate] | 
 | 
| t [Consistbl.Make] | 
 | 
| t [Clflags.Compiler_pass] | 
 | 
| t [Binutils] | 
 | 
| t [Longident] | 
 | 
| t [Location] | 
 | 
| t [CamlinternalMenhirLib.LinearizedArray] | 
 | 
| t [CamlinternalMenhirLib.PackedIntArray] | 
 | 
| t [CamlinternalMenhirLib.InfiniteArray] | 
This module implements infinite arrays. 
 
 | 
| table [CamlinternalMenhirLib.RowDisplacement] | 
 | 
| terminal [CamlinternalMenhirLib.EngineTypes.TABLE] | 
 | 
| terminal [CamlinternalMenhirLib.IncrementalEngine.SYMBOLS] | 
 | 
| text [Docstrings] | 
 | 
| token [Parser] | 
 | 
| token [CamlinternalMenhirLib.TableFormat.TABLES] | 
 | 
| token [CamlinternalMenhirLib.EngineTypes.MONOLITHIC_ENGINE] | 
 | 
| token [CamlinternalMenhirLib.EngineTypes.TABLE] | 
 | 
| token [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | 
 | 
| toplevel_directive [Parsetree] | 
 | 
| toplevel_phrase [Parsetree] | 
 | 
| traditional [CamlinternalMenhirLib.Convert] | 
 | 
| type_declaration [Parsetree] | 
Here are type declarations and their representation,
   for various ptype_kind
           and ptype_manifest values: type t   when type_kind is Ptype_abstract,
               and manifest  is None,, type t = T0
              when type_kind is Ptype_abstract,
               and manifest  is Some T0,, type t = C of T | ...
              when type_kind is Ptype_variant,
               and manifest  is None,, type t = T0 = C of T | ...
              when type_kind is Ptype_variant,
               and manifest  is Some T0,, type t = {l: T; ...}
              when type_kind is Ptype_record,
               and manifest  is None,, type t = T0 = {l : T; ...}
              when type_kind is Ptype_record,
               and manifest  is Some T0,, type t = ..
              when type_kind is Ptype_open,
               and manifest  is None. 
 
 | 
| type_exception [Parsetree] | 
Definition of a new exception (exception E). 
 
 | 
| type_extension [Parsetree] | 
Definition of new extensions constructors for the extensive sum type t
   (type t += ...). 
 
 | 
| type_kind [Parsetree] | 
 | 
U  | 
| unexpected [Misc.Magic_number] | 
 | 
| unexpected_error [Misc.Magic_number] | 
 | 
| update_result [Diffing.Define.Parameters] | 
 | 
V  | 
| value_binding [Parsetree] | 
let pat : type_constraint = exp 
 
 | 
| value_constraint [Parsetree] | 
 | 
| value_description [Parsetree] | 
 | 
| variance [Asttypes] | 
 | 
| version [Misc.Magic_number] | 
 | 
| virtual_flag [Asttypes] | 
 | 
W  | 
| with_constraint [Parsetree] | 
 | 
| with_loc [Ast_helper] | 
 | 
| with_pos [Diffing_with_keys] | 
 | 
X  | 
| xsymbol [CamlinternalMenhirLib.IncrementalEngine.SYMBOLS] | 
 |