( * ) [Pervasives] | Integer multiplication. |
( ** ) [Pervasives] | Exponentiation. |
( *. ) [Pervasives] | Floating-point multiplication. |
(!) [Pervasives] |
|
(!=) [Pervasives] | Negation of |
(&&) [Pervasives] | The boolean 'and'. |
(&) [Pervasives] | |
(+) [Pervasives] | Integer addition. |
(+.) [Pervasives] | Floating-point addition. |
(-) [Pervasives] | Integer subtraction. |
(-.) [Pervasives] | Floating-point subtraction. |
(/) [Pervasives] | Integer division. |
(/.) [Pervasives] | Floating-point division. |
(:=) [Pervasives] |
|
(<) [Pervasives] | See |
(<=) [Pervasives] | See |
(<>) [Pervasives] | Negation of |
(=) [Pervasives] |
|
(==) [Pervasives] |
|
(>) [Pervasives] | See |
(>=) [Pervasives] | Structural ordering functions. |
(@) [Pervasives] | List concatenation. |
(@@) [Pervasives] | Application operator: |
(^) [Pervasives] | String concatenation. |
(^^) [Pervasives] |
|
(asr) [Pervasives] |
|
(land) [Pervasives] | Bitwise logical and. |
(lor) [Pervasives] | Bitwise logical or. |
(lsl) [Pervasives] |
|
(lsr) [Pervasives] |
|
(lxor) [Pervasives] | Bitwise logical exclusive or. |
(mod) [Pervasives] | Integer remainder. |
(or) [Pervasives] | |
(|>) [Pervasives] | Reverse-application operator: |
(||) [Pervasives] | The boolean 'or'. |
(~+) [Pervasives] | Unary addition. |
(~+.) [Pervasives] | Unary addition. |
(~-) [Pervasives] | Unary negation. |
(~-.) [Pervasives] | Unary negation. |
__FILE__ [Pervasives] |
|
__LINE_OF__ [Pervasives] |
|
__LINE__ [Pervasives] |
|
__LOC_OF__ [Pervasives] |
|
__LOC__ [Pervasives] |
|
__MODULE__ [Pervasives] |
|
__POS_OF__ [Pervasives] |
|
__POS__ [Pervasives] |
|
A | |
abs [Targetint] | Return the absolute value of its argument. |
abs [Pervasives] | Return the absolute value of the 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 [Float] |
|
abs_float [Pervasives] |
|
absname [Location] | |
absolute_path [Location] | |
abstract_tag [Obj] | |
accept [UnixLabels] | Accept connections on the given socket. |
accept [Unix] | Accept connections on the given socket. |
accept [ThreadUnix] | |
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 [Pervasives] | Arc cosine. |
acos [Float] | Arc cosine. |
adapt_filename [Dynlink] | In bytecode, the identity function. |
add [Weak.S] |
|
add [Tbl] | |
add [Targetint] | Addition. |
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 [Int64] | Addition. |
add [Int32] | Addition. |
add [Hashtbl.SeededS] | |
add [Hashtbl.S] | |
add [Hashtbl] |
|
add [Float] | Floating-point addition. |
add [Map.S] |
|
add [Set.S] |
|
add [Complex] | Addition |
add_arguments [Clflags] | |
add_available_units [Dynlink] | Same as |
add_base_override [Arg_helper.Make] | |
add_buffer [Buffer] |
|
add_bytes [Buffer] |
|
add_channel [Buffer] |
|
add_char [Buffer] |
|
add_docs_attrs [Docstrings] | Convert item documentation to attributes and add them to an attribute list |
add_hook [Misc.HookSig] | |
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_interfaces [Dynlink] |
|
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 [Queue] | Add the elements from the generator to the end of the queue |
add_seq [MoreLabels.Set.S] | |
add_seq [MoreLabels.Map.S] | |
add_seq [MoreLabels.Hashtbl.SeededS] | |
add_seq [MoreLabels.Hashtbl.S] | |
add_seq [MoreLabels.Hashtbl] | |
add_seq [Hashtbl.SeededS] | |
add_seq [Hashtbl.S] | |
add_seq [Hashtbl] | Add the given bindings to the table, using |
add_seq [Map.S] | Add the given bindings to the map, in order. |
add_seq [Set.S] | Add the given elements to the set, in order. |
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_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] | |
afl_instrument [Clflags] | |
alarm [UnixLabels] | Schedule a |
alarm [Unix] | Schedule a |
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] | |
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 [ListLabels] | Catenate two lists. |
append [List] | Concatenate two lists. |
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_hooks [Misc.HookSig] | |
apply_rewriters [Pparse] | If |
apply_rewriters_sig [Pparse] | |
apply_rewriters_str [Pparse] | |
ar [Config] | |
architecture [Config] | |
arg [Complex] | Argument. |
arg_spec [Clflags] | |
argv [Sys] | The command line arguments given to the process. |
array [Sort] | Sort an array in increasing order according to an ordering predicate. |
array [Ast_helper.Exp] | |
array [Ast_helper.Pat] | |
array0_of_genarray [Bigarray] | Return the zero-dimensional big array corresponding to the given generic big array. |
array1_of_genarray [Bigarray] | Return the one-dimensional big array corresponding to the given generic big array. |
array2_of_genarray [Bigarray] | Return the two-dimensional big array corresponding to the given generic big array. |
array3_of_genarray [Bigarray] | Return the three-dimensional big array corresponding to the given generic big array. |
arrow [Ast_helper.Cty] | |
arrow [Ast_helper.Typ] | |
asin [Pervasives] | Arc sine. |
asin [Float] | Arc sine. |
asm [Config] | |
asm_cfi_supported [Config] | |
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] | |
ast_intf_magic_number [Config] | |
at_exit [Pervasives] | Register the given function to be called at program termination time. |
atan [Pervasives] | Arc tangent. |
atan [Float] | Arc tangent. |
atan2 [Pervasives] |
|
atan2 [Float] |
|
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. |
auto_synchronize [Graphics] | By default, drawing takes place both on the window displayed on screen, and in a memory area (the 'backing store'). |
B | |
backend_type [Sys] | Backend type currently executing the OCaml program. |
background [Graphics] | See |
backtrace_slots [Printexc] | Returns the slots of a raw backtrace, or |
backtrace_status [Printexc] |
|
backup [Warnings] | |
backup [Terminfo] | |
basename [Filename] | Split a file name into directory name / base file name. |
beginning_of_input [Scanf.Scanning] |
|
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. |
bindings [MoreLabels.Map.S] | |
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. |
black [Graphics] | |
blit [Weak] |
|
blit [String] | Same as |
blit [StringLabels] |
|
blit [Misc.LongString] | |
blit [BytesLabels] |
|
blit [Bytes] |
|
blit [Buffer] |
|
blit [Bigarray.Array3] | Copy the first big array to the second big array. |
blit [Bigarray.Array2] | Copy the first big array to the second big array. |
blit [Bigarray.Array1] | Copy the first big array to the second big array. |
blit [Bigarray.Array0] | Copy the first big array to the second big array. |
blit [Bigarray.Genarray] | Copy all elements of a big array in another big array. |
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_image [Graphics] |
|
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 [BytesLabels] |
|
blit_string [Bytes] |
|
blue [Graphics] | |
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 [Pervasives] | Convert the given string to a boolean. |
bool_of_string_opt [Pervasives] | 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] | |
button_down [Graphics] | Return |
bytecode_compatible_32 [Clflags] | |
bytecomp_c_libraries [Config] | |
bytes [Digest] | Return the digest of the given byte sequence. |
C | |
c_compiler [Config] | |
c_compiler [Clflags] | |
c_layout [Bigarray] | |
c_output_obj [Config] | |
call_external_preprocessor [Pparse] | |
call_linker [Ccomp] | |
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] | Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set. |
capitalize_ascii [StringLabels] | Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set. |
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 [MoreLabels.Set.S] | |
cardinal [MoreLabels.Map.S] | |
cardinal [Map.S] | Return the number of bindings of a map. |
cardinal [Set.S] | Return the number of elements of a set. |
case [Ast_helper.Exp] | |
cat [BytesLabels] |
|
cat [Bytes] |
|
catch [Printexc] |
|
catch_break [Sys] |
|
cc_profile [Config] | |
ccobjs [Clflags] | |
ccomp_type [Config] | |
ceil [Pervasives] | Round above to an integer value. |
ceil [Float] | 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 [Bigarray] | As shown by the types of the values above,
big arrays of kind |
char [Ast_helper.Const] | |
char_of_iconv [CamlinternalFormat] | |
char_of_int [Pervasives] | 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 [Weak] |
|
check [Consistbl] | |
check_data [Obj.Ephemeron] | Same as |
check_data [Ephemeron.Kn] | Same as |
check_data [Ephemeron.K2] | Same as |
check_data [Ephemeron.K1] |
|
check_deprecated [Builtin_attributes] | |
check_deprecated_inclusion [Builtin_attributes] | |
check_deprecated_mutable [Builtin_attributes] | |
check_deprecated_mutable_inclusion [Builtin_attributes] | |
check_fatal [Warnings] | |
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_noadd [Consistbl] | |
check_nongen_schemes [Typemod] | |
check_suffix [Filename] |
|
chmod [UnixLabels] | Change the permissions of the named file. |
chmod [Unix] | Change the permissions of the named file. |
choose [MoreLabels.Set.S] | |
choose [MoreLabels.Map.S] | |
choose [Event] |
|
choose [Map.S] | Return one binding of the given map, or raise |
choose [Set.S] | Return one element of the given set, or raise |
choose_opt [MoreLabels.Set.S] | |
choose_opt [MoreLabels.Map.S] | |
choose_opt [Map.S] | Return one binding of the given map, or |
choose_opt [Set.S] | Return one element of the given set, or |
chop_extension [Filename] | Same as |
chop_extensions [Misc] | |
chop_suffix [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 [Pervasives] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number. |
classify_float [Float] | 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 [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] | |
clear [Hashtbl.SeededS] | |
clear [Hashtbl.S] | |
clear [Hashtbl] | Empty a hash table. |
clear [Consistbl] | |
clear [Buffer] | Empty the buffer. |
clear_available_units [Dynlink] | Empty the list of compilation units accessible to dynamically-linked programs. |
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_graph [Graphics] | Erase the graphics window. |
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_graph [Graphics] | Delete the graphics window or switch the screen back to text mode. |
close_in [Scanf.Scanning] | Closes the |
close_in [Pervasives] | Close the given channel. |
close_in_noerr [Pervasives] | Same as |
close_out [Pervasives] | Close the given channel, flushing all buffered write operations. |
close_out_noerr [Pervasives] | 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_subwindow [GraphicsX11] | Close the sub-window having the given identifier. |
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] | |
cmi_magic_number [Config] | |
cmo_magic_number [Config] | |
cmt_magic_number [Config] | |
cmx_magic_number [Config] | |
cmxa_magic_number [Config] | |
cmxs_magic_number [Config] | |
code [Char] | Return the ASCII code of the argument. |
coerce [Ast_helper.Exp] | |
color [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 [Sys] | Execute the given shell command and return its exit code. |
command [Ccomp] | |
comments [Lexer] | |
compact [Gc] | Perform a full major collection and compact the heap. |
compare [Uchar] |
|
compare [Targetint] | The comparison function for target integers, with the same specification as
|
compare [String] | The comparison function for strings, with the same specification as
|
compare [StringLabels] | The comparison function for strings, with the same specification as
|
compare [Pervasives] |
|
compare [Nativeint] | The comparison function for native integers, with the same specification as
|
compare [MoreLabels.Set.S] | |
compare [MoreLabels.Map.S] | |
compare [Misc.Stdlib.List] | The lexicographic order supported by the provided order. |
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 [Map.OrderedType] | A total ordering function over the keys. |
compare [Set.OrderedType] | A total ordering function over the set elements. |
compare [Float] |
|
compare [Digest] | The comparison function for 16-character digest, with the same
specification as |
compare [Map.S] | Total ordering between maps. |
compare [Set.S] | Total ordering between sets. |
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_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. |
compile_file [Ccomp] | |
compile_only [Clflags] | |
complex32 [Bigarray] | See |
complex64 [Bigarray] | See |
component_graph [Strongly_connected_components.S] | |
concat [String] |
|
concat [StringLabels] |
|
concat [ListLabels] | Concatenate a list of lists. |
concat [List] | Concatenate a list of lists. |
concat [Filename] |
|
concat [BytesLabels] |
|
concat [Bytes] |
|
concat [ArrayLabels] | Same as |
concat [Array] | Same as |
concat_fmt [CamlinternalFormatBasics] | |
concat_fmtty [CamlinternalFormatBasics] | |
concrete [Ast_helper.Cf] | |
conj [Complex] | Conjugate: given the complex |
connect [UnixLabels] | Connect a socket to an address. |
connect [Unix] | Connect a socket to an address. |
connect [ThreadUnix] | |
connected_components_sorted_from_roots_to_leaf [Strongly_connected_components.S] | |
cons [ListLabels] |
|
cons [List] |
|
constant [Ast_helper.Exp] | |
constant [Ast_helper.Pat] | |
constr [Ast_helper.Cl] | |
constr [Ast_helper.Cty] | |
constr [Ast_helper.Typ] | |
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 [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] | |
copy [Hashtbl.SeededS] | |
copy [Hashtbl.S] | |
copy [Hashtbl] | Return a copy of the given hashtable. |
copy [CamlinternalOO] | |
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] | |
copysign [Pervasives] |
|
copysign [Float] |
|
core_type [Pprintast] | |
core_type [Parse] | |
cos [Pervasives] | Cosine. |
cos [Float] | Cosine. |
cosh [Pervasives] | Hyperbolic cosine. |
cosh [Float] | 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 [Weak.S] |
|
create [Weak] |
|
create [Thread] |
|
create [String] |
|
create [StringLabels] |
|
create [Stack] | Return a new stack, initially empty. |
create [Spacetime.Series] |
|
create [Queue] | Return a new queue, initially empty. |
create [Obj.Ephemeron] |
|
create [Mutex] | Return a new mutex. |
create [MoreLabels.Hashtbl.SeededS] | |
create [MoreLabels.Hashtbl.S] | |
create [MoreLabels.Hashtbl] | |
create [Misc.LongString] | |
create [Hashtbl.SeededS] | |
create [Hashtbl.S] | |
create [Hashtbl] |
|
create [Float.Array] | |
create [Ephemeron.Kn] | Same as |
create [Ephemeron.K2] | Same as |
create [Ephemeron.K1] |
|
create [Consistbl] | |
create [Condition] | Return a new condition variable. |
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_float [ArrayLabels] |
|
create_float [Array] |
|
create_hashtable [Misc] | |
create_image [Graphics] |
|
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_point [Graphics] | Return the position of the current point. |
current_x [Graphics] | Return the abscissa of the current point. |
current_y [Graphics] | Return the ordinate of the current point. |
curveto [Graphics] |
|
custom_runtime [Clflags] | |
custom_tag [Obj] | |
cut_at [Misc] |
|
cyan [Graphics] | |
cygwin [Sys] | True if |
D | |
data [Identifiable.Map] | |
data_size [Marshal] | See |
debug [Clflags] | |
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 [Pervasives] | Decrement the integer contained in the given reference. |
default [Arg_helper.Make] | |
default_available_units [Dynlink] | Reset the set of units that can be referenced from dynamically-linked code to its default value, that is, all units composing the currently running program. |
default_error_reporter [Location] | Original error reporter for use in hooks. |
default_executable_name [Config] | |
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_printer [Location] | |
default_safe_string [Config] | |
default_simplify_rounds [Clflags] | |
default_styles [Misc.Color] | |
default_unbox_closures_factor [Clflags] | |
default_warning_printer [Location] | Original warning printer for use in hooks. |
defaults_w [Warnings] | |
defaults_warn_error [Warnings] | |
delay [Thread] |
|
delete_alarm [Gc] |
|
delete_eol_spaces [Misc] |
|
deprecated [Location] | |
deprecated_of_attrs [Builtin_attributes] | |
deprecated_of_sig [Builtin_attributes] | |
deprecated_of_str [Builtin_attributes] | |
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 [MoreLabels.Set.S] | |
diff [Set.S] | Set difference. |
dim [Bigarray.Array1] | Return the size (dimension) of the given one-dimensional big array. |
dim1 [Bigarray.Array3] | Return the first dimension of the given three-dimensional big array. |
dim1 [Bigarray.Array2] | Return the first dimension of the given two-dimensional big array. |
dim2 [Bigarray.Array3] | Return the second dimension of the given three-dimensional big array. |
dim2 [Bigarray.Array2] | Return the second dimension of the given two-dimensional big array. |
dim3 [Bigarray.Array3] | Return the third dimension of the given three-dimensional big array. |
dims [Bigarray.Genarray] |
|
dir_sep [Filename] | The directory separator (e.g. |
dirname [Filename] | See |
disjoint_union [Identifiable.Map] |
|
display_mode [Graphics] | Set display mode on or off. |
div [Targetint] | Integer division. |
div [Nativeint] | Integer division. |
div [Int64] | Integer division. |
div [Int32] | Integer division. |
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_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] | |
draw_arc [Graphics] |
|
draw_char [Graphics] | See |
draw_circle [Graphics] |
|
draw_ellipse [Graphics] |
|
draw_image [Graphics] | Draw the given image with lower left corner at the given point. |
draw_poly [Graphics] |
|
draw_poly_line [Graphics] |
|
draw_rect [Graphics] |
|
draw_segments [Graphics] |
|
draw_string [Graphics] | Draw a character or a character string with lower left corner at current position. |
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_image [Graphics] | Convert an image to a color matrix. |
dump_instr [Clflags] | |
dump_interf [Clflags] | |
dump_interval [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 [MoreLabels.Set.S] | |
elements [Set.S] | Return the list of all elements of the given set. |
empty [Tbl] | |
empty [Stream] | Return |
empty [Seq] | The empty sequence, containing no elements. |
empty [MoreLabels.Set.S] | |
empty [MoreLabels.Map.S] | |
empty [Map.S] | The empty map. |
empty [Set.S] | The empty set. |
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_call_counts [Config] | |
enable_runtime_warnings [Sys] | Control whether the OCaml runtime system can emit warnings on stderr. |
enabled [Spacetime] |
|
encode_map [Build_path_prefix_map] | |
encode_pair [Build_path_prefix_map] | |
encode_prefix [Build_path_prefix_map] | |
end_of_input [Scanf.Scanning] |
|
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 [Pervasives] | The difference between |
equal [Uchar] |
|
equal [Targetint] | The equal function for target ints. |
equal [String] | The equal function for strings. |
equal [StringLabels] | The equal function for strings. |
equal [Nativeint] | The equal function for native ints. |
equal [MoreLabels.Set.S] | |
equal [MoreLabels.Map.S] | |
equal [Misc.Stdlib.Option] | |
equal [Misc.Stdlib.List] | Returns |
equal [Int64] | The equal function for int64s. |
equal [Int32] | The equal function for int32s. |
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 [Digest] | The equal function for 16-character digest. |
equal [Map.S] |
|
equal [Set.S] |
|
equal [Char] | The equal function for chars. |
equal [BytesLabels] | The equality function for byte sequences. |
equal [Bytes] | The equality function for byte sequences. |
erase_rel [CamlinternalFormatBasics] | |
err_formatter [Format] | A formatter to write to standard error. |
error [Location] | |
error_message [UnixLabels] | Return a string describing the given error code. |
error_message [Unix] | Return a string describing the given error code. |
error_message [Dynlink] | Convert an error description to a printable message. |
error_of_exn [Location] | |
error_of_extension [Builtin_attributes] | |
error_of_printer [Location] | |
error_of_printer_file [Location] | |
error_reporter [Location] | Hook for intercepting error reports. |
error_size [Clflags] | |
errorf [Location] | |
escaped [String] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml. |
escaped [StringLabels] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml. |
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. |
establish_server [ThreadUnix] | |
eval [Ast_helper.Str] | |
exception_ [Ast_helper.Str] | |
exception_ [Ast_helper.Sig] | |
exception_ [Ast_helper.Pat] | |
exec_magic_number [Config] | |
executable_name [Sys] | The name of the file containing the executable currently running. |
execv [UnixLabels] |
|
execv [Unix] |
|
execv [ThreadUnix] | |
execve [UnixLabels] | Same as |
execve [Unix] | Same as |
execve [ThreadUnix] | |
execvp [UnixLabels] | Same as |
execvp [Unix] | Same as |
execvp [ThreadUnix] | |
execvpe [UnixLabels] | Same as |
execvpe [Unix] | Same as |
exists [MoreLabels.Set.S] | |
exists [MoreLabels.Map.S] | |
exists [ListLabels] |
|
exists [List] |
|
exists [Map.S] |
|
exists [Set.S] |
|
exists [ArrayLabels] |
|
exists [Array] |
|
exists2 [Misc.Stdlib.Array] | |
exists2 [ListLabels] | Same as |
exists2 [List] | Same as |
exit [Thread] | Terminate prematurely the currently executing thread. |
exit [Pervasives] | 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 [Pervasives] | Exponential. |
exp [Float] | Exponential. |
exp [Complex] | Exponentiation. |
expand_directory [Misc] | |
expand_libname [Ccomp] | |
explicit_arity [Builtin_attributes] | |
expm1 [Pervasives] |
|
expm1 [Float] |
|
expression [Printast] | |
expression [Pprintast] | |
expression [Parse] | |
ext_asm [Config] | |
ext_dll [Config] | |
ext_lib [Config] | |
ext_obj [Config] | |
extend [BytesLabels] |
|
extend [Bytes] |
|
extension [Filename] |
|
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_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. |
extract [Consistbl] | |
F | |
failwith [Pervasives] | Raise exception |
fast [Clflags] | |
fast_sort [ListLabels] | Same as |
fast_sort [List] | 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. |
field [Obj] | |
field [Ast_helper.Type] | |
field [Ast_helper.Exp] | |
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. |
fill [Weak] |
|
fill [String] |
|
fill [StringLabels] |
|
fill [BytesLabels] |
|
fill [Bytes] |
|
fill [Bigarray.Array3] | Fill the given big array with the given value. |
fill [Bigarray.Array2] | Fill the given big array with the given value. |
fill [Bigarray.Array1] | Fill the given big array with the given value. |
fill [Bigarray.Array0] | Fill the given big array with the given value. |
fill [Bigarray.Genarray] | Set all elements of a big array to a given value. |
fill [ArrayLabels] |
|
fill [Array] |
|
fill_arc [Graphics] | Fill an elliptical pie slice with the current color. |
fill_circle [Graphics] | Fill a circle with the current color. |
fill_ellipse [Graphics] | Fill an ellipse with the current color. |
fill_poly [Graphics] | Fill the given polygon with the current color. |
fill_rect [Graphics] |
|
filter [Seq] | Remove from the sequence the elements that do not satisfy the given predicate. |
filter [MoreLabels.Set.S] | |
filter [MoreLabels.Map.S] | |
filter [ListLabels] |
|
filter [List] |
|
filter [Map.S] |
|
filter [Set.S] |
|
filter [Consistbl] | |
filter_map [Seq] | Apply the function to every element; if |
filter_map [Misc.Stdlib.List] |
|
filter_map [Identifiable.Map] | |
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] |
|
final_tag [Obj] | |
finalise [Gc] |
|
finalise_last [Gc] | same as |
finalise_release [Gc] | A finalisation function may call |
find [Weak.S] |
|
find [Tbl] | |
find [MoreLabels.Set.S] | |
find [MoreLabels.Map.S] | |
find [MoreLabels.Hashtbl.SeededS] | |
find [MoreLabels.Hashtbl.S] | |
find [MoreLabels.Hashtbl] | |
find [ListLabels] |
|
find [List] |
|
find [Hashtbl.SeededS] | |
find [Hashtbl.S] | |
find [Hashtbl] |
|
find [Map.S] |
|
find [Set.S] |
|
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_first [MoreLabels.Set.S] | |
find_first [MoreLabels.Map.S] | |
find_first [Map.S] |
|
find_first [Set.S] |
|
find_first_opt [MoreLabels.Set.S] | |
find_first_opt [MoreLabels.Map.S] | |
find_first_opt [Map.S] |
|
find_first_opt [Set.S] |
|
find_in_path [Misc] | |
find_in_path_rel [Misc] | |
find_in_path_uncap [Misc] | |
find_last [MoreLabels.Set.S] | |
find_last [MoreLabels.Map.S] | |
find_last [Map.S] |
|
find_last [Set.S] |
|
find_last_opt [MoreLabels.Set.S] | |
find_last_opt [MoreLabels.Map.S] | |
find_last_opt [Map.S] |
|
find_last_opt [Set.S] |
|
find_opt [Weak.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 [ListLabels] |
|
find_opt [List] |
|
find_opt [Hashtbl.SeededS] | |
find_opt [Hashtbl.S] | |
find_opt [Hashtbl] |
|
find_opt [Map.S] |
|
find_opt [Set.S] |
|
find_str [Tbl] | |
first_chars [Str] |
|
first_non_constant_constructor_tag [Obj] | |
flambda [Config] | |
flambda_invariant_checks [Clflags] | |
flat_float_array [Config] | |
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] | An alias for |
flexdll_dirs [Config] | |
float [Random.State] | |
float [Random] |
|
float [Pervasives] | Same as |
float [Ast_helper.Const] | |
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 [Pervasives] | Convert an integer to floating-point. |
float_of_string [Pervasives] | Convert the given string to a float. |
float_of_string_opt [Pervasives] | Same as |
floor [Pervasives] | Round below to an integer value. |
floor [Float] | Round below to an integer value. |
flush [Pervasives] | Flush the buffer associated with the given output channel, performing all pending writes on that channel. |
flush_all [Pervasives] | 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] |
|
fmt_ebb_of_string [CamlinternalFormat] | |
fold [Weak.S] |
|
fold [Tbl] | |
fold [Stack] |
|
fold [Queue] |
|
fold [MoreLabels.Set.S] | |
fold [MoreLabels.Map.S] | |
fold [MoreLabels.Hashtbl.SeededS] | |
fold [MoreLabels.Hashtbl.S] | |
fold [MoreLabels.Hashtbl] | |
fold [Misc.Stdlib.Option] | |
fold [Hashtbl.SeededS] | |
fold [Hashtbl.S] | |
fold [Hashtbl] |
|
fold [Map.S] |
|
fold [Set.S] |
|
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 [ArrayLabels] |
|
fold_left [Array] |
|
fold_left2 [ListLabels] |
|
fold_left2 [List] |
|
fold_right [ListLabels] |
|
fold_right [List] |
|
fold_right [ArrayLabels] |
|
fold_right [Array] |
|
fold_right2 [ListLabels] |
|
fold_right2 [List] |
|
for4 [Misc] | |
for_ [Ast_helper.Exp] | |
for_all [MoreLabels.Set.S] | |
for_all [MoreLabels.Map.S] | |
for_all [ListLabels] |
|
for_all [List] |
|
for_all [Map.S] |
|
for_all [Set.S] |
|
for_all [ArrayLabels] |
|
for_all [Array] |
|
for_all2 [Misc] | |
for_all2 [ListLabels] | Same as |
for_all2 [List] | Same as |
for_package [Clflags] | |
force [Lazy] |
|
force [CamlinternalLazy] | |
force_lazy_block [CamlinternalLazy] | |
force_newline [Format] | Force a new line in the current pretty-printing box. |
force_poly [Ast_helper.Typ] | |
force_slash [Clflags] | |
force_val [Lazy] |
|
force_val [CamlinternalLazy] | |
force_val_lazy_block [CamlinternalLazy] | |
foreground [Graphics] | Default background and foreground colors (usually, either black foreground on a white background or white foreground on a black background). |
fork [UnixLabels] | Fork a new process. |
fork [Unix] | Fork a new process. |
format [Printexc.Slot] |
|
format_from_string [Scanf] |
|
format_of_string [Pervasives] |
|
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] | |
frexp [Pervasives] |
|
frexp [Float] |
|
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 [Pervasives] | 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. |
ftruncate [UnixLabels.LargeFile] | |
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] | |
functor_ [Ast_helper.Mod] | |
functor_ [Ast_helper.Mty] | |
G | |
genarray_of_array0 [Bigarray] | Return the generic big array corresponding to the given zero-dimensional big array. |
genarray_of_array1 [Bigarray] | Return the generic big array corresponding to the given one-dimensional big array. |
genarray_of_array2 [Bigarray] | Return the generic big array corresponding to the given two-dimensional big array. |
genarray_of_array3 [Bigarray] | Return the generic big array corresponding to the given three-dimensional big array. |
generate [Profile] | |
get [Weak] |
|
get [String] |
|
get [StringLabels] |
|
get [Misc.LongString] | |
get [Gc] | Return the current values of the GC parameters in a |
get [Float.Array] | |
get [Clflags.Float_arg_helper] | |
get [Clflags.Int_arg_helper] | |
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 big array. |
get [ArrayLabels] |
|
get [Array] |
|
get [Arg_helper.Make] | |
get_all_formatter_output_functions [Format] | |
get_backtrace [Printexc] |
|
get_bucket [Gc] |
|
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_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_tag_functions [Format] | Return the current semantic tag operation functions of the standard pretty-printer. |
get_image [Graphics] | Capture the contents of a rectangle on the screen as an image. |
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_pos_info [Location] | |
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_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. |
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. |
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 |
gprofile [Clflags] | |
green [Graphics] | |
group_beginning [Str] |
|
group_end [Str] |
|
guard [Event] |
|
H | |
handle_docstrings [Lexer] | |
handle_unix_error [UnixLabels] |
|
handle_unix_error [Unix] |
|
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] | |
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_locations [Location] | |
host [Config] | |
huge_fallback_count [Gc] | Return the number of times we tried to map huge pages and had to fall back to small pages. |
hypot [Pervasives] |
|
hypot [Float] |
|
I | |
i [Complex] | The complex number |
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. |
ident [Ast_helper.Mod] | |
ident [Ast_helper.Mty] | |
ident [Ast_helper.Exp] | |
ifprintf [Printf] | Same as |
ifprintf [Format] | Same as |
ifthenelse [Ast_helper.Exp] | |
ignore [Pervasives] | Discard the value of its argument and return |
ikfprintf [Printf] | Same as |
ikfprintf [Format] | Same as |
ill_formed_ast [Syntaxerr] | |
immediate [Builtin_attributes] | |
implementation [Printast] | |
implementation [Parser] | |
implementation [Parse] | |
in_channel_length [Pervasives.LargeFile] | |
in_channel_length [Pervasives] | 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] | |
incr [Pervasives] | Increment the integer contained in the given reference. |
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 [Pervasives] | Positive infinity. |
infinity [Float] | Positive infinity. |
infix_tag [Obj] | |
info_attr [Docstrings] | |
inherit_ [Ast_helper.Cf] | |
inherit_ [Ast_helper.Ctf] | |
inherits [CamlinternalOO] | |
init [String] |
|
init [StringLabels] |
|
init [Random] | Initialize the generator, using the argument as a seed. |
init [Location] | Set the file name and line number of the |
init [ListLabels] |
|
init [List] |
|
init [Lexer] | |
init [Dynlink] | |
init [Docstrings] | (Re)Initialise all docstring state |
init [BytesLabels] |
|
init [Bytes] |
|
init [ArrayLabels] |
|
init [Array] |
|
init_class [CamlinternalOO] | |
init_file [Clflags] | |
init_mod [CamlinternalMod] | |
initgroups [UnixLabels] |
|
initgroups [Unix] |
|
initial_env [Typemod] | |
initializer_ [Ast_helper.Cf] | |
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 [Pervasives] |
|
input [Digest] | Read a digest from the given input channel. |
input_binary_int [Pervasives] | Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. |
input_byte [Pervasives] | Same as |
input_bytes [Misc.LongString] | |
input_char [Pervasives] | Read one character from the given input channel. |
input_lexbuf [Location] | |
input_line [Pervasives] | Read characters from the given input channel, until a newline character is encountered. |
input_name [Location] | |
input_value [Pervasives] | Read the representation of a structured value, as produced
by |
int [Random.State] | |
int [Random] |
|
int [Misc.Int_literal_converter] | |
int [Bigarray] | See |
int [Ast_helper.Const] | |
int16_signed [Bigarray] | See |
int16_unsigned [Bigarray] | See |
int32 [Random.State] | |
int32 [Random] |
|
int32 [Misc.Int_literal_converter] | |
int32 [Bigarray] | See |
int32 [Ast_helper.Const] | |
int64 [Random.State] | |
int64 [Random] |
|
int64 [Misc.Int_literal_converter] | |
int64 [Bigarray] | See |
int64 [Ast_helper.Const] | |
int8_signed [Bigarray] | See |
int8_unsigned [Bigarray] | See |
int_of_char [Pervasives] | Return the ASCII code of the argument. |
int_of_float [Pervasives] | Truncate the given floating-point number to an integer. |
int_of_string [Pervasives] | Convert the given string to an integer. |
int_of_string_opt [Pervasives] | Same as |
int_size [Sys] | Size of |
int_tag [Obj] | |
integer [Ast_helper.Const] | |
inter [MoreLabels.Set.S] | |
inter [Set.S] | Set intersection. |
interactive [Sys] | This reference is initially set to |
interface [Printast] | |
interface [Parser] | |
interface [Parse] | |
interface_suffix [Config] | |
interval [Ast_helper.Pat] | |
inv [Complex] | Multiplicative inverse ( |
invalid_arg [Pervasives] | Raise exception |
is_active [Warnings] | |
is_block [Obj] | |
is_char [Uchar] |
|
is_directory [Sys] | Returns |
is_empty [Stack] | Return |
is_empty [Queue] | Return |
is_empty [MoreLabels.Set.S] | |
is_empty [MoreLabels.Map.S] | |
is_empty [Map.S] | Test whether a map is empty or not. |
is_empty [Set.S] | Test whether a set is empty or not. |
is_error [Warnings] | |
is_implicit [Filename] | Return |
is_in_char_set [CamlinternalFormat] | |
is_inline [Printexc.Slot] |
|
is_int [Obj] | |
is_native [Dynlink] |
|
is_raise [Printexc.Slot] |
|
is_randomized [MoreLabels.Hashtbl] | |
is_randomized [Hashtbl] | return if the tables are currently created in randomized mode by default |
is_relative [Filename] | Return |
is_tail_native_heuristic [Simplif] | |
is_val [Lazy] |
|
is_valid [Uchar] |
|
isatty [UnixLabels] | Return |
isatty [Unix] | Return |
iter [Weak.S] |
|
iter [Tbl] | |
iter [String] |
|
iter [Stream] |
|
iter [StringLabels] |
|
iter [Stack] |
|
iter [Seq] | Iterate on the sequence, calling the (imperative) function on every element. |
iter [Queue] |
|
iter [MoreLabels.Set.S] | |
iter [MoreLabels.Map.S] | |
iter [MoreLabels.Hashtbl.SeededS] | |
iter [MoreLabels.Hashtbl.S] | |
iter [MoreLabels.Hashtbl] | |
iter [Misc.Stdlib.Option] | |
iter [ListLabels] |
|
iter [List] |
|
iter [Hashtbl.SeededS] | |
iter [Hashtbl.S] | |
iter [Hashtbl] |
|
iter [Map.S] |
|
iter [Set.S] |
|
iter [BytesLabels] |
|
iter [Bytes] |
|
iter [ArrayLabels] |
|
iter [Array] |
|
iter2 [ListLabels] |
|
iter2 [List] |
|
iter2 [ArrayLabels] |
|
iter2 [Array] |
|
iteri [String] | Same as |
iteri [StringLabels] | Same as |
iteri [ListLabels] | Same as |
iteri [List] | Same as |
iteri [BytesLabels] | Same as |
iteri [Bytes] | Same as |
iteri [ArrayLabels] | Same as |
iteri [Array] | Same as |
J | |
join [Thread] |
|
junk [Stream] | Remove the first element of the stream, possibly unfreezing it before. |
K | |
kasprintf [Format] | Same as |
kbprintf [Printf] | Same as |
keep_asm_file [Clflags] | |
keep_docs [Clflags] | |
keep_locs [Clflags] | |
keep_startup_file [Clflags] | |
key_pressed [Graphics] | Return |
keys [Identifiable.Map] | |
kfprintf [Printf] | Same as |
kfprintf [Format] | Same as |
kfscanf [Scanf] | |
kill [UnixLabels] |
|
kill [Unix] |
|
kill [Thread] | Terminate prematurely the thread whose handle is given. |
kind [Bigarray.Array3] | Return the kind of the given big array. |
kind [Bigarray.Array2] | Return the kind of the given big array. |
kind [Bigarray.Array1] | Return the kind of the given big array. |
kind [Bigarray.Array0] | Return the kind of the given big array. |
kind [Bigarray.Genarray] | Return the kind of the given big array. |
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_chars [Str] |
|
last_non_constant_constructor_tag [Obj] | |
layout [Bigarray.Array3] | Return the layout of the given big array. |
layout [Bigarray.Array2] | Return the layout of the given big array. |
layout [Bigarray.Array1] | Return the layout of the given big array. |
layout [Bigarray.Array0] | Return the layout of the given big array. |
layout [Bigarray.Genarray] | Return the layout of the given big array. |
lazy_ [Ast_helper.Exp] | |
lazy_ [Ast_helper.Pat] | |
lazy_from_fun [Lazy] | |
lazy_from_val [Lazy] | |
lazy_is_val [Lazy] | |
lazy_tag [Obj] | |
lazy_tag [Config] | |
ldexp [Pervasives] |
|
ldexp [Float] |
|
length [Weak] |
|
length [String] | Return the length (number of characters) of the given string. |
length [StringLabels] | Return the length (number of characters) of the given string. |
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 [Misc.LongString] | |
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.Array] | |
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] | |
lexeme [Lexing] |
|
lexeme_char [Lexing] |
|
lexeme_end [Lexing] |
|
lexeme_end_p [Lexing] | Like |
lexeme_start [Lexing] |
|
lexeme_start_p [Lexing] | Like |
libunwind_available [Config] | |
libunwind_link_flags [Config] | |
lineto [Graphics] | Draw a line with endpoints the current point and the given point, and move the current point to the given point. |
link [UnixLabels] |
|
link [Unix] |
|
link_everything [Clflags] | |
list [Sort] | Sort a list in increasing order according to an ordering predicate. |
list_remove [Misc] | |
listen [UnixLabels] | Set up a socket for receiving connection requests. |
listen [Unix] | Set up a socket for receiving connection requests. |
lnot [Pervasives] | Bitwise logical negation. |
load_path [Config] | |
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] | |
lock [Mutex] | Lock the given mutex. |
lockf [UnixLabels] |
|
lockf [Unix] |
|
log [Pervasives] | Natural logarithm. |
log [Float] | Natural logarithm. |
log [Complex] | Natural logarithm (in base |
log10 [Pervasives] | Base 10 logarithm. |
log10 [Float] | Base 10 logarithm. |
log1p [Pervasives] |
|
log1p [Float] |
|
log2 [Misc] | |
logand [Targetint] | Bitwise logical and. |
logand [Nativeint] | Bitwise logical and. |
logand [Int64] | Bitwise logical and. |
logand [Int32] | Bitwise logical and. |
lognot [Targetint] | Bitwise logical negation. |
lognot [Nativeint] | Bitwise logical negation. |
lognot [Int64] | Bitwise logical negation. |
lognot [Int32] | Bitwise logical negation. |
logor [Targetint] | Bitwise logical or. |
logor [Nativeint] | Bitwise logical or. |
logor [Int64] | Bitwise logical or. |
logor [Int32] | Bitwise logical or. |
logxor [Targetint] | Bitwise logical exclusive or. |
logxor [Nativeint] | Bitwise logical exclusive or. |
logxor [Int64] | Bitwise logical exclusive or. |
logxor [Int32] | Bitwise logical exclusive or. |
lookup_tables [CamlinternalOO] | |
loop_at_exit [Graphics] | Loop before exiting the program, the list given as argument is the list of handlers and the events on which these handlers are called. |
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] | Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set. |
lowercase_ascii [StringLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set. |
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. |
lseek [UnixLabels.LargeFile] | |
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 | |
magenta [Graphics] | |
magic [Obj] | |
major [Gc] | Do a minor collection and finish the current major collection cycle. |
major_slice [Gc] |
|
make [String] |
|
make [StringLabels] |
|
make [Random.State] | Create a new state and initialize it with the given seed. |
make [BytesLabels] |
|
make [Bytes] |
|
make [ArrayLabels] |
|
make [Array] |
|
make_archive [Clflags] | |
make_class [CamlinternalOO] | |
make_class_store [CamlinternalOO] | |
make_float [ArrayLabels] | |
make_float [Array] | |
make_formatter [Format] |
|
make_image [Graphics] | Convert the given color matrix to an image. |
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 [Tbl] | |
map [String] |
|
map [StringLabels] |
|
map [Seq] |
|
map [MoreLabels.Set.S] | |
map [MoreLabels.Map.S] | |
map [Misc.Stdlib.Option] | |
map [ListLabels] |
|
map [List] |
|
map [Identifiable.Tbl] | |
map [Identifiable.Set] | |
map [Map.S] |
|
map [Set.S] |
|
map [BytesLabels] |
|
map [Bytes] |
|
map [ArrayLabels] |
|
map [Array] |
|
map2 [ListLabels] |
|
map2 [List] |
|
map2 [ArrayLabels] |
|
map2 [Array] |
|
map2_prefix [Misc.Stdlib.List] |
|
map_end [Misc] | |
map_file [UnixLabels] | Memory mapping of a file as a big array. |
map_file [Unix] | Memory mapping of a file as a big array. |
map_keys [Identifiable.Map] | |
map_left_right [Misc] | |
map_opt [Ast_mapper] | |
mapi [String] |
|
mapi [StringLabels] |
|
mapi [MoreLabels.Map.S] | |
mapi [ListLabels] | Same as |
mapi [List] | Same as |
mapi [Map.S] | Same as |
mapi [BytesLabels] |
|
mapi [Bytes] |
|
mapi [ArrayLabels] | Same as |
mapi [Array] | Same as |
mark_rhs_docs [Docstrings] | Mark as associated the item documentation for the symbols between two positions (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_end [Str] |
|
matched_group [Str] |
|
matched_string [Str] |
|
max [Uchar] |
|
max [Pervasives] | Return the greater of the two arguments. |
max_array_length [Sys] | Maximum length of a normal array. |
max_binding [MoreLabels.Map.S] | |
max_binding [Map.S] | Same as |
max_binding_opt [MoreLabels.Map.S] | |
max_binding_opt [Map.S] | Same as |
max_elt [MoreLabels.Set.S] | |
max_elt [Set.S] | Same as |
max_elt_opt [MoreLabels.Set.S] | |
max_elt_opt [Set.S] | Same as |
max_float [Pervasives] | The largest positive finite value of type |
max_float [Float] | The largest positive finite value of type |
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 [Pervasives] | The greatest representable integer. |
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_string_length [Sys] | Maximum length of strings and byte sequences. |
max_tag [Config] | |
max_young_wosize [Config] | |
may [Misc] | |
may_map [Misc] | |
mem [Weak.S] |
|
mem [Tbl] | |
mem [MoreLabels.Set.S] | |
mem [MoreLabels.Map.S] | |
mem [MoreLabels.Hashtbl.SeededS] | |
mem [MoreLabels.Hashtbl.S] | |
mem [MoreLabels.Hashtbl] | |
mem [ListLabels] |
|
mem [List] |
|
mem [Hashtbl.SeededS] | |
mem [Hashtbl.S] | |
mem [Hashtbl] |
|
mem [Map.S] |
|
mem [Set.S] |
|
mem [ArrayLabels] |
|
mem [Array] |
|
mem_assoc [ListLabels] | Same as |
mem_assoc [List] | Same as |
mem_assq [ListLabels] | Same as |
mem_assq [List] | 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 [Sort] | Merge two lists according to the given predicate. |
merge [MoreLabels.Map.S] | |
merge [ListLabels] | Merge two lists:
Assuming that |
merge [List] | Merge two lists:
Assuming that |
merge [Map.S] |
|
method_ [Ast_helper.Cf] | |
method_ [Ast_helper.Ctf] | |
min [Uchar] |
|
min [Pervasives] | Return the smaller of the two arguments. |
min_binding [MoreLabels.Map.S] | |
min_binding [Map.S] | Return the smallest binding of the given map
(with respect to the |
min_binding_opt [MoreLabels.Map.S] | |
min_binding_opt [Map.S] | Return the smallest binding of the given map
(with respect to the |
min_elt [MoreLabels.Set.S] | |
min_elt [Set.S] | Return the smallest element of the given set
(with respect to the |
min_elt_opt [MoreLabels.Set.S] | |
min_elt_opt [Set.S] | Return the smallest element of the given set
(with respect to the |
min_float [Pervasives] | The smallest positive, non-zero, non-denormalized value of type |
min_float [Float] | 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 [Pervasives] | The smallest representable integer. |
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. |
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. |
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.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_lazy [Warnings] | Like |
mkdir [UnixLabels] | Create a directory with the given permissions. |
mkdir [Unix] | Create a directory with the given permissions (see |
mkdll [Config] | |
mkexe [Config] | |
mkfifo [UnixLabels] | Create a named pipe with the given permissions. |
mkfifo [Unix] | Create a named pipe with the given permissions (see |
mkloc [Location] | |
mkmaindll [Config] | |
mknoloc [Location] | |
mktime [UnixLabels] | Convert a date and time, specified by the |
mktime [Unix] | Convert a date and time, specified by the |
mod_float [Pervasives] |
|
model [Config] | |
modf [Pervasives] |
|
modf [Float] |
|
modtype [Ast_helper.Str] | |
modtype [Ast_helper.Sig] | |
modtype_of_package [Typemod] | |
module_ [Ast_helper.Str] | |
module_ [Ast_helper.Sig] | |
mouse_pos [Graphics] | Return the position of the mouse cursor, relative to the graphics window. |
moveto [Graphics] | Position the current point. |
mul [Targetint] | Multiplication. |
mul [Nativeint] | Multiplication. |
mul [Int64] | Multiplication. |
mul [Int32] | Multiplication. |
mul [Float] | Floating-point multiplication. |
mul [Complex] | Multiplication |
N | |
name_of_input [Scanf.Scanning] |
|
nan [Pervasives] | A special floating-point value denoting the result of an
undefined operation such as |
nan [Float] | A special floating-point value denoting the result of an
undefined operation such as |
narrow [CamlinternalOO] | |
native_c_libraries [Config] | |
native_code [Clflags] | |
native_pack_linker [Config] | |
nativeint [Random.State] | |
nativeint [Random] |
|
nativeint [Misc.Int_literal_converter] | |
nativeint [Bigarray] | See |
nativeint [Ast_helper.Const] | |
neg [Targetint] | Unary negation. |
neg [Nativeint] | Unary negation. |
neg [Int64] | Unary negation. |
neg [Int32] | Unary negation. |
neg [Float] | Unary negation. |
neg [Complex] | Unary negation. |
neg_infinity [Pervasives] | Negative infinity. |
neg_infinity [Float] | Negative infinity. |
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. |
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 |
nopervasives [Clflags] | |
noprompt [Clflags] | |
nopromptcont [Clflags] | |
norm [Complex] | Norm: given |
norm2 [Complex] | Norm squared: given |
normalise_eol [Misc] |
|
not [Pervasives] | 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 |
num_dims [Bigarray.Genarray] | Return the number of dimensions of the given big array. |
num_lines [Terminfo] | |
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] | |
ocamlc_cppflags [Config] | |
ocamlopt_cflags [Config] | |
ocamlopt_cppflags [Config] | |
of_array [Bigarray.Array3] | Build a three-dimensional big array initialized from the given array of arrays of arrays. |
of_array [Bigarray.Array2] | Build a two-dimensional big array initialized from the given array of arrays. |
of_array [Bigarray.Array1] | Build a one-dimensional big array 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_int [Uchar] |
|
of_int [Targetint] | Convert the given integer (type |
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 [Stream] | Return the stream holding the elements of the list in the same order. |
of_list [MoreLabels.Set.S] | |
of_list [Identifiable.Tbl] | |
of_list [Identifiable.Map] | |
of_list [Identifiable.Set] | |
of_list [Set.S] |
|
of_list [ArrayLabels] |
|
of_list [Array] |
|
of_map [Identifiable.Tbl] | |
of_nativeint [Int64] | Convert the given native integer (type |
of_seq [String] | Create a string from the generator |
of_seq [StringLabels] | Create a string from the generator |
of_seq [Stack] | Create a stack from the iterator |
of_seq [Queue] | Create an array from the generator |
of_seq [MoreLabels.Set.S] | |
of_seq [MoreLabels.Map.S] | |
of_seq [MoreLabels.Hashtbl.SeededS] | |
of_seq [MoreLabels.Hashtbl.S] | |
of_seq [MoreLabels.Hashtbl] | |
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 [Map.S] | Build a map from the given bindings |
of_seq [Set.S] | Build a set from the given bindings |
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 [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_value [Bigarray.Array0] | Build a zero-dimensional big array initialized from the given value. |
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 [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 [UnixLabels] | Connect to a server at the given address. |
open_connection [Unix] | Connect to a server at the given address. |
open_connection [ThreadUnix] | |
open_graph [Graphics] | Show the graphics window or switch the screen to graphic mode. |
open_hbox [Format] |
|
open_hovbox [Format] |
|
open_hvbox [Format] |
|
open_in [Scanf.Scanning] |
|
open_in [Pervasives] | 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 [Pervasives] | Same as |
open_in_gen [Pervasives] |
|
open_module [Depend] | |
open_modules [Clflags] | |
open_out [Pervasives] | 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 [Pervasives] | Same as |
open_out_gen [Pervasives] |
|
open_process [UnixLabels] | Same as |
open_process [Unix] | Same as |
open_process [ThreadUnix] | |
open_process_full [UnixLabels] | Similar to |
open_process_full [Unix] | Similar to |
open_process_full [ThreadUnix] | |
open_process_in [UnixLabels] | High-level pipe and process management. |
open_process_in [Unix] | High-level pipe and process management. |
open_process_in [ThreadUnix] | |
open_process_out [UnixLabels] | Same as |
open_process_out [Unix] | Same as |
open_process_out [ThreadUnix] | |
open_subwindow [GraphicsX11] | Create a sub-window of the current OCaml graphics window and return its identifier. |
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 [Pervasives.LargeFile] | |
out_channel_length [Pervasives] | 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 [Pervasives] |
|
output [Misc.LongString] | |
output [Identifiable.Set] | |
output [Identifiable.Thing] | |
output [Digest] | Write a digest on the given output channel. |
output_acc [CamlinternalFormat] | |
output_binary_int [Pervasives] | Write one integer in binary format (4 bytes, big-endian) on the given output channel. |
output_buffer [Buffer] |
|
output_byte [Pervasives] | Write one 8-bit integer (as the single character with that code) on the given output channel. |
output_bytes [Pervasives] | Write the byte sequence on the given output channel. |
output_c_object [Clflags] | |
output_char [Pervasives] | Write the character on the given output channel. |
output_complete_object [Clflags] | |
output_name [Clflags] | |
output_string [Pervasives] | Write the string on the given output channel. |
output_substring [Pervasives] | Same as |
output_to_file_via_temporary [Misc] | |
output_value [Pervasives] | 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 [Ast_helper.Exp] | |
package [Ast_helper.Typ] | |
package_units [Typemod] | |
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 [Longident] | |
parse [Clflags.Float_arg_helper] | |
parse [Clflags.Int_arg_helper] | |
parse [Arg_helper.Make] | |
parse [Arg] |
|
parse_and_expand_argv_dynamic [Arg] | Same as |
parse_arguments [Clflags] | |
parse_argv [Arg] |
|
parse_argv_dynamic [Arg] | Same as |
parse_color_setting [Clflags] | |
parse_core_type [Parser] | |
parse_dynamic [Arg] | Same as |
parse_expand [Arg] | Same as |
parse_expression [Parser] | |
parse_implementation [Pparse] | |
parse_interface [Pparse] | |
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] | |
partition [MoreLabels.Set.S] | |
partition [MoreLabels.Map.S] | |
partition [ListLabels] |
|
partition [List] |
|
partition [Map.S] |
|
partition [Set.S] |
|
path_of_module [Typemod] | |
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] |
|
pi [Float] | The constant pi. |
pic_code [Clflags] | |
pipe [UnixLabels] | Create a pipe. |
pipe [Unix] | Create a pipe. |
pipe [ThreadUnix] | |
plot [Graphics] | Plot the given point with the current drawing color. |
plots [Graphics] | Plot the given points with the current drawing color. |
point_color [Graphics] | Return the color of the given point in the backing store (see "Double buffering" below). |
polar [Complex] |
|
poll [Event] | Non-blocking version of |
poly [Ast_helper.Exp] | |
poly [Ast_helper.Typ] | |
pop [Stack] |
|
pop [Queue] |
|
pos_in [Pervasives.LargeFile] | |
pos_in [Pervasives] | Return the current reading position for the given channel. |
pos_out [Pervasives.LargeFile] | |
pos_out [Pervasives] | Return the current writing position for the given channel. |
pow [Float] | Exponentiation. |
pow [Complex] | Power function. |
pp_close_box [Format] | |
pp_close_tag [Format] | |
pp_close_tbox [Format] | |
pp_deps [Depend] | |
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_tag_functions [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_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_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_space [Format] | |
pp_print_string [Format] | |
pp_print_tab [Format] | |
pp_print_tbreak [Format] | |
pp_print_text [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_tag_functions [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] | |
pred [Uchar] |
|
pred [Targetint] | Predecessor. |
pred [Pervasives] |
|
pred [Nativeint] | Predecessor. |
pred [Int64] | Predecessor. |
pred [Int32] | Predecessor. |
preprocess [Pparse] | |
preprocessor [Clflags] | |
prerr_bytes [Pervasives] | Print a byte sequence on standard error. |
prerr_char [Pervasives] | Print a character on standard error. |
prerr_endline [Pervasives] | Print a string, followed by a newline character on standard error and flush standard error. |
prerr_float [Pervasives] | Print a floating-point number, in decimal, on standard error. |
prerr_int [Pervasives] | Print an integer, in decimal, on standard error. |
prerr_newline [Pervasives] | Print a newline character on standard error, and flush standard error. |
prerr_string [Pervasives] | Print a string on standard error. |
prerr_warning [Location] | |
primitive [Ast_helper.Str] | |
principal [Clflags] | |
print [Tbl] | |
print [Profile] | Prints the selected recorded profiling information to the formatter. |
print [Printexc] |
|
print [Location] | |
print [Identifiable.Map] | |
print [Identifiable.Set] | |
print [Identifiable.Thing] | |
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 [Pervasives] | Print a byte sequence on standard output. |
print_char [Pervasives] | Print a character on standard output. |
print_char [Format] | Print a character in the current pretty-printing box. |
print_compact [Location] | |
print_config [Config] | |
print_cut [Format] |
|
print_endline [Pervasives] | Print a string, followed by a newline character, on standard output and flush standard output. |
print_error [Location] | |
print_error_cur_file [Location] | |
print_error_prefix [Location] | |
print_filename [Location] | |
print_float [Pervasives] | Print a floating-point number, in decimal, on standard output. |
print_float [Format] | Print a floating point number in the current pretty-printing box. |
print_flush [Format] | End of pretty-printing: resets the pretty-printer to initial state. |
print_if_newline [Format] | Execute the next formatting command if the preceding line has just been split. |
print_int [Pervasives] | Print an integer, in decimal, on standard output. |
print_int [Format] | Print an integer in the current pretty-printing box. |
print_loc [Location] | |
print_newline [Pervasives] | Print a newline character on standard output, and flush standard output. |
print_newline [Format] | End of pretty-printing: resets the pretty-printer to initial state. |
print_raw_backtrace [Printexc] | Print a raw backtrace in the same format
|
print_space [Format] |
|
print_stat [Gc] | Print the current values of the memory management counters (in human-readable form) into the channel argument. |
print_string [Pervasives] | Print a string on standard output. |
print_string [Format] |
|
print_tab [Format] |
|
print_tbreak [Format] |
|
print_types [Clflags] | |
print_warning [Location] | |
print_warnings [Lexer] | |
printer [Location] | |
printf [Printf] | Same as |
printf [Format] | Same as |
profile_columns [Clflags] | |
profiling [Config] | |
profinfo [Config] | |
profinfo_width [Config] | |
prohibit [Dynlink] |
|
protect_refs [Misc] |
|
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_files [Ccomp] | |
quote_optfile [Ccomp] | |
R | |
raise [Pervasives] | Raise the given exception value |
raise_direct_hook_exn [Misc] | A hook can use |
raise_errorf [Location] | |
raise_notrace [Pervasives] | A faster version |
raise_with_backtrace [Printexc] | Reraise the exception using the given raw_backtrace for the origin of the exception |
randomize [MoreLabels.Hashtbl] | |
randomize [Hashtbl] | After a call to |
ranlib [Config] | |
raw_backtrace_length [Printexc] |
|
raw_backtrace_to_string [Printexc] | Return a string from a raw backtrace, in the same format
|
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 [UnixLabels] |
|
read [Unix] |
|
read [ThreadUnix] | |
read_arg [Arg] |
|
read_arg0 [Arg] | Identical to |
read_ast [Pparse] | |
read_float [Pervasives] | Flush standard output, then read one line from standard input and convert it to a floating-point number. |
read_float_opt [Pervasives] | Flush standard output, then read one line from standard input and convert it to a floating-point number. |
read_int [Pervasives] | Flush standard output, then read one line from standard input and convert it to an integer. |
read_int_opt [Pervasives] | Same as |
read_key [Graphics] | Wait for a key to be pressed, and return the corresponding character. |
read_line [Pervasives] | Flush standard output, then read characters from standard input until a newline character is encountered. |
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 link. |
readlink [Unix] | Read the contents of a symbolic link. |
real_paths [Clflags] | |
really_input [Pervasives] |
|
really_input_string [Pervasives] |
|
rebind [Ast_helper.Te] | |
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 [UnixLabels] | Receive data from a connected socket. |
recv [Unix] | Receive data from a connected socket. |
recv [ThreadUnix] | |
recvfrom [UnixLabels] | Receive data from an unconnected socket. |
recvfrom [Unix] | Receive data from an unconnected socket. |
recvfrom [ThreadUnix] | |
red [Graphics] | |
ref [Pervasives] | 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 [Callback] |
|
register [Ast_mapper] | Apply the |
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] |
|
rem [Targetint] | Integer remainder. |
rem [Nativeint] | Integer remainder. |
rem [Int64] | Integer remainder. |
rem [Int32] | Integer remainder. |
rem [Float] |
|
remember_mode [Graphics] | Set remember mode on or off. |
remove [Weak.S] |
|
remove [Tbl] | |
remove [Sys] | Remove the given file name from the file system. |
remove [MoreLabels.Set.S] | |
remove [MoreLabels.Map.S] | |
remove [MoreLabels.Hashtbl.SeededS] | |
remove [MoreLabels.Hashtbl.S] | |
remove [MoreLabels.Hashtbl] | |
remove [Hashtbl.SeededS] | |
remove [Hashtbl.S] | |
remove [Hashtbl] |
|
remove [Map.S] |
|
remove [Set.S] |
|
remove_assoc [ListLabels] |
|
remove_assoc [List] |
|
remove_assq [ListLabels] | Same as |
remove_assq [List] | Same as |
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 [UnixLabels] |
|
rename [Unix] |
|
rename [Sys] | Rename a file. |
rename [Identifiable.Map] | |
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] | |
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_error [Typemod] | |
report_error [Syntaxerr] | |
report_error [Pparse] | |
report_error [Location] | |
report_error [Lexer] | |
report_error [Attr_helper] | |
report_exception [Location] | Reraise the exception if it is unknown. |
repr [Targetint] | The concrete representation of a native integer. |
repr [Obj] | |
reset [Profile] | erase all recorded profile information |
reset [MoreLabels.Hashtbl.SeededS] | |
reset [MoreLabels.Hashtbl.S] | |
reset [MoreLabels.Hashtbl] | |
reset [Location] | |
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 |
resize_window [Graphics] | Resize and erase the graphics window. |
restore [Warnings] | |
resume [Terminfo] | |
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] | |
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] |
|
rgb [Graphics] |
|
rhs_docs [Docstrings] | Fetch the item documentation for the symbols between two positions. |
rhs_docs_lazy [Docstrings] | |
rhs_end [Parsing] | See |
rhs_end_pos [Parsing] | Same as |
rhs_info [Docstrings] | Fetch the field info following the symbol at a given position. |
rhs_loc [Location] |
|
rhs_post_extra_text [Docstrings] | Fetch additional 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] | Fetch additional text preceding the symbol at the given position |
rhs_start [Parsing] | Same as |
rhs_start_pos [Parsing] | Same as |
rhs_text [Docstrings] | Fetch the text preceding the symbol at the given position. |
rhs_text_lazy [Docstrings] | |
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] |
|
rlineto [Graphics] | Draw a line with endpoints the current point and the current point translated of the given vector, and move the current point to this point. |
rmdir [UnixLabels] | Remove an empty directory. |
rmdir [Unix] | Remove an empty directory. |
rmoveto [Graphics] |
|
rounds [Clflags] | |
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 [Sys] | Return the name of the runtime variant the program is running on. |
runtime_variant [Clflags] | |
runtime_warnings_enabled [Sys] | Return whether runtime warnings are currently enabled. |
S | |
safe_string [Config] | |
save_and_close [Spacetime.Series] |
|
save_event [Spacetime.Series] |
|
save_event_for_automatic_snapshots [Spacetime] | Like |
save_signature [Typemod] | |
scanf [Scanf] | Same as |
search_backward [Str] |
|
search_forward [Str] |
|
search_substring [Misc] | |
seeded_hash [MoreLabels.Hashtbl] | |
seeded_hash [Hashtbl] | A variant of |
seeded_hash_param [MoreLabels.Hashtbl] | |
seeded_hash_param [Hashtbl] | A variant of |
seek_in [Pervasives.LargeFile] | |
seek_in [Pervasives] |
|
seek_out [Pervasives.LargeFile] | |
seek_out [Pervasives] |
|
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. |
select [ThreadUnix] | |
select [Thread] | Suspend the execution of the calling thread until input/output becomes possible on the given Unix file descriptors. |
select [Event] | ``Synchronize'' on an alternative of events. |
self [Thread] | Return the thread currently executing. |
self_init [Random] | Initialize the generator with a random seed chosen in a system-dependent way. |
send [UnixLabels] | Send data over a connected socket. |
send [Unix] | Send data over a connected socket. |
send [ThreadUnix] | |
send [Event] |
|
send [CamlinternalOO] | |
send [Ast_helper.Exp] | |
send_substring [UnixLabels] | Same as |
send_substring [Unix] | Same as |
send_substring [ThreadUnix] | |
sendcache [CamlinternalOO] | |
sendself [CamlinternalOO] | |
sendto [UnixLabels] | Send data over an unconnected socket. |
sendto [Unix] | Send data over an unconnected socket. |
sendto [ThreadUnix] | |
sendto_substring [UnixLabels] | Same as |
sendto_substring [Unix] | Same as |
sendto_substring [ThreadUnix] | |
sequence [Ast_helper.Exp] | |
set [Weak] |
|
set [String] |
|
set [StringLabels] |
|
set [Misc.LongString] | |
set [Gc] |
|
set [Float.Array] | |
set [Consistbl] | |
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 big array. |
set [ArrayLabels] |
|
set [Array] |
|
set_all_formatter_output_functions [Format] | |
set_base_default [Arg_helper.Make] | |
set_binary_mode_in [Pervasives] |
|
set_binary_mode_out [Pervasives] |
|
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 [Graphics] | Set the current drawing color. |
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_floating_docstrings [Docstrings] | Docstrings not immediately adjacent to a token |
set_font [Graphics] | Set the font used for drawing text. |
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_tag_functions [Format] |
|
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_line_width [Graphics] | Set the width of points and lines drawn with the functions above. |
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_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_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_text_size [Graphics] | Set the character size used for drawing text. |
set_trace [Parsing] | Control debugging support for |
set_uncaught_exception_handler [Printexc] |
|
set_user_default [Arg_helper.Make] | |
set_window_title [Graphics] | Set the title of the graphics window. |
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_left [Targetint] |
|
shift_left [Nativeint] |
|
shift_left [Int64] |
|
shift_left [Int32] |
|
shift_right [Targetint] |
|
shift_right [Nativeint] |
|
shift_right [Int64] |
|
shift_right [Int32] |
|
shift_right_logical [Targetint] |
|
shift_right_logical [Nativeint] |
|
shift_right_logical [Int64] |
|
shift_right_logical [Int32] |
|
show_code_at_location [Location] | |
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) |
signal [Sys] | Set the behavior of the system on receipt of a given signal. |
signal [Condition] |
|
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 |
simplify_lambda [Simplif] | |
simplify_rounds [Clflags] | |
simplify_signature [Typemod] | |
sin [Pervasives] | Sine. |
sin [Float] | Sine. |
single_write [UnixLabels] | Same as |
single_write [Unix] | Same as |
single_write [ThreadUnix] | |
single_write_substring [UnixLabels] | Same as |
single_write_substring [Unix] | Same as |
single_write_substring [ThreadUnix] | |
singleton [MoreLabels.Set.S] | |
singleton [MoreLabels.Map.S] | |
singleton [Map.S] |
|
singleton [Set.S] |
|
sinh [Pervasives] | Hyperbolic sine. |
sinh [Float] | 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] |
|
size_x [Graphics] | See |
size_y [Graphics] | Return the size of the graphics window. |
skip_hash_bang [Lexer] | |
sleep [UnixLabels] | Stop execution for the given number of seconds. |
sleep [Unix] | Stop execution for the given number of seconds. |
sleep [ThreadUnix] | |
sleepf [Unix] | Stop execution for the given number of seconds. |
slice [Bigarray.Array1] | Extract a scalar (zero-dimensional slice) of the given one-dimensional big array. |
slice_left [Bigarray.Array2] | Extract a row (one-dimensional slice) of the given two-dimensional big array. |
slice_left [Bigarray.Genarray] | Extract a sub-array of lower dimension from the given big array 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 big array by fixing the first two coordinates. |
slice_left_2 [Bigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional big array by fixing the first coordinate. |
slice_right [Bigarray.Array2] | Extract a column (one-dimensional slice) of the given two-dimensional big array. |
slice_right [Bigarray.Genarray] | Extract a sub-array of lower dimension from the given big array 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 big array by fixing the last two coordinates. |
slice_right_2 [Bigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional big array by fixing the last coordinate. |
snd [Pervasives] | Return the second component of a pair. |
snd3 [Misc] | |
snd4 [Misc] | |
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. |
socket [ThreadUnix] | |
socketpair [UnixLabels] | Create a pair of unnamed sockets, connected together. |
socketpair [Unix] | Create a pair of unnamed sockets, connected together. |
socketpair [ThreadUnix] | |
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 [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 |
sound [Graphics] |
|
source [Consistbl] | |
spacetime [Config] | |
spellcheck [Misc] |
|
split [Str] |
|
split [MoreLabels.Set.S] | |
split [MoreLabels.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 [Map.S] |
|
split [Set.S] |
|
split_at [Misc.Stdlib.List] |
|
split_default_wrapper [Simplif] | |
split_delim [Str] | Same as |
split_last [Misc] | |
split_on_char [String] |
|
split_on_char [StringLabels] |
|
sprintf [Printf] | Same as |
sprintf [Format] | Same as |
sqrt [Pervasives] | Square root. |
sqrt [Float] | Square root. |
sqrt [Complex] | Square root. |
sscanf [Scanf] | Same as |
sscanf_format [Scanf] | Same as |
stable_sort [ListLabels] | Same as |
stable_sort [List] | Same as |
stable_sort [ArrayLabels] | Same as |
stable_sort [Array] | Same as |
stack_safety_margin [Config] | |
stack_threshold [Config] | |
standard_library [Config] | |
standard_runtime [Config] | |
standout [Terminfo] | |
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
|
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 [CamlinternalOO] | |
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 [Pervasives] | 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 [Pervasives] | The standard input for the process. |
stdout [UnixLabels] | File descriptor for standard output. |
stdout [Unix] | File descriptor for standard output. |
stdout [Pervasives] | The standard output for the process. |
str_formatter [Format] | A formatter to output to the |
strict_formats [Clflags] | |
strict_sequence [Clflags] | |
string [Digest] | Return the digest of the given string. |
string [Ast_helper.Const] | |
string_after [Str] |
|
string_before [Str] |
|
string_match [Str] |
|
string_of_bool [Pervasives] | Return the string representation of a boolean. |
string_of_expression [Pprintast] | |
string_of_file [Misc] | |
string_of_float [Pervasives] | Return the string representation of a floating-point number. |
string_of_fmt [CamlinternalFormat] | |
string_of_fmtty [CamlinternalFormat] | |
string_of_format [Pervasives] | Converts a format string into a string. |
string_of_formatting_gen [CamlinternalFormat] | |
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 [Pervasives] | Return the string representation of an integer, in decimal. |
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 [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 big array. |
sub [ArrayLabels] |
|
sub [Array] |
|
sub_left [Bigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional big array by restricting the first dimension. |
sub_left [Bigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional big array by restricting the first dimension. |
sub_left [Bigarray.Genarray] | Extract a sub-array of the given big array by restricting the first (left-most) dimension. |
sub_right [Bigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional big array by restricting the second dimension. |
sub_right [Bigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional big array by restricting the second dimension. |
sub_right [Bigarray.Genarray] | Extract a sub-array of the given big array by restricting the last (right-most) dimension. |
sub_string [BytesLabels] | Same as |
sub_string [Bytes] | Same as |
subbytes [Digest] |
|
subset [MoreLabels.Set.S] | |
subset [Set.S] |
|
substitute_first [Str] | Same as |
substring [Digest] |
|
succ [Uchar] |
|
succ [Targetint] | Successor. |
succ [Pervasives] |
|
succ [Nativeint] | Successor. |
succ [Int64] | Successor. |
succ [Int32] | Successor. |
symbol_docs [Docstrings] | Fetch the item documentation for the current symbol. |
symbol_docs_lazy [Docstrings] | |
symbol_end [Parsing] | See |
symbol_end_pos [Parsing] | Same as |
symbol_gloc [Location] | |
symbol_info [Docstrings] | Fetch the field info for the current symbol. |
symbol_post_extra_text [Docstrings] | Fetch additional text following 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] | Fetch the text preceding the current symbol. |
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. |
synchronize [Graphics] | Synchronize the backing store and the on-screen window, by copying the contents of the backing store onto the graphics window. |
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. |
system [ThreadUnix] | |
system [Config] | |
systhread_supported [Config] | |
T | |
tag [Obj] | |
take [Spacetime.Snapshot] |
|
take [Queue] |
|
tan [Pervasives] | Tangent. |
tan [Float] | Tangent. |
tanh [Pervasives] | Hyperbolic tangent. |
tanh [Float] | Hyperbolic tangent. |
target [Config] | |
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] |
|
text [Ast_helper.Cf] | |
text [Ast_helper.Ctf] | |
text [Ast_helper.Str] | |
text [Ast_helper.Sig] | |
text_attr [Docstrings] | |
text_size [Graphics] | Return the dimensions of the given text, if it were drawn with the current font and size. |
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_hex [Digest] | Return the printable hexadecimal representation of the given digest. |
to_int [Uchar] |
|
to_int [Targetint] | Convert the given target integer (type |
to_int [Numbers.Int16] | |
to_int [Numbers.Int8] | |
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_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 [ArrayLabels] |
|
to_list [Array] |
|
to_map [Identifiable.Tbl] | |
to_nativeint [Int64] | Convert the given 64-bit integer (type |
to_seq [String] | Iterate on the string, in increasing index order. |
to_seq [StringLabels] | Iterate on the string, in increasing index order. |
to_seq [Stack] | Iterate on the stack, top to bottom. |
to_seq [Queue] | Iterate on the queue, in front-to-back order. |
to_seq [MoreLabels.Set.S] | |
to_seq [MoreLabels.Map.S] | |
to_seq [MoreLabels.Hashtbl.SeededS] | |
to_seq [MoreLabels.Hashtbl.S] | |
to_seq [MoreLabels.Hashtbl] | |
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, in unspecified order. |
to_seq [Map.S] | Iterate on the whole map, in ascending order |
to_seq [Set.S] | Iterate on the whole set, in ascending 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 [MoreLabels.Set.S] | |
to_seq_from [MoreLabels.Map.S] | |
to_seq_from [Map.S] |
|
to_seq_from [Set.S] |
|
to_seq_keys [MoreLabels.Hashtbl.SeededS] | |
to_seq_keys [MoreLabels.Hashtbl.S] | |
to_seq_keys [MoreLabels.Hashtbl] | |
to_seq_keys [Hashtbl.SeededS] | |
to_seq_keys [Hashtbl.S] | |
to_seq_keys [Hashtbl] | Iterate on 'as, in ascending order |
to_seq_values [MoreLabels.Hashtbl.SeededS] | |
to_seq_values [MoreLabels.Hashtbl.S] | |
to_seq_values [MoreLabels.Hashtbl] | |
to_seq_values [Hashtbl.SeededS] | |
to_seq_values [Hashtbl.S] | |
to_seq_values [Hashtbl] | Iterate on values, in ascending order of their corresponding 'a |
to_seqi [String] | Iterate on the string, in increasing order, yielding indices along chars |
to_seqi [StringLabels] | Iterate on the string, in increasing order, yielding indices along chars |
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 [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 [Identifiable.Set] | |
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. |
token [Lexer] | |
token_with_comments [Lexer] | |
tool_name [Ast_mapper] | Can be used within a ppx preprocessor to know which tool is
calling it |
top [Stack] |
|
top [Queue] |
|
top_phrase [Printast] | |
top_phrase [Pprintast] | |
toplevel_phrase [Pprintast] | |
toplevel_phrase [Parser] | |
toplevel_phrase [Parse] | |
total_size [Marshal] | See |
trans [CamlinternalFormat] | |
transfer [Queue] |
|
transl [Profile] | |
transl_signature [Typemod] | |
transp [Graphics] | In matrices of colors, this color represent a 'transparent' point: when drawing the corresponding image, all pixels on the screen corresponding to a transparent pixel in the image will not be modified, while other points will be set to the color of the corresponding point in the image. |
transparent_modules [Clflags] | |
transpose_keys_and_data [Identifiable.Map] | |
transpose_keys_and_data_set [Identifiable.Map] | |
trim [String] | Return a copy of the argument, without leading and trailing whitespace. |
trim [StringLabels] | Return a copy of the argument, without leading and trailing whitespace. |
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. |
truncate [UnixLabels.LargeFile] | |
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 [Pervasives] | Same as |
truncate [Obj] | |
truncate [Buffer] |
|
try_ [Ast_helper.Exp] | |
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_implementation [Typemod] | |
type_interface [Typemod] | |
type_module [Typemod] | |
type_open_ [Typemod] | |
type_structure [Typemod] | |
type_toplevel_phrase [Typemod] | |
typeof_ [Ast_helper.Mty] | |
typing [Profile] | |
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] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set. |
uncapitalize_ascii [StringLabels] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set. |
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] | |
union [MoreLabels.Set.S] | |
union [MoreLabels.Map.S] | |
union [Map.S] |
|
union [Set.S] | Set union. |
union_left [Identifiable.Map] |
|
union_merge [Identifiable.Map] | |
union_right [Identifiable.Map] |
|
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_blit_to_bytes [Misc.LongString] | |
unsafe_environment [Unix] | Return the process environment, as an array of strings with the format ``variable=value''. |
unsafe_get [Float.Array] | |
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 [Bytes] | Unsafely convert a shared string to a byte sequence that should not be mutated. |
unsafe_set [Float.Array] | |
unsafe_set [Bigarray.Array3] | Like |
unsafe_set [Bigarray.Array2] | Like |
unsafe_set [Bigarray.Array1] | Like |
unsafe_string [Clflags] | |
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 |
update [MoreLabels.Map.S] | |
update [Map.S] |
|
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] | Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set. |
uppercase_ascii [StringLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set. |
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] | |
use_file [Parse] | |
use_inlining_arguments_set [Clflags] | Set all the inlining arguments for a round. |
use_linscan [Clflags] | |
use_prims [Clflags] | |
use_runtime [Clflags] | |
use_threads [Clflags] | |
use_vmthreads [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] | |
value [Ast_helper.Str] | |
value [Ast_helper.Sig] | |
value_default [Misc.Stdlib.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] | |
virtual_ [Ast_helper.Cf] | |
W | |
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 [ThreadUnix] | |
wait [Condition] |
|
wait_next_event [Graphics] | Wait until one of the events specified in the given event list occurs, and return the status of the mouse and keyboard at that time. |
wait_pid [Thread] |
|
wait_read [Thread] | See |
wait_signal [Thread] |
|
wait_timed_read [Thread] | |
wait_timed_write [Thread] | Same as |
wait_write [Thread] | Suspend the execution of the calling thread until at least
one character or EOF is available for reading ( |
waitpid [UnixLabels] | Same as |
waitpid [Unix] | Same as |
waitpid [ThreadUnix] | |
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_printer [Location] | Hook for intercepting warnings. |
warning_scope [Builtin_attributes] | Execute a function in a new scope for warning settings. |
weaken_map [Depend] | |
while_ [Ast_helper.Exp] | |
white [Graphics] | |
widen [CamlinternalOO] | |
win32 [Sys] | True if |
window_id [GraphicsX11] | Return the unique identifier of the OCaml graphics window. |
windows_unicode [Config] | |
with_ [Ast_helper.Mty] | |
with_default_loc [Ast_helper] | Set the |
with_flambda_invariants [Config] | |
with_frame_pointers [Config] | |
without_warnings [Warnings] | |
word_size [Sys] | Size of one word on the machine currently executing the OCaml program, in bits: 32 or 64. |
wrap [Event] |
|
wrap_abort [Event] |
|
write [UnixLabels] |
|
write [Unix] |
|
write [ThreadUnix] | |
write_arg [Arg] |
|
write_arg0 [Arg] | Identical to |
write_ast [Pparse] | |
write_substring [UnixLabels] | Same as |
write_substring [Unix] | Same as |
write_substring [ThreadUnix] | |
Y | |
yellow [Graphics] | |
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 [Complex] | The complex number |
zero_to_n [Numbers.Int] |
|