| (<) [Int_replace_polymorphic_compare] | |
| (<=) [Int_replace_polymorphic_compare] | |
| (<>) [Int_replace_polymorphic_compare] | |
| (=) [Int_replace_polymorphic_compare] | |
| (>) [Int_replace_polymorphic_compare] | |
| (>=) [Int_replace_polymorphic_compare] | |
A  | |
| abs [Targetint] | abs x is the absolute value of x.
 | 
| absname [Clflags] | |
| absolute_path [Location] | absolute_path path first makes an absolute path, s from path,
     prepending the current working directory if path was relative.
 | 
| acceptable [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| action [CamlinternalMenhirLib.TableFormat.TABLES] | |
| action [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| add [Targetint] | 
Addition.
 
 | 
| add [Load_path] | 
Old name for  
Load_path.append_dir
 | 
| add [Linkdeps] | add t ~filename ~compunit ~provides ~requires registers the
    compilation unit compunit found in filename to t.
 | 
| add_arguments [Clflags] | |
| add_base_override [Arg_helper.Make] | |
| add_dir [Load_path] | 
Add a directory to the end of the load path (i.e.
 
 | 
| add_docs_attrs [Docstrings] | 
Convert item documentation to attributes and add them to an
    attribute list
 
 | 
| add_implementation [Depend] | |
| add_implementation_binding [Depend] | |
| add_info_attrs [Docstrings] | 
Convert field info to attributes and add them to an
    attribute list
 
 | 
| add_ppx_context_sig [Ast_mapper] | 
Same as  
add_ppx_context_str, but for signatures.
 | 
| add_ppx_context_str [Ast_mapper] | 
Extract information from the current environment and encode it
    into an attribute which is prepended to the list of structure
    items in order to pass the information to an external
    processor.
 
 | 
| add_signature [Depend] | |
| add_signature_binding [Depend] | |
| add_text_attrs [Docstrings] | 
Convert text to attributes and add them to an attribute list
 
 | 
| add_use_file [Depend] | |
| add_user_override [Arg_helper.Make] | |
| afl_inst_ratio [Clflags] | |
| afl_instrument [Config] | 
Whether afl-fuzz instrumentation is generated by default
 
 | 
| afl_instrument [Config_main] | 
Whether afl-fuzz instrumentation is generated by default
 
 | 
| afl_instrument [Config_boot] | 
Whether afl-fuzz instrumentation is generated by default
 
 | 
| afl_instrument [Clflags] | |
| alert [Location] | 
Prints an arbitrary alert.
 
 | 
| alert_reporter [Location] | 
Hook for intercepting alerts.
 
 | 
| alerts_of_attrs [Builtin_attributes] | |
| alerts_of_sig [Builtin_attributes] | |
| alerts_of_str [Builtin_attributes] | |
| alias [Ast_helper.Mty] | |
| alias [Ast_helper.Pat] | |
| alias [Ast_helper.Typ] | |
| align [Misc] | align n a rounds n upwards to a multiple of a
           (a power of 2).
 | 
| align_double [Config] | 
Whether the compiler and runtime need to align double values.
 
 | 
| align_double [Config_main] | 
Whether the compiler and runtime need to align double values.
 
 | 
| align_double [Config_boot] | 
Whether the compiler and runtime need to align double values.
 
 | 
| align_error_hint [Misc] | 
Same as  
align_hint ~prefix:"Error: "
 | 
| align_hint [Misc] | aligned_hint main hint vertically aligns a main message and a hint
    message.
 | 
| align_int64 [Config] | 
Whether the compiler and runtime need to align int64 values
 
 | 
| align_int64 [Config_main] | 
Whether the compiler and runtime need to align int64 values
 
 | 
| align_int64 [Config_boot] | 
Whether the compiler and runtime need to align int64 values
 
 | 
| align_prefix [Format_doc.Doc] | 
Align the right side of one  
"@{<ralign>...@}" tag box by inserting
      spaces at the beginning of boxes.
 | 
| align_prefix2 [Format_doc.Doc] | |
| aligned_error_hint [Location] | aligned_error_hint ?loc ?sub ?footnote fmt ... aligned_hint produces an
    error report where the potential aligned_hint message has been aligned
    with the main error message before being added to the list of submessages.
 | 
| aligned_hint [Misc] | aligned_hint ~prefix fmt ... hint align the potential hint with the main
    error message generated by the format string fmt before printing the two
    message.
 | 
| all_ccopts [Clflags] | |
| all_columns [Profile] | |
| all_kinds [Misc.Magic_number] | |
| all_passes [Clflags] | |
| all_ppx [Clflags] | |
| all_somes [Misc.Stdlib.Array] | |
| annot [Unit_info] | |
| annotations [Clflags] | |
| ansi_of_style_l [Misc.Style] | |
| any [Ast_helper.Pat] | |
| any [Ast_helper.Typ] | |
| append_dir [Load_path] | append_dir d adds d to the end of the load path (i.e.
 | 
| applicative_functors [Clflags] | |
| apply [Ast_mapper] | 
Apply a mapper (parametrized by the unit name) to a dumped
    parsetree found in the  
source file and put the result in the
    target file.
 | 
| apply [Ast_helper.Cl] | |
| apply [Ast_helper.Mod] | |
| apply [Ast_helper.Exp] | |
| apply_rewriters [Pparse] | 
If  
restore = true (the default), cookies set by external
      rewriters will be kept for later calls.
 | 
| apply_rewriters_sig [Pparse] | |
| apply_rewriters_str [Pparse] | |
| apply_unit [Ast_helper.Mod] | |
| ar [Config] | 
Name of the ar command, or "" if not needed  (MSVC)
 
 | 
| ar [Config_main] | 
Name of the ar command, or "" if not needed  (MSVC)
 
 | 
| ar [Config_boot] | 
Name of the ar command, or "" if not needed  (MSVC)
 
 | 
| ar_supports_response_files [Config] | 
Whether ar supports @FILE arguments.
 
 | 
| ar_supports_response_files [Config_main] | 
Whether ar supports @FILE arguments.
 
 | 
| ar_supports_response_files [Config_boot] | 
Whether ar supports @FILE arguments.
 
 | 
| architecture [Config] | 
Name of processor type for the native-code compiler
 
 | 
| architecture [Config_main] | 
Name of processor type for the native-code compiler
 
 | 
| architecture [Config_boot] | 
Name of processor type for the native-code compiler
 
 | 
| arg_spec [Clflags] | |
| array [Format_doc.Doc] | |
| array [Ast_helper.Exp] | |
| array [Ast_helper.Pat] | |
| arrow [Ast_helper.Cty] | |
| arrow [Ast_helper.Typ] | |
| as_has_debug_prefix_map [Config] | 
Whether the assembler supports --debug-prefix-map
 
 | 
| as_has_debug_prefix_map [Config_main] | 
Whether the assembler supports --debug-prefix-map
 
 | 
| as_has_debug_prefix_map [Config_boot] | 
Whether the assembler supports --debug-prefix-map
 
 | 
| as_inline_code [Misc.Style] | |
| asm [Config] | 
The assembler (and flags) to use for assembling
    ocamlopt-generated code.
 
 | 
| asm [Config_main] | 
The assembler (and flags) to use for assembling
    ocamlopt-generated code.
 
 | 
| asm [Config_boot] | 
The assembler (and flags) to use for assembling
    ocamlopt-generated code.
 
 | 
| asm_cfi_supported [Config] | 
Whether assembler understands CFI directives
 
 | 
| asm_cfi_supported [Config_main] | 
Whether assembler understands CFI directives
 
 | 
| asm_cfi_supported [Config_boot] | 
Whether assembler understands CFI directives
 
 | 
| asm_size_type_directives [Config] | 
Whether the  
.size and .type assembler directives can be used
 | 
| asm_size_type_directives [Config_main] | 
Whether the  
.size and .type assembler directives can be used
 | 
| asm_size_type_directives [Config_boot] | 
Whether the  
.size and .type assembler directives can be used
 | 
| asprintf [Format_doc] | |
| assert_ [Ast_helper.Exp] | |
| ast_impl_magic_number [Config] | 
Magic number for file holding an implementation syntax tree
 
 | 
| ast_impl_magic_number [Config_main] | 
Magic number for file holding an implementation syntax tree
 
 | 
| ast_impl_magic_number [Config_boot] | 
Magic number for file holding an implementation syntax tree
 
 | 
| ast_intf_magic_number [Config] | 
Magic number for file holding an interface syntax tree
 
 | 
| ast_intf_magic_number [Config_main] | 
Magic number for file holding an interface syntax tree
 
 | 
| ast_intf_magic_number [Config_boot] | 
Magic number for file holding an interface syntax tree
 
 | 
| attr [Ast_helper.Cf] | |
| attr [Ast_helper.Cl] | |
| attr [Ast_helper.Ctf] | |
| attr [Ast_helper.Cty] | |
| attr [Ast_helper.Mod] | |
| attr [Ast_helper.Mty] | |
| attr [Ast_helper.Exp] | |
| attr [Ast_helper.Pat] | |
| attr [Ast_helper.Typ] | |
| attr_equals_builtin [Builtin_attributes] | attr_equals_builtin attr s is true if the name of the attribute is s or
    "ocaml." ^ s.
 | 
| attribute [Ast_helper.Cf] | |
| attribute [Ast_helper.Ctf] | |
| attribute [Ast_helper.Str] | |
| attribute [Ast_helper.Sig] | |
| attribute_of_warning [Ast_mapper] | 
Encode a warning message into an 'ocaml.ppwarning' attribute which can be
    inserted in a generated Parsetree.
 
 | 
| auto_include_alert [Location] | 
Prints an alert that -I +lib has been automatically added to the load
    path
 
 | 
| auto_include_otherlibs [Load_path] | auto_include_otherlibs alert is a callback function to be passed to
    Load_path.init and automatically adds -I +lib to the load path after
    calling alert lib.
 | 
| available [Clflags.Dump_option] | |
| available_pass_names [Clflags.Compiler_pass] | |
B  | |
| backtrack [Lazy_backtrack] | |
| backup [Warnings] | |
| backup [Terminfo] | |
| batch_mode_printer [Location] | |
| best_toplevel_printer [Location] | 
Detects the terminal capabilities and selects an adequate printer
 
 | 
| binary_annotations [Clflags] | |
| binding [Pprintast] | |
| binding_op [Ast_helper.Exp] | |
| bindir [Config] | 
The directory containing the binary programs
 
 | 
| bindir [Config_main] | 
The directory containing the binary programs
 
 | 
| bindir [Config_boot] | 
The directory containing the binary programs
 
 | 
| bool [Format_doc.Doc] | |
| break [Format_doc.Doc] | |
| bytecode_cflags [Config] | 
The flags ocamlc should pass to the C compiler
 
 | 
| bytecode_cflags [Config_main] | 
The flags ocamlc should pass to the C compiler
 
 | 
| bytecode_cflags [Config_boot] | 
The flags ocamlc should pass to the C compiler
 
 | 
| bytecode_compatible_32 [Clflags] | |
| bytecode_cppflags [Config] | 
The flags ocamlc should pass to the C preprocessor
 
 | 
| bytecode_cppflags [Config_main] | 
The flags ocamlc should pass to the C preprocessor
 
 | 
| bytecode_cppflags [Config_boot] | 
The flags ocamlc should pass to the C preprocessor
 
 | 
| bytecomp_c_libraries [Config] | 
The C libraries to link with custom runtimes
 
 | 
| bytecomp_c_libraries [Config_main] | 
The C libraries to link with custom runtimes
 
 | 
| bytecomp_c_libraries [Config_boot] | 
The C libraries to link with custom runtimes
 
 | 
| bytes [Format_doc.Doc] | |
C  | |
| c_compiler [Config] | 
The compiler to use for compiling C files
 
 | 
| c_compiler [Config_main] | 
The compiler to use for compiling C files
 
 | 
| c_compiler [Config_boot] | 
The compiler to use for compiling C files
 
 | 
| c_compiler [Clflags] | |
| c_has_debug_prefix_map [Config] | 
Whether the C compiler supports -fdebug-prefix-map
 
 | 
| c_has_debug_prefix_map [Config_main] | 
Whether the C compiler supports -fdebug-prefix-map
 
 | 
| c_has_debug_prefix_map [Config_boot] | 
Whether the C compiler supports -fdebug-prefix-map
 
 | 
| c_output_obj [Config] | 
Name of the option of the C compiler for specifying the output
    file
 
 | 
| c_output_obj [Config_main] | 
Name of the option of the C compiler for specifying the output
    file
 
 | 
| c_output_obj [Config_boot] | 
Name of the option of the C compiler for specifying the output
    file
 
 | 
| call_external_preprocessor [Pparse] | |
| call_linker [Ccomp] | |
| can_save_ir_after [Clflags.Compiler_pass] | |
| canonical_ids [Clflags] | |
| capitalize [Misc.Utf8_lexeme] | 
Like  
normalize, but if the string starts with a lowercase identifier
      character, it is replaced by the corresponding uppercase character.
 | 
| case [Ast_helper.Exp] | |
| ccobjs [Clflags] | |
| ccomp_type [Config] | 
The "kind" of the C compiler, assembler and linker used: one of
    "cc" (for Unix-style C compilers)
    "msvc" (for Microsoft Visual C++ and MASM)
 
 | 
| ccomp_type [Config_main] | 
The "kind" of the C compiler, assembler and linker used: one of
    "cc" (for Unix-style C compilers)
    "msvc" (for Microsoft Visual C++ and MASM)
 
 | 
| ccomp_type [Config_boot] | 
The "kind" of the C compiler, assembler and linker used: one of
    "cc" (for Unix-style C compilers)
    "msvc" (for Microsoft Visual C++ and MASM)
 
 | 
| char [Format_doc.Doc] | |
| char [Ast_helper.Const] | |
| check [Linkdeps] | check t should be called once all the compilation units to be linked
    have been added.
 | 
| check [Consistbl.Make] | |
| check_alerts [Builtin_attributes] | |
| check_alerts_inclusion [Builtin_attributes] | |
| check_current [Misc.Magic_number] | check_current kind info checks that the provided magic info
      is the current version of kind's magic header.
 | 
| check_deprecated_mutable [Builtin_attributes] | |
| check_deprecated_mutable_inclusion [Builtin_attributes] | |
| check_fatal [Warnings] | |
| check_loc_ghost [Ast_invariants] | 
Checks the invariant of Location.t's loc_ghost field, that are stated in
    location.mli.
 
 | 
| check_noadd [Consistbl.Make] | |
| check_unit_name [Unit_info] | check_unit_name u prints a warning if the derived module name modname u
    should not be used as a module name as specified
    by Unit_info.is_unit_name ~strict:true.
 | 
| chop_extensions [Misc] | 
Return the given file name without its extensions.
 
 | 
| chunks_of [Misc.Stdlib.List] | chunks_of n t returns a list of nonempty lists whose
        concatenation is equal to the original list.
 | 
| clambda_checks [Clflags] | |
| class_ [Ast_helper.Str] | |
| class_ [Ast_helper.Sig] | |
| class_ [Ast_helper.Typ] | |
| class_expr [Pprintast] | |
| class_field [Pprintast] | |
| class_type [Pprintast] | |
| class_type [Ast_helper.Str] | |
| class_type [Ast_helper.Sig] | |
| class_type_field [Pprintast] | |
| classic [Clflags] | |
| classic_arguments [Clflags] | |
| classic_inlining [Clflags] | |
| classify [Diffing] | |
| clear [Consistbl.Make] | |
| close_box [Format_doc.Doc] | |
| close_tag [Format_doc.Doc] | |
| close_tbox [Format_doc.Doc] | |
| cma_magic_number [Config] | 
Magic number for archive files
 
 | 
| cma_magic_number [Config_main] | 
Magic number for archive files
 
 | 
| cma_magic_number [Config_boot] | 
Magic number for archive files
 
 | 
| cmi [Unit_info] | 
Those functions derive a specific  
artifact metadata from an unit
    metadata.
 | 
| cmi_file [Clflags] | |
| cmi_magic_number [Config] | 
Magic number for compiled interface files
 
 | 
| cmi_magic_number [Config_main] | 
Magic number for compiled interface files
 
 | 
| cmi_magic_number [Config_boot] | 
Magic number for compiled interface files
 
 | 
| cmm_invariants [Clflags] | |
| cmo [Unit_info] | |
| cmo_magic_number [Config] | 
Magic number for object bytecode files
 
 | 
| cmo_magic_number [Config_main] | 
Magic number for object bytecode files
 
 | 
| cmo_magic_number [Config_boot] | 
Magic number for object bytecode files
 
 | 
| cmt [Unit_info] | |
| cmt_magic_number [Config] | 
Magic number for compiled interface files
 
 | 
| cmt_magic_number [Config_main] | 
Magic number for compiled interface files
 
 | 
| cmt_magic_number [Config_boot] | 
Magic number for compiled interface files
 
 | 
| cmti [Unit_info] | |
| cmx [Unit_info] | |
| cmx_magic_number [Config] | 
Magic number for compilation unit descriptions
 
 | 
| cmx_magic_number [Config_main] | 
Magic number for compilation unit descriptions
 
 | 
| cmx_magic_number [Config_boot] | 
Magic number for compilation unit descriptions
 
 | 
| cmxa_magic_number [Config] | 
Magic number for libraries of compilation unit descriptions
 
 | 
| cmxa_magic_number [Config_main] | 
Magic number for libraries of compilation unit descriptions
 
 | 
| cmxa_magic_number [Config_boot] | 
Magic number for libraries of compilation unit descriptions
 
 | 
| cmxs_magic_number [Config] | 
Magic number for dynamically-loadable plugins
 
 | 
| cmxs_magic_number [Config_main] | 
Magic number for dynamically-loadable plugins
 
 | 
| cmxs_magic_number [Config_boot] | 
Magic number for dynamically-loadable plugins
 
 | 
| coerce [Ast_helper.Exp] | |
| color [Clflags] | |
| color_reader [Clflags] | |
| comma [Format_doc] | |
| command [Ccomp] | |
| comments [Lexer] | |
| companion_cmi [Unit_info] | 
Beware that  
companion_cmi a strips all extensions from the
 filename of a before adding the ".cmi" suffix contrarily to
 the other functions which only remove the rightmost extension.
 | 
| companion_cmt [Unit_info] | |
| companion_obj [Unit_info] | 
The functions below change the type of an artifact by updating the
    extension of its filename.
 
 | 
| compare [Targetint] | 
The comparison function for target integers, with the same specification as
     
Stdlib.compare.
 | 
| compare [Misc.Stdlib.List] | 
The lexicographic order supported by the provided order.
 
 | 
| compare [Misc.Stdlib] | |
| compare [Int_replace_polymorphic_compare] | |
| compare [Clflags.Dump_option] | |
| compare [Clflags.Compiler_pass] | |
| compare_items [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| compare_nonterminals [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| compare_productions [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| compare_symbols [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| compare_terminals [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| compat [Format_doc] | |
| compat1 [Format_doc] | |
| compat2 [Format_doc] | |
| compile_file [Ccomp] | |
| compile_only [Clflags] | |
| component_graph [Strongly_connected_components.S] | |
| compress [CamlinternalMenhirLib.RowDisplacement] | |
| compress [CamlinternalMenhirLib.ErrorReports] | |
| compression_c_libraries [Config] | 
The C libraries needed with -lcomprmarsh (should appear before
     
Config.native_c_libraries in a call to the C compiler)
 | 
| compression_c_libraries [Config_main] | 
The C libraries needed with -lcomprmarsh (should appear before
     
Config_main.native_c_libraries in a call to the C compiler)
 | 
| compression_c_libraries [Config_boot] | 
The C libraries needed with -lcomprmarsh (should appear before
     
Config_boot.native_c_libraries in a call to the C compiler)
 | 
| compression_supported [Compression] | 
Reports whether compression is supported.
 
 | 
| concat_null_terminated [Misc] | concat_null_terminated [x1;x2; ... xn] is
    x1 ^ "\000" ^ x2 ^ "\000" ^ ... ^ xn ^ "\000"
 | 
| concrete [Ast_helper.Cf] | |
| config_var [Config] | 
the configuration value of a variable, if it exists
 
 | 
| config_var [Config_main] | 
the configuration value of a variable, if it exists
 
 | 
| config_var [Config_boot] | 
the configuration value of a variable, if it exists
 
 | 
| connected_components_sorted_from_roots_to_leaf [Strongly_connected_components.S] | |
| constant [Ast_helper.Exp] | |
| constant [Ast_helper.Pat] | |
| constr [Pprintast.Doc] | |
| constr [Pprintast] | |
| constr [Ast_helper.Cl] | |
| constr [Ast_helper.Cty] | |
| constr [Ast_helper.Typ] | |
| constr_ident [Parse] | 
This function parses a syntactically valid path for a variant constructor.
 
 | 
| constraint_ [Ast_helper.Cf] | |
| constraint_ [Ast_helper.Cl] | |
| constraint_ [Ast_helper.Ctf] | |
| constraint_ [Ast_helper.Mod] | |
| constraint_ [Ast_helper.Exp] | |
| constraint_ [Ast_helper.Pat] | |
| construct [Ast_helper.Exp] | |
| construct [Ast_helper.Pat] | |
| constructor [Ast_helper.Te] | |
| constructor [Ast_helper.Type] | |
| copy_file [Misc] | copy_file ic oc reads the contents of file ic and copies
           them to oc.
 | 
| copy_file_chunk [Misc] | copy_file_chunk ic oc n reads n bytes from ic and copies
           them to oc.
 | 
| core_type [Pprintast] | |
| core_type [Parse] | |
| create [Load_path.Dir] | |
| create [Linkdeps] | create ~complete returns an empty state.
 | 
| create [Lazy_backtrack] | |
| create [Consistbl.Make] | |
| create_archive [Ccomp] | |
| create_failed [Lazy_backtrack] | |
| create_forced [Lazy_backtrack] | |
| create_hashtable [Misc] | 
Create a hashtable with the given initial size and fills it
           with the given bindings.
 
 | 
| create_usage_msg [Clflags] | |
| curr [Location] | 
Get the location of the current token from the  
lexbuf.
 | 
| current_raw [Misc.Magic_number] | 
the current magic number of each kind
 
 | 
| current_state_number [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| current_version [Misc.Magic_number] | 
the current version of each kind
 
 | 
| custom_break [Format_doc.Doc] | |
| custom_runtime [Clflags] | |
| cut [Format_doc.Doc] | |
| cut_at [Misc] | String.cut_at s c returns a pair containing the sub-string before
   the first occurrence of c in s, and the sub-string after the
   first occurrence of c in s.
 | 
D  | |
| data [Identifiable.Map] | |
| debug [Clflags] | |
| debug_full [Clflags] | |
| debug_prefix_map_flags [Misc] | 
Returns the list of  
--debug-prefix-map flags to be passed to the
    assembler, built from the BUILD_PATH_PREFIX_MAP environment variable.
 | 
| decl [Ast_helper.Te] | |
| decode_map [Build_path_prefix_map] | |
| decode_pair [Build_path_prefix_map] | |
| decode_prefix [Build_path_prefix_map] | |
| default [Arg_helper.Make] | |
| default_alert_reporter [Location] | 
Original alert reporter for use in hooks.
 
 | 
| default_executable_name [Config] | 
Name of executable produced by linking if none is given with -o,
    e.g.
 
 | 
| default_executable_name [Config_main] | 
Name of executable produced by linking if none is given with -o,
    e.g.
 
 | 
| default_executable_name [Config_boot] | 
Name of executable produced by linking if none is given with -o,
    e.g.
 
 | 
| default_inline_alloc_cost [Clflags] | |
| default_inline_branch_cost [Clflags] | |
| default_inline_branch_factor [Clflags] | |
| default_inline_call_cost [Clflags] | |
| default_inline_indirect_cost [Clflags] | |
| default_inline_lifting_benefit [Clflags] | |
| default_inline_max_depth [Clflags] | |
| default_inline_max_unroll [Clflags] | |
| default_inline_prim_cost [Clflags] | |
| default_inline_threshold [Clflags] | |
| default_inline_toplevel_threshold [Clflags] | |
| default_iterator [Ast_iterator] | 
A default iterator, which implements a "do not do anything" mapping.
 
 | 
| default_loc [Ast_helper] | 
Default value for all optional location arguments.
 
 | 
| default_mapper [Ast_mapper] | 
A default mapper, which implements a "deep identity" mapping.
 
 | 
| default_reduction [CamlinternalMenhirLib.TableFormat.TABLES] | |
| default_reduction [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| default_report_printer [Location] | 
Original report printer for use in hooks.
 
 | 
| default_rpath [Config] | 
Option to add a directory to be searched for libraries at runtime
    (used by ocamlmklib)
 
 | 
| default_rpath [Config_main] | 
Option to add a directory to be searched for libraries at runtime
    (used by ocamlmklib)
 
 | 
| default_rpath [Config_boot] | 
Option to add a directory to be searched for libraries at runtime
    (used by ocamlmklib)
 
 | 
| default_setting [Misc.Error_style] | |
| default_setting [Misc.Color] | |
| default_simplify_rounds [Clflags] | |
| default_styles [Misc.Style] | |
| default_unbox_closures_factor [Clflags] | |
| default_warning_reporter [Location] | 
Original warning reporter for use in hooks.
 
 | 
| defaults_w [Warnings] | |
| defaults_warn_error [Warnings] | |
| defines_symbol [Binutils] | |
| delete_eol_spaces [Misc] | delete_eol_spaces s returns a fresh copy of s with any end of
   line spaces removed.
 | 
| deprecated [Format_doc] | |
| deprecated [Location] | 
Prints a deprecation alert.
 
 | 
| deprecated1 [Format_doc] | |
| deprecated_printer [Format_doc] | 
If necessary, embbed a  
Format printer inside a formatting instruction
    stream.
 | 
| deprecated_script_alert [Location] | deprecated_script_alert command prints an alert that command foo has
    been deprecated in favour of command ./foo
 | 
| descriptions [Warnings] | |
| did_you_mean [Misc] | did_you_mean ~pp choices hints that the user may have meant one of the
  option in choices.
 | 
| diff [Diffing_with_keys.Define.Simple] | |
| diff [Diffing.Define.S] | diff state l r computes the optimal patch between l and r,
        using the initial state state.
 | 
| disjoint_union [Identifiable.Map] | disjoint_union m1 m2 contains all bindings from m1 and
      m2.
 | 
| div [Targetint] | 
Integer division.
 
 | 
| dlcode [Clflags] | |
| dllibs [Clflags] | |
| dllpaths [Clflags] | |
| doc_printer [Format_doc] | |
| doc_printf [Format_doc] | Format_doc.doc_printf and Format_doc.kdoc_printf creates a document directly
 | 
| docs_attr [Docstrings] | |
| docstring [Docstrings] | 
Create a docstring
 
 | 
| docstring_body [Docstrings] | 
Get the text of a docstring
 
 | 
| docstring_loc [Docstrings] | 
Get the location of a docstring
 
 | 
| domain [CamlinternalMenhirLib.InfiniteArray] | domain a is a fresh copy of an initial segment of the array a
    whose length is extent a.
 | 
| dont_write_files [Clflags] | |
| dprintf [Format_doc] | |
| drop [CamlinternalMenhirLib.General] | |
| drop_ppx_context_sig [Ast_mapper] | 
Same as  
drop_ppx_context_str, but for signatures.
 | 
| drop_ppx_context_str [Ast_mapper] | 
Drop the ocaml.ppx.context attribute from a structure.
 
 | 
| dump_clambda [Clflags] | |
| dump_cmm [Clflags] | |
| dump_combine [Clflags] | |
| dump_cse [Clflags] | |
| dump_dir [Clflags] | |
| dump_flambda [Clflags] | |
| dump_flambda_let [Clflags] | |
| dump_flambda_verbose [Clflags] | |
| dump_instr [Clflags] | |
| dump_interf [Clflags] | |
| dump_interval [Clflags] | |
| dump_into_file [Clflags] | |
| dump_lambda [Clflags] | |
| dump_linear [Clflags] | |
| dump_live [Clflags] | |
| dump_matchcomp [Clflags] | |
| dump_parsetree [Clflags] | |
| dump_prefer [Clflags] | |
| dump_rawclambda [Clflags] | |
| dump_rawflambda [Clflags] | |
| dump_rawlambda [Clflags] | |
| dump_regalloc [Clflags] | |
| dump_reload [Clflags] | |
| dump_scheduling [Clflags] | |
| dump_selection [Clflags] | |
| dump_shape [Clflags] | |
| dump_source [Clflags] | |
| dump_spill [Clflags] | |
| dump_split [Clflags] | |
| dump_typedtree [Clflags] | |
| dumped_pass [Clflags] | |
E  | |
| echo_eof [Location] | |
| edit_distance [Misc] | edit_distance a b cutoff computes the edit distance between
    strings a and b.
 | 
| effect_ [Ast_helper.Pat] | |
| either [Format_doc.Doc] | |
| empty [Format_doc.Doc] | 
Empty document
 
 | 
| empty_docs [Docstrings] | |
| empty_info [Docstrings] | |
| empty_text [Docstrings] | |
| empty_text_lazy [Docstrings] | |
| encode_map [Build_path_prefix_map] | |
| encode_pair [Build_path_prefix_map] | |
| encode_prefix [Build_path_prefix_map] | |
| entry [CamlinternalMenhirLib.EngineTypes.MONOLITHIC_ENGINE] | |
| env_has_default_reduction [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| equal [Targetint] | 
The equal function for target ints.
 
 | 
| equal [Misc.Stdlib.List] | 
Returns  
true if and only if the given lists have the same length and
        content with respect to the given equality function.
 | 
| equal [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| error [Location] | |
| error [CamlinternalMenhirLib.TableFormat.TABLES] | |
| error_of_exn [Location] | |
| error_of_extension [Builtin_attributes] | |
| error_of_printer [Location] | |
| error_of_printer_file [Location] | |
| error_size [Clflags] | |
| error_style [Clflags] | |
| error_style_reader [Clflags] | |
| error_terminal [CamlinternalMenhirLib.TableFormat.TABLES] | |
| error_terminal [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| error_to_string [Binutils] | |
| error_value [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| errorf [Location] | |
| eval [Ast_helper.Str] | |
| exception_ [Ast_helper.Str] | |
| exception_ [Ast_helper.Sig] | |
| exception_ [Ast_helper.Pat] | |
| exec_magic_number [Config] | 
Magic number for bytecode executable files
 
 | 
| exec_magic_number [Config_main] | 
Magic number for bytecode executable files
 
 | 
| exec_magic_number [Config_boot] | 
Magic number for bytecode executable files
 
 | 
| exists2 [Misc.Stdlib.Array] | 
Same as  
Array.exists2 from the standard library.
 | 
| expand [CamlinternalMenhirLib.ErrorReports] | |
| expand_directory [Misc] | expand_directory alt file eventually expands a + at the
           beginning of file into alt (an alternate root directory)
 | 
| explain_parse_error [Misc.Magic_number] | 
Produces an explanation for a parse error.
 
 | 
| explain_unexpected_error [Misc.Magic_number] | 
Provides an explanation of the  
unexpected_error.
 | 
| explicit_arity [Builtin_attributes] | |
| expression [Printast] | |
| expression [Pprintast] | |
| expression [Parse] | |
| ext_asm [Config] | 
Extension for assembler files, e.g.
 
 | 
| ext_asm [Config_main] | 
Extension for assembler files, e.g.
 
 | 
| ext_asm [Config_boot] | 
Extension for assembler files, e.g.
 
 | 
| ext_dll [Config] | 
Extension for dynamically-loaded libraries, e.g.
 
 | 
| ext_dll [Config_main] | 
Extension for dynamically-loaded libraries, e.g.
 
 | 
| ext_dll [Config_boot] | 
Extension for dynamically-loaded libraries, e.g.
 
 | 
| ext_exe [Config] | 
Extension for executable programs, e.g.
 
 | 
| ext_exe [Config_main] | 
Extension for executable programs, e.g.
 
 | 
| ext_exe [Config_boot] | 
Extension for executable programs, e.g.
 
 | 
| ext_lib [Config] | 
Extension for library files, e.g.
 
 | 
| ext_lib [Config_main] | 
Extension for library files, e.g.
 
 | 
| ext_lib [Config_boot] | 
Extension for library files, e.g.
 
 | 
| ext_obj [Config] | 
Extension for object files, e.g.
 
 | 
| ext_obj [Config_main] | 
Extension for object files, e.g.
 
 | 
| ext_obj [Config_boot] | 
Extension for object files, e.g.
 
 | 
| extended_module_path [Parse] | 
This function parse syntactically valid path for an extended module.
 
 | 
| extension [Ast_helper.Cf] | |
| extension [Ast_helper.Cl] | |
| extension [Ast_helper.Ctf] | |
| extension [Ast_helper.Cty] | |
| extension [Ast_helper.Str] | |
| extension [Ast_helper.Sig] | |
| extension [Ast_helper.Mod] | |
| extension [Ast_helper.Mty] | |
| extension [Ast_helper.Exp] | |
| extension [Ast_helper.Pat] | |
| extension [Ast_helper.Typ] | |
| extension_of_error [Ast_mapper] | 
Encode an error into an 'ocaml.error' extension node which can be
    inserted in a generated Parsetree.
 
 | 
| extent [CamlinternalMenhirLib.InfiniteArray] | extent a is the length of an initial segment of the array a
    that is sufficiently large to contain all set operations ever
    performed.
 | 
| extract [Consistbl.Make] | |
| extract [CamlinternalMenhirLib.ErrorReports] | |
| extract_map [Consistbl.Make] | |
F  | |
| fatal_error [Misc] | 
Raise the  
Fatal_error exception with the given string.
 | 
| fatal_errorf [Misc] | 
Format the arguments according to the given format string
      and raise  
Fatal_error with the resulting string.
 | 
| feed [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| field [Ast_helper.Type] | |
| field [Ast_helper.Exp] | |
| file [Pparse] | |
| filename [Unit_info.Artifact] | filename u is the filesystem path for a compilation artifact.
 | 
| filename [Location.Doc] | |
| files [Load_path.Dir] | 
All the files in that directory.
 
 | 
| filter [Consistbl.Make] | |
| find [Load_path.Dir] | find dir fn returns the full path to fn in dir.
 | 
| find [Load_path] | 
Locate a file in the load path.
 
 | 
| find_and_chop_longest_common_prefix [Misc.Stdlib.List] | 
Returns the longest list that, with respect to the provided equality
        function, is a prefix of both of the given lists.
 
 | 
| find_first_mono [Misc] | find_first_mono p takes an integer predicate p : int -> bool
     that we assume:
     1.
 | 
| find_in_path [Misc] | 
Search a file in a list of directories.
 
 | 
| find_in_path_normalized [Misc] | 
Same as  
Misc.find_in_path_rel , but search also for normalized unit filename,
    i.e.
 | 
| find_in_path_rel [Misc] | 
Search a relative file in a list of directories.
 
 | 
| find_normalized [Load_path.Dir] | 
As  
Load_path.Dir.find, but search also for uncapitalized name, i.e.
 | 
| find_normalized [Load_path] | 
Same as  
find, but search also for normalized unit name (see
    Misc.normalized_unit_filename), i.e.
 | 
| find_normalized_cmi [Unit_info] | find_normalized_cmi u finds in the load_path a file matching the module
    name modname u.
 | 
| find_normalized_with_visibility [Load_path] | 
Same as  
find_normalized, but also reports whether the cmi was found in a
    -I directory (Visible) or a -H directory (Hidden)
 | 
| find_production [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| find_production [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| first [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
| first [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| flag [Clflags.Dump_option] | |
| flambda [Config] | 
Whether the compiler was configured for flambda
 
 | 
| flambda [Config_main] | 
Whether the compiler was configured for flambda
 
 | 
| flambda [Config_boot] | 
Whether the compiler was configured for flambda
 
 | 
| flambda_invariant_checks [Clflags] | |
| flat_float_array [Config] | 
Whether the compiler and runtime automagically flatten float
    arrays
 
 | 
| flat_float_array [Config_main] | 
Whether the compiler and runtime automagically flatten float
    arrays
 
 | 
| flat_float_array [Config_boot] | 
Whether the compiler and runtime automagically flatten float
    arrays
 
 | 
| flatten [Longident] | |
| flexdll_dirs [Config] | 
Directories needed for the FlexDLL objects
 
 | 
| flexdll_dirs [Config_main] | 
Directories needed for the FlexDLL objects
 
 | 
| flexdll_dirs [Config_boot] | 
Directories needed for the FlexDLL objects
 
 | 
| float [Format_doc.Doc] | |
| float [Ast_helper.Const] | |
| float_const_prop [Clflags] | |
| flush [Format_doc.Doc] | |
| fold [Format_doc.Doc] | 
Fold over a document as a sequence of instructions
 
 | 
| foldr [CamlinternalMenhirLib.General] | |
| for4 [Misc] | |
| for_ [Ast_helper.Exp] | |
| for_all [Misc.Stdlib.String] | |
| for_all2 [Misc] | 
Same as  
List.for_all but for a binary predicate.
 | 
| for_alli [Misc.Stdlib.Array] | 
Same as  
Array.for_all from the standard library, but the
        function is applied with the index of the element as first argument,
        and the element itself as second argument.
 | 
| for_package [Clflags] | |
| force [Lazy_backtrack] | |
| force_logged [Lazy_backtrack] | |
| force_newline [Format_doc.Doc] | |
| force_poly [Ast_helper.Typ] | |
| force_reduction [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| force_slash [Clflags] | |
| force_stop [Format_doc.Doc] | |
| foreach_terminal [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| foreach_terminal [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| foreach_terminal_but_error [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| format [Format_doc.Doc] | format ppf doc sends the format instruction of doc to the Format's
      formatter doc.
 | 
| formatter [Format_doc] | |
| formatter_for_warnings [Location] | |
| fprintf [Format_doc] | |
| free_structure_names [Depend] | 
Collect free module identifiers in the a.s.t.
 
 | 
| fresh [Local_store] | 
Returns a fresh instance of the store.
 
 | 
| from_filename [Unit_info.Artifact] | from_filename filename reconstructs the module name
       lax_modname_from_source filename associated to the artifact
       filename.
 | 
| fst3 [Misc] | |
| fst4 [Misc] | |
| fun_ [Ast_helper.Cl] | |
| function_ [Ast_helper.Exp] | |
| function_sections [Config] | 
Whether the compiler was configured to generate
    each function in a separate section
 
 | 
| function_sections [Config_main] | 
Whether the compiler was configured to generate
    each function in a separate section
 
 | 
| function_sections [Config_boot] | 
Whether the compiler was configured to generate
    each function in a separate section
 
 | 
| function_sections [Clflags] | |
| functor_ [Ast_helper.Mod] | |
| functor_ [Ast_helper.Mty] | |
G  | |
| generate [Profile] | |
| get [Clflags.Float_arg_helper] | |
| get [Clflags.Int_arg_helper] | |
| get [Arg_helper.Make] | |
| get [CamlinternalMenhirLib.RowDisplacement] | |
| get [CamlinternalMenhirLib.PackedIntArray] | |
| get [CamlinternalMenhirLib.InfiniteArray] | get a i returns the element contained at offset i in the array a.
 | 
| get [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| get1 [CamlinternalMenhirLib.PackedIntArray] | |
| get_arg [Lazy_backtrack] | |
| get_build_path_prefix_map [Misc] | 
Returns the map encoded in the  
BUILD_PATH_PREFIX_MAP environment
    variable.
 | 
| get_contents [Lazy_backtrack] | |
| get_cookie [Ast_mapper] | |
| get_no_payload_attribute [Attr_helper] | 
The  
string argument of the following functions is the name of the
    attribute we are looking for.
 | 
| get_path_list [Load_path] | 
Return the list of directories passed to  
add_dir so far.
 | 
| get_paths [Load_path] | 
Return the directories passed to  
add_dir so far.
 | 
| get_pos_info [Location] | 
file, line, char
 
 | 
| get_ref [Misc] | get_ref lr returns the content of the list reference lr and reset
           its content to the empty list.
 | 
| get_styles [Misc.Style] | |
| get_visible [Load_path] | 
Same as  
get_paths (), except that it returns a Dir.t list, and doesn't
    include the -H paths.
 | 
| getget [CamlinternalMenhirLib.RowDisplacement] | |
| ghost_loc_in_file [Warnings] | 
Return an empty ghost range located in a given file
 
 | 
| goto [CamlinternalMenhirLib.TableFormat.TABLES] | |
| goto_nt [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| goto_prod [CamlinternalMenhirLib.EngineTypes.TABLE] | |
H  | |
| handle_docstrings [Lexer] | |
| handling_error [CamlinternalMenhirLib.EngineTypes.LOG] | |
| has_atomic [Builtin_attributes] | |
| has_attribute [Builtin_attributes] | has_attribute name attrs is true if an attribute with name name or
    "ocaml." ^ name is present in attrs.
 | 
| has_boxed [Builtin_attributes] | |
| has_no_payload_attribute [Attr_helper] | |
| has_unboxed [Builtin_attributes] | |
| help_warnings [Warnings] | |
| hidden [Load_path.Dir] | 
If the modules in this directory should not be bound in the initial
      scope
 
 | 
| hidden_include_dirs [Clflags] | |
| highlight_terminfo [Location] | |
| hint [Misc.Style] | |
| host [Config] | 
Whether the compiler is a cross-compiler
 
 | 
| host [Config_main] | 
Whether the compiler is a cross-compiler
 
 | 
| host [Config_boot] | 
Whether the compiler is a cross-compiler
 
 | 
| human_name_of_kind [Misc.Magic_number] | 
a user-meaningful name for a kind, eg.
 
 | 
I  | |
| ident [Ast_helper.Mod] | |
| ident [Ast_helper.Mty] | |
| ident [Ast_helper.Exp] | |
| idx_of_field [Domainstate] | |
| if_newline [Format_doc.Doc] | |
| ifthenelse [Ast_helper.Exp] | |
| ill_formed_ast [Syntaxerr] | |
| immediate [Builtin_attributes] | |
| immediate64 [Builtin_attributes] | |
| implementation [Printast] | |
| implementation [Parser.Incremental] | |
| implementation [Parser] | |
| implementation [Parse] | |
| in_comment [Lexer] | |
| in_file [Location] | 
Return an empty ghost range located in a given file.
 
 | 
| in_string [Lexer] | |
| include_ [Ast_helper.Str] | |
| include_ [Ast_helper.Sig] | |
| include_dirs [Clflags] | |
| incoming_symbol [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| info_attr [Docstrings] | |
| inherit_ [Ast_helper.Of] | |
| inherit_ [Ast_helper.Rf] | |
| inherit_ [Ast_helper.Cf] | |
| inherit_ [Ast_helper.Ctf] | |
| init [Load_path] | init ~visible ~hidden is the same as
    reset ();
 | 
| init [Location] | 
Set the file name and line number of the  
lexbuf to be the start
    of the named file.
 | 
| init [Lexer] | |
| init [Docstrings] | 
(Re)Initialise all docstring state
 
 | 
| init [CamlinternalMenhirLib.LexerUtil] | init filename lexbuf initializes the lexing buffer lexbuf so
   that the positions that are subsequently read from it refer to the
   file filename.
 | 
| init_file [Clflags] | |
| initializer_ [Ast_helper.Cf] | |
| initiating_error_handling [CamlinternalMenhirLib.EngineTypes.LOG] | |
| inline_alloc_cost [Clflags] | |
| inline_branch_cost [Clflags] | |
| inline_branch_factor [Clflags] | |
| inline_call_cost [Clflags] | |
| inline_code [Misc.Style] | |
| inline_indirect_cost [Clflags] | |
| inline_lifting_benefit [Clflags] | |
| inline_max_depth [Clflags] | |
| inline_max_unroll [Clflags] | |
| inline_prim_cost [Clflags] | |
| inline_threshold [Clflags] | |
| inline_toplevel_threshold [Clflags] | |
| inlining_report [Clflags] | |
| input_lexbuf [Location] | |
| input_name [Location] | |
| input_needed [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| input_phrase_buffer [Location] | |
| input_value [Compression] | Compression.input_value chan reads from channel chan the
    byte representation of a structured value, as produced by
    Compression.output_value, and reconstructs and
    returns the corresponding value.
 | 
| insn_sched [Clflags] | |
| insn_sched_default [Clflags] | |
| int [Misc.Int_literal_converter] | 
Convert a string to an integer.
 
 | 
| int [Format_doc.Doc] | |
| int [Ast_helper.Const] | |
| int32 [Misc.Int_literal_converter] | 
Likewise, at type  
int32
 | 
| int32 [Ast_helper.Const] | |
| int64 [Misc.Int_literal_converter] | 
Likewise, at type  
int64
 | 
| int64 [Ast_helper.Const] | |
| integer [Ast_helper.Const] | |
| interface [Printast] | |
| interface [Parser.Incremental] | |
| interface [Parser] | |
| interface [Parse] | |
| interface_suffix [Config] | 
Suffix for interface file names
 
 | 
| interface_suffix [Config_main] | 
Suffix for interface file names
 
 | 
| interface_suffix [Config_boot] | 
Suffix for interface file names
 
 | 
| interval [Ast_helper.Pat] | |
| is_active [Warnings] | |
| is_bound [Local_store] | 
Returns  
true when a store is active (i.e.
 | 
| is_capitalized [Misc.Utf8_lexeme] | 
Returns  
true if the given normalized string starts with an
      uppercase identifier character, false otherwise.
 | 
| is_cmi [Unit_info] | 
Check if the artifact is a cmi
 
 | 
| is_compilation_pass [Clflags.Compiler_pass] | |
| is_enabled [Misc.Color] | |
| is_error [Warnings] | |
| is_keyword [Lexer] | |
| is_lowercase [Misc.Utf8_lexeme] | 
Returns  
true if the given normalized string only contains lowercase
      identifier character, false otherwise.
 | 
| is_none [Location] | 
True for  
Location.none, false any other location
 | 
| is_prefix [Misc.Stdlib.List] | 
Returns  
true if and only if the given list, with respect to the given
        equality function on list members, is a prefix of the list of_.
 | 
| is_start [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| is_unit_name [Unit_info] | is_unit_name name is true only if name can be used as a
    valid module name.
 | 
| is_valid_identifier [Misc.Utf8_lexeme] | 
Check whether the given normalized string is a valid OCaml identifier: all characters are identifier characters, it does not start with a digit or a single quote
 
 | 
| items [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| iter [Format_doc.Doc] | |
| iteri2 [Misc.Stdlib.List] | 
Same as  
List.iter2, but the function is applied to the index of
        the element as first argument (counting from 0)
 | 
K  | |
| kasprintf [Format_doc] | |
| kdoc_printf [Format_doc] | |
| kdprintf [Format_doc] | |
| keep_asm_file [Clflags] | |
| keep_camlprimc_file [Clflags] | |
| keep_docs [Clflags] | |
| keep_locs [Clflags] | |
| keep_startup_file [Clflags] | |
| key_left [Diffing_with_keys.Define.Parameters] | |
| key_right [Diffing_with_keys.Define.Parameters] | |
| keys [Identifiable.Map] | |
| keyword_edition [Clflags] | |
| kfprintf [Format_doc] | |
| kind [Unit_info] | kind u is the kind (interface or implementation) of the unit.
 | 
| kmsg [Format_doc.Doc] | |
| kprintf [Format_doc.Doc] | |
L  | |
| last [Longident] | |
| last [CamlinternalMenhirLib.ErrorReports] | |
| lax_modname_from_source [Unit_info] | lax_modname_from_source filename is modulize stem where stem is the
    basename of the filename filename stripped from all its extensions.
 | 
| lazy_ [Ast_helper.Exp] | |
| lazy_ [Ast_helper.Pat] | |
| lazy_tag [Config] | 
Normally the same as Obj.lazy_tag.
 
 | 
| lazy_tag [Config_main] | 
Normally the same as Obj.lazy_tag.
 
 | 
| lazy_tag [Config_boot] | 
Normally the same as Obj.lazy_tag.
 
 | 
| length [CamlinternalMenhirLib.LinearizedArray] | |
| length [CamlinternalMenhirLib.General] | |
| let_ [Ast_helper.Cl] | |
| let_ [Ast_helper.Exp] | |
| letexception [Ast_helper.Exp] | |
| letmodule [Ast_helper.Exp] | |
| letop [Ast_helper.Exp] | |
| letter_of_int [Misc] | |
| lexer_lexbuf_to_supplier [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| lhs [CamlinternalMenhirLib.TableFormat.TABLES] | |
| lhs [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| lhs [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| linear_magic_number [Config] | 
Magic number for Linear internal representation files
 
 | 
| linear_magic_number [Config_main] | 
Magic number for Linear internal representation files
 
 | 
| linear_magic_number [Config_boot] | 
Magic number for Linear internal representation files
 
 | 
| link_everything [Clflags] | |
| list [Format_doc.Doc] | |
| list_remove [Misc] | list_remove x l returns a copy of l with the first
           element equal to x removed.
 | 
| loc [Location.Doc] | |
| location_of_error [Syntaxerr] | |
| locations [Clflags] | |
| locs [Location.Doc] | |
| log [Lazy_backtrack] | |
| log [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| log2 [Misc] | log2 n returns s such that n = 1 lsl s
           if n is a power of 2
 | 
| logand [Targetint] | 
Bitwise logical and.
 
 | 
| lognot [Targetint] | 
Bitwise logical negation.
 
 | 
| logor [Targetint] | 
Bitwise logical or.
 
 | 
| logxor [Targetint] | 
Bitwise logical exclusive or.
 
 | 
| longident [Pprintast.Doc] | |
| longident [Pprintast] | |
| longident [Parse] | 
The function  
longident is guaranteed to parse all subclasses
   of Longident.t used in OCaml: values, constructors, simple or extended
   module paths, and types or module types.
 | 
| lookahead_token [CamlinternalMenhirLib.EngineTypes.LOG] | |
| loop [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| loop_handle [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| loop_handle_undo [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| lr0_core [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
| lr0_incoming [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
| lr0_items [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
M  | |
| magic_length [Misc.Magic_number] | 
all magic numbers take the same number of bytes
 
 | 
| make [Unit_info] | make ~check ~source_file kind prefix associates both the
    source_file and the module name Unit_info.lax_modname_from_source target_prefix
    to the prefix filesystem path prefix.
 | 
| make [CamlinternalMenhirLib.LinearizedArray] | |
| make [CamlinternalMenhirLib.InfiniteArray] | make x creates an infinite array, where every slot contains x.
 | 
| make_archive [Clflags] | |
| make_leaf [Depend] | |
| make_node [Depend] | |
| make_package [Clflags] | |
| make_runtime [Clflags] | |
| map [Identifiable.Tbl] | |
| map [Identifiable.Set] | |
| map2_prefix [Misc.Stdlib.List] | let r1, r2 = map2_prefix f l1 l2
        If l1 is of length n and l2 = h2 @ t2 with h2 of length n,
        r1 is List.map2 f l1 h1 and r2 is t2.
 | 
| map_end [Misc] | map_end f l t is map f l @ t, just more efficient.
 | 
| map_keys [Identifiable.Map] | |
| map_left_right [Misc] | 
Like  
List.map, with guaranteed left-to-right evaluation order
 | 
| map_opt [Ast_mapper] | |
| mark_alert_used [Builtin_attributes] | 
Marks the attribute used for the purposes of misplaced attribute warnings if
    it is an alert.
 
 | 
| mark_alerts_used [Builtin_attributes] | 
The same as  
List.iter mark_alert_used.
 | 
| mark_deprecated_mutable_used [Builtin_attributes] | 
Marks "deprecated_mutable" attributes used for the purposes of misplaced
    attribute warnings.
 
 | 
| mark_payload_attrs_used [Builtin_attributes] | 
Marks the attributes hiding in the payload of another attribute used, for
    the purposes of misplaced attribute warnings (see comment on
     
current_phase above).
 | 
| mark_rhs_docs [Docstrings.WithMenhir] | 
Mark as associated the item documentation for the symbols between
    two positions (for ambiguity warnings)
 
 | 
| mark_rhs_docs [Docstrings] | 
Mark as associated the item documentation for the symbols between
    two positions (for ambiguity warnings)
 
 | 
| mark_symbol_docs [Docstrings.WithMenhir] | 
Mark the item documentation for the current symbol (for ambiguity
    warnings).
 
 | 
| mark_symbol_docs [Docstrings] | 
Mark the item documentation for the current symbol (for ambiguity
    warnings).
 
 | 
| mark_warn_on_literal_pattern_used [Builtin_attributes] | 
Marks "warn_on_literal_pattern" attributes used for the purposes of
    misplaced attribute warnings.
 
 | 
| match_ [Ast_helper.Exp] | |
| match_context_rows [Clflags] | |
| max_int [Targetint] | 
The greatest representable target integer,
    either 231 - 1 on a 32-bit platform,
    or 263 - 1 on a 64-bit platform.
 
 | 
| max_tag [Config] | 
Biggest tag that can be stored in the header of a regular block.
 
 | 
| max_tag [Config_main] | 
Biggest tag that can be stored in the header of a regular block.
 
 | 
| max_tag [Config_boot] | 
Biggest tag that can be stored in the header of a regular block.
 
 | 
| max_young_wosize [Config] | 
Maximal size of arrays that are directly allocated in the
    minor heap
 
 | 
| max_young_wosize [Config_main] | 
Maximal size of arrays that are directly allocated in the
    minor heap
 
 | 
| max_young_wosize [Config_boot] | 
Maximal size of arrays that are directly allocated in the
    minor heap
 
 | 
| may_reduce [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| may_reduce_prod [CamlinternalMenhirLib.EngineTypes.TABLE] | may_reduce_prod s t prod determines whether in the state s, with
     lookahead symbol t, the automaton reduces production prod.
 | 
| maybe_goto_nt [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| maybe_shift_t [CamlinternalMenhirLib.EngineTypes.TABLE] | maybe_shift_t s t determines whether there exists a transition out of
     the state s, labeled with the terminal symbol t, to some state
     s'.
 | 
| memoize [Identifiable.Tbl] | |
| method_ [Ast_helper.Cf] | |
| method_ [Ast_helper.Ctf] | |
| min_int [Targetint] | 
The smallest representable target integer,
   either -231 on a 32-bit platform,
   or -263 on a 64-bit platform.
 
 | 
| minus_one [Targetint] | 
The target integer -1.
 
 | 
| mk [Ast_helper.Of] | |
| mk [Ast_helper.Rf] | |
| mk [Ast_helper.Cstr] | |
| mk [Ast_helper.Csig] | |
| mk [Ast_helper.Ci] | |
| mk [Ast_helper.Cf] | |
| mk [Ast_helper.Cl] | |
| mk [Ast_helper.Ctf] | |
| mk [Ast_helper.Cty] | |
| mk [Ast_helper.Vb] | |
| mk [Ast_helper.Incl] | |
| mk [Ast_helper.Opn] | |
| mk [Ast_helper.Mb] | |
| mk [Ast_helper.Mtd] | |
| mk [Ast_helper.Ms] | |
| mk [Ast_helper.Md] | |
| mk [Ast_helper.Str] | |
| mk [Ast_helper.Sig] | |
| mk [Ast_helper.Mod] | |
| mk [Ast_helper.Mty] | |
| mk [Ast_helper.Te] | |
| mk [Ast_helper.Type] | |
| mk [Ast_helper.Val] | |
| mk [Ast_helper.Exp] | |
| mk [Ast_helper.Pat] | |
| mk [Ast_helper.Typ] | |
| mk [Ast_helper.Attr] | |
| mk [Ast_helper.Const] | |
| mk_exception [Ast_helper.Te] | |
| mk_lazy [Warnings] | 
Like  
Lazy.of_fun, but the function is applied with
        the warning/alert settings at the time mk_lazy is called.
 | 
| mkdll [Config] | 
The linker command line to build dynamic libraries.
 
 | 
| mkdll [Config_main] | 
The linker command line to build dynamic libraries.
 
 | 
| mkdll [Config_boot] | 
The linker command line to build dynamic libraries.
 
 | 
| mkexe [Config] | 
The linker command line to build executables.
 
 | 
| mkexe [Config_main] | 
The linker command line to build executables.
 
 | 
| mkexe [Config_boot] | 
The linker command line to build executables.
 
 | 
| mkloc [Location] | |
| mkmaindll [Config] | 
The linker command line to build main programs as dlls.
 
 | 
| mkmaindll [Config_main] | 
The linker command line to build main programs as dlls.
 
 | 
| mkmaindll [Config_boot] | 
The linker command line to build main programs as dlls.
 
 | 
| mknoloc [Location] | |
| mksharedlibrpath [Config] | 
Option to add a directory to be searched for shared libraries at runtime
    (used by ocamlmklib)
 
 | 
| mksharedlibrpath [Config_main] | 
Option to add a directory to be searched for shared libraries at runtime
    (used by ocamlmklib)
 
 | 
| mksharedlibrpath [Config_boot] | 
Option to add a directory to be searched for shared libraries at runtime
    (used by ocamlmklib)
 
 | 
| mli_from_artifact [Unit_info] | mli_from_artifact t is the name of the interface source file derived from
    the artifact t.
 | 
| mli_from_source [Unit_info] | mli_from_source u is the interface source filename associated to the unit
    u.
 | 
| mod_subst [Ast_helper.Sig] | |
| model [Config] | 
Name of processor submodel for the native-code compiler
 
 | 
| model [Config_main] | 
Name of processor submodel for the native-code compiler
 
 | 
| model [Config_boot] | 
Name of processor submodel for the native-code compiler
 
 | 
| modname [Unit_info.Artifact] | modname a is the module name of the compilation artifact.
 | 
| modname [Unit_info] | modname u or artifact_modname a is the module name of the unit
    or compilation artifact.
 | 
| modtype [Ast_helper.Str] | |
| modtype [Ast_helper.Sig] | |
| modtype_subst [Ast_helper.Sig] | |
| module_ [Ast_helper.Str] | |
| module_ [Ast_helper.Sig] | |
| module_expr [Pprintast] | |
| module_expr [Parse] | |
| module_type [Pprintast] | |
| module_type [Parse] | |
| modulize [Unit_info] | modulize s capitalizes the first letter of s.
 | 
| msg [Format_doc.Doc] | Format_doc.Doc.msg and Format_doc.Doc.kmsg produce a document from a format string and its
      argument
 | 
| msg [Location] | |
| mul [Targetint] | 
Multiplication.
 
 | 
N  | |
| naked_pointers [Config] | 
Whether the runtime supports naked pointers
 
 | 
| naked_pointers [Config_main] | 
Whether the runtime supports naked pointers
 
 | 
| naked_pointers [Config_boot] | 
Whether the runtime supports naked pointers
 
 | 
| native_c_libraries [Config] | 
The C libraries to link with native-code programs
 
 | 
| native_c_libraries [Config_main] | 
The C libraries to link with native-code programs
 
 | 
| native_c_libraries [Config_boot] | 
The C libraries to link with native-code programs
 
 | 
| native_cflags [Config] | 
The flags ocamlopt should pass to the C compiler
 
 | 
| native_cflags [Config_main] | 
The flags ocamlopt should pass to the C compiler
 
 | 
| native_cflags [Config_boot] | 
The flags ocamlopt should pass to the C compiler
 
 | 
| native_code [Clflags] | |
| native_compiler [Config] | 
Whether the native compiler is available or not
 
 | 
| native_compiler [Config_main] | 
Whether the native compiler is available or not
 
 | 
| native_compiler [Config_boot] | 
Whether the native compiler is available or not
 
 | 
| native_cppflags [Config] | 
The flags ocamlopt should pass to the C preprocessor
 
 | 
| native_cppflags [Config_main] | 
The flags ocamlopt should pass to the C preprocessor
 
 | 
| native_cppflags [Config_boot] | 
The flags ocamlopt should pass to the C preprocessor
 
 | 
| native_dynlink [Config] | 
Whether native shared libraries are supported
 
 | 
| native_dynlink [Config_main] | 
Whether native shared libraries are supported
 
 | 
| native_dynlink [Config_boot] | 
Whether native shared libraries are supported
 
 | 
| native_ldflags [Config] | |
| native_ldflags [Config_main] | |
| native_ldflags [Config_boot] | |
| native_obj_config [Misc.Magic_number] | 
the native object file configuration of the active/configured compiler.
 
 | 
| native_pack_linker [Config] | 
The linker to use for packaging (ocamlopt -pack) and for partial
    links (ocamlopt -output-obj).
 
 | 
| native_pack_linker [Config_main] | 
The linker to use for packaging (ocamlopt -pack) and for partial
    links (ocamlopt -output-obj).
 
 | 
| native_pack_linker [Config_boot] | 
The linker to use for packaging (ocamlopt -pack) and for partial
    links (ocamlopt -output-obj).
 
 | 
| nativeint [Misc.Int_literal_converter] | 
Likewise, at type  
nativeint
 | 
| nativeint [Ast_helper.Const] | |
| neg [Targetint] | 
Unary negation.
 
 | 
| new_ [Ast_helper.Exp] | |
| newline [CamlinternalMenhirLib.LexerUtil] | newline lexbuf increments the line counter stored within lexbuf.
 | 
| newtype [Ast_helper.Exp] | |
| no_alias_deps [Clflags] | |
| no_auto_include [Load_path] | 
No automatic directory inclusion: misses in the load path raise  
Not_found
    as normal.
 | 
| no_auto_link [Clflags] | |
| no_check_prims [Clflags] | |
| no_cwd [Clflags] | |
| no_overflow_add [Misc] | no_overflow_add n1 n2 returns true if the computation of
           n1 + n2 does not overflow.
 | 
| no_overflow_lsl [Misc] | no_overflow_lsl n k returns true if the computation of
           n lsl k does not overflow.
 | 
| no_overflow_mul [Misc] | no_overflow_mul n1 n2 returns true if the computation of
           n1 * n2 does not overflow.
 | 
| no_overflow_sub [Misc] | no_overflow_sub n1 n2 returns true if the computation of
           n1 - n2 does not overflow.
 | 
| no_std_include [Clflags] | |
| noassert [Clflags] | |
| noinit [Clflags] | |
| nominal_exp [Pprintast.Doc] | 
Returns a format document if the expression reads nicely as the subject
      of a sentence in a error message.
 
 | 
| none [Location] | 
An arbitrary value of type  
t; describes an empty ghost range.
 | 
| nonterminal [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
| nopervasives [Clflags] | |
| noprompt [Clflags] | |
| nopromptcont [Clflags] | |
| normalise_eol [Misc] | normalise_eol s returns a fresh copy of s with any '\r' characters
   removed.
 | 
| normalize [Misc.Utf8_lexeme] | 
Normalize the given UTF-8 encoded string.
 
 | 
| normalize [Unit_info] | normalize s uncapitalizes the first letter of s.
 | 
| normalized_unit_filename [Misc] | 
Normalize file name  
Foo.ml to foo.ml, using NFC and case-folding.
 | 
| noversion [Clflags] | |
| nullable [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
| nullable [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| num_lines [Terminfo] | |
| number [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| number [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
O  | |
| o1_arguments [Clflags] | |
| o2_arguments [Clflags] | |
| o3_arguments [Clflags] | |
| obj [Unit_info] | |
| object_ [Ast_helper.Exp] | |
| object_ [Ast_helper.Typ] | |
| objfiles [Clflags] | |
| of_float [Targetint] | 
Convert the given floating-point number to a target integer,
   discarding the fractional part (truncate towards 0).
 
 | 
| of_input_filename [Clflags.Compiler_pass] | |
| of_int [Targetint] | 
Convert the given integer (type  
int) to a target integer
    (type t), module the target word size.
 | 
| of_int32 [Targetint] | 
Convert the given 32-bit integer (type  
int32)
    to a target integer.
 | 
| of_int64 [Targetint] | 
Convert the given 64-bit integer (type  
int64)
    to a target integer.
 | 
| of_int64_exn [Numbers.Int16] | |
| of_int_exn [Targetint] | 
Convert the given integer (type  
int) to a target integer
    (type t).
 | 
| of_int_exn [Numbers.Int16] | |
| of_int_exn [Numbers.Int8] | |
| of_list [Identifiable.Tbl] | |
| of_list [Identifiable.Map] | |
| of_list [Identifiable.Set] | |
| of_map [Identifiable.Tbl] | |
| of_set [Identifiable.Map] | |
| of_string [Targetint] | 
Convert the given string to a target integer.
 
 | 
| of_string [Clflags.Dump_option] | |
| of_string [Clflags.Compiler_pass] | |
| offer [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| one [Targetint] | 
The target integer 1.
 
 | 
| one [Numbers.Int8] | |
| opaque [Clflags] | |
| open_ [Ast_helper.Cl] | |
| open_ [Ast_helper.Cty] | |
| open_ [Ast_helper.Str] | |
| open_ [Ast_helper.Sig] | |
| open_ [Ast_helper.Exp] | |
| open_ [Ast_helper.Pat] | |
| open_ [Ast_helper.Typ] | |
| open_and_check_magic [Pparse] | |
| open_box [Format_doc.Doc] | 
The functions below mirror  
Format printers, without the pp_print_
      prefix naming convention
 | 
| open_module [Depend] | |
| open_modules [Clflags] | |
| open_tag [Format_doc.Doc] | |
| open_tbox [Format_doc.Doc] | |
| optimize_for_speed [Clflags] | |
| option [Format_doc.Doc] | |
| options_doc [Profile] | |
| or_ [Ast_helper.Pat] | |
| ordinal_suffix [Misc] | ordinal_suffix n is the appropriate suffix to append to the numeral n as
    an ordinal number: 1 -> "st", 2 -> "nd", 3 -> "rd",
    4 -> "th", and so on.
 | 
| output [Identifiable.Set] | |
| output [Identifiable.Thing] | |
| output_c_object [Clflags] | |
| output_complete_executable [Clflags] | |
| output_complete_object [Clflags] | |
| output_name [Clflags] | |
| output_to_file_via_temporary [Misc] | 
Produce output in temporary file, then rename it
           (as atomically as possible) to the desired output file name.
 
 | 
| output_value [Compression] | Compression.output_value chan v writes the representation
    of v on channel chan.
 | 
| override [Ast_helper.Exp] | |
P  | |
| pack [CamlinternalMenhirLib.PackedIntArray] | |
| pack [Ast_helper.Exp] | |
| package [Ast_helper.Typ] | |
| package_type [Ast_helper.Typ] | |
| parse [Misc.Magic_number] | 
Parses a raw magic number
 
 | 
| parse [Clflags.Float_arg_helper] | |
| parse [Clflags.Int_arg_helper] | |
| parse [Arg_helper.Make] | |
| parse [Longident] | 
This function is broken on identifiers that are not just "Word.Word.word";
   for example, it returns incorrect results on infix operators
   and extended module paths.
 
 | 
| parse_alert_option [Warnings] | 
Disable/enable alerts based on the parameter to the -alert
      command-line option.
 
 | 
| parse_any_longident [Parser.Incremental] | |
| parse_any_longident [Parser] | |
| parse_constr_longident [Parser.Incremental] | |
| parse_constr_longident [Parser] | |
| parse_core_type [Parser.Incremental] | |
| parse_core_type [Parser] | |
| parse_expression [Parser.Incremental] | |
| parse_expression [Parser] | |
| parse_implementation [Pparse] | |
| parse_interface [Pparse] | |
| parse_keyword_edition [Clflags] | |
| parse_kind [Misc.Magic_number] | 
parse a raw kind into a kind
 
 | 
| parse_mod_ext_longident [Parser.Incremental] | |
| parse_mod_ext_longident [Parser] | |
| parse_mod_longident [Parser.Incremental] | |
| parse_mod_longident [Parser] | |
| parse_module_expr [Parser.Incremental] | |
| parse_module_expr [Parser] | |
| parse_module_type [Parser.Incremental] | |
| parse_module_type [Parser] | |
| parse_mty_longident [Parser.Incremental] | |
| parse_mty_longident [Parser] | |
| parse_no_error [Clflags.Float_arg_helper] | |
| parse_no_error [Clflags.Int_arg_helper] | |
| parse_no_error [Arg_helper.Make] | |
| parse_options [Warnings] | |
| parse_pattern [Parser.Incremental] | |
| parse_pattern [Parser] | |
| parse_val_longident [Parser.Incremental] | |
| parse_val_longident [Parser] | |
| parsetree_ghost_loc_invariant [Clflags] | |
| path [Load_path.Dir] | |
| pattern [Printast] | |
| pattern [Pprintast] | |
| pattern [Parse] | |
| payload [Printast] | |
| payload [Pprintast] | |
| pic_code [Clflags] | |
| plugin [Clflags] | |
| poly [Ast_helper.Exp] | |
| poly [Ast_helper.Typ] | |
| pop [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| pop_many [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| positions [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| pp_close_box [Format_doc] | |
| pp_close_stag [Format_doc] | |
| pp_close_tbox [Format_doc] | |
| pp_deps [Depend] | 
Dependencies found by preprocessing tools.
 
 | 
| pp_doc [Format_doc] | |
| pp_force_newline [Format_doc] | |
| pp_open_box [Format_doc] | |
| pp_open_stag [Format_doc] | |
| pp_open_tbox [Format_doc] | |
| pp_print_array [Format_doc] | |
| pp_print_as [Format_doc] | |
| pp_print_bool [Format_doc] | |
| pp_print_break [Format_doc] | |
| pp_print_bytes [Format_doc] | |
| pp_print_char [Format_doc] | |
| pp_print_custom_break [Format_doc] | |
| pp_print_cut [Format_doc] | |
| pp_print_either [Format_doc] | |
| pp_print_float [Format_doc] | |
| pp_print_flush [Format_doc] | |
| pp_print_if_newline [Format_doc] | |
| pp_print_int [Format_doc] | |
| pp_print_iter [Format_doc] | |
| pp_print_list [Format_doc] | |
| pp_print_newline [Format_doc] | |
| pp_print_nothing [Format_doc] | |
| pp_print_option [Format_doc] | |
| pp_print_result [Format_doc] | |
| pp_print_seq [Format_doc] | |
| pp_print_space [Format_doc] | |
| pp_print_string [Format_doc] | |
| pp_print_substring [Format_doc] | |
| pp_print_substring_as [Format_doc] | |
| pp_print_tab [Format_doc] | |
| pp_print_tbreak [Format_doc] | |
| pp_print_text [Format_doc] | |
| pp_set_tab [Format_doc] | |
| pp_two_columns [Format_doc] | pp_two_columns ?sep ?max_lines ppf l prints the lines in l as two
   columns separated by sep ("|" by default).
 | 
| pred [Targetint] | 
Predecessor.
 
 | 
| prefix [Diffing_with_keys] | |
| prefix [Diffing] | |
| prefix [Unit_info.Artifact] | prefix a is the filename prefix of the compilation artifact.
 | 
| prefix [Unit_info] | prefix u is the filename prefix of the unit.
 | 
| prepend_dir [Load_path] | prepend_dir d adds d to the start of the load path (i.e.
 | 
| preprocess [Pparse] | |
| preprocessor [Clflags] | |
| prerr_alert [Location] | 
Same as  
print_alert, but uses !formatter_for_warnings as output
   formatter.
 | 
| prerr_warning [Location] | 
Same as  
print_warning, but uses !formatter_for_warnings as output
   formatter.
 | 
| primitive [Ast_helper.Str] | |
| principal [Clflags] | |
| print [Targetint] | 
Print a target integer to a formatter.
 
 | 
| print [Profile] | 
Prints the selected recorded profiling information to the formatter.
 
 | 
| print [Misc.Stdlib.Option] | |
| print [Identifiable.Map] | |
| print [Identifiable.Set] | |
| print [Identifiable.Thing] | |
| print [Misc.Stdlib.String] | |
| print_alert [Location] | 
Prints an alert.
 
 | 
| print_arguments [Clflags] | |
| print_config [Config] | 
Access to configuration values
 
 | 
| print_config [Config_main] | 
Access to configuration values
 
 | 
| print_config [Config_boot] | 
Access to configuration values
 
 | 
| print_current_state [CamlinternalMenhirLib.Printers.Make] | |
| print_element_as_symbol [CamlinternalMenhirLib.Printers.Make] | |
| print_env [CamlinternalMenhirLib.Printers.Make] | |
| print_filename [Location] | |
| print_if [Misc] | print_if ppf flag fmt x prints x with fmt on ppf if b is true.
 | 
| print_item [CamlinternalMenhirLib.Printers.Make] | |
| print_loc [Location] | |
| print_locs [Location] | |
| print_production [CamlinternalMenhirLib.Printers.Make] | |
| print_report [Location] | 
Display an error or warning report.
 
 | 
| print_see_manual [Misc] | 
See manual section
 
 | 
| print_stack [CamlinternalMenhirLib.Printers.Make] | |
| print_symbols [CamlinternalMenhirLib.Printers.Make] | |
| print_types [Clflags] | |
| print_variance [Clflags] | |
| print_warning [Location] | 
Prints a warning.
 
 | 
| print_warnings [Lexer] | |
| printf [Format_doc.Doc] | Format_doc.Doc.printf and Format_doc.Doc.kprintf produce a printer from a format string and its
      argument
 | 
| production_index [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| production_index [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| profile_columns [Clflags] | |
| protect_refs [Misc] | protect_refs l f temporarily sets r to v for each R (r, v) in l
    while executing f.
 | 
| protect_writing_to_file [Misc] | 
Open the given  
filename for writing (in binary mode), pass
          the out_channel to the given function, then close the
          channel.
 | 
Q  | |
| quote_files [Ccomp] | |
| quote_optfile [Ccomp] | |
| quoted_filename [Location.Doc] | |
R  | |
| raise_errorf [Location] | |
| range [CamlinternalMenhirLib.LexerUtil] | range (startpos, endpos) prints a textual description of the range
   delimited by the start and end positions startpos and endpos.
 | 
| raw [Misc.Magic_number] | 
A valid raw representation of the magic number.
 
 | 
| raw_kind [Misc.Magic_number] | 
the current raw representation of a kind.
 
 | 
| read [Binutils] | |
| read [CamlinternalMenhirLib.LinearizedArray] | |
| read [CamlinternalMenhirLib.LexerUtil] | read filename reads the entire contents of the file filename and
   returns a pair of this content (a string) and a lexing buffer that
   has been initialized, based on this string.
 | 
| read_ast [Pparse] | |
| read_current_info [Misc.Magic_number] | 
Read a magic number as  
read_info,
      and check that it is the current version as its kind.
 | 
| read_info [Misc.Magic_number] | 
Read a raw magic number from an input channel.
 
 | 
| read_row [CamlinternalMenhirLib.LinearizedArray] | |
| read_row_via [CamlinternalMenhirLib.LinearizedArray] | |
| read_via [CamlinternalMenhirLib.LinearizedArray] | |
| real_paths [Clflags] | |
| rebind [Ast_helper.Te] | |
| rec_module [Ast_helper.Str] | |
| rec_module [Ast_helper.Sig] | |
| record [Profile] | record pass f arg records the profile information of f arg
 | 
| record [Ast_helper.Exp] | |
| record [Ast_helper.Pat] | |
| record_call [Profile] | record_call pass f calls f and records its profile information.
 | 
| recursive_types [Clflags] | |
| reduce_or_accept [CamlinternalMenhirLib.EngineTypes.LOG] | |
| register [Docstrings] | 
Register a docstring
 
 | 
| register [Ast_mapper] | 
Apply the  
register_function.
 | 
| register_attr [Builtin_attributes] | |
| register_error_of_exn [Location] | 
Each compiler module which defines a custom type of exception
    which can surface as a user-visible error should register
    a "printer" for this exception using  
register_error_of_exn.
 | 
| register_function [Ast_mapper] | |
| rem [Targetint] | 
Integer remainder.
 
 | 
| remove_dir [Load_path] | 
Remove a directory from the load path
 
 | 
| remove_file [Misc] | 
Delete the given file if it exists and is a regular file.
 
 | 
| remove_preprocessed [Pparse] | |
| remove_unused_arguments [Clflags] | |
| rename [Identifiable.Map] | |
| repeated_label [Misc] | 
Detects a repeated label - for use with labeled tuples.
 
 | 
| replace_substring [Misc] | replace_substring ~before ~after str replaces all
           occurrences of before with after in str and returns
           the resulting string.
 | 
| replicate_list [Misc] | replicate_list elem n is the list with n elements
           all identical to elem.
 | 
| report [Warnings] | |
| report_alert [Warnings] | |
| report_alert [Location] | report_alert loc w produces a report for the given alert w, or
   None if the alert is not to be printed.
 | 
| report_error [Pparse] | |
| report_error [Linkdeps] | |
| report_error [Attr_helper] | |
| report_error_doc [Pparse] | |
| report_error_doc [Linkdeps] | |
| report_error_doc [Attr_helper] | |
| report_exception [Location] | 
Reraise the exception if it is unknown.
 
 | 
| report_printer [Location] | 
Hook for redefining the printer of reports.
 
 | 
| report_warning [Location] | report_warning loc w produces a report for the given warning w, or
   None if the warning is not to be printed.
 | 
| repr [Targetint] | 
The concrete representation of a native integer.
 
 | 
| require_20240715 [CamlinternalMenhirLib.StaticVersion] | |
| required [Linkdeps] | required t compunit returns true if compunit is a dependency of
    previously added compilation units.
 | 
| reraise_preserving_backtrace [Misc] | reraise_preserving_backtrace e f is (f (); raise e) except that the
    current backtrace is preserved, even if f uses exceptions internally.
 | 
| reserved_header_bits [Config] | 
How many bits of a block's header are reserved
 
 | 
| reserved_header_bits [Config_main] | 
How many bits of a block's header are reserved
 
 | 
| reserved_header_bits [Config_boot] | 
How many bits of a block's header are reserved
 
 | 
| reset [Profile] | 
erase all recorded profile information
 
 | 
| reset [Local_store] | 
Resets all the references to the initial snapshot (i.e.
 
 | 
| reset [Load_path] | 
Remove all directories
 
 | 
| reset [Location] | |
| reset_arguments [Clflags] | |
| reset_base_overrides [Arg_helper.Make] | |
| reset_fatal [Warnings] | |
| restore [Warnings] | |
| result [Format_doc.Doc] | |
| resume [Terminfo] | |
| resume [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| resuming_error_handling [CamlinternalMenhirLib.EngineTypes.LOG] | |
| rev_map_end [Misc] | map_end f l t is map f (rev l) @ t, just more efficient.
 | 
| rev_split_words [Misc] | rev_split_words s splits s in blank-separated words, and returns
           the list of words in reverse order.
 | 
| revised2traditional [CamlinternalMenhirLib.Convert.Simplified] | |
| revised2traditional [CamlinternalMenhirLib.Convert] | |
| rewrite [Build_path_prefix_map] | rewrite path uses rewrite_first to try to find a
    mapping for path.
 | 
| rewrite_absolute_path [Location] | rewrite_absolute_path path rewrites path to honor the
    BUILD_PATH_PREFIX_MAP variable
    if it is set.
 | 
| rewrite_all [Build_path_prefix_map] | rewrite_all map path finds all sources in map
    that are a prefix of the input path.
 | 
| rewrite_find_all_existing_dirs [Location] | rewrite_find_all_existing_dirs dir accumulates a list of existing
    directories, dirs, that are the result of mapping a potentially
    abstract directory, dir, over all the mapping pairs in the
    BUILD_PATH_PREFIX_MAP environment variable, if any.
 | 
| rewrite_find_first_existing [Location] | rewrite_find_first_existing path uses a BUILD_PATH_PREFIX_MAP mapping
    and tries to find a source in mapping
    that maps to a result that exists in the file system.
 | 
| rewrite_first [Build_path_prefix_map] | rewrite_first map path tries to find a source in map
    that is a prefix of the input path.
 | 
| rhs [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
| rhs [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
| rhs_docs [Docstrings.WithMenhir] | 
Fetch the item documentation for the symbols between two
    positions.
 
 | 
| rhs_docs [Docstrings] | 
Fetch the item documentation for the symbols between two
    positions.
 
 | 
| rhs_docs_lazy [Docstrings.WithMenhir] | |
| rhs_docs_lazy [Docstrings] | |
| rhs_info [Docstrings.WithMenhir] | 
Fetch the field info following the symbol at a given position.
 
 | 
| rhs_info [Docstrings] | 
Fetch the field info following the symbol at a given position.
 
 | 
| rhs_interval [Location] | |
| rhs_loc [Location] | rhs_loc n returns the location of the symbol at position n, starting
  at 1, in the current parser rule.
 | 
| rhs_post_extra_text [Docstrings.WithMenhir] | 
Fetch additional text following the symbol at the given position
 
 | 
| rhs_post_extra_text [Docstrings] | 
Fetch additional text following the symbol at the given position
 
 | 
| rhs_post_text [Docstrings.WithMenhir] | 
Fetch text following the symbol at the given position
 
 | 
| rhs_post_text [Docstrings] | 
Fetch text following the symbol at the given position
 
 | 
| rhs_pre_extra_text [Docstrings.WithMenhir] | 
Fetch additional text preceding the symbol at the given position
 
 | 
| rhs_pre_extra_text [Docstrings] | 
Fetch additional text preceding the symbol at the given position
 
 | 
| rhs_text [Docstrings.WithMenhir] | 
Fetch the text preceding the symbol at the given position.
 
 | 
| rhs_text [Docstrings] | 
Fetch the text preceding the symbol at the given position.
 
 | 
| rhs_text_lazy [Docstrings.WithMenhir] | |
| rhs_text_lazy [Docstrings] | |
| rounds [Clflags] | |
| row_length [CamlinternalMenhirLib.LinearizedArray] | |
| row_length_via [CamlinternalMenhirLib.LinearizedArray] | |
| run_command [Ccomp] | |
| run_main [Ast_mapper] | 
Entry point to call to implement a standalone -ppx rewriter from a
    mapper, parametrized by the command line arguments.
 
 | 
| runtime_variant [Clflags] | |
S  | |
| s_ref [Local_store] | 
Similar to  
Stdlib.ref, except the allocated reference is registered
    into the store.
 | 
| s_table [Local_store] | 
Used to register hash tables.
 
 | 
| safer_matching [Clflags] | |
| same [Longident] | same t t' compares the longidents t and t' without taking locations
    into account.
 | 
| sanitize [CamlinternalMenhirLib.ErrorReports] | |
| search_substring [Misc] | search_substring pat str start returns the position of the first
           occurrence of string pat in string str.
 | 
| select_attributes [Builtin_attributes] | |
| semantic_action [CamlinternalMenhirLib.TableFormat.TABLES] | |
| semantic_action [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| semicolon [Format_doc] | |
| send [Ast_helper.Exp] | |
| separate_new_message [Location.Doc] | |
| separate_new_message [Location] | |
| seq [Format_doc.Doc] | |
| sequence [Ast_helper.Exp] | |
| set [CamlinternalMenhirLib.InfiniteArray] | set a i x sets the element contained at offset i in the array
    a to x.
 | 
| set_base_default [Arg_helper.Make] | |
| set_cookie [Ast_mapper] | |
| set_dumped_pass [Clflags] | |
| set_floating_docstrings [Docstrings] | 
Docstrings not immediately adjacent to a token
 
 | 
| set_or_ignore [Misc] | set_or_ignore f opt x sets opt to f x if it returns Some _,
           or leaves it unmodified if it returns None.
 | 
| set_post_docstrings [Docstrings] | 
Docstrings immediately following a token
 
 | 
| set_post_extra_docstrings [Docstrings] | 
Docstrings immediately preceding the token which follows this one
 
 | 
| set_pre_docstrings [Docstrings] | 
Docstrings immediately preceding a token
 
 | 
| set_pre_extra_docstrings [Docstrings] | 
Docstrings immediately following the token which precedes this one
 
 | 
| set_preprocessor [Lexer] | |
| set_save_ir_after [Clflags] | |
| set_styles [Misc.Style] | |
| set_tab [Format_doc.Doc] | |
| set_tag_handling [Misc.Style] | |
| set_user_default [Arg_helper.Make] | |
| setfield [Ast_helper.Exp] | |
| setinstvar [Ast_helper.Exp] | |
| setup [Terminfo] | |
| setup [Misc.Style] | |
| shared [Clflags] | |
| shift [CamlinternalMenhirLib.EngineTypes.LOG] | |
| shift_left [Targetint] | Targetint.shift_left x y shifts x to the left by y bits.
 | 
| shift_right [Targetint] | Targetint.shift_right x y shifts x to the right by y bits.
 | 
| shift_right_logical [Targetint] | Targetint.shift_right_logical x y shifts x to the right
    by y bits.
 | 
| shifts [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| shorten [CamlinternalMenhirLib.ErrorReports] | |
| should_save_ir_after [Clflags] | |
| should_stop_after [Clflags] | |
| show [CamlinternalMenhirLib.ErrorReports] | |
| show_config_and_exit [Misc] | 
Display the values of all compiler configuration variables from module
       
Config, then exit the program with code 0.
 | 
| show_config_variable_and_exit [Misc] | 
Display the value of the given configuration variable,
      then exit the program with code 0.
 
 | 
| show_filename [Location] | 
In -absname mode, return the absolute path for this filename.
 
 | 
| signature [Pprintast] | |
| signature [Ast_invariants] | |
| signature [Ast_helper.Cty] | |
| signature [Ast_helper.Mty] | |
| signature_item [Pprintast] | |
| simple_module_path [Parse] | 
This function parses a syntactically valid path for a module.
 
 | 
| simplify_rounds [Clflags] | |
| size [Targetint] | 
The size in bits of a target native integer.
 
 | 
| skip_hash_bang [Lexer] | |
| snd3 [Misc] | |
| snd4 [Misc] | |
| some_if_all_elements_are_some [Misc.Stdlib.List] | 
If all elements of the given list are  
Some _ then Some xs
        is returned with the xs being the contents of those Somes, with
        order preserved.
 | 
| source [Consistbl.Make] | |
| source_file [Unit_info.Artifact] | source_file a is the source file of a if it exists.
 | 
| source_file [Unit_info] | source_file u is the source file of u.
 | 
| space [Format_doc.Doc] | |
| spellcheck [Misc] | spellcheck env name takes a list of names env that exist in
    the current environment and an erroneous name, and returns a
    list of suggestions taken from env, that are close enough to
    name that it may be a typo for one of them.
 | 
| split_at [Misc.Stdlib.List] | split_at n l returns the pair before, after where before is
        the n first elements of l and after the remaining ones.
 | 
| split_last [Misc] | 
Return the last element and the other elements of the given list.
 
 | 
| split_null_terminated [Misc] | split_null_terminated s is similar
    String.split_on_char '\000' but ignores the trailing separator, if any
 | 
| split_path_contents [Misc] | split_path_contents ?sep s interprets s as the value of
          a "PATH"-like variable and returns the corresponding list of
          directories.
 | 
| stack [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| stack_ctx_words [Domainstate] | |
| stack_safety_margin [Config] | 
Size in words of the safety margin between the bottom of
    the stack and the stack pointer.
 
 | 
| stack_safety_margin [Config_main] | 
Size in words of the safety margin between the bottom of
    the stack and the stack pointer.
 
 | 
| stack_safety_margin [Config_boot] | 
Size in words of the safety margin between the bottom of
    the stack and the stack pointer.
 
 | 
| stack_threshold [Config] | 
Size in words of safe area at bottom of VM stack,
    see runtime/caml/config.h
 
 | 
| stack_threshold [Config_main] | 
Size in words of safe area at bottom of VM stack,
    see runtime/caml/config.h
 
 | 
| stack_threshold [Config_boot] | 
Size in words of safe area at bottom of VM stack,
    see runtime/caml/config.h
 
 | 
| standard_library [Config] | 
The directory containing the standard libraries
 
 | 
| standard_library [Config_main] | 
The directory containing the standard libraries
 
 | 
| standard_library [Config_boot] | 
The directory containing the standard libraries
 
 | 
| standout [Terminfo] | |
| start [CamlinternalMenhirLib.TableFormat.TABLES] | |
| start [CamlinternalMenhirLib.EngineTypes.INCREMENTAL_ENGINE_START] | |
| starts_like_a_valid_identifier [Misc.Utf8_lexeme] | 
Checks whether the given normalized string starts with an identifier
      character other than a digit or a single quote.
 
 | 
| state [CamlinternalMenhirLib.EngineTypes.LOG] | |
| state_has_default_reduction [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| std_include_dir [Clflags] | |
| std_include_flag [Clflags] | |
| stop_after [Clflags] | |
| store_occurrences [Clflags] | |
| strict_formats [Clflags] | |
| strict_modname_from_source [Unit_info] | 
Same as  
Unit_info.lax_modname_from_source but raises an Unit_info.error.Invalid_encoding
    error on filename with invalid utf8 encoding.
 | 
| strict_sequence [Clflags] | |
| string [Format_doc.Doc] | |
| string [Ast_helper.Const] | |
| string_of_expression [Pprintast] | |
| string_of_file [Misc] | string_of_file ic reads the contents of file ic and copies
           them to a string.
 | 
| string_of_kind [Misc.Magic_number] | 
a user-printable string for a kind, eg.
 
 | 
| string_of_label [Asttypes] | |
| string_of_structure [Pprintast] | |
| structure [Printast] | |
| structure [Pprintast] | |
| structure [Ast_invariants] | |
| structure [Ast_helper.Cl] | |
| structure [Ast_helper.Mod] | |
| structure_item [Pprintast] | |
| style [Diffing] | |
| sub [Targetint] | 
Subtraction.
 
 | 
| succ [Targetint] | 
Successor.
 
 | 
| supports_shared_libraries [Config] | 
Whether shared libraries are supported
 
 | 
| supports_shared_libraries [Config_main] | 
Whether shared libraries are supported
 
 | 
| supports_shared_libraries [Config_boot] | 
Whether shared libraries are supported
 
 | 
| symbol_docs [Docstrings.WithMenhir] | 
Fetch the item documentation for the current symbol.
 
 | 
| symbol_docs [Docstrings] | 
Fetch the item documentation for the current symbol.
 
 | 
| symbol_docs_lazy [Docstrings.WithMenhir] | |
| symbol_docs_lazy [Docstrings] | |
| symbol_gloc [Location] | |
| symbol_info [Docstrings.WithMenhir] | 
Fetch the field info for the current symbol.
 
 | 
| symbol_info [Docstrings] | 
Fetch the field info for the current symbol.
 
 | 
| symbol_offset [Binutils] | |
| symbol_post_extra_text [Docstrings.WithMenhir] | 
Fetch additional text following the current symbol
 
 | 
| symbol_post_extra_text [Docstrings] | 
Fetch additional text following the current symbol
 
 | 
| symbol_pre_extra_text [Docstrings.WithMenhir] | 
Fetch additional text preceding the current symbol
 
 | 
| symbol_pre_extra_text [Docstrings] | 
Fetch additional text preceding the current symbol
 
 | 
| symbol_rloc [Location] | |
| symbol_text [Docstrings.WithMenhir] | 
Fetch the text preceding the current symbol.
 
 | 
| symbol_text [Docstrings] | 
Fetch the text preceding the current symbol.
 
 | 
| symbol_text_lazy [Docstrings.WithMenhir] | |
| symbol_text_lazy [Docstrings] | |
| system [Config] | 
Name of operating system for the native-code compiler
 
 | 
| system [Config_main] | 
Name of operating system for the native-code compiler
 
 | 
| system [Config_boot] | 
Name of operating system for the native-code compiler
 
 | 
| systhread_supported [Config] | 
Whether the system thread library is implemented
 
 | 
| systhread_supported [Config_main] | 
Whether the system thread library is implemented
 
 | 
| systhread_supported [Config_boot] | 
Whether the system thread library is implemented
 
 | 
T  | |
| tab [Format_doc.Doc] | |
| tab_break [Format_doc.Doc] | |
| tabulate [CamlinternalMenhirLib.LexerUtil] | tabulate is_eof lexer tabulates the lexer lexer: that is, it
   immediately runs this lexer all the way until an EOF token is found, stores
   the tokens in an array in memory, and returns a new lexer which (when
   invoked) reads tokens from this array.
 | 
| tag [Ast_helper.Of] | |
| tag [Ast_helper.Rf] | |
| take [CamlinternalMenhirLib.General] | |
| target [Config] | 
Whether the compiler is a cross-compiler
 
 | 
| target [Config_main] | 
Whether the compiler is a cross-compiler
 
 | 
| target [Config_boot] | 
Whether the compiler is a cross-compiler
 
 | 
| target_os_type [Config] | 
Operating system targetted by the native-code compiler.
 
 | 
| target_os_type [Config_main] | 
Operating system targetted by the native-code compiler.
 
 | 
| target_os_type [Config_boot] | 
Operating system targetted by the native-code compiler.
 
 | 
| terminal [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
| terminfo_toplevel_printer [Location] | |
| test [Diffing_with_keys.Define.Parameters] | |
| test [Diffing.Define.Parameters] | test st xl xr tests if the elements xl and xr are
        co  mpatible (Ok) or not (Error).
 | 
| text [Format_doc.Doc] | |
| text [Ast_helper.Cf] | |
| text [Ast_helper.Ctf] | |
| text [Ast_helper.Str] | |
| text [Ast_helper.Sig] | |
| text_attr [Docstrings] | |
| thd3 [Misc] | |
| thd4 [Misc] | |
| to_float [Targetint] | 
Convert the given target integer to a floating-point number.
 
 | 
| to_int [Targetint] | 
Convert the given target integer (type  
t) to an
    integer (type int).
 | 
| to_int [Numbers.Int16] | |
| to_int [Numbers.Int8] | |
| to_int32 [Targetint] | 
Convert the given target integer to a
    32-bit integer (type  
int32).
 | 
| to_int64 [Targetint] | 
Convert the given target integer to a
    64-bit integer (type  
int64).
 | 
| to_list [Identifiable.Tbl] | |
| to_map [Identifiable.Tbl] | |
| to_output_filename [Clflags.Compiler_pass] | |
| to_string [Targetint] | 
Return the string representation of its argument, in decimal.
 
 | 
| to_string [Numbers.Int] | |
| to_string [Identifiable.Set] | |
| to_string [Clflags.Dump_option] | |
| to_string [Clflags.Compiler_pass] | |
| token [Lexer] | |
| token2terminal [CamlinternalMenhirLib.TableFormat.TABLES] | |
| token2terminal [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| token2value [CamlinternalMenhirLib.TableFormat.TABLES] | |
| token2value [CamlinternalMenhirLib.EngineTypes.TABLE] | |
| token_with_comments [Lexer] | |
| tool_name [Ast_mapper] | 
Can be used within a ppx preprocessor to know which tool is
    calling it  
"ocamlc", "ocamlopt", "ocamldoc", "ocamldep",
    "ocaml", ...
 | 
| top [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
| top_phrase [Printast] | |
| top_phrase [Pprintast] | |
| toplevel_phrase [Pprintast] | |
| toplevel_phrase [Parser.Incremental] | |
| toplevel_phrase [Parser] | |
| toplevel_phrase [Parse] | |
| trace [CamlinternalMenhirLib.TableFormat.TABLES] | |
| traditional2revised [CamlinternalMenhirLib.Convert.Simplified] | |
| traditional2revised [CamlinternalMenhirLib.Convert] | |
| transl [Profile] | |
| transpose_keys_and_data [Identifiable.Map] | |
| transpose_keys_and_data_set [Identifiable.Map] | |
| try_ [Ast_helper.Exp] | |
| try_finally [Misc] | try_finally work ~always ~exceptionally is designed to run code
    in work that may fail with an exception, and has two kind of
    cleanup routines: always, that must be run after any execution
    of the function (typically, freeing system resources), and
    exceptionally, that should be run only if work or always
    failed with an exception (typically, undoing user-visible state
    changes that would only make sense if the function completes
    correctly).
 | 
| tsan [Config] | 
Whether ThreadSanitizer instrumentation is enabled
 
 | 
| tsan [Config_main] | 
Whether ThreadSanitizer instrumentation is enabled
 
 | 
| tsan [Config_boot] | 
Whether ThreadSanitizer instrumentation is enabled
 
 | 
| tuple [Ast_helper.Exp] | |
| tuple [Ast_helper.Pat] | |
| tuple [Ast_helper.Typ] | |
| type_ [Ast_helper.Str] | |
| type_ [Ast_helper.Sig] | |
| type_ [Ast_helper.Pat] | |
| type_extension [Ast_helper.Str] | |
| type_extension [Ast_helper.Sig] | |
| type_ident [Parse] | 
This function parse syntactically valid path for a type or a module type.
 
 | 
| type_subst [Ast_helper.Sig] | |
| typeof_ [Ast_helper.Mty] | |
| typing [Profile] | |
| tyvar [Pprintast.Doc] | |
| tyvar [Pprintast] | 
Print a type variable name as a valid identifier, taking care of the
      special treatment required for the single quote character in second
      position, or for keywords by escaping them with \#.
 
 | 
| tyvar_of_name [Pprintast] | 
Turn a type variable name into a valid identifier, taking care of the
      special treatment required for the single quote character in second
      position, or for keywords by escaping them with \#.
 
 | 
U  | |
| unbox_closures [Clflags] | |
| unbox_closures_factor [Clflags] | |
| unbox_free_vars_of_closures [Clflags] | |
| unbox_specialised_args [Clflags] | |
| unboxed_types [Clflags] | |
| uncapitalize [Misc.Utf8_lexeme] | 
Like  
normalize, but if the string starts with an uppercase identifier
      character, it is replaced by the corresponding lowercase character.
 | 
| unflatten [Longident] | 
For a non-empty list  
l, unflatten l is Some lid where lid is
    the long identifier created by concatenating the elements of l
    with Ldot.
 | 
| unflatten1 [CamlinternalMenhirLib.PackedIntArray] | |
| union_left [Identifiable.Map] | union_left m1 m2 = union_right m2 m1
 | 
| union_merge [Identifiable.Map] | |
| union_right [Identifiable.Map] | union_right m1 m2 contains all bindings from m1 and m2.
 | 
| uniq [CamlinternalMenhirLib.General] | |
| unique_ids [Clflags] | |
| unpack [Ast_helper.Mod] | |
| unpack [Ast_helper.Pat] | |
| unreachable [Ast_helper.Exp] | |
| unsafe [Clflags] | |
| unsigned_compare [Targetint] | 
Same as  
Targetint.compare, except that arguments are interpreted as unsigned
    integers.
 | 
| unsigned_div [Targetint] | 
Same as  
Targetint.div, except that arguments and result are interpreted as     unsigned integers.
 | 
| unsigned_rem [Targetint] | 
Same as  
Targetint.rem, except that arguments and result are interpreted as     unsigned integers.
 | 
| update [Diffing_with_keys.Define.Parameters] | |
| update [Diffing.Define.Parameters] | update ch st returns the new state after applying a change.
 | 
| use_file [Parser.Incremental] | |
| use_file [Parser] | |
| use_file [Parse] | |
| use_inlining_arguments_set [Clflags] | 
Set all the inlining arguments for a round.
 
 | 
| use_linscan [Clflags] | |
| use_prims [Clflags] | |
| use_runtime [Clflags] | |
| use_threads [Clflags] | |
V  | |
| val_ [Ast_helper.Cf] | |
| val_ [Ast_helper.Ctf] | |
| val_ident [Parse] | 
This function parses a syntactically valid path for a value.
 
 | 
| validate_identifier [Misc.Utf8_lexeme] | 
Like  
is_valid_identifier, but returns a more detailed error code.
 | 
| value [Ast_helper.Str] | |
| value [Ast_helper.Sig] | |
| var [Ast_helper.Pat] | |
| var [Ast_helper.Typ] | |
| variant [Ast_helper.Exp] | |
| variant [Ast_helper.Pat] | |
| variant [Ast_helper.Typ] | |
| varify_constructors [Ast_helper.Typ] | varify_constructors newtypes te is type expression te, of which
        any of nullary type constructor tc is replaced by type variable of
        the same name, if tc's name appears in newtypes.
 | 
| verbose [Clflags] | |
| version [Config] | 
The current version number of the system
 
 | 
| version [Config_main] | 
The current version number of the system
 
 | 
| version [Config_boot] | 
The current version number of the system
 
 | 
| virtual_ [Ast_helper.Cf] | |
W  | |
| warn_bad_docstrings [Docstrings] | 
Emit warnings for unattached and ambiguous docstrings
 
 | 
| warn_on_literal_pattern [Builtin_attributes] | |
| warn_unused [Builtin_attributes] | 
Issue misplaced attribute warnings for all attributes created with
     
mk_internal but not yet marked used.
 | 
| warning_attribute [Builtin_attributes] | 
Apply warning settings from the specified attribute.
 
 | 
| warning_reporter [Location] | 
Hook for intercepting warnings.
 
 | 
| warning_scope [Builtin_attributes] | 
Execute a function in a new scope for warning settings.
 
 | 
| weaken_map [Depend] | |
| weed [CamlinternalMenhirLib.General] | |
| weight [Diffing_with_keys.Define.Parameters] | |
| weight [Diffing.Define.Parameters] | weight ch returns the weight of the change ch.
 | 
| while_ [Ast_helper.Exp] | |
| windows_unicode [Config] | 
Whether Windows Unicode runtime is enabled
 
 | 
| windows_unicode [Config_main] | 
Whether Windows Unicode runtime is enabled
 
 | 
| windows_unicode [Config_boot] | 
Whether Windows Unicode runtime is enabled
 
 | 
| with_ [Ast_helper.Mty] | |
| with_cmm_invariants [Config] | 
Whether the invariants checks for Cmm are enabled
 
 | 
| with_cmm_invariants [Config_main] | 
Whether the invariants checks for Cmm are enabled
 
 | 
| with_cmm_invariants [Config_boot] | 
Whether the invariants checks for Cmm are enabled
 
 | 
| with_codegen_invariants [Config] | 
Whether the invariant checks for native code generation are enabled.
 
 | 
| with_codegen_invariants [Config_main] | 
Whether the invariant checks for native code generation are enabled.
 
 | 
| with_codegen_invariants [Config_boot] | 
Whether the invariant checks for native code generation are enabled.
 
 | 
| with_default_loc [Ast_helper] | 
Set the  
default_loc within the scope of the execution
        of the provided function.
 | 
| with_flambda_invariants [Config] | 
Whether the invariants checks for flambda are enabled
 
 | 
| with_flambda_invariants [Config_main] | 
Whether the invariants checks for flambda are enabled
 
 | 
| with_flambda_invariants [Config_boot] | 
Whether the invariants checks for flambda are enabled
 
 | 
| with_frame_pointers [Config] | 
Whether assembler should maintain frame pointers
 
 | 
| with_frame_pointers [Config_main] | 
Whether assembler should maintain frame pointers
 
 | 
| with_frame_pointers [Config_boot] | 
Whether assembler should maintain frame pointers
 
 | 
| with_nonexecstack_note [Config] | 
Whether an explicit ".note.GNU-stack" section is to be added to indicate
    the stack should not be executable
 
 | 
| with_nonexecstack_note [Config_main] | 
Whether an explicit ".note.GNU-stack" section is to be added to indicate
    the stack should not be executable
 
 | 
| with_nonexecstack_note [Config_boot] | 
Whether an explicit ".note.GNU-stack" section is to be added to indicate
    the stack should not be executable
 
 | 
| with_pos [Diffing_with_keys] | |
| with_runtime [Clflags] | |
| with_size [Format_doc.Doc] | |
| with_state [Warnings] | |
| with_store [Local_store] | with_store s f resets all the registered references to the value they have
    in s for the run of f.
 | 
| without_warnings [Warnings] | 
Run the thunk with all warnings and alerts disabled.
 
 | 
| wrap [CamlinternalMenhirLib.ErrorReports] | |
| wrap_supplier [CamlinternalMenhirLib.ErrorReports] | |
| write [CamlinternalMenhirLib.LinearizedArray] | |
| write_ast [Pparse] | |
X  | |
| xfirst [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
Z  | |
| zero [Targetint] | 
The target integer 0.
 
 | 
| zero [Numbers.Int8] | |
| zero_to_n [Numbers.Int] | zero_to_n n is the set of numbers {0, ..., n} (inclusive).
 |