( * ) [Stdlib] | Integer multiplication. |
( ** ) [Stdlib] | Exponentiation. |
( *. ) [Stdlib] | Floating-point multiplication. |
(!) [Stdlib] |
|
(!=) [Stdlib] | Negation of |
(&&) [Bool] |
|
(&&) [Stdlib] | The boolean 'and'. |
(&) [Stdlib] | |
(+) [Stdlib] | Integer addition. |
(+.) [Stdlib] | Floating-point addition. |
(-) [Stdlib] | Integer subtraction. |
(-.) [Stdlib] | Floating-point subtraction. |
(/) [Stdlib] | Integer division. |
(/.) [Stdlib] | Floating-point division. |
(:=) [Stdlib] |
|
(<) [Int_replace_polymorphic_compare] | |
(<) [Stdlib] | See |
(<=) [Int_replace_polymorphic_compare] | |
(<=) [Stdlib] | See |
(<>) [Int_replace_polymorphic_compare] | |
(<>) [Stdlib] | Negation of |
(=) [Int_replace_polymorphic_compare] | |
(=) [Stdlib] |
|
(==) [Stdlib] |
|
(>) [Int_replace_polymorphic_compare] | |
(>) [Stdlib] | See |
(>=) [Int_replace_polymorphic_compare] | |
(>=) [Stdlib] | Structural ordering functions. |
(@) [Stdlib] | List concatenation. |
(@@) [Stdlib] | Application operator: |
(^) [Stdlib] | String concatenation. |
(^^) [Stdlib] |
|
(asr) [Stdlib] |
|
(land) [Stdlib] | Bitwise logical and. |
(lor) [Stdlib] | Bitwise logical or. |
(lsl) [Stdlib] |
|
(lsr) [Stdlib] |
|
(lxor) [Stdlib] | Bitwise logical exclusive or. |
(mod) [Stdlib] | Integer remainder. |
(or) [Stdlib] | |
(|>) [Stdlib] | Reverse-application operator: |
(||) [Bool] |
|
(||) [Stdlib] | The boolean 'or'. |
(~+) [Stdlib] | Unary addition. |
(~+.) [Stdlib] | Unary addition. |
(~-) [Stdlib] | Unary negation. |
(~-.) [Stdlib] | Unary negation. |
__FILE__ [Stdlib] |
|
__FUNCTION__ [Stdlib] |
|
__LINE_OF__ [Stdlib] |
|
__LINE__ [Stdlib] |
|
__LOC_OF__ [Stdlib] |
|
__LOC__ [Stdlib] |
|
__MODULE__ [Stdlib] |
|
__POS_OF__ [Stdlib] |
|
__POS__ [Stdlib] |
|
_exit [UnixLabels] | Terminate the calling process immediately, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure. |
_exit [Unix] | Terminate the calling process immediately, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure. |
A | |
abs [Targetint] | Return the absolute value of its argument. |
abs [Nativeint] | Return the absolute value of its argument. |
abs [Int64] | Return the absolute value of its argument. |
abs [Int32] | Return the absolute value of its argument. |
abs [Int] |
|
abs [Float] |
|
abs [Stdlib] | Return the absolute value of the argument. |
abs_float [Stdlib] |
|
absname [Clflags] | |
absolute_path [Location] | |
abstract_tag [Obj] | |
accept [ThreadUnix] | |
accept [UnixLabels] | Accept connections on the given socket. |
accept [Unix] | Accept connections on the given socket. |
acceptable [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
access [UnixLabels] | Check that the process has the given permissions over the named file. |
access [Unix] | Check that the process has the given permissions over the named file. |
acos [Float] | Arc cosine. |
acos [Stdlib] | Arc cosine. |
acquire [Semaphore.Binary] |
|
acquire [Semaphore.Counting] |
|
action [CamlinternalMenhirLib.TableFormat.TABLES] | |
action [CamlinternalMenhirLib.EngineTypes.TABLE] | |
adapt_filename [Dynlink] | In bytecode, the identity function. |
add [Targetint] | Addition. |
add [Load_path] | |
add [Weak.S] |
|
add [Set.S] |
|
add [Queue] |
|
add [Nativeint] | Addition. |
add [MoreLabels.Set.S] |
|
add [MoreLabels.Map.S] |
|
add [MoreLabels.Hashtbl.SeededS] | |
add [MoreLabels.Hashtbl.S] | |
add [MoreLabels.Hashtbl] |
|
add [Map.S] |
|
add [Int64] | Addition. |
add [Int32] | Addition. |
add [Int] |
|
add [Hashtbl.SeededS] | |
add [Hashtbl.S] | |
add [Hashtbl] |
|
add [Float] | Floating-point addition. |
add [Complex] | Addition |
add_arguments [Clflags] | |
add_base_override [Arg_helper.Make] | |
add_buffer [Buffer] |
|
add_bytes [Buffer] |
|
add_channel [Buffer] |
|
add_char [Buffer] |
|
add_dir [Load_path] | Add a directory to the load path |
add_docs_attrs [Docstrings] | Convert item documentation to attributes and add them to an attribute list |
add_implementation [Depend] | |
add_implementation_binding [Depend] | |
add_in_char_set [CamlinternalFormat] | |
add_info_attrs [Docstrings] | Convert field info to attributes and add them to an attribute list |
add_initializer [CamlinternalOO] | |
add_int16_be [Buffer] |
|
add_int16_le [Buffer] |
|
add_int16_ne [Buffer] |
|
add_int32_be [Buffer] |
|
add_int32_le [Buffer] |
|
add_int32_ne [Buffer] |
|
add_int64_be [Buffer] |
|
add_int64_le [Buffer] |
|
add_int64_ne [Buffer] |
|
add_int8 [Buffer] |
|
add_offset [Obj] | |
add_ppx_context_sig [Ast_mapper] | Same as |
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_seq [Stack] | Add the elements from the iterator on the top of the stack. |
add_seq [Set.S] | Add the given elements to the set, in order. |
add_seq [Queue] | Add the elements from the generator to the end of the queue |
add_seq [MoreLabels.Set.S] | Add the given elements to the set, in order. |
add_seq [MoreLabels.Map.S] | Add the given bindings to the map, in order. |
add_seq [MoreLabels.Hashtbl.SeededS] | |
add_seq [MoreLabels.Hashtbl.S] | |
add_seq [MoreLabels.Hashtbl] | Add the given bindings to the table, using |
add_seq [Map.S] | Add the given bindings to the map, in order. |
add_seq [Hashtbl.SeededS] | |
add_seq [Hashtbl.S] | |
add_seq [Hashtbl] | Add the given bindings to the table, using |
add_seq [Buffer] | Add chars to the buffer |
add_signature [Depend] | |
add_signature_binding [Depend] | |
add_string [Buffer] |
|
add_subbytes [Buffer] |
|
add_substitute [Buffer] |
|
add_substring [Buffer] |
|
add_symbolic_output_item [Format] |
|
add_text_attrs [Docstrings] | Convert text to attributes and add them to an attribute list |
add_uint16_be [Buffer] |
|
add_uint16_le [Buffer] |
|
add_uint16_ne [Buffer] |
|
add_uint8 [Buffer] |
|
add_use_file [Depend] | |
add_user_override [Arg_helper.Make] | |
add_utf_16be_uchar [Buffer] |
|
add_utf_16le_uchar [Buffer] |
|
add_utf_8_uchar [Buffer] |
|
afl_inst_ratio [Clflags] | |
afl_instrument [Config] | Whether afl-fuzz instrumentation is generated by default |
afl_instrument [Clflags] | |
alarm [UnixLabels] | Schedule a |
alarm [Unix] | Schedule a |
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 [Arg] | Align the documentation strings by inserting spaces at the first alignment separator (tab or, if tab is not found, space), according to the length of the keyword. |
all_ccopts [Clflags] | |
all_columns [Profile] | |
all_passes [Clflags] | |
all_ppx [Clflags] | |
all_somes [Misc.Stdlib.Array] | |
all_units [Dynlink] | Return the list of compilation units that form the main program together
with those that have been dynamically loaded via |
allocated_bytes [Gc] | Return the total number of bytes allocated since the program was started. |
allow_only [Dynlink] |
|
allow_unsafe_modules [Dynlink] | Govern whether unsafe object files are allowed to be dynamically linked. |
always [Event] |
|
annotations [Clflags] | |
ansi_of_style_l [Misc.Color] | |
any [Ast_helper.Pat] | |
any [Ast_helper.Typ] | |
append [Seq] |
|
append [ListLabels] | Concatenate two lists. |
append [List] | Concatenate two lists. |
append [Float.ArrayLabels] |
|
append [Float.Array] |
|
append [ArrayLabels] |
|
append [Array] |
|
applicative_functors [Clflags] | |
apply [Ast_mapper] | Apply a mapper (parametrized by the unit name) to a dumped
parsetree found in the |
apply [Ast_helper.Cl] | |
apply [Ast_helper.Mod] | |
apply [Ast_helper.Exp] | |
apply_rewriters [Pparse] | If |
apply_rewriters_sig [Pparse] | |
apply_rewriters_str [Pparse] | |
ar [Config] | Name of the ar command, or "" if not needed (MSVC) |
architecture [Config] | Name of processor type for the native-code compiler |
arg [Complex] | Argument. |
arg_spec [Clflags] | |
argv [Sys] | The command line arguments given to the process. |
array [Ast_helper.Exp] | |
array [Ast_helper.Pat] | |
array0_of_genarray [Bigarray] | Return the zero-dimensional Bigarray corresponding to the given generic Bigarray. |
array1_of_genarray [Bigarray] | Return the one-dimensional Bigarray corresponding to the given generic Bigarray. |
array2_of_genarray [Bigarray] | Return the two-dimensional Bigarray corresponding to the given generic Bigarray. |
array3_of_genarray [Bigarray] | Return the three-dimensional Bigarray corresponding to the given generic Bigarray. |
arrow [Ast_helper.Cty] | |
arrow [Ast_helper.Typ] | |
as_has_debug_prefix_map [Config] | Whether the assembler supports --debug-prefix-map |
asin [Float] | Arc sine. |
asin [Stdlib] | Arc sine. |
asm [Config] | The assembler (and flags) to use for assembling ocamlopt-generated code. |
asm_cfi_supported [Config] | Whether assembler understands CFI directives |
asprintf [Format] | Same as |
assert_ [Ast_helper.Exp] | |
assoc [ListLabels] |
|
assoc [List] |
|
assoc_opt [ListLabels] |
|
assoc_opt [List] |
|
assq [ListLabels] | Same as |
assq [List] | Same as |
assq_opt [ListLabels] | Same as |
assq_opt [List] | Same as |
ast_impl_magic_number [Config] | Magic number for file holding an implementation syntax tree |
ast_intf_magic_number [Config] | Magic number for file holding an interface syntax tree |
at_exit [Stdlib] | Register the given function to be called at program termination time. |
atan [Float] | Arc tangent. |
atan [Stdlib] | Arc tangent. |
atan2 [Float] |
|
atan2 [Stdlib] |
|
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] | |
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. |
available_pass_names [Clflags.Compiler_pass] | |
B | |
backend_type [Sys] | Backend type currently executing the OCaml program. |
backtrace_slots [Printexc] | Returns the slots of a raw backtrace, or |
backtrace_slots_of_raw_entry [Printexc] | Returns the slots of a single raw backtrace entry, or |
backtrace_status [Printexc] |
|
backtrack [Misc.EnvLazy] | |
backup [Warnings] | |
backup [Terminfo] | |
basename [Filename] | Split a file name into directory name / base file name. |
batch_mode_printer [Location] | |
beginning_of_input [Scanf.Scanning] |
|
best_toplevel_printer [Location] | Detects the terminal capabilities and selects an adequate printer |
big_endian [Sys] | Whether the machine currently executing the Caml program is big-endian. |
binary_annotations [Clflags] | |
bind [UnixLabels] | Bind a socket to an address. |
bind [Unix] | Bind a socket to an address. |
bind [Result] |
|
bind [Option] |
|
binding_op [Ast_helper.Exp] | |
bindings [MoreLabels.Map.S] | Return the list of all bindings of the given map. |
bindings [Map.S] | Return the list of all bindings of the given map. |
bits [Random.State] | |
bits [Random] | Return 30 random bits in a nonnegative integer. |
bits_of_float [Int64] | Return the internal representation of the given float according to the IEEE 754 floating-point 'double format' bit layout. |
bits_of_float [Int32] | Return the internal representation of the given float according to the IEEE 754 floating-point 'single format' bit layout. |
blit [Misc.LongString] | |
blit [Weak] |
|
blit [String] |
|
blit [StringLabels] |
|
blit [Float.ArrayLabels] |
|
blit [Float.Array] |
|
blit [BytesLabels] |
|
blit [Bytes] |
|
blit [Buffer] |
|
blit [Bigarray.Array3] | Copy the first Bigarray to the second Bigarray. |
blit [Bigarray.Array2] | Copy the first Bigarray to the second Bigarray. |
blit [Bigarray.Array1] | Copy the first Bigarray to the second Bigarray. |
blit [Bigarray.Array0] | Copy the first Bigarray to the second Bigarray. |
blit [Bigarray.Genarray] | Copy all elements of a Bigarray in another Bigarray. |
blit [ArrayLabels] |
|
blit [Array] |
|
blit_data [Obj.Ephemeron] | Same as |
blit_data [Ephemeron.Kn] | Same as |
blit_data [Ephemeron.K2] | Same as |
blit_data [Ephemeron.K1] |
|
blit_key [Obj.Ephemeron] | Same as |
blit_key [Ephemeron.Kn] | Same as |
blit_key [Ephemeron.K1] |
|
blit_key1 [Ephemeron.K2] | Same as |
blit_key12 [Ephemeron.K2] | Same as |
blit_key2 [Ephemeron.K2] | Same as |
blit_string [Misc.LongString] | |
blit_string [BytesLabels] |
|
blit_string [Bytes] |
|
bom [Uchar] |
|
bool [Random.State] | These functions are the same as the basic functions, except that they use (and update) the given PRNG state instead of the default one. |
bool [Random] |
|
bool_of_string [Stdlib] | Same as |
bool_of_string_opt [Stdlib] | Convert the given string to a boolean. |
bounded_full_split [Str] | Same as |
bounded_split [Str] | Same as |
bounded_split_delim [Str] | Same as |
bprintf [Printf] | Same as |
bprintf [Format] | |
broadcast [Condition] |
|
bscanf [Scanf] | |
bscanf_format [Scanf] |
|
bufput_acc [CamlinternalFormat] | |
bytecode_compatible_32 [Clflags] | |
bytecomp_c_libraries [Config] | The C libraries to link with custom runtimes |
bytes [Digest] | Return the digest of the given byte sequence. |
C | |
c_compiler [Config] | 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_layout [Bigarray] | |
c_output_obj [Config] | 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] | |
capitalize [String] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.. |
capitalize [StringLabels] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.. |
capitalize [BytesLabels] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set. |
capitalize [Bytes] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set. |
capitalize_ascii [String] |
|
capitalize_ascii [StringLabels] |
|
capitalize_ascii [BytesLabels] | Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set. |
capitalize_ascii [Bytes] | Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set. |
cardinal [Set.S] | Return the number of elements of a set. |
cardinal [MoreLabels.Set.S] | Return the number of elements of a set. |
cardinal [MoreLabels.Map.S] | Return the number of bindings of a map. |
cardinal [Map.S] | Return the number of bindings of a map. |
case [Ast_helper.Exp] | |
cat [BytesLabels] |
|
cat [Bytes] |
|
catch [Printexc] |
|
catch_break [Sys] |
|
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) |
ceil [Float] | Round above to an integer value. |
ceil [Stdlib] | Round above to an integer value. |
change_layout [Bigarray.Array3] |
|
change_layout [Bigarray.Array2] |
|
change_layout [Bigarray.Array1] |
|
change_layout [Bigarray.Array0] |
|
change_layout [Bigarray.Genarray] |
|
channel [Digest] | If |
char [Ast_helper.Const] | |
char [Bigarray] | As shown by the types of the values above,
Bigarrays of kind |
char_of_iconv [CamlinternalFormat] | |
char_of_int [Stdlib] | Return the character with the given ASCII code. |
chdir [UnixLabels] | Change the process working directory. |
chdir [Unix] | Change the process working directory. |
chdir [Sys] | Change the current working directory of the process. |
check [Consistbl.Make] | |
check [Weak] |
|
check_alerts [Builtin_attributes] | |
check_alerts_inclusion [Builtin_attributes] | |
check_current [Misc.Magic_number] |
|
check_data [Obj.Ephemeron] | Same as |
check_data [Ephemeron.Kn] | Same as |
check_data [Ephemeron.K2] | Same as |
check_data [Ephemeron.K1] |
|
check_deprecated_mutable [Builtin_attributes] | |
check_deprecated_mutable_inclusion [Builtin_attributes] | |
check_fatal [Warnings] | |
check_geometry [Format] | Check if the formatter geometry is valid: |
check_key [Obj.Ephemeron] | Same as |
check_key [Ephemeron.Kn] | Same as |
check_key [Ephemeron.K1] |
|
check_key1 [Ephemeron.K2] | Same as |
check_key2 [Ephemeron.K2] | Same as |
check_no_alert [Builtin_attributes] | |
check_noadd [Consistbl.Make] | |
check_suffix [Filename] |
|
chmod [UnixLabels] | Change the permissions of the named file. |
chmod [Unix] | Change the permissions of the named file. |
choose [Event] |
|
choose [Set.S] | Return one element of the given set, or raise |
choose [MoreLabels.Set.S] | Return one element of the given set, or raise |
choose [MoreLabels.Map.S] | Return one binding of the given map, or raise |
choose [Map.S] | Return one binding of the given map, or raise |
choose_opt [Set.S] | Return one element of the given set, or |
choose_opt [MoreLabels.Set.S] | Return one element of the given set, or |
choose_opt [MoreLabels.Map.S] | Return one binding of the given map, or |
choose_opt [Map.S] | Return one binding of the given map, or |
chop_extension [Filename] | Same as |
chop_extensions [Misc] | |
chop_suffix [Filename] |
|
chop_suffix_opt [Filename] |
|
chown [UnixLabels] | Change the owner uid and owner gid of the named file. |
chown [Unix] | Change the owner uid and owner gid of the named file. |
chr [Char] | Return the character with the given ASCII code. |
chroot [UnixLabels] | Change the process root directory. |
chroot [Unix] | Change the process root directory. |
clambda_checks [Clflags] | |
class_ [Ast_helper.Str] | |
class_ [Ast_helper.Sig] | |
class_ [Ast_helper.Typ] | |
class_type [Ast_helper.Str] | |
class_type [Ast_helper.Sig] | |
classic [Clflags] | |
classic_arguments [Clflags] | |
classic_inlining [Clflags] | |
classify_float [Float] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number. |
classify_float [Stdlib] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number. |
clean [Ephemeron.SeededS] | remove all dead bindings. |
clean [Ephemeron.S] | remove all dead bindings. |
clear [Consistbl.Make] | |
clear [Weak.S] | Remove all elements from the table. |
clear [Stack] | Discard all elements from a stack. |
clear [Queue] | Discard all elements from a queue. |
clear [MoreLabels.Hashtbl.SeededS] | |
clear [MoreLabels.Hashtbl.S] | |
clear [MoreLabels.Hashtbl] | Empty a hash table. |
clear [Hashtbl.SeededS] | |
clear [Hashtbl.S] | |
clear [Hashtbl] | Empty a hash table. |
clear [Buffer] | Empty the buffer. |
clear_close_on_exec [UnixLabels] | Clear the ``close-on-exec'' flag on the given descriptor. |
clear_close_on_exec [Unix] | Clear the ``close-on-exec'' flag on the given descriptor. |
clear_nonblock [UnixLabels] | Clear the ``non-blocking'' flag on the given descriptor. |
clear_nonblock [Unix] | Clear the ``non-blocking'' flag on the given descriptor. |
clear_parser [Parsing] | Empty the parser stack. |
clear_symbolic_output_buffer [Format] |
|
close [UnixLabels] | Close a file descriptor. |
close [Unix] | Close a file descriptor. |
close_box [Format] | Closes the most recently open pretty-printing box. |
close_in [Scanf.Scanning] | Closes the |
close_in [Stdlib] | Close the given channel. |
close_in_noerr [Stdlib] | Same as |
close_out [Stdlib] | Close the given channel, flushing all buffered write operations. |
close_out_noerr [Stdlib] | Same as |
close_process [UnixLabels] | Close channels opened by |
close_process [Unix] | Close channels opened by |
close_process_full [UnixLabels] | Close channels opened by |
close_process_full [Unix] | Close channels opened by |
close_process_in [UnixLabels] | Close channels opened by |
close_process_in [Unix] | Close channels opened by |
close_process_out [UnixLabels] | Close channels opened by |
close_process_out [Unix] | Close channels opened by |
close_stag [Format] |
|
close_tag [Format] | |
close_tbox [Format] | Closes the most recently opened tabulation box. |
closedir [UnixLabels] | Close a directory descriptor. |
closedir [Unix] | Close a directory descriptor. |
closure_tag [Obj] | |
cma_magic_number [Config] | Magic number for archive files |
cmi_magic_number [Config] | Magic number for compiled interface files |
cmo_magic_number [Config] | Magic number for object bytecode files |
cmt_magic_number [Config] | Magic number for compiled interface files |
cmx_magic_number [Config] | Magic number for compilation unit descriptions |
cmxa_magic_number [Config] | Magic number for libraries of compilation unit descriptions |
cmxs_magic_number [Config] | Magic number for dynamically-loadable plugins |
code [Char] | Return the ASCII code of the argument. |
coerce [Ast_helper.Exp] | |
color [Clflags] | |
color_reader [Clflags] | |
combine [ListLabels] | Transform a pair of lists into a list of pairs:
|
combine [List] | Transform a pair of lists into a list of pairs:
|
command [Ccomp] | |
command [Sys] | Execute the given shell command and return its exit code. |
comments [Lexer] | |
compact [Gc] | Perform a full major collection and compact the heap. |
compare [Targetint] | The comparison function for target integers, with the same specification as
|
compare [Misc.Stdlib.List] | The lexicographic order supported by the provided order. |
compare [Misc.Stdlib] | |
compare [Int_replace_polymorphic_compare] | |
compare [Clflags.Compiler_pass] | |
compare [Unit] |
|
compare [Uchar] |
|
compare [String] |
|
compare [StringLabels] |
|
compare [Set.OrderedType] | A total ordering function over the set elements. |
compare [Set.S] | Total ordering between sets. |
compare [Result] |
|
compare [Option] |
|
compare [Nativeint] | The comparison function for native integers, with the same specification as
|
compare [MoreLabels.Set.OrderedType] | A total ordering function over the set elements. |
compare [MoreLabels.Set.S] | Total ordering between sets. |
compare [MoreLabels.Map.OrderedType] | A total ordering function over the keys. |
compare [MoreLabels.Map.S] | Total ordering between maps. |
compare [Map.OrderedType] | A total ordering function over the keys. |
compare [Map.S] | Total ordering between maps. |
compare [ListLabels] |
|
compare [List] |
|
compare [Int64] | The comparison function for 64-bit integers, with the same specification as
|
compare [Int32] | The comparison function for 32-bit integers, with the same specification as
|
compare [Int] |
|
compare [Float] |
|
compare [Either] |
|
compare [Digest] | The comparison function for 16-character digest, with the same
specification as |
compare [Char] | The comparison function for characters, with the same specification as
|
compare [BytesLabels] | The comparison function for byte sequences, with the same
specification as |
compare [Bytes] | The comparison function for byte sequences, with the same
specification as |
compare [Bool] |
|
compare [Stdlib] |
|
compare_and_set [Atomic] |
|
compare_and_set [CamlinternalAtomic] | |
compare_items [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
compare_length_with [ListLabels] | Compare the length of a list to an integer. |
compare_length_with [List] | Compare the length of a list to an integer. |
compare_lengths [ListLabels] | Compare the lengths of two lists. |
compare_lengths [List] | Compare the lengths of two lists. |
compare_nonterminals [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
compare_productions [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
compare_symbols [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
compare_terminals [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
compile_file [Ccomp] | |
compile_only [Clflags] | |
complex32 [Bigarray] | See |
complex64 [Bigarray] | See |
component_graph [Strongly_connected_components.S] | |
compress [CamlinternalMenhirLib.RowDisplacement] | |
concat [String] |
|
concat [StringLabels] |
|
concat [ListLabels] | Concatenate a list of lists. |
concat [List] | Concatenate a list of lists. |
concat [Float.ArrayLabels] | Same as |
concat [Float.Array] | Same as |
concat [Filename] |
|
concat [BytesLabels] |
|
concat [Bytes] |
|
concat [ArrayLabels] | Same as |
concat [Array] | Same as |
concat_fmt [CamlinternalFormatBasics] | |
concat_fmtty [CamlinternalFormatBasics] | |
concat_map [ListLabels] |
|
concat_map [List] |
|
concrete [Ast_helper.Cf] | |
config_var [Config] | the configuration value of a variable, if it exists |
conj [Complex] | Conjugate: given the complex |
connect [ThreadUnix] | |
connect [UnixLabels] | Connect a socket to an address. |
connect [Unix] | Connect a socket to an address. |
connected_components_sorted_from_roots_to_leaf [Strongly_connected_components.S] | |
cons [Seq] |
|
cons [ListLabels] |
|
cons [List] |
|
const [Fun] |
|
constant [Ast_helper.Exp] | |
constant [Ast_helper.Pat] | |
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] | |
contains [String] |
|
contains [StringLabels] |
|
contains [BytesLabels] |
|
contains [Bytes] |
|
contains_from [String] |
|
contains_from [StringLabels] |
|
contains_from [BytesLabels] |
|
contains_from [Bytes] |
|
contents [Buffer] | Return a copy of the current contents of the buffer. |
convert_raw_backtrace_slot [Printexc] | Extracts the user-friendly |
copy [CamlinternalOO] | |
copy [String] | Return a copy of the given string. |
copy [StringLabels] | Return a copy of the given string. |
copy [Stack] | Return a copy of the given stack. |
copy [Random.State] | Return a copy of the given state. |
copy [Queue] | Return a copy of the given queue. |
copy [Oo] |
|
copy [MoreLabels.Hashtbl.SeededS] | |
copy [MoreLabels.Hashtbl.S] | |
copy [MoreLabels.Hashtbl] | Return a copy of the given hashtable. |
copy [Hashtbl.SeededS] | |
copy [Hashtbl.S] | |
copy [Hashtbl] | Return a copy of the given hashtable. |
copy [Float.ArrayLabels] |
|
copy [Float.Array] |
|
copy [BytesLabels] | Return a new byte sequence that contains the same bytes as the argument. |
copy [Bytes] | Return a new byte sequence that contains the same bytes as the argument. |
copy [ArrayLabels] |
|
copy [Array] |
|
copy_file [Misc] | |
copy_file_chunk [Misc] | |
copy_sign [Float] |
|
copysign [Stdlib] |
|
core_type [Pprintast] | |
core_type [Parse] | |
cos [Float] | Cosine. |
cos [Stdlib] | Cosine. |
cosh [Float] | Hyperbolic cosine. |
cosh [Stdlib] | Hyperbolic cosine. |
count [Weak.S] | Count the number of elements in the table. |
count [Stream] | Return the current count of the stream elements, i.e. |
counters [Gc] | Return |
create [Misc.EnvLazy] | |
create [Misc.LongString] | |
create [Load_path.Dir] | |
create [Consistbl.Make] | |
create [Mutex] | Return a new mutex. |
create [Condition] | Return a new condition variable. |
create [Thread] |
|
create [Weak.S] |
|
create [Weak] |
|
create [String] |
|
create [StringLabels] |
|
create [Stack] | Return a new stack, initially empty. |
create [Queue] | Return a new queue, initially empty. |
create [Obj.Ephemeron] |
|
create [MoreLabels.Hashtbl.SeededS] | |
create [MoreLabels.Hashtbl.S] | |
create [MoreLabels.Hashtbl] |
|
create [Hashtbl.SeededS] | |
create [Hashtbl.S] | |
create [Hashtbl] |
|
create [Float.ArrayLabels] |
|
create [Float.Array] |
|
create [Ephemeron.Kn] | Same as |
create [Ephemeron.K2] | Same as |
create [Ephemeron.K1] |
|
create [BytesLabels] |
|
create [Bytes] |
|
create [Buffer] |
|
create [Bigarray.Array3] |
|
create [Bigarray.Array2] |
|
create [Bigarray.Array1] |
|
create [Bigarray.Array0] |
|
create [Bigarray.Genarray] |
|
create [ArrayLabels] | |
create [Array] | |
create_alarm [Gc] |
|
create_archive [Ccomp] | |
create_char_set [CamlinternalFormat] | |
create_failed [Misc.EnvLazy] | |
create_float [ArrayLabels] |
|
create_float [Array] |
|
create_forced [Misc.EnvLazy] | |
create_hashtable [Misc] | |
create_matrix [ArrayLabels] | |
create_matrix [Array] | |
create_object [CamlinternalOO] | |
create_object_and_run_initializers [CamlinternalOO] | |
create_object_opt [CamlinternalOO] | |
create_process [UnixLabels] |
|
create_process [Unix] |
|
create_process_env [UnixLabels] |
|
create_process_env [Unix] |
|
create_table [CamlinternalOO] | |
curr [Location] | Get the location of the current token from the |
current [Arg] | Position (in |
current_dir_name [Filename] | The conventional name for the current directory (e.g. |
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_runtime [Clflags] | |
custom_tag [Obj] | |
cut_at [Misc] |
|
cygwin [Sys] | True if |
D | |
data [Identifiable.Map] | |
data_size [Marshal] | See |
debug [Clflags] | |
debug_full [Clflags] | |
debug_prefix_map_flags [Misc] | Returns the list of |
debug_runavail [Clflags] | |
decl [Ast_helper.Te] | |
decode_map [Build_path_prefix_map] | |
decode_pair [Build_path_prefix_map] | |
decode_prefix [Build_path_prefix_map] | |
decr [Atomic] |
|
decr [Stdlib] | Decrement the integer contained in the given reference. |
decr [CamlinternalAtomic] | |
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_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_safe_string [Config] | Whether the compiler was configured to use the -safe-string or -unsafe-string compile-time option by default. |
default_setting [Misc.Error_style] | |
default_setting [Misc.Color] | |
default_simplify_rounds [Clflags] | |
default_styles [Misc.Color] | |
default_unbox_closures_factor [Clflags] | |
default_uncaught_exception_handler [Printexc] |
|
default_warning_reporter [Location] | Original warning reporter for use in hooks. |
defaults_w [Warnings] | |
defaults_warn_error [Warnings] | |
defines_symbol [Binutils] | |
delay [Thread] |
|
delete_alarm [Gc] |
|
delete_eol_spaces [Misc] |
|
deprecated [Location] | Prints a deprecation alert. |
descr_of_in_channel [UnixLabels] | Return the descriptor corresponding to an input channel. |
descr_of_in_channel [Unix] | Return the descriptor corresponding to an input channel. |
descr_of_out_channel [UnixLabels] | Return the descriptor corresponding to an output channel. |
descr_of_out_channel [Unix] | Return the descriptor corresponding to an output channel. |
did_you_mean [Misc] |
|
diff [Set.S] | Set difference: |
diff [MoreLabels.Set.S] | Set difference: |
dim [Bigarray.Array1] | Return the size (dimension) of the given one-dimensional Bigarray. |
dim1 [Bigarray.Array3] | Return the first dimension of the given three-dimensional Bigarray. |
dim1 [Bigarray.Array2] | Return the first dimension of the given two-dimensional Bigarray. |
dim2 [Bigarray.Array3] | Return the second dimension of the given three-dimensional Bigarray. |
dim2 [Bigarray.Array2] | Return the second dimension of the given two-dimensional Bigarray. |
dim3 [Bigarray.Array3] | Return the third dimension of the given three-dimensional Bigarray. |
dims [Bigarray.Genarray] |
|
dir_sep [Filename] | The directory separator (e.g. |
dirname [Filename] | See |
disjoint [Set.S] | Test if two sets are disjoint. |
disjoint [MoreLabels.Set.S] | Test if two sets are disjoint. |
disjoint_union [Identifiable.Map] |
|
div [Targetint] | Integer division. |
div [Nativeint] | Integer division. |
div [Int64] | Integer division. |
div [Int32] | Integer division. |
div [Int] |
|
div [Float] | Floating-point division. |
div [Complex] | Division |
dlcode [Clflags] | |
dllibs [Clflags] | |
dllpaths [Clflags] | |
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_of_sockaddr [UnixLabels] | Return the socket domain adequate for the given socket address. |
domain_of_sockaddr [Unix] | Return the socket domain adequate for the given socket address. |
dont_write_files [Clflags] | |
double_array_tag [Obj] | |
double_field [Obj] | |
double_tag [Obj] | |
dprintf [Format] | Same as |
drop [CamlinternalMenhirLib.General] | |
drop_ppx_context_sig [Ast_mapper] | Same as |
drop_ppx_context_str [Ast_mapper] | Drop the ocaml.ppx.context attribute from a structure. |
dummy_class [CamlinternalOO] | |
dummy_pos [Lexing] | A value of type |
dummy_table [CamlinternalOO] | |
dump_avail [Clflags] | |
dump_clambda [Clflags] | |
dump_cmm [Clflags] | |
dump_combine [Clflags] | |
dump_cse [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_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_source [Clflags] | |
dump_spill [Clflags] | |
dump_split [Clflags] | |
dump_typedtree [Clflags] | |
dumped_pass [Clflags] | |
dup [UnixLabels] | Return a new file descriptor referencing the same file as the given descriptor. |
dup [Unix] | Return a new file descriptor referencing the same file as the given descriptor. |
dup [Obj] | |
dup2 [UnixLabels] |
|
dup2 [Unix] |
|
E | |
echo_eof [Location] | |
edit_distance [Misc] |
|
elements [Set.S] | Return the list of all elements of the given set. |
elements [MoreLabels.Set.S] | Return the list of all elements of the given set. |
empty [Stream] | Return |
empty [Set.S] | The empty set. |
empty [Seq] | The empty sequence, containing no elements. |
empty [MoreLabels.Set.S] | The empty set. |
empty [MoreLabels.Map.S] | The empty map. |
empty [Map.S] | The empty map. |
empty [BytesLabels] | A byte sequence of size 0. |
empty [Bytes] | A byte sequence of size 0. |
empty_docs [Docstrings] | |
empty_info [Docstrings] | |
empty_text [Docstrings] | |
empty_text_lazy [Docstrings] | |
enable_runtime_warnings [Sys] | Control whether the OCaml runtime system can emit warnings on stderr. |
encode_map [Build_path_prefix_map] | |
encode_pair [Build_path_prefix_map] | |
encode_prefix [Build_path_prefix_map] | |
end_of_input [Scanf.Scanning] |
|
entry [CamlinternalMenhirLib.EngineTypes.MONOLITHIC_ENGINE] | |
env_has_default_reduction [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
environment [UnixLabels] | Return the process environment, as an array of strings with the format ``variable=value''. |
environment [Unix] | Return the process environment, as an array of strings with the format ``variable=value''. |
eprintf [Printf] | Same as |
eprintf [Format] | Same as |
epsilon [Float] | The difference between |
epsilon_float [Stdlib] | The difference between |
equal [Targetint] | The equal function for target ints. |
equal [Misc.Stdlib.List] | Returns |
equal [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
equal [Unit] |
|
equal [Uchar] |
|
equal [String] |
|
equal [StringLabels] |
|
equal [Set.S] |
|
equal [Result] |
|
equal [Option] |
|
equal [Nativeint] | The equal function for native ints. |
equal [MoreLabels.Set.S] |
|
equal [MoreLabels.Map.S] |
|
equal [MoreLabels.Hashtbl.SeededHashedType] | The equality predicate used to compare keys. |
equal [MoreLabels.Hashtbl.HashedType] | The equality predicate used to compare keys. |
equal [Map.S] |
|
equal [ListLabels] |
|
equal [List] |
|
equal [Int64] | The equal function for int64s. |
equal [Int32] | The equal function for int32s. |
equal [Int] |
|
equal [Hashtbl.SeededHashedType] | The equality predicate used to compare keys. |
equal [Hashtbl.HashedType] | The equality predicate used to compare keys. |
equal [Float] | The equal function for floating-point numbers, compared using |
equal [Either] |
|
equal [Digest] | The equal function for 16-character digest. |
equal [Char] | The equal function for chars. |
equal [BytesLabels] | The equality function for byte sequences. |
equal [Bytes] | The equality function for byte sequences. |
equal [Bool] |
|
erase_rel [CamlinternalFormatBasics] | |
err_formatter [Format] | A formatter to write to standard error. |
error [Location] | |
error [CamlinternalMenhirLib.TableFormat.TABLES] | |
error [Result] |
|
error_message [Dynlink] | Convert an error description to a printable message. |
error_message [UnixLabels] | Return a string describing the given error code. |
error_message [Unix] | Return a string describing the given error code. |
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] | |
escaped [String] |
|
escaped [StringLabels] |
|
escaped [Char] | Return a string representing the given character, with special characters escaped following the lexical conventions of OCaml. |
escaped [BytesLabels] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml. |
escaped [Bytes] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml. |
establish_server [UnixLabels] | Establish a server on the given address. |
establish_server [Unix] | Establish a server on the given address. |
eval [Ast_helper.Str] | |
eventlog_pause [Gc] |
|
eventlog_resume [Gc] |
|
exception_ [Ast_helper.Str] | |
exception_ [Ast_helper.Sig] | |
exception_ [Ast_helper.Pat] | |
exchange [Atomic] | Set a new value for the atomic reference, and return the current value. |
exchange [CamlinternalAtomic] | |
exec_magic_number [Config] | Magic number for bytecode executable files |
executable_name [Sys] | The name of the file containing the executable currently running. |
execv [ThreadUnix] | |
execv [UnixLabels] |
|
execv [Unix] |
|
execve [ThreadUnix] | |
execve [UnixLabels] | Same as |
execve [Unix] | Same as |
execvp [ThreadUnix] | |
execvp [UnixLabels] | Same as |
execvp [Unix] | Same as |
execvpe [UnixLabels] | Same as |
execvpe [Unix] | Same as |
exists [Set.S] |
|
exists [MoreLabels.Set.S] |
|
exists [MoreLabels.Map.S] |
|
exists [Map.S] |
|
exists [ListLabels] |
|
exists [List] |
|
exists [Float.ArrayLabels] |
|
exists [Float.Array] |
|
exists [ArrayLabels] |
|
exists [Array] |
|
exists2 [Misc.Stdlib.Array] | |
exists2 [ListLabels] | Same as |
exists2 [List] | Same as |
exists2 [ArrayLabels] | Same as |
exists2 [Array] | Same as |
exit [Thread] | Terminate prematurely the currently executing thread. |
exit [Stdlib] | Terminate the process, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure. |
exn_slot_id [Printexc] |
|
exn_slot_name [Printexc] |
|
exp [Float] | Exponential. |
exp [Complex] | Exponentiation. |
exp [Stdlib] | Exponential. |
expand_directory [Misc] | |
expand_libname [Ccomp] | |
explain_parse_error [Misc.Magic_number] | Produces an explanation for a parse error. |
explain_unexpected_error [Misc.Magic_number] | Provides an explanation of the |
explicit_arity [Builtin_attributes] | |
expm1 [Float] |
|
expm1 [Stdlib] |
|
expression [Printast] | |
expression [Pprintast] | |
expression [Parse] | |
ext_asm [Config] | Extension for assembler files, e.g. |
ext_dll [Config] | Extension for dynamically-loaded libraries, e.g. |
ext_exe [Config] | Extension for executable programs, e.g. |
ext_lib [Config] | Extension for library files, e.g. |
ext_obj [Config] | Extension for object files, e.g. |
extend [BytesLabels] |
|
extend [Bytes] |
|
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 [Filename] |
|
extension_constructor [Obj] | |
extension_id [Obj] | |
extension_name [Obj] | |
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] |
|
extract [Consistbl.Make] | |
extract_map [Consistbl.Make] | |
F | |
failwith [Stdlib] | Raise exception |
fast_sort [ListLabels] | Same as |
fast_sort [List] | Same as |
fast_sort [Float.ArrayLabels] | Same as |
fast_sort [Float.Array] | Same as |
fast_sort [ArrayLabels] | Same as |
fast_sort [Array] | Same as |
fatal_error [Misc] | |
fatal_errorf [Misc] | |
fchmod [UnixLabels] | Change the permissions of an opened file. |
fchmod [Unix] | Change the permissions of an opened file. |
fchown [UnixLabels] | Change the owner uid and owner gid of an opened file. |
fchown [Unix] | Change the owner uid and owner gid of an opened file. |
feed [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
fetch_and_add [Atomic] |
|
fetch_and_add [CamlinternalAtomic] | |
field [Ast_helper.Type] | |
field [Ast_helper.Exp] | |
field [Obj] | |
file [Pparse] | |
file [Digest] | Return the digest of the file whose name is given. |
file_exists [Sys] | Test if a file with the given name exists. |
files [Load_path.Dir] | All the files in that directory. |
fill [Weak] |
|
fill [String] |
|
fill [StringLabels] |
|
fill [Float.ArrayLabels] |
|
fill [Float.Array] |
|
fill [BytesLabels] |
|
fill [Bytes] |
|
fill [Bigarray.Array3] | Fill the given Bigarray with the given value. |
fill [Bigarray.Array2] | Fill the given Bigarray with the given value. |
fill [Bigarray.Array1] | Fill the given Bigarray with the given value. |
fill [Bigarray.Array0] | Fill the given Bigarray with the given value. |
fill [Bigarray.Genarray] | Set all elements of a Bigarray to a given value. |
fill [ArrayLabels] |
|
fill [Array] |
|
filter [Consistbl.Make] | |
filter [Set.S] |
|
filter [Seq] | Remove from the sequence the elements that do not satisfy the given predicate. |
filter [MoreLabels.Set.S] |
|
filter [MoreLabels.Map.S] |
|
filter [Map.S] |
|
filter [ListLabels] |
|
filter [List] |
|
filter_map [Set.S] |
|
filter_map [Seq] | Apply the function to every element; if |
filter_map [MoreLabels.Set.S] |
|
filter_map [MoreLabels.Map.S] |
|
filter_map [Map.S] |
|
filter_map [ListLabels] |
|
filter_map [List] |
|
filter_map_inplace [MoreLabels.Hashtbl.SeededS] | |
filter_map_inplace [MoreLabels.Hashtbl.S] | |
filter_map_inplace [MoreLabels.Hashtbl] |
|
filter_map_inplace [Hashtbl.SeededS] | |
filter_map_inplace [Hashtbl.S] | |
filter_map_inplace [Hashtbl] |
|
filteri [ListLabels] | Same as |
filteri [List] | Same as |
final_tag [Obj] | |
finalise [Gc] |
|
finalise_last [Gc] | same as |
finalise_release [Gc] | A finalisation function may call |
find [Load_path] | Locate a file in the load path. |
find [Weak.S] |
|
find [Set.S] |
|
find [MoreLabels.Set.S] |
|
find [MoreLabels.Map.S] |
|
find [MoreLabels.Hashtbl.SeededS] | |
find [MoreLabels.Hashtbl.S] | |
find [MoreLabels.Hashtbl] |
|
find [Map.S] |
|
find [ListLabels] |
|
find [List] |
|
find [Hashtbl.SeededS] | |
find [Hashtbl.S] | |
find [Hashtbl] |
|
find_all [Weak.S] |
|
find_all [MoreLabels.Hashtbl.SeededS] | |
find_all [MoreLabels.Hashtbl.S] | |
find_all [MoreLabels.Hashtbl] |
|
find_all [ListLabels] |
|
find_all [List] |
|
find_all [Hashtbl.SeededS] | |
find_all [Hashtbl.S] | |
find_all [Hashtbl] |
|
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 [Set.S] |
|
find_first [MoreLabels.Set.S] |
|
find_first [MoreLabels.Map.S] |
|
find_first [Map.S] |
|
find_first_opt [Set.S] |
|
find_first_opt [MoreLabels.Set.S] |
|
find_first_opt [MoreLabels.Map.S] |
|
find_first_opt [Map.S] |
|
find_in_path [Misc] | |
find_in_path_rel [Misc] | |
find_in_path_uncap [Misc] | |
find_last [Set.S] |
|
find_last [MoreLabels.Set.S] |
|
find_last [MoreLabels.Map.S] |
|
find_last [Map.S] |
|
find_last_opt [Set.S] |
|
find_last_opt [MoreLabels.Set.S] |
|
find_last_opt [MoreLabels.Map.S] |
|
find_last_opt [Map.S] |
|
find_left [Either] |
|
find_map [ListLabels] |
|
find_map [List] |
|
find_opt [Weak.S] |
|
find_opt [Set.S] |
|
find_opt [MoreLabels.Set.S] |
|
find_opt [MoreLabels.Map.S] |
|
find_opt [MoreLabels.Hashtbl.SeededS] | |
find_opt [MoreLabels.Hashtbl.S] | |
find_opt [MoreLabels.Hashtbl] |
|
find_opt [Map.S] |
|
find_opt [ListLabels] |
|
find_opt [List] |
|
find_opt [Hashtbl.SeededS] | |
find_opt [Hashtbl.S] | |
find_opt [Hashtbl] |
|
find_production [CamlinternalMenhirLib.EngineTypes.TABLE] | |
find_production [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
find_right [Either] |
|
find_uncap [Load_path] | Same as |
first [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
first [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
first_chars [Str] |
|
first_non_constant_constructor_tag [Obj] | |
flambda [Config] | 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_map [Seq] | Map each element to a subsequence, then return each element of this sub-sequence in turn. |
flatten [Longident] | |
flatten [ListLabels] | Same as |
flatten [List] | Same as |
flexdll_dirs [Config] | Directories needed for the FlexDLL objects |
flip [Fun] |
|
float [Ast_helper.Const] | |
float [Random.State] | |
float [Random] |
|
float [Stdlib] | Same as |
float32 [Bigarray] | See |
float64 [Bigarray] | See |
float_const_prop [Clflags] | |
float_of_bits [Int64] | Return the floating-point number whose internal representation,
according to the IEEE 754 floating-point 'double format' bit layout,
is the given |
float_of_bits [Int32] | Return the floating-point number whose internal representation,
according to the IEEE 754 floating-point 'single format' bit layout,
is the given |
float_of_int [Stdlib] | Convert an integer to floating-point. |
float_of_string [Stdlib] | Same as |
float_of_string_opt [Stdlib] | Convert the given string to a float. |
floor [Float] | Round below to an integer value. |
floor [Stdlib] | Round below to an integer value. |
flush [Stdlib] | Flush the buffer associated with the given output channel, performing all pending writes on that channel. |
flush_all [Stdlib] | Flush all open output channels; ignore errors. |
flush_input [Lexing] | Discard the contents of the buffer and reset the current position to 0. |
flush_str_formatter [Format] | Returns the material printed with |
flush_symbolic_output_buffer [Format] |
|
fma [Float] |
|
fmt_ebb_of_string [CamlinternalFormat] | |
fold [Weak.S] |
|
fold [Stack] |
|
fold [Set.S] |
|
fold [Result] |
|
fold [Queue] |
|
fold [Option] |
|
fold [MoreLabels.Set.S] |
|
fold [MoreLabels.Map.S] |
|
fold [MoreLabels.Hashtbl.SeededS] | |
fold [MoreLabels.Hashtbl.S] | |
fold [MoreLabels.Hashtbl] |
|
fold [Map.S] |
|
fold [Hashtbl.SeededS] | |
fold [Hashtbl.S] | |
fold [Hashtbl] |
|
fold [Either] |
|
fold_left [Seq] | Traverse the sequence from left to right, combining each element with the accumulator using the given function. |
fold_left [ListLabels] |
|
fold_left [List] |
|
fold_left [Float.ArrayLabels] |
|
fold_left [Float.Array] |
|
fold_left [ArrayLabels] |
|
fold_left [Array] |
|
fold_left2 [ListLabels] |
|
fold_left2 [List] |
|
fold_left_map [ListLabels] |
|
fold_left_map [List] |
|
fold_right [ListLabels] |
|
fold_right [List] |
|
fold_right [Float.ArrayLabels] |
|
fold_right [Float.Array] |
|
fold_right [ArrayLabels] |
|
fold_right [Array] |
|
fold_right2 [ListLabels] |
|
fold_right2 [List] |
|
foldr [CamlinternalMenhirLib.General] | |
for4 [Misc] | |
for_ [Ast_helper.Exp] | |
for_all [Misc.Stdlib.String] | |
for_all [Set.S] |
|
for_all [MoreLabels.Set.S] |
|
for_all [MoreLabels.Map.S] |
|
for_all [Map.S] |
|
for_all [ListLabels] |
|
for_all [List] |
|
for_all [Float.ArrayLabels] |
|
for_all [Float.Array] |
|
for_all [Either] |
|
for_all [ArrayLabels] |
|
for_all [Array] |
|
for_all2 [Misc] | |
for_all2 [ListLabels] | Same as |
for_all2 [List] | Same as |
for_all2 [ArrayLabels] | Same as |
for_all2 [Array] | Same as |
for_alli [Misc.Stdlib.Array] | Same as |
for_package [Clflags] | |
force [Misc.EnvLazy] | |
force [CamlinternalLazy] | |
force [Lazy] |
|
force_lazy_block [CamlinternalLazy] | |
force_logged [Misc.EnvLazy] | |
force_newline [Format] | Force a new line in the current pretty-printing box. |
force_poly [Ast_helper.Typ] | |
force_reduction [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
force_slash [Clflags] | |
force_val [CamlinternalLazy] | |
force_val [Lazy] |
|
force_val_lazy_block [CamlinternalLazy] | |
foreach_terminal [CamlinternalMenhirLib.EngineTypes.TABLE] | |
foreach_terminal [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
foreach_terminal_but_error [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
fork [UnixLabels] | Fork a new process. |
fork [Unix] | Fork a new process. |
format [Printexc.Slot] |
|
format_from_string [Scanf] |
|
format_of_string [Stdlib] |
|
format_of_string_fmtty [CamlinternalFormat] | |
format_of_string_format [CamlinternalFormat] | |
formatter_for_warnings [Location] | |
formatter_of_buffer [Format] |
|
formatter_of_out_channel [Format] |
|
formatter_of_out_functions [Format] |
|
formatter_of_symbolic_output_buffer [Format] |
|
fortran_layout [Bigarray] | |
forward_tag [Obj] | |
fprintf [Printf] |
|
fprintf [Format] | |
free_structure_names [Depend] | |
freeze_char_set [CamlinternalFormat] | |
fresh [Local_store] | Returns a fresh instance of the store. |
frexp [Float] |
|
frexp [Stdlib] |
|
from [Stream] |
|
from_bytes [Marshal] |
|
from_channel [Scanf.Scanning] |
|
from_channel [Marshal] |
|
from_channel [Lexing] | Create a lexer buffer on the given input channel. |
from_file [Scanf.Scanning] | An alias for |
from_file_bin [Scanf.Scanning] | An alias for |
from_fun [Lazy] |
|
from_function [Scanf.Scanning] |
|
from_function [Lexing] | Create a lexer buffer with the given function as its reading method. |
from_hex [Digest] | Convert a hexadecimal representation back into the corresponding digest. |
from_string [Scanf.Scanning] |
|
from_string [Marshal] | Same as |
from_string [Lexing] | Create a lexer buffer which reads from the given string. |
from_val [Lazy] |
|
fscanf [Scanf] | |
fst [Stdlib] | Return the first component of a pair. |
fst3 [Misc] | |
fst4 [Misc] | |
fstat [UnixLabels.LargeFile] | |
fstat [UnixLabels] | Return the information for the file associated with the given descriptor. |
fstat [Unix.LargeFile] | |
fstat [Unix] | Return the information for the file associated with the given descriptor. |
fsync [UnixLabels] | Flush file buffers to disk. |
fsync [Unix] | Flush file buffers to disk. |
ftruncate [UnixLabels.LargeFile] | See |
ftruncate [UnixLabels] | Truncates the file corresponding to the given descriptor to the given size. |
ftruncate [Unix.LargeFile] | See |
ftruncate [Unix] | Truncates the file corresponding to the given descriptor to the given size. |
full_init [Random] | Same as |
full_major [Gc] | Do a minor collection, finish the current major collection cycle, and perform a complete new cycle. |
full_split [Str] | Same as |
fun_ [Ast_helper.Cl] | |
fun_ [Ast_helper.Exp] | |
function_ [Ast_helper.Exp] | |
function_sections [Config] | 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 | |
genarray_of_array0 [Bigarray] | Return the generic Bigarray corresponding to the given zero-dimensional Bigarray. |
genarray_of_array1 [Bigarray] | Return the generic Bigarray corresponding to the given one-dimensional Bigarray. |
genarray_of_array2 [Bigarray] | Return the generic Bigarray corresponding to the given two-dimensional Bigarray. |
genarray_of_array3 [Bigarray] | Return the generic Bigarray corresponding to the given three-dimensional Bigarray. |
generate [Profile] | |
get [Misc.LongString] | |
get [Load_path] | Same as |
get [Clflags.Float_arg_helper] | |
get [Clflags.Int_arg_helper] | |
get [Arg_helper.Make] | |
get [CamlinternalMenhirLib.RowDisplacement] | |
get [CamlinternalMenhirLib.PackedIntArray] | |
get [CamlinternalMenhirLib.InfiniteArray] |
|
get [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
get [Weak] |
|
get [String] |
|
get [StringLabels] |
|
get [Option] |
|
get [Gc] | Return the current values of the GC parameters in a |
get [Float.ArrayLabels] |
|
get [Float.Array] |
|
get [BytesLabels] |
|
get [Bytes] |
|
get [Bigarray.Array3] |
|
get [Bigarray.Array2] |
|
get [Bigarray.Array1] |
|
get [Bigarray.Array0] |
|
get [Bigarray.Genarray] | Read an element of a generic Bigarray. |
get [Atomic] | Get the current value of the atomic reference. |
get [ArrayLabels] |
|
get [Array] |
|
get [CamlinternalAtomic] | |
get1 [CamlinternalMenhirLib.PackedIntArray] | |
get_all_formatter_output_functions [Format] | |
get_arg [Misc.EnvLazy] | |
get_backtrace [Printexc] |
|
get_bucket [Gc] |
|
get_build_path_prefix_map [Misc] | Returns the map encoded in the |
get_callstack [Printexc] |
|
get_cookie [Ast_mapper] | |
get_copy [Weak] |
|
get_credit [Gc] |
|
get_data [Obj.Ephemeron] | Same as |
get_data [Ephemeron.Kn] | Same as |
get_data [Ephemeron.K2] | Same as |
get_data [Ephemeron.K1] |
|
get_data_copy [Obj.Ephemeron] | Same as |
get_data_copy [Ephemeron.Kn] | Same as |
get_data_copy [Ephemeron.K2] | Same as |
get_data_copy [Ephemeron.K1] |
|
get_ellipsis_text [Format] | Return the text of the ellipsis. |
get_error [Result] |
|
get_formatter_out_functions [Format] | Return the current output functions of the pretty-printer, including line splitting and indentation functions. |
get_formatter_output_functions [Format] | Return the current output functions of the standard pretty-printer. |
get_formatter_stag_functions [Format] | Return the current semantic tag operation functions of the standard pretty-printer. |
get_formatter_tag_functions [Format] | |
get_geometry [Format] | Return the current geometry of the formatter |
get_int16_be [BytesLabels] |
|
get_int16_be [Bytes] |
|
get_int16_le [BytesLabels] |
|
get_int16_le [Bytes] |
|
get_int16_ne [BytesLabels] |
|
get_int16_ne [Bytes] |
|
get_int32_be [BytesLabels] |
|
get_int32_be [Bytes] |
|
get_int32_le [BytesLabels] |
|
get_int32_le [Bytes] |
|
get_int32_ne [BytesLabels] |
|
get_int32_ne [Bytes] |
|
get_int64_be [BytesLabels] |
|
get_int64_be [Bytes] |
|
get_int64_le [BytesLabels] |
|
get_int64_le [Bytes] |
|
get_int64_ne [BytesLabels] |
|
get_int64_ne [Bytes] |
|
get_int8 [BytesLabels] |
|
get_int8 [Bytes] |
|
get_key [Obj.Ephemeron] | Same as |
get_key [Ephemeron.Kn] | Same as |
get_key [Ephemeron.K1] |
|
get_key1 [Ephemeron.K2] | Same as |
get_key1_copy [Ephemeron.K2] | Same as |
get_key2 [Ephemeron.K2] | Same as |
get_key2_copy [Ephemeron.K2] | Same as |
get_key_copy [Obj.Ephemeron] | Same as |
get_key_copy [Ephemeron.Kn] | Same as |
get_key_copy [Ephemeron.K1] |
|
get_margin [Format] | Returns the position of the right margin. |
get_mark_tags [Format] | Return the current status of tag-marking operations. |
get_max_boxes [Format] | Returns the maximum number of pretty-printing boxes allowed before ellipsis. |
get_max_indent [Format] | Return the maximum indentation limit (in characters). |
get_method [CamlinternalOO] | |
get_method_label [CamlinternalOO] | |
get_method_labels [CamlinternalOO] | |
get_minor_free [Gc] | Return the current size of the free space inside the minor heap. |
get_no_payload_attribute [Attr_helper] | The |
get_ok [Result] |
|
get_paths [Load_path] | Return the list of directories passed to |
get_pos_info [Location] | file, line, char |
get_print_tags [Format] | Return the current status of tag-printing operations. |
get_public_method [CamlinternalOO] | |
get_raw_backtrace [Printexc] |
|
get_raw_backtrace_next_slot [Printexc] |
|
get_raw_backtrace_slot [Printexc] |
|
get_ref [Misc] | |
get_state [Random] | Return the current state of the generator used by the basic functions. |
get_styles [Misc.Color] | |
get_symbolic_output_buffer [Format] |
|
get_temp_dir_name [Filename] | The name of the temporary directory:
Under Unix, the value of the |
get_uint16_be [BytesLabels] |
|
get_uint16_be [Bytes] |
|
get_uint16_le [BytesLabels] |
|
get_uint16_le [Bytes] |
|
get_uint16_ne [BytesLabels] |
|
get_uint16_ne [Bytes] |
|
get_uint8 [BytesLabels] |
|
get_uint8 [Bytes] |
|
get_value [Semaphore.Counting] |
|
get_variable [CamlinternalOO] | |
get_variables [CamlinternalOO] | |
getaddrinfo [UnixLabels] |
|
getaddrinfo [Unix] |
|
getcwd [UnixLabels] | Return the name of the current working directory. |
getcwd [Unix] | Return the name of the current working directory. |
getcwd [Sys] | Return the current working directory of the process. |
getegid [UnixLabels] | Return the effective group id under which the process runs. |
getegid [Unix] | Return the effective group id under which the process runs. |
getenv [UnixLabels] | Return the value associated to a variable in the process environment, unless the process has special privileges. |
getenv [Unix] | Return the value associated to a variable in the process environment, unless the process has special privileges. |
getenv [Sys] | Return the value associated to a variable in the process environment. |
getenv_opt [Sys] | Return the value associated to a variable in the process
environment or |
geteuid [UnixLabels] | Return the effective user id under which the process runs. |
geteuid [Unix] | Return the effective user id under which the process runs. |
getget [CamlinternalMenhirLib.RowDisplacement] | |
getgid [UnixLabels] | Return the group id of the user executing the process. |
getgid [Unix] | Return the group id of the user executing the process. |
getgrgid [UnixLabels] | Find an entry in |
getgrgid [Unix] | Find an entry in |
getgrnam [UnixLabels] | Find an entry in |
getgrnam [Unix] | Find an entry in |
getgroups [UnixLabels] | Return the list of groups to which the user executing the process belongs. |
getgroups [Unix] | Return the list of groups to which the user executing the process belongs. |
gethostbyaddr [UnixLabels] | Find an entry in |
gethostbyaddr [Unix] | Find an entry in |
gethostbyname [UnixLabels] | Find an entry in |
gethostbyname [Unix] | Find an entry in |
gethostname [UnixLabels] | Return the name of the local host. |
gethostname [Unix] | Return the name of the local host. |
getitimer [UnixLabels] | Return the current status of the given interval timer. |
getitimer [Unix] | Return the current status of the given interval timer. |
getlogin [UnixLabels] | Return the login name of the user executing the process. |
getlogin [Unix] | Return the login name of the user executing the process. |
getnameinfo [UnixLabels] |
|
getnameinfo [Unix] |
|
getpeername [UnixLabels] | Return the address of the host connected to the given socket. |
getpeername [Unix] | Return the address of the host connected to the given socket. |
getpid [UnixLabels] | Return the pid of the process. |
getpid [Unix] | Return the pid of the process. |
getppid [UnixLabels] | Return the pid of the parent process. |
getppid [Unix] | Return the pid of the parent process. |
getprotobyname [UnixLabels] | Find an entry in |
getprotobyname [Unix] | Find an entry in |
getprotobynumber [UnixLabels] | Find an entry in |
getprotobynumber [Unix] | Find an entry in |
getpwnam [UnixLabels] | Find an entry in |
getpwnam [Unix] | Find an entry in |
getpwuid [UnixLabels] | Find an entry in |
getpwuid [Unix] | Find an entry in |
getservbyname [UnixLabels] | Find an entry in |
getservbyname [Unix] | Find an entry in |
getservbyport [UnixLabels] | Find an entry in |
getservbyport [Unix] | Find an entry in |
getsockname [UnixLabels] | Return the address of the given socket. |
getsockname [Unix] | Return the address of the given socket. |
getsockopt [UnixLabels] | Return the current status of a boolean-valued option in the given socket. |
getsockopt [Unix] | Return the current status of a boolean-valued option in the given socket. |
getsockopt_error [UnixLabels] | Return the error condition associated with the given socket, and clear it. |
getsockopt_error [Unix] | Return the error condition associated with the given socket, and clear it. |
getsockopt_float [UnixLabels] | Same as |
getsockopt_float [Unix] | Same as |
getsockopt_int [UnixLabels] | Same as |
getsockopt_int [Unix] | Same as |
getsockopt_optint [UnixLabels] | Same as |
getsockopt_optint [Unix] | Same as |
gettimeofday [UnixLabels] | Same as |
gettimeofday [Unix] | Same as |
getuid [UnixLabels] | Return the user id of the user executing the process. |
getuid [Unix] | Return the user id of the user executing the process. |
global_replace [Str] |
|
global_substitute [Str] |
|
gmtime [UnixLabels] | Convert a time in seconds, as returned by |
gmtime [Unix] | Convert a time in seconds, as returned by |
goto [CamlinternalMenhirLib.TableFormat.TABLES] | |
goto_nt [CamlinternalMenhirLib.EngineTypes.TABLE] | |
goto_prod [CamlinternalMenhirLib.EngineTypes.TABLE] | |
group_beginning [Str] |
|
group_end [Str] |
|
guard [Event] |
|
H | |
handle_docstrings [Lexer] | |
handle_unix_error [UnixLabels] |
|
handle_unix_error [Unix] |
|
handling_error [CamlinternalMenhirLib.EngineTypes.TABLE.Log] | |
has_boxed [Builtin_attributes] | |
has_no_payload_attribute [Attr_helper] | |
has_symlink [UnixLabels] | Returns |
has_symlink [Unix] | Returns |
has_unboxed [Builtin_attributes] | |
hash [Uchar] |
|
hash [MoreLabels.Hashtbl.SeededHashedType] | A seeded hashing function on keys. |
hash [MoreLabels.Hashtbl.HashedType] | A hashing function on keys. |
hash [MoreLabels.Hashtbl] |
|
hash [Hashtbl.SeededHashedType] | A seeded hashing function on keys. |
hash [Hashtbl.HashedType] | A hashing function on keys. |
hash [Hashtbl] |
|
hash [Float] | The hash function for floating-point numbers. |
hash_param [MoreLabels.Hashtbl] |
|
hash_param [Hashtbl] |
|
hd [ListLabels] | Return the first element of the given list. |
hd [List] | Return the first element of the given list. |
header_size [Marshal] | The bytes representing a marshaled value are composed of a fixed-size header and a variable-sized data part, whose size can be determined from the header. |
help_warnings [Warnings] | |
highlight_terminfo [Location] | |
host [Config] | Whether the compiler is a cross-compiler |
huge_fallback_count [Gc] | Return the number of times we tried to map huge pages and had to fall back to small pages. |
human_name_of_kind [Misc.Magic_number] | a user-meaningful name for a kind, eg. |
hypot [Float] |
|
hypot [Stdlib] |
|
I | |
i [Complex] | The complex number |
ibprintf [Printf] | Same as |
id [Thread] | Return the identifier of the given thread. |
id [Oo] | Return an integer identifying this object, unique for the current execution of the program. |
id [Obj.Extension_constructor] | |
id [Fun] |
|
ident [Ast_helper.Mod] | |
ident [Ast_helper.Mty] | |
ident [Ast_helper.Exp] | |
idx_of_field [Domainstate] | |
ifprintf [Printf] | Same as |
ifprintf [Format] | Same as |
ifthenelse [Ast_helper.Exp] | |
ignore [Stdlib] | Discard the value of its argument and return |
ikbprintf [Printf] | Same as |
ikfprintf [Printf] | Same as |
ikfprintf [Format] | Same as |
ill_formed_ast [Syntaxerr] | |
immediate [Builtin_attributes] | |
immediate64 [Builtin_attributes] | |
implementation [Printast] | |
implementation [Parser.Incremental] | |
implementation [Parser] | |
implementation [Parse] | |
in_channel_length [Stdlib.LargeFile] | |
in_channel_length [Stdlib] | Return the size (number of characters) of the regular file on which the given channel is opened. |
in_channel_of_descr [UnixLabels] | Create an input channel reading from the given descriptor. |
in_channel_of_descr [Unix] | Create an input channel reading from the given descriptor. |
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] | |
incr [Atomic] |
|
incr [Stdlib] | Increment the integer contained in the given reference. |
incr [CamlinternalAtomic] | |
index [String] |
|
index [StringLabels] |
|
index [BytesLabels] |
|
index [Bytes] |
|
index_from [String] |
|
index_from [StringLabels] |
|
index_from [BytesLabels] |
|
index_from [Bytes] |
|
index_from_opt [String] |
|
index_from_opt [StringLabels] |
|
index_from_opt [BytesLabels] |
|
index_from_opt [Bytes] |
|
index_opt [String] |
|
index_opt [StringLabels] |
|
index_opt [BytesLabels] |
|
index_opt [Bytes] |
|
inet6_addr_any [UnixLabels] | A special IPv6 address, for use only with |
inet6_addr_any [Unix] | A special IPv6 address, for use only with |
inet6_addr_loopback [UnixLabels] | A special IPv6 address representing the host machine ( |
inet6_addr_loopback [Unix] | A special IPv6 address representing the host machine ( |
inet_addr_any [UnixLabels] | A special IPv4 address, for use only with |
inet_addr_any [Unix] | A special IPv4 address, for use only with |
inet_addr_loopback [UnixLabels] | A special IPv4 address representing the host machine ( |
inet_addr_loopback [Unix] | A special IPv4 address representing the host machine ( |
inet_addr_of_string [UnixLabels] | Conversion from the printable representation of an Internet address to its internal representation. |
inet_addr_of_string [Unix] | Conversion from the printable representation of an Internet address to its internal representation. |
infinity [Float] | Positive infinity. |
infinity [Stdlib] | Positive infinity. |
infix_tag [Obj] | |
info [Obj.Closure] | |
info_attr [Docstrings] | |
inherit_ [Ast_helper.Of] | |
inherit_ [Ast_helper.Rf] | |
inherit_ [Ast_helper.Cf] | |
inherit_ [Ast_helper.Ctf] | |
inherits [CamlinternalOO] | |
init [Load_path] |
|
init [Location] | Set the file name and line number of the |
init [Lexer] | |
init [Docstrings] | (Re)Initialise all docstring state |
init [String] |
|
init [StringLabels] |
|
init [Random] | Initialize the generator, using the argument as a seed. |
init [ListLabels] |
|
init [List] |
|
init [Float.ArrayLabels] |
|
init [Float.Array] |
|
init [BytesLabels] |
|
init [Bytes] |
|
init [Bigarray.Array3] |
|
init [Bigarray.Array2] |
|
init [Bigarray.Array1] |
|
init [Bigarray.Array0] |
|
init [Bigarray.Genarray] |
|
init [ArrayLabels] |
|
init [Array] |
|
init_class [CamlinternalOO] | |
init_file [Clflags] | |
init_mod [CamlinternalMod] | |
initgroups [UnixLabels] |
|
initgroups [Unix] |
|
initializer_ [Ast_helper.Cf] | |
initiating_error_handling [CamlinternalMenhirLib.EngineTypes.TABLE.Log] | |
inline_alloc_cost [Clflags] | |
inline_branch_cost [Clflags] | |
inline_branch_factor [Clflags] | |
inline_call_cost [Clflags] | |
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 [Digest] | Read a digest from the given input channel. |
input [Stdlib] |
|
input_binary_int [Stdlib] | Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. |
input_byte [Stdlib] | Same as |
input_bytes [Misc.LongString] | |
input_bytes_into [Misc.LongString] | |
input_char [Stdlib] | Read one character from the given input channel. |
input_lexbuf [Location] | |
input_line [Stdlib] | Read characters from the given input channel, until a newline character is encountered. |
input_name [Location] | |
input_needed [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
input_phrase_buffer [Location] | |
input_value [Stdlib] | Read the representation of a structured value, as produced
by |
insn_sched [Clflags] | |
insn_sched_default [Clflags] | |
int [Misc.Int_literal_converter] | |
int [Ast_helper.Const] | |
int [Random.State] | |
int [Random] |
|
int [Bigarray] | See |
int16_signed [Bigarray] | See |
int16_unsigned [Bigarray] | See |
int32 [Misc.Int_literal_converter] | |
int32 [Ast_helper.Const] | |
int32 [Random.State] | |
int32 [Random] |
|
int32 [Bigarray] | See |
int64 [Misc.Int_literal_converter] | |
int64 [Ast_helper.Const] | |
int64 [Random.State] | |
int64 [Random] |
|
int64 [Bigarray] | See |
int8_signed [Bigarray] | See |
int8_unsigned [Bigarray] | See |
int_of_char [Stdlib] | Return the ASCII code of the argument. |
int_of_float [Stdlib] | Truncate the given floating-point number to an integer. |
int_of_string [Stdlib] | Same as |
int_of_string_opt [Stdlib] | Convert the given string to an integer. |
int_size [Sys] | Size of |
int_tag [Obj] | |
integer [Ast_helper.Const] | |
inter [Set.S] | Set intersection. |
inter [MoreLabels.Set.S] | Set intersection. |
interactive [Sys] | This reference is initially set to |
interface [Printast] | |
interface [Parser.Incremental] | |
interface [Parser] | |
interface [Parse] | |
interface_suffix [Config] | Suffix for interface file names |
interval [Ast_helper.Pat] | |
inv [Complex] | Multiplicative inverse ( |
invalid_arg [Stdlib] | Raise exception |
is_active [Warnings] | |
is_block [Obj] | |
is_bound [Local_store] | Returns |
is_char [Uchar] |
|
is_compilation_pass [Clflags.Compiler_pass] | |
is_directory [Sys] | Returns |
is_empty [Stack] | Return |
is_empty [Set.S] | Test whether a set is empty or not. |
is_empty [Queue] | Return |
is_empty [MoreLabels.Set.S] | Test whether a set is empty or not. |
is_empty [MoreLabels.Map.S] | Test whether a map is empty or not. |
is_empty [Map.S] | Test whether a map is empty or not. |
is_error [Warnings] | |
is_error [Result] |
|
is_finite [Float] |
|
is_implicit [Filename] | Return |
is_in_char_set [CamlinternalFormat] | |
is_inet6_addr [UnixLabels] | Whether the given |
is_inet6_addr [Unix] | Whether the given |
is_infinite [Float] |
|
is_inline [Printexc.Slot] |
|
is_int [Obj] | |
is_integer [Float] |
|
is_left [Either] |
|
is_nan [Float] |
|
is_native [Dynlink] |
|
is_none [Location] | True for |
is_none [Option] |
|
is_ok [Result] |
|
is_prefix [Misc.Stdlib.List] | Returns |
is_raise [Printexc.Slot] |
|
is_randomized [MoreLabels.Hashtbl] | Return |
is_randomized [Hashtbl] | Return |
is_relative [Filename] | Return |
is_right [Either] |
|
is_some [Option] |
|
is_start [CamlinternalMenhirLib.EngineTypes.TABLE] | |
is_val [Lazy] |
|
is_valid [Uchar] |
|
isatty [UnixLabels] | Return |
isatty [Unix] | Return |
items [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
iter [Weak.S] |
|
iter [String] |
|
iter [Stream] |
|
iter [StringLabels] |
|
iter [Stack] |
|
iter [Set.S] |
|
iter [Seq] | Iterate on the sequence, calling the (imperative) function on every element. |
iter [Result] |
|
iter [Queue] |
|
iter [Option] |
|
iter [MoreLabels.Set.S] |
|
iter [MoreLabels.Map.S] |
|
iter [MoreLabels.Hashtbl.SeededS] | |
iter [MoreLabels.Hashtbl.S] | |
iter [MoreLabels.Hashtbl] |
|
iter [Map.S] |
|
iter [ListLabels] |
|
iter [List] |
|
iter [Hashtbl.SeededS] | |
iter [Hashtbl.S] | |
iter [Hashtbl] |
|
iter [Float.ArrayLabels] |
|
iter [Float.Array] |
|
iter [Either] |
|
iter [BytesLabels] |
|
iter [Bytes] |
|
iter [ArrayLabels] |
|
iter [Array] |
|
iter2 [ListLabels] |
|
iter2 [List] |
|
iter2 [Float.ArrayLabels] |
|
iter2 [Float.Array] |
|
iter2 [ArrayLabels] |
|
iter2 [Array] |
|
iter_error [Result] |
|
iteri [String] |
|
iteri [StringLabels] |
|
iteri [ListLabels] | Same as |
iteri [List] | Same as |
iteri [Float.ArrayLabels] | Same as |
iteri [Float.Array] | Same as |
iteri [BytesLabels] | Same as |
iteri [Bytes] | Same as |
iteri [ArrayLabels] | Same as |
iteri [Array] | Same as |
J | |
join [Thread] |
|
join [Result] |
|
join [Option] |
|
junk [Stream] | Remove the first element of the stream, possibly unfreezing it before. |
K | |
kasprintf [Format] | Same as |
kbprintf [Printf] | Same as |
kdprintf [Format] | Same as |
keep_asm_file [Clflags] | |
keep_camlprimc_file [Clflags] | |
keep_docs [Clflags] | |
keep_locs [Clflags] | |
keep_startup_file [Clflags] | |
keys [Identifiable.Map] | |
kfprintf [Printf] | Same as |
kfprintf [Format] | Same as |
kfscanf [Scanf] | |
kill [Thread] | This function was supposed to terminate prematurely the thread whose handle is given. |
kill [UnixLabels] |
|
kill [Unix] |
|
kind [Bigarray.Array3] | Return the kind of the given Bigarray. |
kind [Bigarray.Array2] | Return the kind of the given Bigarray. |
kind [Bigarray.Array1] | Return the kind of the given Bigarray. |
kind [Bigarray.Array0] | Return the kind of the given Bigarray. |
kind [Bigarray.Genarray] | Return the kind of the given Bigarray. |
kind_size_in_bytes [Bigarray] |
|
kprintf [Printf] | A deprecated synonym for |
kprintf [Format] | |
kscanf [Scanf] | Same as |
ksprintf [Printf] | Same as |
ksprintf [Format] | Same as |
ksscanf [Scanf] | Same as |
L | |
last [Longident] | |
last [CamlinternalMenhirLib.ErrorReports] | |
last_chars [Str] |
|
last_non_constant_constructor_tag [Obj] | |
layout [Bigarray.Array3] | Return the layout of the given Bigarray. |
layout [Bigarray.Array2] | Return the layout of the given Bigarray. |
layout [Bigarray.Array1] | Return the layout of the given Bigarray. |
layout [Bigarray.Array0] | Return the layout of the given Bigarray. |
layout [Bigarray.Genarray] | Return the layout of the given Bigarray. |
lazy_ [Ast_helper.Exp] | |
lazy_ [Ast_helper.Pat] | |
lazy_from_fun [Lazy] | |
lazy_from_val [Lazy] | |
lazy_is_val [Lazy] | |
lazy_tag [Config] | Normally the same as Obj.lazy_tag. |
lazy_tag [Obj] | |
ldexp [Float] |
|
ldexp [Stdlib] |
|
left [Either] |
|
length [Misc.LongString] | |
length [CamlinternalMenhirLib.LinearizedArray] | |
length [CamlinternalMenhirLib.General] | |
length [Weak] |
|
length [String] |
|
length [StringLabels] |
|
length [Stack] | Return the number of elements in a stack. |
length [Queue] | Return the number of elements in a queue. |
length [Obj.Ephemeron] | return the number of keys |
length [MoreLabels.Hashtbl.SeededS] | |
length [MoreLabels.Hashtbl.S] | |
length [MoreLabels.Hashtbl] |
|
length [ListLabels] | Return the length (number of elements) of the given list. |
length [List] | Return the length (number of elements) of the given list. |
length [Hashtbl.SeededS] | |
length [Hashtbl.S] | |
length [Hashtbl] |
|
length [Float.ArrayLabels] | Return the length (number of elements) of the given floatarray. |
length [Float.Array] | Return the length (number of elements) of the given floatarray. |
length [BytesLabels] | Return the length (number of bytes) of the argument. |
length [Bytes] | Return the length (number of bytes) of the argument. |
length [Buffer] | Return the number of characters currently contained in the buffer. |
length [ArrayLabels] | Return the length (number of elements) of the given array. |
length [Array] | Return the length (number of elements) of the given array. |
let_ [Ast_helper.Cl] | |
let_ [Ast_helper.Exp] | |
letexception [Ast_helper.Exp] | |
letmodule [Ast_helper.Exp] | |
letop [Ast_helper.Exp] | |
lexeme [Lexing] |
|
lexeme_char [Lexing] |
|
lexeme_end [Lexing] |
|
lexeme_end_p [Lexing] | Like |
lexeme_start [Lexing] |
|
lexeme_start_p [Lexing] | Like |
lexer_lexbuf_to_supplier [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
lhs [CamlinternalMenhirLib.TableFormat.TABLES] | |
lhs [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
linear_magic_number [Config] | Magic number for Linear internal representation files |
link [UnixLabels] |
|
link [Unix] |
|
link_everything [Clflags] | |
linker_is_flexlink [Ccomp] | |
list_remove [Misc] | |
listen [UnixLabels] | Set up a socket for receiving connection requests. |
listen [Unix] | Set up a socket for receiving connection requests. |
lnot [Stdlib] | Bitwise logical negation. |
loadfile [Dynlink] | In bytecode: load the given bytecode object file ( |
loadfile_private [Dynlink] | Same as |
localtime [UnixLabels] | Convert a time in seconds, as returned by |
localtime [Unix] | Convert a time in seconds, as returned by |
location [Printexc.Slot] |
|
location_of_error [Syntaxerr] | |
locations [Clflags] | |
lock [Mutex] | Lock the given mutex. |
lockf [UnixLabels] |
|
lockf [Unix] |
|
log [Misc.EnvLazy] | |
log [CamlinternalMenhirLib.EngineTypes.TABLE] | |
log [Float] | Natural logarithm. |
log [Complex] | Natural logarithm (in base |
log [Stdlib] | Natural logarithm. |
log10 [Float] | Base 10 logarithm. |
log10 [Stdlib] | Base 10 logarithm. |
log1p [Float] |
|
log1p [Stdlib] |
|
log2 [Misc] | |
logand [Targetint] | Bitwise logical and. |
logand [Nativeint] | Bitwise logical and. |
logand [Int64] | Bitwise logical and. |
logand [Int32] | Bitwise logical and. |
logand [Int] |
|
lognot [Targetint] | Bitwise logical negation. |
lognot [Nativeint] | Bitwise logical negation. |
lognot [Int64] | Bitwise logical negation. |
lognot [Int32] | Bitwise logical negation. |
lognot [Int] |
|
logor [Targetint] | Bitwise logical or. |
logor [Nativeint] | Bitwise logical or. |
logor [Int64] | Bitwise logical or. |
logor [Int32] | Bitwise logical or. |
logor [Int] |
|
logxor [Targetint] | Bitwise logical exclusive or. |
logxor [Nativeint] | Bitwise logical exclusive or. |
logxor [Int64] | Bitwise logical exclusive or. |
logxor [Int32] | Bitwise logical exclusive or. |
logxor [Int] |
|
longident [Pprintast] | |
longident [Parse] | The function |
lookahead_token [CamlinternalMenhirLib.EngineTypes.TABLE.Log] | |
lookup_tables [CamlinternalOO] | |
loop [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
loop_handle [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
loop_handle_undo [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
lowercase [String] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
lowercase [StringLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
lowercase [Char] | Convert the given character to its equivalent lowercase character, using the ISO Latin-1 (8859-1) character set. |
lowercase [BytesLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
lowercase [Bytes] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
lowercase_ascii [String] |
|
lowercase_ascii [StringLabels] |
|
lowercase_ascii [Char] | Convert the given character to its equivalent lowercase character, using the US-ASCII character set. |
lowercase_ascii [BytesLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set. |
lowercase_ascii [Bytes] | Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set. |
lr0_core [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
lr0_incoming [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
lr0_items [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
lseek [UnixLabels.LargeFile] | See |
lseek [UnixLabels] | Set the current position for a file descriptor, and return the resulting offset (from the beginning of the file). |
lseek [Unix.LargeFile] | See |
lseek [Unix] | Set the current position for a file descriptor, and return the resulting offset (from the beginning of the file). |
lstat [UnixLabels.LargeFile] | |
lstat [UnixLabels] | Same as |
lstat [Unix.LargeFile] | |
lstat [Unix] | Same as |
M | |
magic [Obj] | |
magic_length [Misc.Magic_number] | all magic numbers take the same number of bytes |
main_program_units [Dynlink] | Return the list of compilation units that form the main program (i.e. |
major [Gc] | Do a minor collection and finish the current major collection cycle. |
major_slice [Gc] |
|
make [CamlinternalMenhirLib.LinearizedArray] | |
make [CamlinternalMenhirLib.InfiniteArray] |
|
make [Semaphore.Binary] |
|
make [Semaphore.Counting] |
|
make [String] |
|
make [StringLabels] |
|
make [Random.State] | Create a new state and initialize it with the given seed. |
make [Float.ArrayLabels] |
|
make [Float.Array] |
|
make [BytesLabels] |
|
make [Bytes] |
|
make [Atomic] | Create an atomic reference. |
make [ArrayLabels] |
|
make [Array] |
|
make [CamlinternalAtomic] | |
make_archive [Clflags] | |
make_class [CamlinternalOO] | |
make_class_store [CamlinternalOO] | |
make_float [ArrayLabels] | |
make_float [Array] | |
make_formatter [Format] |
|
make_iprintf [CamlinternalFormat] | |
make_leaf [Depend] | |
make_lexer [Genlex] | Construct the lexer function. |
make_matrix [ArrayLabels] |
|
make_matrix [Array] |
|
make_node [Depend] | |
make_package [Clflags] | |
make_printf [CamlinternalFormat] | |
make_runtime [Clflags] | |
make_self_init [Random.State] | Create a new state and initialize it with a system-dependent low-entropy seed. |
make_symbolic_output_buffer [Format] |
|
map [Identifiable.Tbl] | |
map [Identifiable.Set] | |
map [String] |
|
map [StringLabels] |
|
map [Set.S] |
|
map [Seq] |
|
map [Result] |
|
map [Option] |
|
map [MoreLabels.Set.S] |
|
map [MoreLabels.Map.S] |
|
map [Map.S] |
|
map [ListLabels] |
|
map [List] |
|
map [Float.ArrayLabels] |
|
map [Float.Array] |
|
map [Either] |
|
map [BytesLabels] |
|
map [Bytes] |
|
map [ArrayLabels] |
|
map [Array] |
|
map2 [ListLabels] |
|
map2 [List] |
|
map2 [Float.ArrayLabels] |
|
map2 [Float.Array] |
|
map2 [ArrayLabels] |
|
map2 [Array] |
|
map2_prefix [Misc.Stdlib.List] |
|
map_end [Misc] | |
map_error [Result] |
|
map_file [UnixLabels] | Memory mapping of a file as a Bigarray. |
map_file [Unix] | Memory mapping of a file as a Bigarray. |
map_from_array [Float.ArrayLabels] |
|
map_from_array [Float.Array] |
|
map_keys [Identifiable.Map] | |
map_left [Either] |
|
map_left_right [Misc] | |
map_opt [Ast_mapper] | |
map_right [Either] |
|
map_to_array [Float.ArrayLabels] |
|
map_to_array [Float.Array] |
|
mapi [String] |
|
mapi [StringLabels] |
|
mapi [MoreLabels.Map.S] | Same as |
mapi [Map.S] | Same as |
mapi [ListLabels] | Same as |
mapi [List] | Same as |
mapi [Float.ArrayLabels] | Same as |
mapi [Float.Array] | Same as |
mapi [BytesLabels] |
|
mapi [Bytes] |
|
mapi [ArrayLabels] | Same as |
mapi [Array] | Same as |
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). |
marshal [Obj] | |
match_ [Ast_helper.Exp] | |
match_beginning [Str] |
|
match_context_rows [Clflags] | |
match_end [Str] |
|
matched_group [Str] |
|
matched_string [Str] |
|
max [Uchar] |
|
max [Float] |
|
max [Stdlib] | Return the greater of the two arguments. |
max_array_length [Sys] | Maximum length of a normal array (i.e. |
max_binding [MoreLabels.Map.S] | Same as |
max_binding [Map.S] | Same as |
max_binding_opt [MoreLabels.Map.S] | Same as |
max_binding_opt [Map.S] | Same as |
max_elt [Set.S] | Same as |
max_elt [MoreLabels.Set.S] | Same as |
max_elt_opt [Set.S] | Same as |
max_elt_opt [MoreLabels.Set.S] | Same as |
max_ephe_length [Obj.Ephemeron] | Maximum length of an ephemeron, ie the maximum number of keys an ephemeron could contain |
max_float [Float] | The largest positive finite value of type |
max_float [Stdlib] | The largest positive finite value of type |
max_floatarray_length [Sys] | Maximum length of a floatarray. |
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_int [Nativeint] | The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform. |
max_int [Int64] | The greatest representable 64-bit integer, 263 - 1. |
max_int [Int32] | The greatest representable 32-bit integer, 231 - 1. |
max_int [Int] |
|
max_int [Stdlib] | The greatest representable integer. |
max_num [Float] |
|
max_string_length [Sys] | Maximum length of strings and byte sequences. |
max_tag [Config] | 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 |
may_reduce [CamlinternalMenhirLib.EngineTypes.TABLE] | |
maybe_goto_nt [CamlinternalMenhirLib.EngineTypes.TABLE] | |
mem [Weak.S] |
|
mem [Set.S] |
|
mem [MoreLabels.Set.S] |
|
mem [MoreLabels.Map.S] |
|
mem [MoreLabels.Hashtbl.SeededS] | |
mem [MoreLabels.Hashtbl.S] | |
mem [MoreLabels.Hashtbl] |
|
mem [Map.S] |
|
mem [ListLabels] |
|
mem [List] |
|
mem [Hashtbl.SeededS] | |
mem [Hashtbl.S] | |
mem [Hashtbl] |
|
mem [Float.ArrayLabels] |
|
mem [Float.Array] |
|
mem [ArrayLabels] |
|
mem [Array] |
|
mem_assoc [ListLabels] | Same as |
mem_assoc [List] | Same as |
mem_assq [ListLabels] | Same as |
mem_assq [List] | Same as |
mem_ieee [Float.ArrayLabels] | Same as |
mem_ieee [Float.Array] | Same as |
memoize [Identifiable.Tbl] | |
memq [ListLabels] | Same as |
memq [List] | Same as |
memq [ArrayLabels] | Same as |
memq [Array] | Same as |
merge [Weak.S] |
|
merge [MoreLabels.Map.S] |
|
merge [Map.S] |
|
merge [ListLabels] | Merge two lists:
Assuming that |
merge [List] | Merge two lists:
Assuming that |
method_ [Ast_helper.Cf] | |
method_ [Ast_helper.Ctf] | |
min [Uchar] |
|
min [Float] |
|
min [Stdlib] | Return the smaller of the two arguments. |
min_binding [MoreLabels.Map.S] | Return the binding with the smallest key in a given map
(with respect to the |
min_binding [Map.S] | Return the binding with the smallest key in a given map
(with respect to the |
min_binding_opt [MoreLabels.Map.S] | Return the binding with the smallest key in the given map
(with respect to the |
min_binding_opt [Map.S] | Return the binding with the smallest key in the given map
(with respect to the |
min_elt [Set.S] | Return the smallest element of the given set
(with respect to the |
min_elt [MoreLabels.Set.S] | Return the smallest element of the given set
(with respect to the |
min_elt_opt [Set.S] | Return the smallest element of the given set
(with respect to the |
min_elt_opt [MoreLabels.Set.S] | Return the smallest element of the given set
(with respect to the |
min_float [Float] | The smallest positive, non-zero, non-denormalized value of type |
min_float [Stdlib] | The smallest positive, non-zero, non-denormalized value of type |
min_int [Targetint] | The smallest representable target integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform. |
min_int [Nativeint] | The smallest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform. |
min_int [Int64] | The smallest representable 64-bit integer, -263. |
min_int [Int32] | The smallest representable 32-bit integer, -231. |
min_int [Int] |
|
min_int [Stdlib] | The smallest representable integer. |
min_max [Float] |
|
min_max_num [Float] |
|
min_num [Float] |
|
minor [Gc] | Trigger a minor collection. |
minor_words [Gc] | Number of words allocated in the minor heap since the program was started. |
minus_one [Targetint] | The target integer -1. |
minus_one [Nativeint] | The native integer -1. |
minus_one [Int64] | The 64-bit integer -1. |
minus_one [Int32] | The 32-bit integer -1. |
minus_one [Int] |
|
minus_one [Float] | The floating-point -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_exception [Ast_helper.Te] | |
mk_lazy [Warnings] | Like |
mkdir [UnixLabels] | Create a directory with the given permissions (see |
mkdir [Unix] | Create a directory with the given permissions (see |
mkdir [Sys] | Create a directory with the given permissions. |
mkdll [Config] | The linker command line to build dynamic libraries. |
mkexe [Config] | The linker command line to build executables. |
mkfifo [UnixLabels] | Create a named pipe with the given permissions (see |
mkfifo [Unix] | Create a named pipe with the given permissions (see |
mkloc [Location] | |
mkmaindll [Config] | The linker command line to build main programs as dlls. |
mknoloc [Location] | |
mktime [UnixLabels] | Convert a date and time, specified by the |
mktime [Unix] | Convert a date and time, specified by the |
mod_float [Stdlib] |
|
mod_subst [Ast_helper.Sig] | |
model [Config] | Name of processor submodel for the native-code compiler |
modf [Float] |
|
modf [Stdlib] |
|
modtype [Ast_helper.Str] | |
modtype [Ast_helper.Sig] | |
module_ [Ast_helper.Str] | |
module_ [Ast_helper.Sig] | |
msg [Location] | |
mul [Targetint] | Multiplication. |
mul [Nativeint] | Multiplication. |
mul [Int64] | Multiplication. |
mul [Int32] | Multiplication. |
mul [Int] |
|
mul [Float] | Floating-point multiplication. |
mul [Complex] | Multiplication |
N | |
name [Printexc.Slot] |
|
name [Obj.Extension_constructor] | |
name_of_input [Scanf.Scanning] |
|
nan [Float] | A special floating-point value denoting the result of an
undefined operation such as |
nan [Stdlib] | A special floating-point value denoting the result of an
undefined operation such as |
narrow [CamlinternalOO] | |
native_c_libraries [Config] | The C libraries to link with native-code programs |
native_code [Clflags] | |
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). |
nativeint [Misc.Int_literal_converter] | |
nativeint [Ast_helper.Const] | |
nativeint [Random.State] | |
nativeint [Random] |
|
nativeint [Bigarray] | See |
neg [Targetint] | Unary negation. |
neg [Nativeint] | Unary negation. |
neg [Int64] | Unary negation. |
neg [Int32] | Unary negation. |
neg [Int] |
|
neg [Float] | Unary negation. |
neg [Complex] | Unary negation. |
neg_infinity [Float] | Negative infinity. |
neg_infinity [Stdlib] | Negative infinity. |
negate [Fun] |
|
new_ [Ast_helper.Exp] | |
new_block [Obj] | |
new_channel [Event] | Return a new channel. |
new_line [Lexing] | Update the |
new_method [CamlinternalOO] | |
new_methods_variables [CamlinternalOO] | |
new_variable [CamlinternalOO] | |
newtype [Ast_helper.Exp] | |
next [Stream] | Return the first element of the stream and remove it from the stream. |
next_after [Float] |
|
nice [UnixLabels] | Change the process priority. |
nice [Unix] | Change the process priority. |
no_auto_link [Clflags] | |
no_check_prims [Clflags] | |
no_overflow_add [Misc] | |
no_overflow_lsl [Misc] | |
no_overflow_mul [Misc] | |
no_overflow_sub [Misc] | |
no_scan_tag [Obj] | |
no_std_include [Clflags] | |
noassert [Clflags] | |
noinit [Clflags] | |
none [Location] | An arbitrary value of type |
none [Option] |
|
nonterminal [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
nopervasives [Clflags] | |
noprompt [Clflags] | |
nopromptcont [Clflags] | |
norm [Complex] | Norm: given |
norm2 [Complex] | Norm squared: given |
normalise_eol [Misc] |
|
not [Bool] |
|
not [Stdlib] | The boolean negation. |
noversion [Clflags] | |
npeek [Stream] |
|
nth [ListLabels] | Return the |
nth [List] | Return the |
nth [Buffer] | Get the n-th character of the buffer. |
nth_dim [Bigarray.Genarray] |
|
nth_opt [ListLabels] | Return the |
nth_opt [List] | Return the |
null [Filename] |
|
null_tracker [Gc.Memprof] | Default callbacks simply return |
nullable [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
nullable [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
num_dims [Bigarray.Genarray] | Return the number of dimensions of the given Bigarray. |
num_lines [Terminfo] | |
number [CamlinternalMenhirLib.EngineTypes.TABLE] | |
number [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
O | |
o1_arguments [Clflags] | |
o2_arguments [Clflags] | |
o3_arguments [Clflags] | |
obj [Obj] | |
object_ [Ast_helper.Exp] | |
object_ [Ast_helper.Typ] | |
object_tag [Obj] | |
objfiles [Clflags] | |
ocaml_version [Sys] |
|
ocamlc_cflags [Config] | The flags ocamlc should pass to the C compiler |
ocamlc_cppflags [Config] | The flags ocamlc should pass to the C preprocessor |
ocamlopt_cflags [Config] | |
ocamlopt_cppflags [Config] | |
of_array [Bigarray.Array3] | Build a three-dimensional Bigarray initialized from the given array of arrays of arrays. |
of_array [Bigarray.Array2] | Build a two-dimensional Bigarray initialized from the given array of arrays. |
of_array [Bigarray.Array1] | Build a one-dimensional Bigarray initialized from the given array. |
of_bytes [Stream] | Return the stream of the characters of the bytes parameter. |
of_channel [Stream] | Return the stream of the characters read from the input channel. |
of_char [Uchar] |
|
of_float [Targetint] | Convert the given floating-point number to a target integer, discarding the fractional part (truncate towards 0). |
of_float [Nativeint] | Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0). |
of_float [Int64] | Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0). |
of_float [Int32] | Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0). |
of_float [Int] |
|
of_input_filename [Clflags.Compiler_pass] | |
of_int [Targetint] | Convert the given integer (type |
of_int [Uchar] |
|
of_int [Nativeint] | Convert the given integer (type |
of_int [Int64] | Convert the given integer (type |
of_int [Int32] | Convert the given integer (type |
of_int [Float] | Convert an integer to floating-point. |
of_int32 [Targetint] | Convert the given 32-bit integer (type |
of_int32 [Nativeint] | Convert the given 32-bit integer (type |
of_int32 [Int64] | Convert the given 32-bit integer (type |
of_int64 [Targetint] | Convert the given 64-bit integer (type |
of_int64_exn [Numbers.Int16] | |
of_int_exn [Targetint] | Convert the given integer (type |
of_int_exn [Numbers.Int16] | |
of_int_exn [Numbers.Int8] | |
of_list [Identifiable.Tbl] | |
of_list [Identifiable.Map] | |
of_list [Identifiable.Set] | |
of_list [Stream] | Return the stream holding the elements of the list in the same order. |
of_list [Set.S] |
|
of_list [MoreLabels.Set.S] |
|
of_list [Float.ArrayLabels] |
|
of_list [Float.Array] |
|
of_list [ArrayLabels] |
|
of_list [Array] |
|
of_map [Identifiable.Tbl] | |
of_nativeint [Int64] | Convert the given native integer (type |
of_seq [String] |
|
of_seq [StringLabels] |
|
of_seq [Stack] | Create a stack from the iterator |
of_seq [Set.S] | Build a set from the given bindings |
of_seq [Queue] | Create a queue from the generator |
of_seq [MoreLabels.Set.S] | Build a set from the given bindings |
of_seq [MoreLabels.Map.S] | Build a map from the given bindings |
of_seq [MoreLabels.Hashtbl.SeededS] | |
of_seq [MoreLabels.Hashtbl.S] | |
of_seq [MoreLabels.Hashtbl] | Build a table from the given bindings. |
of_seq [Map.S] | Build a map from the given bindings |
of_seq [ListLabels] | Create a list from the iterator. |
of_seq [List] | Create a list from the iterator. |
of_seq [Hashtbl.SeededS] | |
of_seq [Hashtbl.S] | |
of_seq [Hashtbl] | Build a table from the given bindings. |
of_seq [Float.ArrayLabels] | Create an array from the generator. |
of_seq [Float.Array] | Create an array from the generator. |
of_seq [BytesLabels] | Create a string from the generator |
of_seq [Bytes] | Create a string from the generator |
of_seq [Buffer] | Create a buffer from the generator |
of_seq [ArrayLabels] | Create an array from the generator |
of_seq [Array] | Create an array from the generator |
of_set [Identifiable.Map] | |
of_string [Targetint] | Convert the given string to a target integer. |
of_string [Clflags.Compiler_pass] | |
of_string [Stream] | Return the stream of the characters of the string parameter. |
of_string [Nativeint] | Convert the given string to a native integer. |
of_string [Int64] | Convert the given string to a 64-bit integer. |
of_string [Int32] | Convert the given string to a 32-bit integer. |
of_string [Float] | Convert the given string to a float. |
of_string [BytesLabels] | Return a new byte sequence that contains the same bytes as the given string. |
of_string [Bytes] | Return a new byte sequence that contains the same bytes as the given string. |
of_string_opt [Nativeint] | Same as |
of_string_opt [Int64] | Same as |
of_string_opt [Int32] | Same as |
of_string_opt [Float] | Same as |
of_val [Obj.Extension_constructor] | |
of_value [Bigarray.Array0] | Build a zero-dimensional Bigarray initialized from the given value. |
offer [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
ok [Result] |
|
one [Targetint] | The target integer 1. |
one [Numbers.Int8] | |
one [Nativeint] | The native integer 1. |
one [Int64] | The 64-bit integer 1. |
one [Int32] | The 32-bit integer 1. |
one [Int] |
|
one [Float] | The floating-point 1. |
one [Complex] | The complex number |
opaque [Clflags] | |
opaque_identity [Sys] | For the purposes of optimization, |
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_and_check_magic [Pparse] | |
open_box [Format] |
|
open_box_of_string [CamlinternalFormat] | |
open_connection [ThreadUnix] | |
open_connection [UnixLabels] | Connect to a server at the given address. |
open_connection [Unix] | Connect to a server at the given address. |
open_hbox [Format] |
|
open_hovbox [Format] |
|
open_hvbox [Format] |
|
open_in [Scanf.Scanning] |
|
open_in [Stdlib] | Open the named file for reading, and return a new input channel on that file, positioned at the beginning of the file. |
open_in_bin [Scanf.Scanning] |
|
open_in_bin [Stdlib] | Same as |
open_in_gen [Stdlib] |
|
open_module [Depend] | |
open_modules [Clflags] | |
open_out [Stdlib] | Open the named file for writing, and return a new output channel on that file, positioned at the beginning of the file. |
open_out_bin [Stdlib] | Same as |
open_out_gen [Stdlib] |
|
open_process [ThreadUnix] | |
open_process [UnixLabels] | Same as |
open_process [Unix] | Same as |
open_process_args [UnixLabels] | Same as |
open_process_args [Unix] | Same as |
open_process_args_full [UnixLabels] | Similar to |
open_process_args_full [Unix] | Similar to |
open_process_args_in [UnixLabels] | High-level pipe and process management. |
open_process_args_in [Unix] | High-level pipe and process management. |
open_process_args_out [UnixLabels] | Same as |
open_process_args_out [Unix] | Same as |
open_process_full [UnixLabels] | Similar to |
open_process_full [Unix] | Similar to |
open_process_in [ThreadUnix] | |
open_process_in [UnixLabels] | High-level pipe and process management. |
open_process_in [Unix] | High-level pipe and process management. |
open_process_out [ThreadUnix] | |
open_process_out [UnixLabels] | Same as |
open_process_out [Unix] | Same as |
open_stag [Format] |
|
open_tag [Format] | |
open_tbox [Format] |
|
open_temp_file [Filename] | Same as |
open_vbox [Format] |
|
opendir [UnixLabels] | Open a descriptor on a directory |
opendir [Unix] | Open a descriptor on a directory |
openfile [UnixLabels] | Open the named file with the given flags. |
openfile [Unix] | Open the named file with the given flags. |
optimize_for_speed [Clflags] | |
options_doc [Profile] | |
or_ [Ast_helper.Pat] | |
os_type [Sys] | Operating system currently executing the OCaml program. |
out_channel_length [Stdlib.LargeFile] | |
out_channel_length [Stdlib] | Return the size (number of characters) of the regular file on which the given channel is opened. |
out_channel_of_descr [UnixLabels] | Create an output channel writing on the given descriptor. |
out_channel_of_descr [Unix] | Create an output channel writing on the given descriptor. |
out_of_heap_tag [Obj] | |
output [Misc.LongString] | |
output [Identifiable.Set] | |
output [Identifiable.Thing] | |
output [Digest] | Write a digest on the given output channel. |
output [Stdlib] |
|
output_acc [CamlinternalFormat] | |
output_binary_int [Stdlib] | Write one integer in binary format (4 bytes, big-endian) on the given output channel. |
output_buffer [Buffer] |
|
output_byte [Stdlib] | Write one 8-bit integer (as the single character with that code) on the given output channel. |
output_bytes [Stdlib] | Write the byte sequence on the given output channel. |
output_c_object [Clflags] | |
output_char [Stdlib] | Write the character on the given output channel. |
output_complete_executable [Clflags] | |
output_complete_object [Clflags] | |
output_name [Clflags] | |
output_string [Stdlib] | Write the string on the given output channel. |
output_substring [Stdlib] | Same as |
output_to_file_via_temporary [Misc] | |
output_value [Stdlib] | Write the representation of a structured value of any type to a channel. |
over_max_boxes [Format] | Tests if the maximum number of pretty-printing boxes allowed have already been opened. |
override [Ast_helper.Exp] | |
P | |
pack [CamlinternalMenhirLib.PackedIntArray] | |
pack [Ast_helper.Exp] | |
package [Ast_helper.Typ] | |
param_format_of_ignored_format [CamlinternalFormat] | |
params [CamlinternalOO] | |
parent_dir_name [Filename] | The conventional name for the parent of the current directory (e.g. |
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 [Arg] |
|
parse_alert_option [Warnings] | Disable/enable alerts based on the parameter to the -alert command-line option. |
parse_and_expand_argv_dynamic [Arg] | Same as |
parse_any_longident [Parser.Incremental] | |
parse_any_longident [Parser] | |
parse_arguments [Clflags] | |
parse_argv [Arg] |
|
parse_argv_dynamic [Arg] | Same as |
parse_constr_longident [Parser.Incremental] | |
parse_constr_longident [Parser] | |
parse_core_type [Parser.Incremental] | |
parse_core_type [Parser] | |
parse_dynamic [Arg] | Same as |
parse_expand [Arg] | Same as |
parse_expression [Parser.Incremental] | |
parse_expression [Parser] | |
parse_implementation [Pparse] | |
parse_interface [Pparse] | |
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_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] | |
partition [Set.S] |
|
partition [MoreLabels.Set.S] |
|
partition [MoreLabels.Map.S] |
|
partition [Map.S] |
|
partition [ListLabels] |
|
partition [List] |
|
partition_map [ListLabels] |
|
partition_map [List] |
|
path [Load_path.Dir] | |
pattern [Pprintast] | |
pattern [Parse] | |
pause [UnixLabels] | Wait until a non-ignored, non-blocked signal is delivered. |
pause [Unix] | Wait until a non-ignored, non-blocked signal is delivered. |
payload [Printast] | |
peek [Stream] | Return |
peek [Queue] |
|
peek_opt [Queue] |
|
pi [Float] | The constant pi. |
pic_code [Clflags] | |
pipe [ThreadUnix] | |
pipe [UnixLabels] | Create a pipe. |
pipe [Unix] | Create a pipe. |
plugin [Clflags] | |
polar [Complex] |
|
poll [Event] | Non-blocking version of |
poly [Ast_helper.Exp] | |
poly [Ast_helper.Typ] | |
pop [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
pop [Stack] |
|
pop [Queue] |
|
pop_many [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
pop_opt [Stack] |
|
pos_in [Stdlib.LargeFile] | |
pos_in [Stdlib] | Return the current reading position for the given channel. |
pos_out [Stdlib.LargeFile] | |
pos_out [Stdlib] | Return the current writing position for the given channel. |
positions [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
pow [Float] | Exponentiation. |
pow [Complex] | Power function. |
pp_close_box [Format] | |
pp_close_stag [Format] | |
pp_close_tag [Format] | |
pp_close_tbox [Format] | |
pp_deps [Depend] | dependencies found by preprocessing tools |
pp_force_newline [Format] | |
pp_get_all_formatter_output_functions [Format] | |
pp_get_ellipsis_text [Format] | |
pp_get_formatter_out_functions [Format] | |
pp_get_formatter_output_functions [Format] | |
pp_get_formatter_stag_functions [Format] | |
pp_get_formatter_tag_functions [Format] | |
pp_get_geometry [Format] | |
pp_get_margin [Format] | |
pp_get_mark_tags [Format] | |
pp_get_max_boxes [Format] | |
pp_get_max_indent [Format] | |
pp_get_print_tags [Format] | |
pp_open_box [Format] | |
pp_open_hbox [Format] | |
pp_open_hovbox [Format] | |
pp_open_hvbox [Format] | |
pp_open_stag [Format] | |
pp_open_tag [Format] | |
pp_open_tbox [Format] | |
pp_open_vbox [Format] | |
pp_over_max_boxes [Format] | |
pp_print_as [Format] | |
pp_print_bool [Format] | |
pp_print_break [Format] | |
pp_print_char [Format] | |
pp_print_custom_break [Format] |
|
pp_print_cut [Format] | |
pp_print_float [Format] | |
pp_print_flush [Format] | |
pp_print_if_newline [Format] | |
pp_print_int [Format] | |
pp_print_list [Format] |
|
pp_print_newline [Format] | |
pp_print_option [Format] |
|
pp_print_result [Format] |
|
pp_print_seq [Format] |
|
pp_print_space [Format] | |
pp_print_string [Format] | |
pp_print_tab [Format] | |
pp_print_tbreak [Format] | |
pp_print_text [Format] |
|
pp_safe_set_geometry [Format] | |
pp_set_all_formatter_output_functions [Format] | |
pp_set_ellipsis_text [Format] | |
pp_set_formatter_out_channel [Format] | Redirecting the standard formatter output |
pp_set_formatter_out_functions [Format] | |
pp_set_formatter_output_functions [Format] | |
pp_set_formatter_stag_functions [Format] | |
pp_set_formatter_tag_functions [Format] | This function will erase non-string tag formatting functions. |
pp_set_geometry [Format] | |
pp_set_margin [Format] | |
pp_set_mark_tags [Format] | |
pp_set_max_boxes [Format] | |
pp_set_max_indent [Format] | |
pp_set_print_tags [Format] | |
pp_set_tab [Format] | |
pp_set_tags [Format] | |
pp_two_columns [Misc] |
|
pp_update_geometry [Format] |
|
pred [Targetint] | Predecessor. |
pred [Uchar] |
|
pred [Nativeint] | Predecessor. |
pred [Int64] | Predecessor. |
pred [Int32] | Predecessor. |
pred [Int] |
|
pred [Float] |
|
pred [Stdlib] |
|
preprocess [Pparse] | |
preprocessor [Clflags] | |
prerr_alert [Location] | Same as |
prerr_bytes [Stdlib] | Print a byte sequence on standard error. |
prerr_char [Stdlib] | Print a character on standard error. |
prerr_endline [Stdlib] | Print a string, followed by a newline character on standard error and flush standard error. |
prerr_float [Stdlib] | Print a floating-point number, in decimal, on standard error. |
prerr_int [Stdlib] | Print an integer, in decimal, on standard error. |
prerr_newline [Stdlib] | Print a newline character on standard error, and flush standard error. |
prerr_string [Stdlib] | Print a string on standard error. |
prerr_warning [Location] | Same as |
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 [Printexc] |
|
print_alert [Location] | Prints an alert. |
print_arguments [Clflags] | |
print_as [Format] |
|
print_backtrace [Printexc] |
|
print_bool [Format] | Print a boolean in the current pretty-printing box. |
print_break [Format] |
|
print_bytes [Stdlib] | Print a byte sequence on standard output. |
print_char [Format] | Print a character in the current pretty-printing box. |
print_char [Stdlib] | Print a character on standard output. |
print_config [Config] | Access to configuration values |
print_current_state [CamlinternalMenhirLib.Printers.Make] | |
print_cut [Format] |
|
print_element_as_symbol [CamlinternalMenhirLib.Printers.Make] | |
print_endline [Stdlib] | Print a string, followed by a newline character, on standard output and flush standard output. |
print_env [CamlinternalMenhirLib.Printers.Make] | |
print_filename [Location] | |
print_float [Format] | Print a floating point number in the current pretty-printing box. |
print_float [Stdlib] | Print a floating-point number, in decimal, on standard output. |
print_flush [Format] | End of pretty-printing: resets the pretty-printer to initial state. |
print_if [Misc] |
|
print_if_newline [Format] | Execute the next formatting command if the preceding line has just been split. |
print_int [Format] | Print an integer in the current pretty-printing box. |
print_int [Stdlib] | Print an integer, in decimal, on standard output. |
print_item [CamlinternalMenhirLib.Printers.Make] | |
print_loc [Location] | |
print_locs [Location] | |
print_newline [Format] | End of pretty-printing: resets the pretty-printer to initial state. |
print_newline [Stdlib] | Print a newline character on standard output, and flush standard output. |
print_production [CamlinternalMenhirLib.Printers.Make] | |
print_raw_backtrace [Printexc] | Print a raw backtrace in the same format
|
print_report [Location] | Display an error or warning report. |
print_space [Format] |
|
print_stack [CamlinternalMenhirLib.Printers.Make] | |
print_stat [Gc] | Print the current values of the memory management counters (in human-readable form) into the channel argument. |
print_string [Format] |
|
print_string [Stdlib] | Print a string on standard output. |
print_symbols [CamlinternalMenhirLib.Printers.Make] | |
print_tab [Format] |
|
print_tbreak [Format] |
|
print_types [Clflags] | |
print_warning [Location] | Prints a warning. |
print_warnings [Lexer] | |
printf [Printf] | Same as |
printf [Format] | Same as |
process_full_pid [UnixLabels] | Return the pid of a process opened via |
process_full_pid [Unix] | Return the pid of a process opened via |
process_in_pid [UnixLabels] | Return the pid of a process opened via |
process_in_pid [Unix] | Return the pid of a process opened via |
process_out_pid [UnixLabels] | Return the pid of a process opened via |
process_out_pid [Unix] | Return the pid of a process opened via |
process_pid [UnixLabels] | Return the pid of a process opened via |
process_pid [Unix] | Return the pid of a process opened via |
production_index [CamlinternalMenhirLib.EngineTypes.TABLE] | |
production_index [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
profile_columns [Clflags] | |
profinfo [Config] | Whether the compiler was configured for profiling |
profinfo_width [Config] | How many bits are to be used in values' headers for profiling information |
prohibit [Dynlink] |
|
protect [Fun] |
|
protect_refs [Misc] |
|
protect_writing_to_file [Misc] | Open the given |
public_dynamically_loaded_units [Dynlink] | Return the list of compilation units that have been dynamically loaded via
|
public_method_label [CamlinternalOO] | |
push [Stack] |
|
push [Queue] |
|
putenv [UnixLabels] |
|
putenv [Unix] |
|
Q | |
quick_stat [Gc] | Same as |
quote [Str] |
|
quote [Filename] | Return a quoted version of a file name, suitable for use as one argument in a command line, escaping all meta-characters. |
quote_command [Filename] |
|
quote_files [Ccomp] | |
quote_optfile [Ccomp] | |
R | |
raise [Stdlib] | Raise the given exception value |
raise_errorf [Location] | |
raise_notrace [Stdlib] | A faster version |
raise_with_backtrace [Printexc] | Reraise the exception using the given raw_backtrace for the origin of the exception |
randomize [MoreLabels.Hashtbl] | After a call to |
randomize [Hashtbl] | After a call to |
ranlib [Config] | Command to randomize a library, or "" if not needed |
raw [Misc.Magic_number] | A valid raw representation of the magic number. |
raw_backtrace_entries [Printexc] | |
raw_backtrace_length [Printexc] |
|
raw_backtrace_to_string [Printexc] | Return a string from a raw backtrace, in the same format
|
raw_field [Obj] | |
raw_kind [Misc.Magic_number] | the current raw representation of a kind. |
rcontains_from [String] |
|
rcontains_from [StringLabels] |
|
rcontains_from [BytesLabels] |
|
rcontains_from [Bytes] |
|
reachable_words [Obj] | Computes the total size (in words, including the headers) of all heap blocks accessible from the argument. |
read [Binutils] | |
read [CamlinternalMenhirLib.LinearizedArray] | |
read [ThreadUnix] | |
read [UnixLabels] |
|
read [Unix] |
|
read_arg [Arg] |
|
read_arg0 [Arg] | Identical to |
read_ast [Pparse] | |
read_current_info [Misc.Magic_number] | Read a magic number as |
read_float [Stdlib] | Same as |
read_float_opt [Stdlib] | Flush standard output, then read one line from standard input and convert it to a floating-point number. |
read_info [Misc.Magic_number] | Read a raw magic number from an input channel. |
read_int [Stdlib] | Same as |
read_int_opt [Stdlib] | Flush standard output, then read one line from standard input and convert it to an integer. |
read_line [Stdlib] | Flush standard output, then read characters from standard input until a newline character is encountered. |
read_row [CamlinternalMenhirLib.LinearizedArray] | |
read_row_via [CamlinternalMenhirLib.LinearizedArray] | |
read_via [CamlinternalMenhirLib.LinearizedArray] | |
readdir [UnixLabels] | Return the next entry in a directory. |
readdir [Unix] | Return the next entry in a directory. |
readdir [Sys] | Return the names of all files present in the given directory. |
readlink [UnixLabels] | Read the contents of a symbolic link. |
readlink [Unix] | Read the contents of a symbolic link. |
real_paths [Clflags] | |
really_input [Stdlib] |
|
really_input_string [Stdlib] |
|
rebind [Ast_helper.Te] | |
rebuild [MoreLabels.Hashtbl] | Return a copy of the given hashtable. |
rebuild [Hashtbl] | Return a copy of the given hashtable. |
rec_module [Ast_helper.Str] | |
rec_module [Ast_helper.Sig] | |
recast [CamlinternalFormat] | |
receive [Event] |
|
record [Profile] |
|
record [Ast_helper.Exp] | |
record [Ast_helper.Pat] | |
record_backtrace [Printexc] |
|
record_call [Profile] |
|
recursive_types [Clflags] | |
recv [ThreadUnix] | |
recv [UnixLabels] | Receive data from a connected socket. |
recv [Unix] | Receive data from a connected socket. |
recvfrom [ThreadUnix] | |
recvfrom [UnixLabels] | Receive data from an unconnected socket. |
recvfrom [Unix] | Receive data from an unconnected socket. |
reduce_or_accept [CamlinternalMenhirLib.EngineTypes.TABLE.Log] | |
ref [Stdlib] | Return a fresh reference containing the given value. |
regexp [Str] | Compile a regular expression. |
regexp_case_fold [Str] | Same as |
regexp_string [Str] |
|
regexp_string_case_fold [Str] |
|
register [Docstrings] | Register a docstring |
register [Ast_mapper] | Apply the |
register [Callback] |
|
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_exception [Callback] |
|
register_function [Ast_mapper] | |
register_printer [Printexc] |
|
release [Semaphore.Binary] |
|
release [Semaphore.Counting] |
|
rem [Targetint] | Integer remainder. |
rem [Nativeint] | Integer remainder. |
rem [Int64] | Integer remainder. |
rem [Int32] | Integer remainder. |
rem [Int] |
|
rem [Float] |
|
remove [Weak.S] |
|
remove [Sys] | Remove the given file name from the file system. |
remove [Set.S] |
|
remove [MoreLabels.Set.S] |
|
remove [MoreLabels.Map.S] |
|
remove [MoreLabels.Hashtbl.SeededS] | |
remove [MoreLabels.Hashtbl.S] | |
remove [MoreLabels.Hashtbl] |
|
remove [Map.S] |
|
remove [Hashtbl.SeededS] | |
remove [Hashtbl.S] | |
remove [Hashtbl] |
|
remove_assoc [ListLabels] |
|
remove_assoc [List] |
|
remove_assq [ListLabels] | Same as |
remove_assq [List] | Same as |
remove_dir [Load_path] | Remove a directory from the load path |
remove_extension [Filename] | Return the given file name without its extension, as defined
in |
remove_file [Misc] | |
remove_preprocessed [Pparse] | |
remove_unused_arguments [Clflags] | |
rename [Identifiable.Map] | |
rename [UnixLabels] |
|
rename [Unix] |
|
rename [Sys] | Rename a file. |
rep [Uchar] |
|
replace [MoreLabels.Hashtbl.SeededS] | |
replace [MoreLabels.Hashtbl.S] | |
replace [MoreLabels.Hashtbl] |
|
replace [Hashtbl.SeededS] | |
replace [Hashtbl.S] | |
replace [Hashtbl] |
|
replace_first [Str] | Same as |
replace_matched [Str] |
|
replace_seq [MoreLabels.Hashtbl.SeededS] | |
replace_seq [MoreLabels.Hashtbl.S] | |
replace_seq [MoreLabels.Hashtbl] | Add the given bindings to the table, using |
replace_seq [Hashtbl.SeededS] | |
replace_seq [Hashtbl.S] | |
replace_seq [Hashtbl] | Add the given bindings to the table, using |
replace_substring [Misc] | |
replicate_list [Misc] | |
report [Warnings] | |
report_alert [Warnings] | |
report_alert [Location] |
|
report_error [Pparse] | |
report_error [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] |
|
repr [Targetint] | The concrete representation of a native integer. |
repr [Sys.Immediate64.Make] | |
repr [Obj] | |
require_20190924 [CamlinternalMenhirLib.StaticVersion] | |
reraise_preserving_backtrace [Misc] |
|
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 [MoreLabels.Hashtbl.SeededS] | |
reset [MoreLabels.Hashtbl.S] | |
reset [MoreLabels.Hashtbl] | Empty a hash table and shrink the size of the bucket table to its initial size. |
reset [Hashtbl.SeededS] | |
reset [Hashtbl.S] | |
reset [Hashtbl] | Empty a hash table and shrink the size of the bucket table to its initial size. |
reset [Buffer] | Empty the buffer and deallocate the internal byte sequence holding the
buffer contents, replacing it with the initial internal byte sequence
of length |
reset_arguments [Clflags] | |
reset_base_overrides [Arg_helper.Make] | |
reset_fatal [Warnings] | |
reshape [Bigarray] |
|
reshape_0 [Bigarray] | Specialized version of |
reshape_1 [Bigarray] | Specialized version of |
reshape_2 [Bigarray] | Specialized version of |
reshape_3 [Bigarray] | Specialized version of |
restore [Warnings] | |
resume [Terminfo] | |
resume [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
resuming_error_handling [CamlinternalMenhirLib.EngineTypes.TABLE.Log] | |
return [Seq] | The singleton sequence containing only the given element. |
rev [ListLabels] | List reversal. |
rev [List] | List reversal. |
rev_append [ListLabels] |
|
rev_append [List] |
|
rev_char_set [CamlinternalFormat] | |
rev_map [ListLabels] |
|
rev_map [List] | |
rev_map2 [ListLabels] |
|
rev_map2 [List] | |
rev_split_words [Misc] | |
revised2traditional [CamlinternalMenhirLib.Convert.Simplified] | |
revised2traditional [CamlinternalMenhirLib.Convert] | |
rewinddir [UnixLabels] | Reposition the descriptor to the beginning of the directory |
rewinddir [Unix] | Reposition the descriptor to the beginning of the directory |
rewrite [Build_path_prefix_map] | |
rewrite_absolute_path [Location] | rewrite absolute path to honor the BUILD_PATH_PREFIX_MAP variable (https://reproducible-builds.org/specs/build-path-prefix-map/) if it is set. |
rewrite_opt [Build_path_prefix_map] |
|
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_end [Parsing] | See |
rhs_end_pos [Parsing] | Same as |
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_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_start [Parsing] | Same as |
rhs_start_pos [Parsing] | Same as |
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] | |
right [Either] |
|
rindex [String] |
|
rindex [StringLabels] |
|
rindex [BytesLabels] |
|
rindex [Bytes] |
|
rindex_from [String] |
|
rindex_from [StringLabels] |
|
rindex_from [BytesLabels] |
|
rindex_from [Bytes] |
|
rindex_from_opt [String] |
|
rindex_from_opt [StringLabels] |
|
rindex_from_opt [BytesLabels] |
|
rindex_from_opt [Bytes] |
|
rindex_opt [String] |
|
rindex_opt [StringLabels] |
|
rindex_opt [BytesLabels] |
|
rindex_opt [Bytes] |
|
rmdir [UnixLabels] | Remove an empty directory. |
rmdir [Unix] | Remove an empty directory. |
rmdir [Sys] | Remove an empty directory. |
round [Float] |
|
rounds [Clflags] | |
row_length [CamlinternalMenhirLib.LinearizedArray] | |
row_length_via [CamlinternalMenhirLib.LinearizedArray] | |
run_command [Ccomp] | |
run_initializers [CamlinternalOO] | |
run_initializers_opt [CamlinternalOO] | |
run_main [Ast_mapper] | Entry point to call to implement a standalone -ppx rewriter from a mapper, parametrized by the command line arguments. |
runtime_parameters [Sys] | Return the value of the runtime parameters, in the same format
as the contents of the |
runtime_variant [Clflags] | |
runtime_variant [Sys] | Return the name of the runtime variant the program is running on. |
runtime_warnings_enabled [Sys] | Return whether runtime warnings are currently enabled. |
S | |
s_ref [Local_store] | Similar to |
s_table [Local_store] | Used to register hash tables. |
safe_set_geometry [Format] |
|
safe_string [Config] | Whether the compiler was configured with -force-safe-string; in that case, the -unsafe-string compile-time option is unavailable |
scanf [Scanf] | Same as |
search_backward [Str] |
|
search_forward [Str] |
|
search_substring [Misc] | |
seeded_hash [MoreLabels.Hashtbl] | A variant of |
seeded_hash [Hashtbl] | A variant of |
seeded_hash_param [MoreLabels.Hashtbl] | A variant of |
seeded_hash_param [Hashtbl] | A variant of |
seek_in [Stdlib.LargeFile] | |
seek_in [Stdlib] |
|
seek_out [Stdlib.LargeFile] | |
seek_out [Stdlib] |
|
select [ThreadUnix] | |
select [Event] | 'Synchronize' on an alternative of events. |
select [Thread] | Same function as |
select [UnixLabels] | Wait until some input/output operations become possible on some channels. |
select [Unix] | Wait until some input/output operations become possible on some channels. |
self [Thread] | Return the handle for the thread currently executing. |
self_init [Random] | Initialize the generator with a random seed chosen in a system-dependent way. |
semantic_action [CamlinternalMenhirLib.TableFormat.TABLES] | |
semantic_action [CamlinternalMenhirLib.EngineTypes.TABLE] | |
send [Ast_helper.Exp] | |
send [ThreadUnix] | |
send [Event] |
|
send [UnixLabels] | Send data over a connected socket. |
send [Unix] | Send data over a connected socket. |
send [CamlinternalOO] | |
send_substring [ThreadUnix] | |
send_substring [UnixLabels] | Same as |
send_substring [Unix] | Same as |
sendcache [CamlinternalOO] | |
sendself [CamlinternalOO] | |
sendto [ThreadUnix] | |
sendto [UnixLabels] | Send data over an unconnected socket. |
sendto [Unix] | Send data over an unconnected socket. |
sendto_substring [ThreadUnix] | |
sendto_substring [UnixLabels] | Same as |
sendto_substring [Unix] | Same as |
sequence [Ast_helper.Exp] | |
set [Misc.LongString] | |
set [Consistbl.Make] | |
set [CamlinternalMenhirLib.InfiniteArray] |
|
set [Weak] |
|
set [String] |
|
set [StringLabels] |
|
set [Gc] |
|
set [Float.ArrayLabels] |
|
set [Float.Array] |
|
set [BytesLabels] |
|
set [Bytes] |
|
set [Bigarray.Array3] |
|
set [Bigarray.Array2] |
|
set [Bigarray.Array1] |
|
set [Bigarray.Array0] |
|
set [Bigarray.Genarray] | Assign an element of a generic Bigarray. |
set [Atomic] | Set a new value for the atomic reference. |
set [ArrayLabels] |
|
set [Array] |
|
set [CamlinternalAtomic] | |
set_all_formatter_output_functions [Format] | |
set_allowed_units [Dynlink] | Set the list of compilation units that may be referenced from units that are dynamically loaded in the future to be exactly the given value. |
set_base_default [Arg_helper.Make] | |
set_binary_mode_in [Stdlib] |
|
set_binary_mode_out [Stdlib] |
|
set_close_on_exec [UnixLabels] | Set the ``close-on-exec'' flag on the given descriptor. |
set_close_on_exec [Unix] | Set the ``close-on-exec'' flag on the given descriptor. |
set_color_tag_handling [Misc.Color] | |
set_cookie [Ast_mapper] | |
set_data [Obj.Ephemeron] | Same as |
set_data [Ephemeron.Kn] | Same as |
set_data [Ephemeron.K2] | Same as |
set_data [Ephemeron.K1] |
|
set_double_field [Obj] | |
set_dumped_pass [Clflags] | |
set_ellipsis_text [Format] | Set the text of the ellipsis printed when too many pretty-printing boxes
are open (a single dot, |
set_field [Obj] | When using flambda: |
set_filename [Lexing] | Set filename in the initial tracked position to |
set_floating_docstrings [Docstrings] | Docstrings not immediately adjacent to a token |
set_formatter_out_channel [Format] | Redirect the standard pretty-printer output to the given channel. |
set_formatter_out_functions [Format] |
|
set_formatter_output_functions [Format] |
|
set_formatter_stag_functions [Format] |
|
set_formatter_tag_functions [Format] | |
set_geometry [Format] | |
set_int16_be [BytesLabels] |
|
set_int16_be [Bytes] |
|
set_int16_le [BytesLabels] |
|
set_int16_le [Bytes] |
|
set_int16_ne [BytesLabels] |
|
set_int16_ne [Bytes] |
|
set_int32_be [BytesLabels] |
|
set_int32_be [Bytes] |
|
set_int32_le [BytesLabels] |
|
set_int32_le [Bytes] |
|
set_int32_ne [BytesLabels] |
|
set_int32_ne [Bytes] |
|
set_int64_be [BytesLabels] |
|
set_int64_be [Bytes] |
|
set_int64_le [BytesLabels] |
|
set_int64_le [Bytes] |
|
set_int64_ne [BytesLabels] |
|
set_int64_ne [Bytes] |
|
set_int8 [BytesLabels] |
|
set_int8 [Bytes] |
|
set_key [Obj.Ephemeron] | Same as |
set_key [Ephemeron.Kn] | Same as |
set_key [Ephemeron.K1] |
|
set_key1 [Ephemeron.K2] | Same as |
set_key2 [Ephemeron.K2] | Same as |
set_margin [Format] |
|
set_mark_tags [Format] |
|
set_max_boxes [Format] |
|
set_max_indent [Format] |
|
set_method [CamlinternalOO] | |
set_methods [CamlinternalOO] | |
set_nonblock [UnixLabels] | Set the ``non-blocking'' flag on the given descriptor. |
set_nonblock [Unix] | Set the ``non-blocking'' flag on the given descriptor. |
set_or_ignore [Misc] | |
set_position [Lexing] | Set the initial tracked input position for |
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_print_tags [Format] |
|
set_raw_field [Obj] | |
set_save_ir_after [Clflags] | |
set_signal [Sys] | Same as |
set_state [Random] | Set the state of the generator used by the basic functions. |
set_styles [Misc.Color] | |
set_tab [Format] | Sets a tabulation marker at current insertion point. |
set_tag [Obj] | |
set_tags [Format] |
|
set_temp_dir_name [Filename] | Change the temporary directory returned by |
set_trace [Parsing] | Control debugging support for |
set_uint16_be [BytesLabels] |
|
set_uint16_be [Bytes] |
|
set_uint16_le [BytesLabels] |
|
set_uint16_le [Bytes] |
|
set_uint16_ne [BytesLabels] |
|
set_uint16_ne [Bytes] |
|
set_uint8 [BytesLabels] |
|
set_uint8 [Bytes] |
|
set_uncaught_exception_handler [Printexc] |
|
set_user_default [Arg_helper.Make] | |
setfield [Ast_helper.Exp] | |
setgid [UnixLabels] | Set the real group id and effective group id for the process. |
setgid [Unix] | Set the real group id and effective group id for the process. |
setgroups [UnixLabels] |
|
setgroups [Unix] |
|
setinstvar [Ast_helper.Exp] | |
setitimer [UnixLabels] |
|
setitimer [Unix] |
|
setsid [UnixLabels] | Put the calling process in a new session and detach it from its controlling terminal. |
setsid [Unix] | Put the calling process in a new session and detach it from its controlling terminal. |
setsockopt [UnixLabels] | Set or clear a boolean-valued option in the given socket. |
setsockopt [Unix] | Set or clear a boolean-valued option in the given socket. |
setsockopt_float [UnixLabels] | Same as |
setsockopt_float [Unix] | Same as |
setsockopt_int [UnixLabels] | Same as |
setsockopt_int [Unix] | Same as |
setsockopt_optint [UnixLabels] | Same as |
setsockopt_optint [Unix] | Same as |
setuid [UnixLabels] | Set the real user id and effective user id for the process. |
setuid [Unix] | Set the real user id and effective user id for the process. |
setup [Terminfo] | |
setup [Misc.Color] | |
shared [Clflags] | |
shift [CamlinternalMenhirLib.EngineTypes.TABLE.Log] | |
shift_left [Targetint] |
|
shift_left [Nativeint] |
|
shift_left [Int64] |
|
shift_left [Int32] |
|
shift_left [Int] |
|
shift_right [Targetint] |
|
shift_right [Nativeint] |
|
shift_right [Int64] |
|
shift_right [Int32] |
|
shift_right [Int] |
|
shift_right_logical [Targetint] |
|
shift_right_logical [Nativeint] |
|
shift_right_logical [Int64] |
|
shift_right_logical [Int32] |
|
shift_right_logical [Int] |
|
shifts [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
should_save_ir_after [Clflags] | |
should_stop_after [Clflags] | |
show [CamlinternalMenhirLib.ErrorReports] | |
show_config_and_exit [Misc] | configuration variables |
show_config_variable_and_exit [Misc] | |
show_filename [Location] | In -absname mode, return the absolute path for this filename. |
shutdown [UnixLabels] | Shutdown a socket connection. |
shutdown [Unix] | Shutdown a socket connection. |
shutdown_connection [UnixLabels] | ``Shut down'' a connection established with |
shutdown_connection [Unix] | ``Shut down'' a connection established with |
sigabrt [Sys] | Abnormal termination |
sigalrm [Sys] | Timeout |
sigbus [Sys] | Bus error |
sigchld [Sys] | Child process terminated |
sigcont [Sys] | Continue |
sigfpe [Sys] | Arithmetic exception |
sighup [Sys] | Hangup on controlling terminal |
sigill [Sys] | Invalid hardware instruction |
sigint [Sys] | Interactive interrupt (ctrl-C) |
sigkill [Sys] | Termination (cannot be ignored) |
sigmask [Thread] |
|
sign_bit [Float] |
|
signal [Condition] |
|
signal [Sys] | Set the behavior of the system on receipt of a given signal. |
signature [Pprintast] | |
signature [Ast_invariants] | |
signature [Ast_helper.Cty] | |
signature [Ast_helper.Mty] | |
sigpending [UnixLabels] | Return the set of blocked signals that are currently pending. |
sigpending [Unix] | Return the set of blocked signals that are currently pending. |
sigpipe [Sys] | Broken pipe |
sigpoll [Sys] | Pollable event |
sigprocmask [UnixLabels] |
|
sigprocmask [Unix] |
|
sigprof [Sys] | Profiling interrupt |
sigquit [Sys] | Interactive termination |
sigsegv [Sys] | Invalid memory reference |
sigstop [Sys] | Stop |
sigsuspend [UnixLabels] |
|
sigsuspend [Unix] |
|
sigsys [Sys] | Bad argument to routine |
sigterm [Sys] | Termination |
sigtrap [Sys] | Trace/breakpoint trap |
sigtstp [Sys] | Interactive stop |
sigttin [Sys] | Terminal read from background process |
sigttou [Sys] | Terminal write from background process |
sigurg [Sys] | Urgent condition on socket |
sigusr1 [Sys] | Application-defined signal 1 |
sigusr2 [Sys] | Application-defined signal 2 |
sigvtalrm [Sys] | Timeout in virtual time |
sigxcpu [Sys] | Timeout in cpu time |
sigxfsz [Sys] | File size limit exceeded |
simple_module_path [Parse] | This function parses a syntactically valid path for a module. |
simplify_rounds [Clflags] | |
sin [Float] | Sine. |
sin [Stdlib] | Sine. |
single_write [UnixLabels] | Same as |
single_write [Unix] | Same as |
single_write_substring [UnixLabels] | Same as |
single_write_substring [Unix] | Same as |
singleton [Set.S] |
|
singleton [MoreLabels.Set.S] |
|
singleton [MoreLabels.Map.S] |
|
singleton [Map.S] |
|
sinh [Float] | Hyperbolic sine. |
sinh [Stdlib] | Hyperbolic sine. |
size [Targetint] | The size in bits of a target native integer. |
size [Obj] | |
size [Nativeint] | The size in bits of a native integer. |
size_in_bytes [Bigarray.Array3] |
|
size_in_bytes [Bigarray.Array2] |
|
size_in_bytes [Bigarray.Array1] |
|
size_in_bytes [Bigarray.Array0] |
|
size_in_bytes [Bigarray.Genarray] |
|
skip_hash_bang [Lexer] | |
sleep [ThreadUnix] | |
sleep [UnixLabels] | Stop execution for the given number of seconds. |
sleep [Unix] | Stop execution for the given number of seconds. |
sleepf [UnixLabels] | Stop execution for the given number of seconds. |
sleepf [Unix] | Stop execution for the given number of seconds. |
slice [Bigarray.Array1] | Extract a scalar (zero-dimensional slice) of the given one-dimensional Bigarray. |
slice_left [Bigarray.Array2] | Extract a row (one-dimensional slice) of the given two-dimensional Bigarray. |
slice_left [Bigarray.Genarray] | Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of the first (left-most) coordinates. |
slice_left_1 [Bigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the first two coordinates. |
slice_left_2 [Bigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional Bigarray by fixing the first coordinate. |
slice_right [Bigarray.Array2] | Extract a column (one-dimensional slice) of the given two-dimensional Bigarray. |
slice_right [Bigarray.Genarray] | Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of the last (right-most) coordinates. |
slice_right_1 [Bigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the last two coordinates. |
slice_right_2 [Bigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional Bigarray by fixing the last coordinate. |
snd [Stdlib] | Return the second component of a pair. |
snd3 [Misc] | |
snd4 [Misc] | |
socket [ThreadUnix] | |
socket [UnixLabels] | Create a new socket in the given domain, and with the given kind. |
socket [Unix] | Create a new socket in the given domain, and with the given kind. |
socketpair [UnixLabels] | Create a pair of unnamed sockets, connected together. |
socketpair [Unix] | Create a pair of unnamed sockets, connected together. |
some [Option] |
|
some_if_all_elements_are_some [Misc.Stdlib.List] | If all elements of the given list are |
sort [ListLabels] | Sort a list in increasing order according to a comparison function. |
sort [List] | Sort a list in increasing order according to a comparison function. |
sort [Float.ArrayLabels] | Sort a floatarray in increasing order according to a comparison function. |
sort [Float.Array] | Sort a floatarray in increasing order according to a comparison function. |
sort [ArrayLabels] | Sort an array in increasing order according to a comparison function. |
sort [Array] | Sort an array in increasing order according to a comparison function. |
sort_uniq [ListLabels] | Same as |
sort_uniq [List] | Same as |
source [Consistbl.Make] | |
spellcheck [Misc] |
|
split [Str] |
|
split [Set.S] |
|
split [MoreLabels.Set.S] |
|
split [MoreLabels.Map.S] |
|
split [Map.S] |
|
split [ListLabels] | Transform a list of pairs into a pair of lists:
|
split [List] | Transform a list of pairs into a pair of lists:
|
split_at [Misc.Stdlib.List] |
|
split_delim [Str] | Same as |
split_last [Misc] | |
split_on_char [String] |
|
split_on_char [StringLabels] |
|
split_path_contents [Misc] | |
sprintf [Printf] | Same as |
sprintf [Format] | Same as |
sqrt [Float] | Square root. |
sqrt [Complex] | Square root. |
sqrt [Stdlib] | Square root. |
sscanf [Scanf] | Same as |
sscanf_format [Scanf] | Same as |
stable_sort [ListLabels] | Same as |
stable_sort [List] | Same as |
stable_sort [Float.ArrayLabels] | Same as |
stable_sort [Float.Array] | Same as |
stable_sort [ArrayLabels] | Same as |
stable_sort [Array] | Same as |
stack [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
stack_safety_margin [Config] | 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 |
standard_library [Config] | The directory containing the standard libraries |
standout [Terminfo] | |
start [CamlinternalMenhirLib.TableFormat.TABLES] | |
start [CamlinternalMenhirLib.EngineTypes.INCREMENTAL_ENGINE_START] | |
start [Gc.Memprof] | Start the sampling with the given parameters. |
stat [UnixLabels.LargeFile] | |
stat [UnixLabels] | Return the information for the named file. |
stat [Unix.LargeFile] | |
stat [Unix] | Return the information for the named file. |
stat [Gc] | Return the current values of the memory management counters in a
|
state [CamlinternalMenhirLib.EngineTypes.TABLE.Log] | |
state_has_default_reduction [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
stats [CamlinternalOO] | |
stats [Weak.S] | Return statistics on the table. |
stats [MoreLabels.Hashtbl.SeededS] | |
stats [MoreLabels.Hashtbl.S] | |
stats [MoreLabels.Hashtbl] |
|
stats [Hashtbl.SeededS] | |
stats [Hashtbl.S] | |
stats [Hashtbl] |
|
stats_alive [Ephemeron.SeededS] | same as |
stats_alive [Ephemeron.S] | same as |
std_formatter [Format] | The standard formatter to write to standard output. |
std_include_dir [Clflags] | |
std_include_flag [Clflags] | |
stdbuf [Format] | The string buffer in which |
stderr [UnixLabels] | File descriptor for standard error. |
stderr [Unix] | File descriptor for standard error. |
stderr [Stdlib] | The standard error output for the process. |
stdib [Scanf.Scanning] | A deprecated alias for |
stdin [UnixLabels] | File descriptor for standard input. |
stdin [Unix] | File descriptor for standard input. |
stdin [Scanf.Scanning] | The standard input notion for the |
stdin [Stdlib] | The standard input for the process. |
stdout [UnixLabels] | File descriptor for standard output. |
stdout [Unix] | File descriptor for standard output. |
stdout [Stdlib] | The standard output for the process. |
stop [Gc.Memprof] | Stop the sampling. |
stop_after [Clflags] | |
str_formatter [Format] | A formatter to output to the |
strict_formats [Clflags] | |
strict_sequence [Clflags] | |
string [Ast_helper.Const] | |
string [Digest] | Return the digest of the given string. |
string_after [Str] |
|
string_before [Str] |
|
string_match [Str] |
|
string_of_bool [Stdlib] | Return the string representation of a boolean. |
string_of_expression [Pprintast] | |
string_of_file [Misc] | |
string_of_float [Stdlib] | Return the string representation of a floating-point number. |
string_of_fmt [CamlinternalFormat] | |
string_of_fmtty [CamlinternalFormat] | |
string_of_format [Stdlib] | Converts a format string into a string. |
string_of_formatting_lit [CamlinternalFormat] | |
string_of_inet_addr [UnixLabels] | Return the printable representation of the given Internet address. |
string_of_inet_addr [Unix] | Return the printable representation of the given Internet address. |
string_of_int [Stdlib] | Return the string representation of an integer, in decimal. |
string_of_kind [Misc.Magic_number] | a user-printable string for a kind, eg. |
string_of_structure [Pprintast] | |
string_partial_match [Str] | Similar to |
string_tag [Obj] | |
strput_acc [CamlinternalFormat] | |
structure [Printast] | |
structure [Pprintast] | |
structure [Ast_invariants] | |
structure [Ast_helper.Cl] | |
structure [Ast_helper.Mod] | |
sub [Targetint] | Subtraction. |
sub [String] |
|
sub [StringLabels] |
|
sub [Nativeint] | Subtraction. |
sub [Int64] | Subtraction. |
sub [Int32] | Subtraction. |
sub [Int] |
|
sub [Float.ArrayLabels] |
|
sub [Float.Array] |
|
sub [Float] | Floating-point subtraction. |
sub [Complex] | Subtraction |
sub [BytesLabels] |
|
sub [Bytes] |
|
sub [Buffer] |
|
sub [Bigarray.Array1] | Extract a sub-array of the given one-dimensional Bigarray. |
sub [ArrayLabels] |
|
sub [Array] |
|
sub_left [Bigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the first dimension. |
sub_left [Bigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the first dimension. |
sub_left [Bigarray.Genarray] | Extract a sub-array of the given Bigarray by restricting the first (left-most) dimension. |
sub_right [Bigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the second dimension. |
sub_right [Bigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the second dimension. |
sub_right [Bigarray.Genarray] | Extract a sub-array of the given Bigarray by restricting the last (right-most) dimension. |
sub_string [BytesLabels] | Same as |
sub_string [Bytes] | Same as |
subbytes [Digest] |
|
subset [Set.S] |
|
subset [MoreLabels.Set.S] |
|
substitute_first [Str] | Same as |
substring [Digest] |
|
succ [Targetint] | Successor. |
succ [Uchar] |
|
succ [Nativeint] | Successor. |
succ [Int64] | Successor. |
succ [Int32] | Successor. |
succ [Int] |
|
succ [Float] |
|
succ [Stdlib] |
|
supports_shared_libraries [Config] | 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_end [Parsing] | See |
symbol_end_pos [Parsing] | Same as |
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_start [Parsing] |
|
symbol_start_pos [Parsing] | Same as |
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] | |
symlink [UnixLabels] |
|
symlink [Unix] |
|
symm [CamlinternalFormat] | |
sync [Event] | 'Synchronize' on an event: offer all the communication possibilities specified in the event to the outside world, and block until one of the communications succeed. |
system [Config] | Name of operating system for the native-code compiler |
system [ThreadUnix] | |
system [UnixLabels] | Execute the given command, wait until it terminates, and return its termination status. |
system [Unix] | Execute the given command, wait until it terminates, and return its termination status. |
systhread_supported [Config] | Whether the system thread library is implemented |
T | |
tag [Ast_helper.Of] | |
tag [Ast_helper.Rf] | |
tag [Obj] | |
take [CamlinternalMenhirLib.General] | |
take [Queue] |
|
take_opt [Queue] |
|
tan [Float] | Tangent. |
tan [Stdlib] | Tangent. |
tanh [Float] | Hyperbolic tangent. |
tanh [Stdlib] | Hyperbolic tangent. |
target [Config] | Whether the compiler is a cross-compiler |
tcdrain [UnixLabels] | Waits until all output written on the given file descriptor has been transmitted. |
tcdrain [Unix] | Waits until all output written on the given file descriptor has been transmitted. |
tcflow [UnixLabels] | Suspend or restart reception or transmission of data on
the given file descriptor, depending on the second argument:
|
tcflow [Unix] | Suspend or restart reception or transmission of data on
the given file descriptor, depending on the second argument:
|
tcflush [UnixLabels] | Discard data written on the given file descriptor but not yet
transmitted, or data received but not yet read, depending on the
second argument: |
tcflush [Unix] | Discard data written on the given file descriptor but not yet
transmitted, or data received but not yet read, depending on the
second argument: |
tcgetattr [UnixLabels] | Return the status of the terminal referred to by the given file descriptor. |
tcgetattr [Unix] | Return the status of the terminal referred to by the given file descriptor. |
tcsendbreak [UnixLabels] | Send a break condition on the given file descriptor. |
tcsendbreak [Unix] | Send a break condition on the given file descriptor. |
tcsetattr [UnixLabels] | Set the status of the terminal referred to by the given file descriptor. |
tcsetattr [Unix] | Set the status of the terminal referred to by the given file descriptor. |
temp_dir_name [Filename] | The name of the initial temporary directory:
Under Unix, the value of the |
temp_file [Filename] |
|
terminal [CamlinternalMenhirLib.InspectionTableFormat.TABLES] | |
terminfo_toplevel_printer [Location] | |
text [Ast_helper.Cf] | |
text [Ast_helper.Ctf] | |
text [Ast_helper.Str] | |
text [Ast_helper.Sig] | |
text_attr [Docstrings] | |
thd3 [Misc] | |
thd4 [Misc] | |
time [UnixLabels] | Return the current time since 00:00:00 GMT, Jan. |
time [Unix] | Return the current time since 00:00:00 GMT, Jan. |
time [Sys] | Return the processor time, in seconds, used by the program since the beginning of execution. |
timed_read [ThreadUnix] | |
timed_write [ThreadUnix] | Behave as |
timed_write_substring [ThreadUnix] | |
times [UnixLabels] | Return the execution times of the process. |
times [Unix] | Return the execution times of the process. |
tl [ListLabels] | Return the given list without its first element. |
tl [List] | Return the given list without its first element. |
to_buffer [Marshal] |
|
to_bytes [Marshal] |
|
to_bytes [Buffer] | Return a copy of the current contents of the buffer. |
to_channel [Marshal] |
|
to_char [Uchar] |
|
to_float [Targetint] | Convert the given target integer to a floating-point number. |
to_float [Nativeint] | Convert the given native integer to a floating-point number. |
to_float [Int64] | Convert the given 64-bit integer to a floating-point number. |
to_float [Int32] | Convert the given 32-bit integer to a floating-point number. |
to_float [Int] |
|
to_float [Bool] |
|
to_hex [Digest] | Return the printable hexadecimal representation of the given digest. |
to_int [Targetint] | Convert the given target integer (type |
to_int [Numbers.Int16] | |
to_int [Numbers.Int8] | |
to_int [Uchar] |
|
to_int [Nativeint] | Convert the given native integer (type |
to_int [Int64] | Convert the given 64-bit integer (type |
to_int [Int32] | Convert the given 32-bit integer (type |
to_int [Float] | Truncate the given floating-point number to an integer. |
to_int [Bool] |
|
to_int32 [Targetint] | Convert the given target integer to a
32-bit integer (type |
to_int32 [Nativeint] | Convert the given native integer to a
32-bit integer (type |
to_int32 [Int64] | Convert the given 64-bit integer (type |
to_int64 [Targetint] | Convert the given target integer to a
64-bit integer (type |
to_list [Identifiable.Tbl] | |
to_list [Result] |
|
to_list [Option] |
|
to_list [Float.ArrayLabels] |
|
to_list [Float.Array] |
|
to_list [ArrayLabels] |
|
to_list [Array] |
|
to_map [Identifiable.Tbl] | |
to_nativeint [Int64] | Convert the given 64-bit integer (type |
to_option [Result] |
|
to_output_filename [Clflags.Compiler_pass] | |
to_result [Option] |
|
to_rev_seq [Set.S] | Iterate on the whole set, in descending order |
to_rev_seq [MoreLabels.Set.S] | Iterate on the whole set, in descending order |
to_rev_seq [MoreLabels.Map.S] | Iterate on the whole map, in descending order of keys |
to_rev_seq [Map.S] | Iterate on the whole map, in descending order of keys |
to_seq [String] |
|
to_seq [StringLabels] |
|
to_seq [Stack] | Iterate on the stack, top to bottom. |
to_seq [Set.S] | Iterate on the whole set, in ascending order |
to_seq [Result] |
|
to_seq [Queue] | Iterate on the queue, in front-to-back order. |
to_seq [Option] |
|
to_seq [MoreLabels.Set.S] | Iterate on the whole set, in ascending order |
to_seq [MoreLabels.Map.S] | Iterate on the whole map, in ascending order of keys |
to_seq [MoreLabels.Hashtbl.SeededS] | |
to_seq [MoreLabels.Hashtbl.S] | |
to_seq [MoreLabels.Hashtbl] | Iterate on the whole table. |
to_seq [Map.S] | Iterate on the whole map, in ascending order of keys |
to_seq [ListLabels] | Iterate on the list. |
to_seq [List] | Iterate on the list. |
to_seq [Hashtbl.SeededS] | |
to_seq [Hashtbl.S] | |
to_seq [Hashtbl] | Iterate on the whole table. |
to_seq [Float.ArrayLabels] | Iterate on the floatarray, in increasing order. |
to_seq [Float.Array] | Iterate on the floatarray, in increasing order. |
to_seq [BytesLabels] | Iterate on the string, in increasing index order. |
to_seq [Bytes] | Iterate on the string, in increasing index order. |
to_seq [Buffer] | Iterate on the buffer, in increasing order. |
to_seq [ArrayLabels] | Iterate on the array, in increasing order. |
to_seq [Array] | Iterate on the array, in increasing order. |
to_seq_from [Set.S] |
|
to_seq_from [MoreLabels.Set.S] |
|
to_seq_from [MoreLabels.Map.S] |
|
to_seq_from [Map.S] |
|
to_seq_keys [MoreLabels.Hashtbl.SeededS] | |
to_seq_keys [MoreLabels.Hashtbl.S] | |
to_seq_keys [MoreLabels.Hashtbl] | Same as |
to_seq_keys [Hashtbl.SeededS] | |
to_seq_keys [Hashtbl.S] | |
to_seq_keys [Hashtbl] | Same as |
to_seq_values [MoreLabels.Hashtbl.SeededS] | |
to_seq_values [MoreLabels.Hashtbl.S] | |
to_seq_values [MoreLabels.Hashtbl] | Same as |
to_seq_values [Hashtbl.SeededS] | |
to_seq_values [Hashtbl.S] | |
to_seq_values [Hashtbl] | Same as |
to_seqi [String] |
|
to_seqi [StringLabels] |
|
to_seqi [Float.ArrayLabels] | Iterate on the floatarray, in increasing order, yielding indices along elements. |
to_seqi [Float.Array] | Iterate on the floatarray, in increasing order, yielding indices along elements. |
to_seqi [BytesLabels] | Iterate on the string, in increasing order, yielding indices along chars |
to_seqi [Bytes] | Iterate on the string, in increasing order, yielding indices along chars |
to_seqi [Buffer] | Iterate on the buffer, in increasing order, yielding indices along chars. |
to_seqi [ArrayLabels] | Iterate on the array, in increasing order, yielding indices along elements. |
to_seqi [Array] | Iterate on the array, in increasing order, yielding indices along elements. |
to_string [Targetint] | Return the string representation of its argument, in decimal. |
to_string [Numbers.Int] | |
to_string [Identifiable.Set] | |
to_string [Clflags.Compiler_pass] | |
to_string [Unit] |
|
to_string [Printexc] |
|
to_string [Nativeint] | Return the string representation of its argument, in decimal. |
to_string [Marshal] | Same as |
to_string [Int64] | Return the string representation of its argument, in decimal. |
to_string [Int32] | Return the string representation of its argument, in signed decimal. |
to_string [Int] |
|
to_string [Float] | Return the string representation of a floating-point number. |
to_string [BytesLabels] | Return a new string that contains the same bytes as the given byte sequence. |
to_string [Bytes] | Return a new string that contains the same bytes as the given byte sequence. |
to_string [Bool] |
|
to_string_default [Printexc] |
|
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 |
top [CamlinternalMenhirLib.IncrementalEngine.INCREMENTAL_ENGINE] | |
top [Stack] |
|
top [Queue] |
|
top_opt [Stack] |
|
top_phrase [Printast] | |
top_phrase [Pprintast] | |
toplevel_phrase [Pprintast] | |
toplevel_phrase [Parser.Incremental] | |
toplevel_phrase [Parser] | |
toplevel_phrase [Parse] | |
total_size [Marshal] | See |
trace [CamlinternalMenhirLib.TableFormat.TABLES] | |
traditional2revised [CamlinternalMenhirLib.Convert.Simplified] | |
traditional2revised [CamlinternalMenhirLib.Convert] | |
trans [CamlinternalFormat] | |
transfer [Queue] |
|
transl [Profile] | |
transparent_modules [Clflags] | |
transpose_keys_and_data [Identifiable.Map] | |
transpose_keys_and_data_set [Identifiable.Map] | |
trim [String] |
|
trim [StringLabels] |
|
trim [BytesLabels] | Return a copy of the argument, without leading and trailing whitespace. |
trim [Bytes] | Return a copy of the argument, without leading and trailing whitespace. |
trunc [Float] |
|
truncate [UnixLabels.LargeFile] | See |
truncate [UnixLabels] | Truncates the named file to the given size. |
truncate [Unix.LargeFile] | See |
truncate [Unix] | Truncates the named file to the given size. |
truncate [Obj] | |
truncate [Buffer] |
|
truncate [Stdlib] | Same as |
try_ [Ast_helper.Exp] | |
try_acquire [Semaphore.Binary] |
|
try_acquire [Semaphore.Counting] |
|
try_finally [Misc] |
|
try_lock [Mutex] | Same as |
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_format [CamlinternalFormat] | |
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] | Print a type variable name, taking care of the special treatment required for the single quote character in second position. |
U | |
umask [UnixLabels] | Set the process's file mode creation mask, and return the previous mask. |
umask [Unix] | Set the process's file mode creation mask, and return the previous mask. |
unaligned_tag [Obj] | |
unbox_closures [Clflags] | |
unbox_closures_factor [Clflags] | |
unbox_free_vars_of_closures [Clflags] | |
unbox_specialised_args [Clflags] | |
unboxed_types [Clflags] | |
uncapitalize [String] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set. |
uncapitalize [StringLabels] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set. |
uncapitalize [BytesLabels] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set. |
uncapitalize [Bytes] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set. |
uncapitalize_ascii [String] |
|
uncapitalize_ascii [StringLabels] |
|
uncapitalize_ascii [BytesLabels] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set. |
uncapitalize_ascii [Bytes] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set. |
unescaped [Scanf] |
|
unflatten [Longident] | For a non-empty list |
unflatten1 [CamlinternalMenhirLib.PackedIntArray] | |
unfold [Seq] | Build a sequence from a step function and an initial value. |
union [Set.S] | Set union. |
union [MoreLabels.Set.S] | Set union. |
union [MoreLabels.Map.S] |
|
union [Map.S] |
|
union_left [Identifiable.Map] |
|
union_merge [Identifiable.Map] | |
union_right [Identifiable.Map] |
|
uniq [CamlinternalMenhirLib.General] | |
unique_ids [Clflags] | |
unix [Sys] | True if |
unlink [UnixLabels] | Removes the named file. |
unlink [Unix] | Removes the named file. |
unlock [Mutex] | Unlock the given mutex. |
unmarshal [Obj] | |
unpack [Ast_helper.Mod] | |
unpack [Ast_helper.Pat] | |
unreachable [Ast_helper.Exp] | |
unsafe [Clflags] | |
unsafe_environment [UnixLabels] | Return the process environment, as an array of strings with the format ``variable=value''. |
unsafe_environment [Unix] | Return the process environment, as an array of strings with the format ``variable=value''. |
unsafe_get [Bigarray.Array3] | Like |
unsafe_get [Bigarray.Array2] | Like |
unsafe_get [Bigarray.Array1] | Like |
unsafe_getenv [UnixLabels] | Return the value associated to a variable in the process environment. |
unsafe_getenv [Unix] | Return the value associated to a variable in the process environment. |
unsafe_of_string [BytesLabels] | Unsafely convert a shared string to a byte sequence that should not be mutated. |
unsafe_of_string [Bytes] | Unsafely convert a shared string to a byte sequence that should not be mutated. |
unsafe_set [Bigarray.Array3] | Like |
unsafe_set [Bigarray.Array2] | Like |
unsafe_set [Bigarray.Array1] | Like |
unsafe_string [Clflags] | |
unsafe_to_string [BytesLabels] | Unsafely convert a byte sequence into a string. |
unsafe_to_string [Bytes] | Unsafely convert a byte sequence into a string. |
unset_data [Obj.Ephemeron] | Same as |
unset_data [Ephemeron.Kn] | Same as |
unset_data [Ephemeron.K2] | Same as |
unset_data [Ephemeron.K1] |
|
unset_key [Obj.Ephemeron] | Same as |
unset_key [Ephemeron.Kn] | Same as |
unset_key [Ephemeron.K1] |
|
unset_key1 [Ephemeron.K2] | Same as |
unset_key2 [Ephemeron.K2] | Same as |
unsigned_compare [Targetint] | Same as |
unsigned_compare [Nativeint] | Same as |
unsigned_compare [Int64] | Same as |
unsigned_compare [Int32] | Same as |
unsigned_div [Targetint] | Same as |
unsigned_div [Nativeint] | Same as |
unsigned_div [Int64] | Same as |
unsigned_div [Int32] | Same as |
unsigned_rem [Targetint] | Same as |
unsigned_rem [Nativeint] | Same as |
unsigned_rem [Int64] | Same as |
unsigned_rem [Int32] | Same as |
unsigned_to_int [Nativeint] | Same as |
unsigned_to_int [Int64] | Same as |
unsigned_to_int [Int32] | Same as |
update [MoreLabels.Map.S] |
|
update [Map.S] |
|
update_geometry [Format] | |
update_mod [CamlinternalMod] | |
uppercase [String] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
uppercase [StringLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
uppercase [Char] | Convert the given character to its equivalent uppercase character, using the ISO Latin-1 (8859-1) character set. |
uppercase [BytesLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
uppercase [Bytes] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
uppercase_ascii [String] |
|
uppercase_ascii [StringLabels] |
|
uppercase_ascii [Char] | Convert the given character to its equivalent uppercase character, using the US-ASCII character set. |
uppercase_ascii [BytesLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set. |
uppercase_ascii [Bytes] | Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set. |
usage [Arg] |
|
usage_string [Arg] | Returns the message that would have been printed by |
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_printers [Printexc] |
|
use_runtime [Clflags] | |
use_threads [Clflags] | |
utimes [UnixLabels] | Set the last access time (second arg) and last modification time (third arg) for a file. |
utimes [Unix] | Set the last access time (second arg) and last modification time (third arg) for a file. |
V | |
val_ [Ast_helper.Cf] | |
val_ [Ast_helper.Ctf] | |
val_ident [Parse] | This function parses a syntactically valid path for a value. |
value [Ast_helper.Str] | |
value [Ast_helper.Sig] | |
value [Result] |
|
value [Option] |
|
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] |
|
verbose [Clflags] | |
version [Config] | The current version number of the system |
virtual_ [Ast_helper.Cf] | |
W | |
wait [ThreadUnix] | |
wait [Condition] |
|
wait [UnixLabels] | Wait until one of the children processes die, and return its pid and termination status. |
wait [Unix] | Wait until one of the children processes die, and return its pid and termination status. |
wait_pid [Thread] | Same function as |
wait_read [Thread] | This function does nothing in the current implementation of the threading library and can be removed from all user programs. |
wait_signal [Thread] |
|
wait_timed_read [Thread] | |
wait_timed_write [Thread] | Suspend the execution of the calling thread until at least
one character or EOF is available for reading ( |
wait_write [Thread] | This function does nothing in the current implementation of the threading library and can be removed from all user programs. |
waitpid [ThreadUnix] | |
waitpid [UnixLabels] | Same as |
waitpid [Unix] | Same as |
warn_bad_docstrings [Docstrings] | Emit warnings for unattached and ambiguous docstrings |
warn_on_literal_pattern [Builtin_attributes] | |
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] | |
while_ [Ast_helper.Exp] | |
widen [CamlinternalOO] | |
win32 [Sys] | True if |
windows_unicode [Config] | Whether Windows Unicode runtime is enabled |
with_ [Ast_helper.Mty] | |
with_default_loc [Ast_helper] | Set the |
with_flambda_invariants [Config] | Whether the invariants checks for flambda are enabled |
with_frame_pointers [Config] | Whether assembler should maintain frame pointers |
with_positions [Lexing] | Tell whether the lexer buffer keeps track of position fields
|
with_runtime [Clflags] | |
with_store [Local_store] |
|
with_tag [Obj] | |
without_warnings [Warnings] | Run the thunk with all warnings and alerts disabled. |
word_size [Sys] | Size of one word on the machine currently executing the OCaml program, in bits: 32 or 64. |
wrap [CamlinternalMenhirLib.ErrorReports] | |
wrap [Event] |
|
wrap_abort [Event] |
|
write [CamlinternalMenhirLib.LinearizedArray] | |
write [ThreadUnix] | |
write [UnixLabels] |
|
write [Unix] |
|
write_arg [Arg] |
|
write_arg0 [Arg] | Identical to |
write_ast [Pparse] | |
write_substring [ThreadUnix] | |
write_substring [UnixLabels] | Same as |
write_substring [Unix] | Same as |
X | |
xfirst [CamlinternalMenhirLib.IncrementalEngine.INSPECTION] | |
Y | |
yield [Thread] | Re-schedule the calling thread without suspending it. |
Z | |
zero [Targetint] | The target integer 0. |
zero [Numbers.Int8] | |
zero [Nativeint] | The native integer 0. |
zero [Int64] | The 64-bit integer 0. |
zero [Int32] | The 32-bit integer 0. |
zero [Int] |
|
zero [Float] | The floating point 0. |
zero [Complex] | The complex number |
zero_to_n [Numbers.Int] |
|