# Index of values

( * ) [Pervasives] | Integer multiplication.
( ** ) [Pervasives] | Exponentiation.
( **/ ) [Num] | Same as `Num.power_num`.
( *. ) [Pervasives] | Floating-point multiplication
( */ ) [Num] | Same as `Num.mult_num`.
(!) [Pervasives] | `!r` returns the current contents of reference `r`.
(!=) [Pervasives] | Negation of `(==)`.
(&&) [Pervasives] | The boolean 'and'.
(&) [Pervasives] |
(+) [Pervasives] | Integer addition.
(+.) [Pervasives] | Floating-point addition
(+/) [Num] | Same as `Num.add_num`.
(-) [Pervasives] | Integer subtraction.
(-.) [Pervasives] | Floating-point subtraction
(-/) [Num] | Same as `Num.sub_num`.
(/) [Pervasives] | Integer division.
(/.) [Pervasives] | Floating-point division.
(//) [Num] | Same as `Num.div_num`.
(:=) [Pervasives] | `r := a` stores the value of `a` in reference `r`.
(<) [Pervasives] | See `(>=)`.
(</) [Num] |
(<=) [Pervasives] | See `(>=)`.
(<=/) [Num] |
(<>) [Pervasives] | Negation of `(=)`.
(<>/) [Num] |
(=) [Pervasives] | `e1 = e2` tests for structural equality of `e1` and `e2`.
(=/) [Num] |
(==) [Pervasives] | `e1 == e2` tests for physical equality of `e1` and `e2`.
(>) [Pervasives] | See `(>=)`.
(>/) [Num] |
(>=) [Pervasives] | Structural ordering functions.
(>=/) [Num] |
(@) [Pervasives] | List concatenation.
(@@) [Pervasives] | Application operator: `g @@ f @@ x` is exactly equivalent to `g (f (x))`.
(^) [Pervasives] | String concatenation.
(^^) [Pervasives] | `f1 ^^ f2` catenates format strings `f1` and `f2`.
(asr) [Pervasives] | `n asr m` shifts `n` to the right by `m` bits.
(land) [Pervasives] | Bitwise logical and.
(lor) [Pervasives] | Bitwise logical or.
(lsl) [Pervasives] | `n lsl m` shifts `n` to the left by `m` bits.
(lsr) [Pervasives] | `n lsr m` shifts `n` to the right by `m` bits.
(lxor) [Pervasives] | Bitwise logical exclusive or.
(mod) [Pervasives] | Integer remainder.
(or) [Pervasives] |
(|>) [Pervasives] | Reverse-application operator: `x |> f |> g` is exactly equivalent to `g (f (x))`.
(||) [Pervasives] | The boolean 'or'.
(~+) [Pervasives] | Unary addition.
(~+.) [Pervasives] | Unary addition.
(~-) [Pervasives] | Unary negation.
(~-.) [Pervasives] | Unary negation.
__FILE__ [Pervasives] | `__FILE__` returns the name of the file currently being parsed by the compiler.
__LINE_OF__ [Pervasives] | `__LINE__ expr` returns a pair `(line, expr)`, where `line` is the line number at which the expression `expr` appears in the file currently being parsed by the compiler.
__LINE__ [Pervasives] | `__LINE__` returns the line number at which this expression appears in the file currently being parsed by the compiler.
__LOC_OF__ [Pervasives] | `__LOC_OF__ expr` returns a pair `(loc, expr)` where `loc` is the location of `expr` in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".
__LOC__ [Pervasives] | `__LOC__` returns the location at which this expression appears in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".
__MODULE__ [Pervasives] | `__MODULE__` returns the module name of the file being parsed by the compiler.
__POS_OF__ [Pervasives] | `__POS_OF__ expr` returns a pair `(loc,expr)`, where `loc` is a tuple `(file,lnum,cnum,enum)` corresponding to the location at which the expression `expr` appears in the file currently being parsed by the compiler.
__POS__ [Pervasives] | `__POS__` returns a tuple `(file,lnum,cnum,enum)`, corresponding to the location at which this expression appears in the file currently being parsed by the compiler.
A
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_big_int [Big_int] | Absolute value.
abs_float [Pervasives] | `abs_float f` returns the absolute value of `f`.
abs_num [Num] | Absolute value.
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.
accumulate_time [Timings] | Like time for passes that can run multiple times
acos [Pervasives] | Arc cosine.
adapt_filename [Dynlink] | In bytecode, the identity function.
add [Weak.S] | `add t x` adds `x` to `t`.
add [Tbl] |
add [Queue] | `add x q` adds the element `x` at the end of the queue `q`.
add [Nativeint] | Addition.
add [MoreLabels.Set.S] |
add [MoreLabels.Map.S] |
add [MoreLabels.Hashtbl.SeededS] |
add [MoreLabels.Hashtbl.S] |
add [MoreLabels.Hashtbl] |
add [Set.S] | `add x s` returns a set containing all elements of `s`, plus `x`.
add [Map.S] | `add x y m` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`.
add [Int64] | Addition.
add [Int32] | Addition.
add [Hashtbl.SeededS] |
add [Hashtbl.S] |
add [Hashtbl] | `Hashtbl.add tbl x y` adds a binding of `x` to `y` in table `tbl`.
add [Complex] | Addition
add_available_units [Dynlink] | Same as `Dynlink.add_interfaces`, but instead of searching `.cmi` files to find the unit interfaces, uses the interface digests given for each unit.
add_base_override [Arg_helper.Make] |
add_big_int [Big_int] | Addition.
add_buffer [Buffer] | `add_buffer b1 b2` appends the current contents of buffer `b2` at the end of buffer `b1`.
add_bytes [Buffer] | `add_bytes b s` appends the byte sequence `s` at the end of buffer `b`.
add_channel [Buffer] | `add_channel b ic n` reads at most `n` characters from the input channel `ic` and stores them at the end of buffer `b`.
add_char [Buffer] | `add_char b c` appends the character `c` at the end of buffer `b`.
add_docs_attrs [Docstrings] | Convert item documentation to attributes and add them to an attribute list
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_int_big_int [Big_int] | Addition of a small integer to a big integer.
add_interfaces [Dynlink] | `add_interfaces units path` grants dynamically-linked object files access to the compilation units named in list `units`.
add_num [Num] | Addition
add_offset [Obj] |
add_ppx_context_sig [Ast_mapper] | Same as `add_ppx_context_str`, but for signatures.
add_ppx_context_str [Ast_mapper] | Extract information from the current environment and encode it into an attribute which is prepended to the list of structure items in order to pass the information to an external processor.
add_string [Buffer] | `add_string b s` appends the string `s` at the end of buffer `b`.
add_subbytes [Buffer] | `add_subbytes b s ofs len` takes `len` characters from offset `ofs` in byte sequence `s` and appends them at the end of buffer `b`.
add_substitute [Buffer] | `add_substitute b f s` appends the string pattern `s` at the end of buffer `b` with substitution.
add_substring [Buffer] | `add_substring b s ofs len` takes `len` characters from offset `ofs` in string `s` and appends them at the end of buffer `b`.
add_text_attrs [Docstrings] | Convert text to attributes and add them to an attribute list
add_user_override [Arg_helper.Make] |
alarm [UnixLabels] | Schedule a `SIGALRM` signal after the given number of seconds.
alarm [Unix] | Schedule a `SIGALRM` signal after the given number of seconds.
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 space, according to the length of the keyword.
all_ccopts [Clflags] |
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_only units` restricts the compilation units that dynamically-linked units can reference: it forbids all references to units other than those named in the list `units`.
allow_unsafe_modules [Dynlink] | Govern whether unsafe object files are allowed to be dynamically linked.
always [Event] | `always v` returns an event that is always ready for synchronization.
and_big_int [Big_int] | Bitwise logical 'and'.
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] | `ArrayLabels.append v1 v2` returns a fresh array containing the concatenation of the arrays `v1` and `v2`.
append [Array] | `Array.append v1 v2` returns a fresh array containing the concatenation of the arrays `v1` and `v2`.
applicative_functors [Clflags] |
apply [Ast_mapper] | Apply a mapper (parametrized by the unit name) to a dumped parsetree found in the `source` file and put the result in the `target` file.
apply [Ast_helper.Cl] |
apply [Ast_helper.Mod] |
apply [Ast_helper.Exp] |
approx_num_exp [Num] | Approximate a number by a decimal.
approx_num_fix [Num] | See `Num.approx_num_exp`.
ar [Config] |
architecture [Config] |
arg [Complex] | Argument.
argv [Sys] | The command line arguments given to the process.
arith_status [Arith_status] | Print the current status of the arithmetic flags.
array [Sort] | Sort an array in increasing order according to an ordering predicate.
array [Ast_helper.Exp] |
array [Ast_helper.Pat] |
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.
asm [Config] |
asm_cfi_supported [Config] |
asprintf [Format] | Same as `printf` above, but instead of printing on a formatter, returns a string containing the result of formatting the arguments.
assert_ [Ast_helper.Exp] |
assoc [ListLabels] | `assoc a l` returns the value associated with key `a` in the list of pairs `l`.
assoc [List] | `assoc a l` returns the value associated with key `a` in the list of pairs `l`.
assq [ListLabels] | Same as `ListLabels.assoc`, but uses physical equality instead of structural equality to compare keys.
assq [List] | Same as `List.assoc`, but uses physical equality instead of structural equality to compare keys.
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.
atan2 [Pervasives] | `atan2 y x` returns the arc tangent of `y /. x`.
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
background [Graphics] | See `Graphics.foreground`.
backtrace_slots [Printexc] | Returns the slots of a raw backtrace, or `None` if none of them contain useful information.
backtrace_status [Printexc] | `Printexc.backtrace_status()` returns `true` if exception backtraces are currently recorded, `false` if not.
backup [Warnings] |
backup [Terminfo] |
basename [Filename] | Split a file name into directory name / base file name.
beginning_of_input [Scanf.Scanning] | `Scanning.beginning_of_input ic` tests the beginning of input condition of the given `!Scanning.in_channel` formatted input channel.
big_endian [Sys] | Whether the machine currently executing the Caml program is big-endian.
big_int_of_int [Big_int] | Convert a small integer to a big integer.
big_int_of_int32 [Big_int] | Convert a 32-bit integer to a big integer.
big_int_of_int64 [Big_int] | Convert a 64-bit integer to a big integer.
big_int_of_nativeint [Big_int] | Convert a native integer to a big integer.
big_int_of_num [Num] |
big_int_of_string [Big_int] | Convert a string to a big integer, in decimal.
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] | `Weak.blit ar1 off1 ar2 off2 len` copies `len` weak pointers from `ar1` (starting at `off1`) to `ar2` (starting at `off2`).
blit [String] | Same as `Bytes.blit_string`.
blit [StringLabels] | `String.blit src srcoff dst dstoff len` copies `len` bytes from the string `src`, starting at index `srcoff`, to byte sequence `dst`, starting at character number `dstoff`.
blit [Misc.LongString] |
blit [BytesLabels] | `blit src srcoff dst dstoff len` copies `len` bytes from sequence `src`, starting at index `srcoff`, to sequence `dst`, starting at index `dstoff`.
blit [Bytes] | `blit src srcoff dst dstoff len` copies `len` bytes from sequence `src`, starting at index `srcoff`, to sequence `dst`, starting at index `dstoff`.
blit [Buffer] | `Buffer.blit src srcoff dst dstoff len` copies `len` characters from the current contents of the buffer `src`, starting at offset `srcoff` to `dst`, starting at character `dstoff`.
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.Genarray] | Copy all elements of a big array in another big array.
blit [ArrayLabels] | `ArrayLabels.blit v1 o1 v2 o2 len` copies `len` elements from array `v1`, starting at element number `o1`, to array `v2`, starting at element number `o2`.
blit [Array] | `Array.blit v1 o1 v2 o2 len` copies `len` elements from array `v1`, starting at element number `o1`, to array `v2`, starting at element number `o2`.
blit_data [Obj.Ephemeron] | Same as `Ephemeron.K1.blit_data`
blit_data [Ephemeron.Kn] | Same as `Ephemeron.K1.blit_data`
blit_data [Ephemeron.K2] | Same as `Ephemeron.K1.blit_data`
blit_data [Ephemeron.K1] | `Ephemeron.K1.blit_data eph1 eph2` sets the data of `eph2` with the data of `eph1`.
blit_image [Graphics] | `blit_image img x y` copies screen pixels into the image `img`, modifying `img` in-place.
blit_key [Obj.Ephemeron] | Same as `Ephemeron.K1.blit_key`
blit_key [Ephemeron.Kn] | Same as `Ephemeron.K1.blit_key`
blit_key [Ephemeron.K1] | `Ephemeron.K1.blit_key eph1 eph2` sets the key of `eph2` with the key of `eph1`.
blit_key1 [Ephemeron.K2] | Same as `Ephemeron.K1.blit_key`
blit_key12 [Ephemeron.K2] | Same as `Ephemeron.K1.blit_key`
blit_key2 [Ephemeron.K2] | Same as `Ephemeron.K1.blit_key`
blit_string [Bytes] | `blit src srcoff dst dstoff len` copies `len` bytes from string `src`, starting at index `srcoff`, to byte sequence `dst`, starting at index `dstoff`.
blue [Graphics] |
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] | `Random.bool ()` returns `true` or `false` with probability 0.5 each.
bool_of_string [Pervasives] | Convert the given string to a boolean.
bounded_full_split [Str] | Same as `Str.bounded_split_delim`, but returns the delimiters as well as the substrings contained between delimiters.
bounded_split [Str] | Same as `Str.split`, but splits into at most `n` substrings, where `n` is the extra integer parameter.
bounded_split_delim [Str] | Same as `Str.bounded_split`, but occurrences of the delimiter at the beginning and at the end of the string are recognized and returned as empty strings in the result.
bprintf [Printf] | Same as `Printf.fprintf`, but instead of printing on an output channel, append the formatted arguments to the given extensible buffer (see module `Buffer`).
bprintf [Format] |
broadcast [Condition] | `broadcast c` restarts all processes waiting on the condition variable `c`.
bscanf [Scanf] |
bscanf_format [Scanf] | `bscanf_format ic fmt f` reads a format string token from the formatted input channel `ic`, according to the given format string `fmt`, and applies `f` to the resulting format string value.
bufput_acc [CamlinternalFormat] |
button_down [Graphics] | Return `true` if the mouse button is pressed, `false` otherwise.
bytecode_compatible_32 [Clflags] |
bytecomp_c_compiler [Config] |
bytecomp_c_libraries [Config] |
bytes [Digest] | Return the digest of the given byte sequence.
C
c_compiler [Clflags] |
c_layout [Bigarray] |
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.
capitalize [BytesLabels] | Return a copy of the argument, with the first byte set to uppercase.
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 [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 [Set.S] | Return the number of elements of a set.
cardinal [Map.S] | Return the number of bindings of a map.
case [Ast_helper.Exp] |
cat [Bytes] | `cat s1 s2` concatenates `s1` and `s2` and returns the result as new byte sequence.
catch [Printexc] | `Printexc.catch fn x` is similar to `Printexc.print`, but aborts the program with exit code 2 after printing the uncaught exception.
catch_break [Sys] | `catch_break` governs whether interactive interrupt (ctrl-C) terminates the program or raises the `Break` exception.
cc_profile [Config] |
ccobjs [Clflags] |
ccomp_type [Config] |
ceil [Pervasives] | Round above to an integer value.
ceiling_num [Num] | `ceiling_num n` returns the smallest integer bigger or equal to `n`.
channel [Digest] | If `len` is nonnegative, `Digest.channel ic len` reads `len` characters from channel `ic` and returns their digest, or raises `End_of_file` if end-of-file is reached before `len` characters are read.
char [Bigarray] | As shown by the types of the values above, big arrays of kind `float32_elt` and `float64_elt` are accessed using the OCaml type `float`.
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] | `Weak.check ar n` returns `true` if the `n`th cell of `ar` is full, `false` if it is empty.
check [Consistbl] |
check_data [Obj.Ephemeron] | Same as `Ephemeron.K1.check_data`
check_data [Ephemeron.Kn] | Same as `Ephemeron.K1.check_data`
check_data [Ephemeron.K2] | Same as `Ephemeron.K1.check_data`
check_data [Ephemeron.K1] | `Ephemeron.K1.check_data eph` returns `true` if the data of the `eph` is full, `false` if it is empty.
check_deprecated [Builtin_attributes] |
check_deprecated_mutable [Builtin_attributes] |
check_fatal [Warnings] |
check_key [Obj.Ephemeron] | Same as `Ephemeron.K1.check_key`
check_key [Ephemeron.Kn] | Same as `Ephemeron.K1.check_key`
check_key [Ephemeron.K1] | `Ephemeron.K1.check_key eph` returns `true` if the key of the `eph` is full, `false` if it is empty.
check_key1 [Ephemeron.K2] | Same as `Ephemeron.K1.check_key`
check_key2 [Ephemeron.K2] | Same as `Ephemeron.K1.check_key`
check_noadd [Consistbl] |
check_suffix [Filename] | `check_suffix name suff` returns `true` if the filename `name` ends with the suffix `suff`.
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 [Set.S] | Return one element of the given set, or raise `Not_found` if the set is empty.
choose [Map.S] | Return one binding of the given map, or raise `Not_found` if the map is empty.
choose [Event] | `choose evl` returns the event that is the alternative of all the events in the list `evl`.
chop_extension [Filename] | Return the given file name without its extension.
chop_extension_if_any [Misc] |
chop_extensions [Misc] |
chop_suffix [Filename] | `chop_suffix name suff` removes the suffix `suff` from the filename `name`.
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.
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.
close [UnixLabels] | Close a file descriptor.
close [Unix] | Close a file descriptor.
close_box [Format] | Closes the most recently opened pretty-printing box.
close_graph [Graphics] | Delete the graphics window or switch the screen back to text mode.
close_in [Scanf.Scanning] | Closes the `!Pervasives.in_channel` associated with the given `!Scanning.in_channel` formatted input channel.
close_in [Pervasives] | Close the given channel.
close_in_noerr [Pervasives] | Same as `close_in`, but ignore all errors.
close_out [Pervasives] | Close the given channel, flushing all buffered write operations.
close_out_noerr [Pervasives] | Same as `close_out`, but ignore all errors.
close_process [UnixLabels] | Close channels opened by `UnixLabels.open_process`, wait for the associated command to terminate, and return its termination status.
close_process [Unix] | Close channels opened by `Unix.open_process`, wait for the associated command to terminate, and return its termination status.
close_process_full [UnixLabels] | Close channels opened by `UnixLabels.open_process_full`, wait for the associated command to terminate, and return its termination status.
close_process_full [Unix] | Close channels opened by `Unix.open_process_full`, wait for the associated command to terminate, and return its termination status.
close_process_in [UnixLabels] | Close channels opened by `UnixLabels.open_process_in`, wait for the associated command to terminate, and return its termination status.
close_process_in [Unix] | Close channels opened by `Unix.open_process_in`, wait for the associated command to terminate, and return its termination status.
close_process_out [UnixLabels] | Close channels opened by `UnixLabels.open_process_out`, wait for the associated command to terminate, and return its termination status.
close_process_out [Unix] | Close channels opened by `Unix.open_process_out`, wait for the associated command to terminate, and return its termination status.
close_subwindow [GraphicsX11] | Close the sub-window having the given identifier.
close_tag [Format] | `close_tag ()` closes the most recently opened tag `t`.
close_tbox [Format] |
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 [a1; ...; an] [b1; ...; bn]` is `[(a1,b1); ...; (an,bn)]`.
combine [List] | Transform a pair of lists into a list of pairs: `combine [a1; ...; an] [b1; ...; bn]` is `[(a1,b1); ...; (an,bn)]`.
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 u u'` is `Pervasives.compare u u'`.
compare [String] | The comparison function for strings, with the same specification as `compare`.
compare [StringLabels] | The comparison function for strings, with the same specification as `compare`.
compare [Pervasives] | `compare x y` returns `0` if `x` is equal to `y`, a negative integer if `x` is less than `y`, and a positive integer if `x` is greater than `y`.
compare [Nativeint] | The comparison function for native integers, with the same specification as `compare`.
compare [Set.OrderedType] | A total ordering function over the set elements.
compare [MoreLabels.Set.S] |
compare [MoreLabels.Map.S] |
compare [Set.S] | Total ordering between sets.
compare [Misc.Stdlib.List] | The lexicographic order supported by the provided order.
compare [Map.OrderedType] | A total ordering function over the keys.
compare [Map.S] | Total ordering between maps.
compare [Int64] | The comparison function for 64-bit integers, with the same specification as `compare`.
compare [Int32] | The comparison function for 32-bit integers, with the same specification as `compare`.
compare [Digest] | The comparison function for 16-character digest, with the same specification as `compare` and the implementation shared with `String.compare`.
compare [Char] | The comparison function for characters, with the same specification as `compare`.
compare [BytesLabels] | The comparison function for byte sequences, with the same specification as `compare`.
compare [Bytes] | The comparison function for byte sequences, with the same specification as `compare`.
compare_big_int [Big_int] | `compare_big_int a b` returns `0` if `a` and `b` are equal, `1` if `a` is greater than `b`, and `-1` if `a` is smaller than `b`.
compare_num [Num] | Return `-1`, `0` or `1` if the first argument is less than, equal to, or greater than the second argument.
compile_file [Ccomp] |
compile_only [Clflags] |
complex32 [Bigarray] | See `Bigarray.char`.
complex64 [Bigarray] | See `Bigarray.char`.
component_graph [Strongly_connected_components.S] |
concat [String] | `String.concat sep sl` concatenates the list of strings `sl`, inserting the separator string `sep` between each.
concat [StringLabels] | `String.concat sep sl` concatenates the list of strings `sl`, inserting the separator string `sep` between each.
concat [ListLabels] | Concatenate a list of lists.
concat [List] | Concatenate a list of lists.
concat [Filename] | `concat dir file` returns a file name that designates file `file` in directory `dir`.
concat [BytesLabels] | `concat sep sl` concatenates the list of byte sequences `sl`, inserting the separator byte sequence `sep` between each, and returns the result as a new byte sequence.
concat [Bytes] | `concat sep sl` concatenates the list of byte sequences `sl`, inserting the separator byte sequence `sep` between each, and returns the result as a new byte sequence.
concat [ArrayLabels] | Same as `ArrayLabels.append`, but concatenates a list of arrays.
concat [Array] | Same as `Array.append`, but concatenates a list of arrays.
concat_fmt [CamlinternalFormatBasics] |
concat_fmtty [CamlinternalFormatBasics] |
concrete [Ast_helper.Cf] |
conj [Complex] | Conjugate: given the complex `x + i.y`, returns `x - i.y`.
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 [List] | `cons x xs` is `x :: xs`
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] | `String.contains s c` tests if character `c` appears in the string `s`.
contains [StringLabels] | `String.contains s c` tests if character `c` appears in the string `s`.
contains [BytesLabels] | `contains s c` tests if byte `c` appears in `s`.
contains [Bytes] | `contains s c` tests if byte `c` appears in `s`.
contains_from [String] | `String.contains_from s start c` tests if character `c` appears in `s` after position `start`.
contains_from [StringLabels] | `String.contains_from s start c` tests if character `c` appears in `s` after position `start`.
contains_from [BytesLabels] | `contains_from s start c` tests if byte `c` appears in `s` after position `start`.
contains_from [Bytes] | `contains_from s start c` tests if byte `c` appears in `s` after position `start`.
contents [Buffer] | Return a copy of the current contents of the buffer.
convert_raw_backtrace_slot [Printexc] | Extracts the user-friendly `backtrace_slot` from a low-level `raw_backtrace_slot`.
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] | `Oo.copy o` returns a copy of object `o`, that is a fresh object with the same methods and instance variables as `o`.
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] | `ArrayLabels.copy a` returns a copy of `a`, that is, a fresh array containing the same elements as `a`.
copy [Array] | `Array.copy a` returns a copy of `a`, that is, a fresh array containing the same elements as `a`.
copy_file [Misc] |
copy_file_chunk [Misc] |
copysign [Pervasives] | `copysign x y` returns a float whose absolute value is that of `x` and whose sign is that of `y`.
core_type [Pprintast] |
core_type [Parse] |
cos [Pervasives] | Cosine.
cosh [Pervasives] | 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 `(minor_words, promoted_words, major_words)`.
create [Weak.S] | `create n` creates a new empty weak hash set, of initial size `n`.
create [Weak] | `Weak.create n` returns a new weak array of length `n`.
create [Thread] | `Thread.create funct arg` creates a new thread of control, in which the function application `funct arg` is executed concurrently with the other threads of the program.
create [String] | `String.create n` returns a fresh byte sequence of length `n`.
create [StringLabels] | `String.create n` returns a fresh byte sequence of length `n`.
create [Stack] | Return a new stack, initially empty.
create [Queue] | Return a new queue, initially empty.
create [Obj.Ephemeron] | `create n` returns an ephemeron with `n` keys.
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] | `Hashtbl.create n` creates a new, empty hash table, with initial size `n`.
create [Ephemeron.Kn] | Same as `Ephemeron.K1.create`
create [Ephemeron.K2] | Same as `Ephemeron.K1.create`
create [Ephemeron.K1] | `Ephemeron.K1.create ()` creates an ephemeron with one key.
create [Consistbl] |
create [Condition] | Return a new condition variable.
create [BytesLabels] | `create n` returns a new byte sequence of length `n`.
create [Bytes] | `create n` returns a new byte sequence of length `n`.
create [Buffer] | `create n` returns a fresh buffer, initially empty.
create [Bigarray.Array3] | `Array3.create kind layout dim1 dim2 dim3` returns a new bigarray of three dimension, whose size is `dim1` in the first dimension, `dim2` in the second dimension, and `dim3` in the third.
create [Bigarray.Array2] | `Array2.create kind layout dim1 dim2` returns a new bigarray of two dimension, whose size is `dim1` in the first dimension and `dim2` in the second dimension.
create [Bigarray.Array1] | `Array1.create kind layout dim` returns a new bigarray of one dimension, whose size is `dim`.
create [Bigarray.Genarray] | `Genarray.create kind layout dimensions` returns a new big array whose element kind is determined by the parameter `kind` (one of `float32`, `float64`, `int8_signed`, etc) and whose layout is determined by the parameter `layout` (one of `c_layout` or `fortran_layout`).
create [ArrayLabels] |
create [Array] |
create_alarm [Gc] | `create_alarm f` will arrange for `f` to be called at the end of each major GC cycle, starting with the current cycle or the next one.
create_archive [Ccomp] |
create_char_set [CamlinternalFormat] |
create_float [ArrayLabels] | `ArrayLabels.create_float n` returns a fresh float array of length `n`, with uninitialized data.
create_float [Array] | `Array.create_float n` returns a fresh float array of length `n`, with uninitialized data.
create_hashtable [Misc] |
create_image [Graphics] | `create_image w h` returns a new image `w` pixels wide and `h` pixels tall, to be used in conjunction with `blit_image`.
create_matrix [ArrayLabels] |
create_matrix [Array] |
create_object [CamlinternalOO] |
create_object_and_run_initializers [CamlinternalOO] |
create_object_opt [CamlinternalOO] |
create_process [UnixLabels] | `create_process prog args new_stdin new_stdout new_stderr` forks a new process that executes the program in file `prog`, with arguments `args`.
create_process [Unix] | `create_process prog args new_stdin new_stdout new_stderr` forks a new process that executes the program in file `prog`, with arguments `args`.
create_process_env [UnixLabels] | `create_process_env prog args env new_stdin new_stdout new_stderr` works as `UnixLabels.create_process`, except that the extra argument `env` specifies the environment passed to the program.
create_process_env [Unix] | `create_process_env prog args env new_stdin new_stdout new_stderr` works as `Unix.create_process`, except that the extra argument `env` specifies the environment passed to the program.
create_table [CamlinternalOO] |
curr [Location] | Get the location of the current token from the `lexbuf`.
current [Arg] | Position (in `Sys.argv`) of the argument being processed.
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] | `curveto b c d` draws a cubic Bezier curve starting from the current point to point `d`, with control points `b` and `c`, and moves the current point to `d`.
custom_runtime [Clflags] |
custom_tag [Obj] |
cut_at [Misc] | `String.cut_at s c` returns a pair containing the sub-string before the first occurrence of `c` in `s`, and the sub-string after the first occurrence of `c` in `s`.
cyan [Graphics] |
cygwin [Sys] | True if `Sys.os_type = "Cygwin"`.
D
data [Identifiable.S.Map] |
data_size [Marshal] | See `Marshal.header_size`.
debug [Clflags] |
decl [Ast_helper.Te] |
decr [Pervasives] | Decrement the integer contained in the given reference.
decr_num [Num] | `decr r` is `r:=!r-1`, where `r` is a reference to a number.
default [Pprintast] |
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_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] | `delay d` suspends the execution of the calling thread for `d` seconds.
delete_alarm [Gc] | `delete_alarm a` will stop the calls to the function associated to `a`.
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] | `did_you_mean ppf get_choices` hints that the user may have meant one of the option returned by calling `get_choices`.
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] | `Genarray.dims a` returns all dimensions of the big array `a`, as an array of integers of length `Genarray.num_dims a`.
dir_sep [Filename] | The directory separator (e.g.
dirname [Filename] | See `Filename.basename`.
disjoint_union [Identifiable.S.Map] | `disjoint_union m1 m2` contains all bindings from `m1` and `m2`.
display_mode [Graphics] | Set display mode on or off.
div [Nativeint] | Integer division.
div [Int64] | Integer division.
div [Int32] | Integer division.
div [Complex] | Division
div_big_int [Big_int] | Euclidean quotient of two big integers.
div_num [Num] | 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_arc x y rx ry a1 a2` draws an elliptical arc with center `x,y`, horizontal radius `rx`, vertical radius `ry`, from angle `a1` to angle `a2` (in degrees).
draw_char [Graphics] | See `Graphics.draw_string`.
draw_circle [Graphics] | `draw_circle x y r` draws a circle with center `x,y` and radius `r`.
draw_ellipse [Graphics] | `draw_ellipse x y rx ry` draws an ellipse with center `x,y`, horizontal radius `rx` and vertical radius `ry`.
draw_image [Graphics] | Draw the given image with lower left corner at the given point.
draw_poly [Graphics] | `draw_poly polygon` draws the given polygon.
draw_poly_line [Graphics] | `draw_poly_line points` draws the line that joins the points given by the array argument.
draw_rect [Graphics] | `draw_rect x y w h` draws the rectangle with lower left corner at `x,y`, width `w` and height `h`.
draw_segments [Graphics] | `draw_segments segments` draws the segments given in the array argument.
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`, but for signatures.
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 `position`, guaranteed to be different from any valid position.
dummy_table [CamlinternalOO] |
dump [Uchar] | `dump ppf u` prints a representation of `u` on `ppf` using only US-ASCII encoded characters according to the Unicode notational convention for code points.
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_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 fd1 fd2` duplicates `fd1` to `fd2`, closing `fd2` if already opened.
dup2 [Unix] | `dup2 fd1 fd2` duplicates `fd1` to `fd2`, closing `fd2` if already opened.
E
echo_eof [Location] |
edit_distance [Misc] | `edit_distance a b cutoff` computes the edit distance between strings `a` and `b`.
elements [MoreLabels.Set.S] |
elements [Set.S] | Return the list of all elements of the given set.
emit_external_warnings [Builtin_attributes] |
empty [Tbl] |
empty [Stream] | Return `()` if the stream is empty, else raise `Stream.Failure`.
empty [MoreLabels.Set.S] |
empty [MoreLabels.Map.S] |
empty [Set.S] | The empty set.
empty [Map.S] | The empty map.
empty [BytesLabels] | A byte sequence of size 0.
empty [Bytes] | A byte sequence of size 0.
empty_docs [Docstrings] |
empty_info [Docstrings] |
empty_text [Docstrings] |
empty_text_lazy [Docstrings] |
enable_runtime_warnings [Sys] | Control whether the OCaml runtime system can emit warnings on stderr.
end_of_input [Scanf.Scanning] | `Scanning.end_of_input ic` tests the end-of-input condition of the given `!Scanning.in_channel` formatted input channel.
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 `Printf.fprintf`, but output on `stderr`.
eprintf [Format] | Same as `fprintf` above, but output on `err_formatter`.
epsilon_float [Pervasives] | The difference between `1.0` and the smallest exactly representable floating-point number greater than `1.0`.
eq_big_int [Big_int] |
eq_num [Num] |
equal [Uchar] | `equal u u'` is `u = u'`.
equal [String] | The equal function for strings.
equal [Nativeint] | The equal function for natives ints.
equal [MoreLabels.Set.S] |
equal [MoreLabels.Map.S] |
equal [Set.S] | `equal s1 s2` tests whether the sets `s1` and `s2` are equal, that is, contain equal elements.
equal [Misc.Stdlib.Option] |
equal [Misc.Stdlib.List] | Returns `true` iff the given lists have the same length and content with respect to the given equality function.
equal [Map.S] | `equal cmp m1 m2` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
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 [Digest] | The equal function for 16-character digest.
equal [Char] | The equal function for chars.
equal [Bytes] | The equality function for byte sequences.
erase_rel [CamlinternalFormatBasics] |
err_formatter [Format] | A formatter to use with formatting functions below for output 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] |
errorf_prefixed [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.
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 prog args` execute the program in file `prog`, with the arguments `args`, and the current process environment.
execv [Unix] | `execv prog args` execute the program in file `prog`, with the arguments `args`, and the current process environment.
execv [ThreadUnix] |
execve [UnixLabels] | Same as `UnixLabels.execv`, except that the third argument provides the environment to the program executed.
execve [Unix] | Same as `Unix.execv`, except that the third argument provides the environment to the program executed.
execve [ThreadUnix] |
execvp [UnixLabels] | Same as `UnixLabels.execv`, except that the program is searched in the path.
execvp [Unix] | Same as `Unix.execv`, except that the program is searched in the path.
execvp [ThreadUnix] |
execvpe [UnixLabels] | Same as `UnixLabels.execve`, except that the program is searched in the path.
execvpe [Unix] | Same as `Unix.execve`, except that the program is searched in the path.
exists [MoreLabels.Set.S] |
exists [MoreLabels.Map.S] |
exists [Set.S] | `exists p s` checks if at least one element of the set satisfies the predicate `p`.
exists [Map.S] | `exists p m` checks if at least one binding of the map satisfy the predicate `p`.
exists [ListLabels] | `exists p [a1; ...; an]` checks if at least one element of the list satisfies the predicate `p`.
exists [List] | `exists p [a1; ...; an]` checks if at least one element of the list satisfies the predicate `p`.
exists [ArrayLabels] | `ArrayLabels.exists p [|a1; ...; an|]` checks if at least one element of the array satisfies the predicate `p`.
exists [Array] | `Array.exists p [|a1; ...; an|]` checks if at least one element of the array satisfies the predicate `p`.
exists2 [ListLabels] | Same as `ListLabels.exists`, but for a two-argument predicate.
exists2 [List] | Same as `List.exists`, but for a two-argument predicate.
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] | `Printexc.exn_slot_id` returns an integer which uniquely identifies the constructor used to create the exception value `exn` (in the current runtime).
exn_slot_name [Printexc] | `Printexc.exn_slot_id exn` returns the internal name of the constructor used to create the exception value `exn`.
exp [Pervasives] | Exponential.
exp [Complex] | Exponentiation.
expand_directory [Misc] |
expand_libname [Ccomp] |
explicit_arity [Builtin_attributes] |
expm1 [Pervasives] | `expm1 x` computes `exp x -. 1.0`, giving numerically-accurate results even if `x` is close to `0.0`.
expression [Printast] |
expression [Pprintast] |
expression [Parse] |
ext_asm [Config] |
ext_dll [Config] |
ext_lib [Config] |
ext_obj [Config] |
extend [Bytes] | `extend s left right` returns a new byte sequence that contains the bytes of `s`, with `left` uninitialized bytes prepended and `right` uninitialized bytes appended to it.
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] |
extract_big_int [Big_int] | `extract_big_int bi ofs n` returns a nonnegative number corresponding to bits `ofs` to `ofs + n - 1` of the binary representation of `bi`.
F
failwith [Pervasives] | Raise exception `Failure` with the given string.
fast [Clflags] |
fast_sort [ListLabels] | Same as `ListLabels.sort` or `ListLabels.stable_sort`, whichever is faster on typical input.
fast_sort [List] | Same as `List.sort` or `List.stable_sort`, whichever is faster on typical input.
fast_sort [ArrayLabels] | Same as `ArrayLabels.sort` or `ArrayLabels.stable_sort`, whichever is faster on typical input.
fast_sort [Array] | Same as `Array.sort` or `Array.stable_sort`, whichever is faster on typical input.
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 [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] | `Weak.fill ar ofs len el` sets to `el` all pointers of `ar` from `ofs` to `ofs + len - 1`.
fill [String] | `String.fill s start len c` modifies byte sequence `s` in place, replacing `len` bytes with `c`, starting at `start`.
fill [StringLabels] | `String.fill s start len c` modifies byte sequence `s` in place, replacing `len` bytes by `c`, starting at `start`.
fill [BytesLabels] | `fill s start len c` modifies `s` in place, replacing `len` characters with `c`, starting at `start`.
fill [Bytes] | `fill s start len c` modifies `s` in place, replacing `len` characters with `c`, starting at `start`.
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.Genarray] | Set all elements of a big array to a given value.
fill [ArrayLabels] | `ArrayLabels.fill a ofs len x` modifies the array `a` in place, storing `x` in elements number `ofs` to `ofs + len - 1`.
fill [Array] | `Array.fill a ofs len x` modifies the array `a` in place, storing `x` in elements number `ofs` to `ofs + len - 1`.
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] | `fill_rect x y w h` fills the rectangle with lower left corner at `x,y`, width `w` and height `h`, with the current color.
filter [MoreLabels.Set.S] |
filter [MoreLabels.Map.S] |
filter [Set.S] | `filter p s` returns the set of all elements in `s` that satisfy predicate `p`.
filter [Map.S] | `filter p m` returns the map with all the bindings in `m` that satisfy predicate `p`.
filter [ListLabels] | `filter p l` returns all the elements of the list `l` that satisfy the predicate `p`.
filter [List] | `filter p l` returns all the elements of the list `l` that satisfy the predicate `p`.
filter [Consistbl] |
filter_map [Misc.Stdlib.List] | `filter_map f l` applies `f` to every element of `l`, filters out the `None` elements and returns the list of the arguments of the `Some` elements.
filter_map [Identifiable.S.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] | `Hashtbl.filter_map_inplace f tbl` applies `f` to all bindings in table `tbl` and update each binding depending on the result of `f`.
final_tag [Obj] |
finalise [Gc] | `finalise f v` registers `f` as a finalisation function for `v`.
finalise_release [Gc] | A finalisation function may call `finalise_release` to tell the GC that it can launch the next finalisation function without waiting for the current one to return.
find [Weak.S] | `find t x` returns an instance of `x` found in `t`.
find [Tbl] |
find [MoreLabels.Set.S] |
find [MoreLabels.Map.S] |
find [MoreLabels.Hashtbl.SeededS] |
find [MoreLabels.Hashtbl.S] |
find [MoreLabels.Hashtbl] |
find [Set.S] | `find x s` returns the element of `s` equal to `x` (according to `Ord.compare`), or raise `Not_found` if no such element exists.
find [Map.S] | `find x m` returns the current binding of `x` in `m`, or raises `Not_found` if no such binding exists.
find [ListLabels] | `find p l` returns the first element of the list `l` that satisfies the predicate `p`.
find [List] | `find p l` returns the first element of the list `l` that satisfies the predicate `p`.
find [Hashtbl.SeededS] |
find [Hashtbl.S] |
find [Hashtbl] | `Hashtbl.find tbl x` returns the current binding of `x` in `tbl`, or raises `Not_found` if no such binding exists.
find_all [Weak.S] | `find_all t x` returns a list of all the instances of `x` found in `t`.
find_all [MoreLabels.Hashtbl.SeededS] |
find_all [MoreLabels.Hashtbl.S] |
find_all [MoreLabels.Hashtbl] |
find_all [ListLabels] | `find_all` is another name for `ListLabels.filter`.
find_all [List] | `find_all` is another name for `List.filter`.
find_all [Hashtbl.SeededS] |
find_all [Hashtbl.S] |
find_all [Hashtbl] | `Hashtbl.find_all tbl x` returns the list of all data associated with `x` in `tbl`.
find_in_path [Misc] |
find_in_path_rel [Misc] |
find_in_path_uncap [Misc] |
first_chars [Str] | `first_chars s n` returns the first `n` characters of `s`.
first_non_constant_constructor_tag [Obj] |
flambda [Config] |
flambda_invariant_checks [Clflags] |
flatten [Longident] |
flatten [ListLabels] | Same as `concat`.
flatten [List] | Same as `concat`.
float [Random.State] |
float [Random] | `Random.float bound` returns a random floating-point number between 0 and `bound` (inclusive).
float [Pervasives] | Same as `float_of_int`.
float [Ast_helper.Const] |
float32 [Bigarray] | See `Bigarray.char`.
float64 [Bigarray] | See `Bigarray.char`.
float_const_prop [Clflags] |
float_of_big_int [Big_int] | Returns a floating-point number approximating the given big integer.
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 `int64`.
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 `int32`.
float_of_int [Pervasives] | Convert an integer to floating-point.
float_of_num [Num] |
float_of_string [Pervasives] | Convert the given string to a float.
floor [Pervasives] | Round below to an integer value.
floor_num [Num] | `floor_num n` returns the largest integer smaller or equal to `n`.
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 `str_formatter`, flushes the formatter and resets the corresponding buffer.
fmt_ebb_of_string [CamlinternalFormat] |
fold [Weak.S] | `fold f t init` computes `(f d1 (... (f dN init)))` where `d1 ... dN` are the elements of `t` in some unspecified order.
fold [Tbl] |
fold [Stack] | `fold f accu s` is `(f (... (f (f accu x1) x2) ...) xn)` where `x1` is the top of the stack, `x2` the second element, and `xn` the bottom element.
fold [Queue] | `fold f accu q` is equivalent to `List.fold_left f accu l`, where `l` is the list of `q`'s elements.
fold [MoreLabels.Set.S] |
fold [MoreLabels.Map.S] |
fold [MoreLabels.Hashtbl.SeededS] |
fold [MoreLabels.Hashtbl.S] |
fold [MoreLabels.Hashtbl] |
fold [Set.S] | `fold f s a` computes `(f xN ... (f x2 (f x1 a))...)`, where `x1 ... xN` are the elements of `s`, in increasing order.
fold [Misc.Stdlib.Option] |
fold [Map.S] | `fold f m a` computes `(f kN dN ... (f k1 d1 a)...)`, where `k1 ... kN` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
fold [Hashtbl.SeededS] |
fold [Hashtbl.S] |
fold [Hashtbl] | `Hashtbl.fold f tbl init` computes `(f kN dN ... (f k1 d1 init)...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values.
fold_left [ListLabels] | `ListLabels.fold_left f a [b1; ...; bn]` is `f (... (f (f a b1) b2) ...) bn`.
fold_left [List] | `List.fold_left f a [b1; ...; bn]` is `f (... (f (f a b1) b2) ...) bn`.
fold_left [ArrayLabels] | `ArrayLabels.fold_left f x a` computes `f (... (f (f x a.(0)) a.(1)) ...) a.(n-1)`, where `n` is the length of the array `a`.
fold_left [Array] | `Array.fold_left f x a` computes `f (... (f (f x a.(0)) a.(1)) ...) a.(n-1)`, where `n` is the length of the array `a`.
fold_left2 [ListLabels] | `ListLabels.fold_left2 f a [b1; ...; bn] [c1; ...; cn]` is `f (... (f (f a b1 c1) b2 c2) ...) bn cn`.
fold_left2 [List] | `List.fold_left2 f a [b1; ...; bn] [c1; ...; cn]` is `f (... (f (f a b1 c1) b2 c2) ...) bn cn`.
fold_right [ListLabels] | `ListLabels.fold_right f [a1; ...; an] b` is `f a1 (f a2 (... (f an b) ...))`.
fold_right [List] | `List.fold_right f [a1; ...; an] b` is `f a1 (f a2 (... (f an b) ...))`.
fold_right [ArrayLabels] | `ArrayLabels.fold_right f a x` computes `f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...))`, where `n` is the length of the array `a`.
fold_right [Array] | `Array.fold_right f a x` computes `f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...))`, where `n` is the length of the array `a`.
fold_right2 [ListLabels] | `ListLabels.fold_right2 f [a1; ...; an] [b1; ...; bn] c` is `f a1 b1 (f a2 b2 (... (f an bn c) ...))`.
fold_right2 [List] | `List.fold_right2 f [a1; ...; an] [b1; ...; bn] c` is `f a1 b1 (f a2 b2 (... (f an bn c) ...))`.
for4 [Misc] |
for_ [Ast_helper.Exp] |
for_all [MoreLabels.Set.S] |
for_all [MoreLabels.Map.S] |
for_all [Set.S] | `for_all p s` checks if all elements of the set satisfy the predicate `p`.
for_all [Map.S] | `for_all p m` checks if all the bindings of the map satisfy the predicate `p`.
for_all [ListLabels] | `for_all p [a1; ...; an]` checks if all elements of the list satisfy the predicate `p`.
for_all [List] | `for_all p [a1; ...; an]` checks if all elements of the list satisfy the predicate `p`.
for_all [ArrayLabels] | `ArrayLabels.for_all p [|a1; ...; an|]` checks if all elements of the array satisfy the predicate `p`.
for_all [Array] | `Array.for_all p [|a1; ...; an|]` checks if all elements of the array satisfy the predicate `p`.
for_all2 [Misc] |
for_all2 [ListLabels] | Same as `ListLabels.for_all`, but for a two-argument predicate.
for_all2 [List] | Same as `List.for_all`, but for a two-argument predicate.
for_package [Clflags] |
force [Lazy] | `force x` forces the suspension `x` and returns its result.
force [CamlinternalLazy] |
force_lazy_block [CamlinternalLazy] |
force_newline [Format] | Forces a new line in the current box.
force_poly [Ast_helper.Typ] |
force_slash [Clflags] |
force_val [Lazy] | `force_val x` forces the suspension `x` and returns its result.
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 pos slot` returns the string representation of `slot` as `raw_backtrace_to_string` would format it, assuming it is the `pos`-th element of the backtrace: the `0`-th element is pretty-printed differently than the others.
format_from_string [Scanf] | `format_from_string s fmt` converts a string argument to a format string, according to the given format string `fmt`.
format_of_string [Pervasives] | `format_of_string s` returns a format string read from the string literal `s`.
format_of_string_fmtty [CamlinternalFormat] |
format_of_string_format [CamlinternalFormat] |
formatter_for_warnings [Location] |
formatter_of_buffer [Format] | `formatter_of_buffer b` returns a new formatter writing to buffer `b`.
formatter_of_out_channel [Format] | `formatter_of_out_channel oc` returns a new formatter that writes to the corresponding channel `oc`.
fortran_layout [Bigarray] |
forward_tag [Obj] |
fprintf [Printf] | `fprintf outchan format arg1 ... argN` formats the arguments `arg1` to `argN` according to the format string `format`, and outputs the resulting string on the channel `outchan`.
fprintf [Format] |
freeze_char_set [CamlinternalFormat] |
frexp [Pervasives] | `frexp f` returns the pair of the significant and the exponent of `f`.
from [Stream] | `Stream.from f` returns a stream built from the function `f`.
from_bytes [Marshal] | `Marshal.from_bytes buff ofs` unmarshals a structured value like `Marshal.from_channel` does, except that the byte representation is not read from a channel, but taken from the byte sequence `buff`, starting at position `ofs`.
from_channel [Scanf.Scanning] | `Scanning.from_channel ic` returns a `!Scanning.in_channel` formatted input channel which reads from the regular `!Pervasives.in_channel` input channel `ic` argument.
from_channel [Marshal] | `Marshal.from_channel chan` reads from channel `chan` the byte representation of a structured value, as produced by one of the `Marshal.to_*` functions, and reconstructs and returns the corresponding value.
from_channel [Lexing] | Create a lexer buffer on the given input channel.
from_file [Scanf.Scanning] | An alias for `!Scanning.open_in` above.
from_file_bin [Scanf.Scanning] | An alias for `!Scanning.open_in_bin` above.
from_fun [Lazy] | `from_fun f` is the same as `lazy (f ())` but slightly more efficient.
from_function [Scanf.Scanning] | `Scanning.from_function f` returns a `!Scanning.in_channel` formatted input channel with the given function as its reading method.
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] | `Scanning.from_string s` returns a `!Scanning.in_channel` formatted input channel which reads from the given string.
from_string [Marshal] | Same as `from_bytes` but take a string as argument instead of a byte sequence.
from_string [Lexing] | Create a lexer buffer which reads from the given string.
from_val [Lazy] | `from_val v` returns an already-forced suspension of `v`.
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 `Unix.ftruncate`.
ftruncate [Unix] | Truncates the file corresponding to the given descriptor to the given size.
full_init [Random] | Same as `Random.init` but takes more data as seed.
full_major [Gc] | Do a minor collection, finish the current major collection cycle, and perform a complete new cycle.
full_split [Str] | Same as `Str.split_delim`, but returns the delimiters as well as the substrings contained between delimiters.
fun_ [Ast_helper.Cl] |
fun_ [Ast_helper.Exp] |
function_ [Ast_helper.Exp] |
functor_ [Ast_helper.Mod] |
functor_ [Ast_helper.Mty] |
G
gcd_big_int [Big_int] | Greatest common divisor of two big integers.
ge_big_int [Big_int] |
ge_num [Num] |
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.
get [Weak] | `Weak.get ar n` returns None if the `n`th cell of `ar` is empty, `Some x` (where `x` is the value) if it is full.
get [Timings] | returns the runtime in seconds of a completed pass
get [String] | `String.get s n` returns the character at index `n` in string `s`.
get [StringLabels] | `String.get s n` returns the character at index `n` in string `s`.
get [Misc.LongString] |
get [Gc] | Return the current values of the GC parameters in a `control` record.
get [Clflags.Float_arg_helper] |
get [Clflags.Int_arg_helper] |
get [BytesLabels] | `get s n` returns the byte at index `n` in argument `s`.
get [Bytes] | `get s n` returns the byte at index `n` in argument `s`.
get [Bigarray.Array3] | `Array3.get a x y z`, also written `a.{x,y,z}`, returns the element of `a` at coordinates (`x`, `y`, `z`).
get [Bigarray.Array2] | `Array2.get a x y`, also written `a.{x,y}`, returns the element of `a` at coordinates (`x`, `y`).
get [Bigarray.Array1] | `Array1.get a x`, or alternatively `a.{x}`, returns the element of `a` at index `x`.
get [Bigarray.Genarray] | Read an element of a generic big array.
get [ArrayLabels] | `ArrayLabels.get a n` returns the element number `n` of array `a`.
get [Array] | `Array.get a n` returns the element number `n` of array `a`.
get [Arg_helper.Make] |
get_all_formatter_output_functions [Format] |
get_approx_printing [Arith_status] | See `Arith_status.set_approx_printing`.
get_backtrace [Printexc] | `Printexc.get_backtrace ()` returns a string containing the same exception backtrace that `Printexc.print_backtrace` would print.
get_bucket [Gc] | `get_bucket n` returns the current size of the `n`-th future bucket of the GC smoothing system.
get_callstack [Printexc] | `Printexc.get_callstack n` returns a description of the top of the call stack on the current program point (for the current thread), with at most `n` entries.
get_cookie [Ast_mapper] |
get_copy [Weak] | `Weak.get_copy ar n` returns None if the `n`th cell of `ar` is empty, `Some x` (where `x` is a (shallow) copy of the value) if it is full.
get_credit [Gc] | `get_credit ()` returns the current size of the "work done in advance" counter of the GC smoothing system.
get_data [Obj.Ephemeron] | Same as `Ephemeron.K1.get_data`
get_data [Ephemeron.Kn] | Same as `Ephemeron.K1.get_data`
get_data [Ephemeron.K2] | Same as `Ephemeron.K1.get_data`
get_data [Ephemeron.K1] | `Ephemeron.K1.get_data eph` returns `None` if the data of `eph` is empty, `Some x` (where `x` is the data) if it is full.
get_data_copy [Obj.Ephemeron] | Same as `Ephemeron.K1.get_data_copy`
get_data_copy [Ephemeron.Kn] | Same as `Ephemeron.K1.get_data_copy`
get_data_copy [Ephemeron.K2] | Same as `Ephemeron.K1.get_data_copy`
get_data_copy [Ephemeron.K1] | `Ephemeron.K1.get_data_copy eph` returns `None` if the data of `eph` is empty, `Some x` (where `x` is a (shallow) copy of the data) if it is full.
get_ellipsis_text [Format] | Return the text of the ellipsis.
get_error_when_null_denominator [Arith_status] | See `Arith_status.set_error_when_null_denominator`.
get_floating_precision [Arith_status] | See `Arith_status.set_floating_precision`.
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 pretty-printer.
get_formatter_tag_functions [Format] | Return the current tag functions of the pretty-printer.
get_image [Graphics] | Capture the contents of a rectangle on the screen as an image.
get_key [Obj.Ephemeron] | Same as `Ephemeron.K1.get_key`
get_key [Ephemeron.Kn] | Same as `Ephemeron.K1.get_key`
get_key [Ephemeron.K1] | `Ephemeron.K1.get_key eph` returns `None` if the key of `eph` is empty, `Some x` (where `x` is the key) if it is full.
get_key1 [Ephemeron.K2] | Same as `Ephemeron.K1.get_key`
get_key1_copy [Ephemeron.K2] | Same as `Ephemeron.K1.get_key_copy`
get_key2 [Ephemeron.K2] | Same as `Ephemeron.K1.get_key`
get_key2_copy [Ephemeron.K2] | Same as `Ephemeron.K1.get_key_copy`
get_key_copy [Obj.Ephemeron] | Same as `Ephemeron.K1.get_key_copy`
get_key_copy [Ephemeron.Kn] | Same as `Ephemeron.K1.get_key_copy`
get_key_copy [Ephemeron.K1] | `Ephemeron.K1.get_key_copy eph` returns `None` if the key of `eph` is empty, `Some x` (where `x` is a (shallow) copy of the key) if it is full.
get_margin [Format] | Returns the position of the right margin.
get_mark_tags [Format] | Return the current status of tags marking.
get_max_boxes [Format] | Returns the maximum number of 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 `string list` argument of the following functions is a list of alternative names for the attribute we are looking for.
get_normalize_ratio [Arith_status] | See `Arith_status.set_normalize_ratio`.
get_normalize_ratio_when_printing [Arith_status] | See `Arith_status.set_normalize_ratio_when_printing`.
get_pos_info [Location] |
get_print_tags [Format] | Return the current status of tags printing.
get_public_method [CamlinternalOO] |
get_raw_backtrace [Printexc] | `Printexc.get_raw_backtrace ()` returns the same exception backtrace that `Printexc.print_backtrace` would print, but in a raw format.
get_raw_backtrace_slot [Printexc] | `get_slot bckt pos` returns the slot in position `pos` in the backtrace `bckt`.
get_ref [Misc] |
get_state [Random] | Return the current state of the generator used by the basic functions.
get_styles [Misc.Color] |
get_temp_dir_name [Filename] | The name of the temporary directory: Under Unix, the value of the `TMPDIR` environment variable, or "/tmp" if the variable is not set.
get_variable [CamlinternalOO] |
get_variables [CamlinternalOO] |
getaddrinfo [UnixLabels] | `getaddrinfo host service opts` returns a list of `Unix.addr_info` records describing socket parameters and addresses suitable for communicating with the given host and service.
getaddrinfo [Unix] | `getaddrinfo host service opts` returns a list of `Unix.addr_info` records describing socket parameters and addresses suitable for communicating with the given host and service.
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.
getenv [Sys] | Return the value associated to a variable in the process environment.
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 `group` with the given group id, or raise `Not_found`.
getgrgid [Unix] | Find an entry in `group` with the given group id.
getgrnam [UnixLabels] | Find an entry in `group` with the given name, or raise `Not_found`.
getgrnam [Unix] | Find an entry in `group` with the given name.
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 `hosts` with the given address, or raise `Not_found`.
gethostbyaddr [Unix] | Find an entry in `hosts` with the given address.
gethostbyname [UnixLabels] | Find an entry in `hosts` with the given name, or raise `Not_found`.
gethostbyname [Unix] | Find an entry in `hosts` with the given name.
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 addr opts` returns the host name and service name corresponding to the socket address `addr`.
getnameinfo [Unix] | `getnameinfo addr opts` returns the host name and service name corresponding to the socket address `addr`.
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 `protocols` with the given name, or raise `Not_found`.
getprotobyname [Unix] | Find an entry in `protocols` with the given name.
getprotobynumber [UnixLabels] | Find an entry in `protocols` with the given protocol number, or raise `Not_found`.
getprotobynumber [Unix] | Find an entry in `protocols` with the given protocol number.
getpwnam [UnixLabels] | Find an entry in `passwd` with the given name, or raise `Not_found`.
getpwnam [Unix] | Find an entry in `passwd` with the given name.
getpwuid [UnixLabels] | Find an entry in `passwd` with the given user id, or raise `Not_found`.
getpwuid [Unix] | Find an entry in `passwd` with the given user id.
getservbyname [UnixLabels] | Find an entry in `services` with the given name, or raise `Not_found`.
getservbyname [Unix] | Find an entry in `services` with the given name.
getservbyport [UnixLabels] | Find an entry in `services` with the given service number, or raise `Not_found`.
getservbyport [Unix] | Find an entry in `services` with the given service number.
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 `Unix.getsockopt` for a socket option whose value is a floating-point number.
getsockopt_float [Unix] | Same as `Unix.getsockopt` for a socket option whose value is a floating-point number.
getsockopt_int [UnixLabels] | Same as `Unix.getsockopt` for an integer-valued socket option.
getsockopt_int [Unix] | Same as `Unix.getsockopt` for an integer-valued socket option.
getsockopt_optint [UnixLabels] | Same as `Unix.getsockopt` for a socket option whose value is an `int option`.
getsockopt_optint [Unix] | Same as `Unix.getsockopt` for a socket option whose value is an `int option`.
gettimeofday [UnixLabels] | Same as `UnixLabels.time`, but with resolution better than 1 second.
gettimeofday [Unix] | Same as `Unix.time`, but with resolution better than 1 second.
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_replace regexp templ s` returns a string identical to `s`, except that all substrings of `s` that match `regexp` have been replaced by `templ`.
global_substitute [Str] | `global_substitute regexp subst s` returns a string identical to `s`, except that all substrings of `s` that match `regexp` have been replaced by the result of function `subst`.
gmtime [UnixLabels] | Convert a time in seconds, as returned by `UnixLabels.time`, into a date and a time.
gmtime [Unix] | Convert a time in seconds, as returned by `Unix.time`, into a date and a time.
gprofile [Clflags] |
green [Graphics] |
group_beginning [Str] | `group_beginning n` returns the position of the first character of the substring that was matched by the `n`th group of the regular expression that was matched by the last call to a matching or searching function (see `Str.matched_string` for details).
group_end [Str] | `group_end n` returns the position of the character following the last character of substring that was matched by the `n`th group of the regular expression that was matched by the last call to a matching or searching function (see `Str.matched_string` for details).
gt_big_int [Big_int] | Usual boolean comparisons between two big integers.
gt_num [Num] |
guard [Event] | `guard fn` returns the event that, when synchronized, computes `fn()` and behaves as the resulting event.
H
handle_docstrings [Lexer] |
handle_unix_error [UnixLabels] | `handle_unix_error f x` applies `f` to `x` and returns the result.
handle_unix_error [Unix] | `handle_unix_error f x` applies `f` to `x` and returns the result.
has_no_payload_attribute [Attr_helper] |
has_symlink [UnixLabels] | Returns `true` if the user is able to create symbolic links.
has_symlink [Unix] | Returns `true` if the user is able to create symbolic links.
hash [Uchar] | `hash u` associates a non-negative integer to `u`.
hash [MoreLabels.Hashtbl] |
hash [Hashtbl.SeededHashedType] | A seeded hashing function on keys.
hash [Hashtbl.HashedType] | A hashing function on keys.
hash [Hashtbl] | `Hashtbl.hash x` associates a nonnegative integer to any value of any type.
hash_param [MoreLabels.Hashtbl] |
hash_param [Hashtbl] | `Hashtbl.hash_param meaningful total x` computes a hash value for `x`, with the same properties as for `hash`.
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 x y` returns `sqrt(x *. x + y *. y)`, that is, the length of the hypotenuse of a right-angled triangle with sides of length `x` and `y`, or, equivalently, the distance of the point `(x,y)` to origin.
I
i [Complex] | The complex number `i`.
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 `Printf.fprintf`, but does not print anything.
ifprintf [Format] | Same as `fprintf` above, but does not print anything.
ifthenelse [Ast_helper.Exp] |
ignore [Pervasives] | Discard the value of its argument and return `()`.
ikfprintf [Printf] | Same as `kfprintf` above, but does not print anything.
ikfprintf [Format] | Same as `kfprintf` above, but does not print anything.
ill_formed_ast [Syntaxerr] |
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.
incr_num [Num] | `incr r` is `r:=!r+1`, where `r` is a reference to a number.
index [String] | `String.index s c` returns the index of the first occurrence of character `c` in string `s`.
index [StringLabels] | `String.index s c` returns the index of the first occurrence of character `c` in string `s`.
index [BytesLabels] | `index s c` returns the index of the first occurrence of byte `c` in `s`.
index [Bytes] | `index s c` returns the index of the first occurrence of byte `c` in `s`.
index_from [String] | `String.index_from s i c` returns the index of the first occurrence of character `c` in string `s` after position `i`.
index_from [StringLabels] | `String.index_from s i c` returns the index of the first occurrence of character `c` in string `s` after position `i`.
index_from [BytesLabels] | `index_from s i c` returns the index of the first occurrence of byte `c` in `s` after position `i`.
index_from [Bytes] | `index_from s i c` returns the index of the first occurrence of byte `c` in `s` after position `i`.
inet6_addr_any [UnixLabels] | A special IPv6 address, for use only with `bind`, representing all the Internet addresses that the host machine possesses.
inet6_addr_any [Unix] | A special IPv6 address, for use only with `bind`, representing all the Internet addresses that the host machine possesses.
inet6_addr_loopback [UnixLabels] | A special IPv6 address representing the host machine (`::1`).
inet6_addr_loopback [Unix] | A special IPv6 address representing the host machine (`::1`).
inet_addr_any [UnixLabels] | A special IPv4 address, for use only with `bind`, representing all the Internet addresses that the host machine possesses.
inet_addr_any [Unix] | A special IPv4 address, for use only with `bind`, representing all the Internet addresses that the host machine possesses.
inet_addr_loopback [UnixLabels] | A special IPv4 address representing the host machine (`127.0.0.1`).
inet_addr_loopback [Unix] | A special IPv4 address representing the host machine (`127.0.0.1`).
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.
infix_tag [Obj] |
info_attr [Docstrings] |
inherit_ [Ast_helper.Cf] |
inherit_ [Ast_helper.Ctf] |
inherits [CamlinternalOO] |
init [String] | `String.init n f` returns a string of length `n`, with character `i` initialized to the result of `f i` (called in increasing index order).
init [StringLabels] | `init n f` returns a string of length `n`, with character `i` initialized to the result of `f i`.
init [Random] | Initialize the generator, using the argument as a seed.
init [Location] | Set the file name and line number of the `lexbuf` to be the start of the named file.
init [Lexer] |
init [Dynlink] |
init [Docstrings] |
init [BytesLabels] | `init n f` returns a fresh byte sequence of length `n`, with character `i` initialized to the result of `f i`.
init [Bytes] | `Bytes.init n f` returns a fresh byte sequence of length `n`, with character `i` initialized to the result of `f i` (in increasing index order).
init [ArrayLabels] | `ArrayLabels.init n f` returns a fresh array of length `n`, with element number `i` initialized to the result of `f i`.
init [Array] | `Array.init n f` returns a fresh array of length `n`, with element number `i` initialized to the result of `f i`.
init_class [CamlinternalOO] |
init_file [Clflags] |
init_mod [CamlinternalMod] |
initgroups [UnixLabels] | `initgroups user group` initializes the group access list by reading the group database /etc/group and using all groups of which `user` is a member.
initgroups [Unix] | `initgroups user group` initializes the group access list by reading the group database /etc/group and using all groups of which `user` is a member.
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 ic buf pos len` reads up to `len` characters from the given channel `ic`, storing them in byte sequence `buf`, starting at character number `pos`.
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_char`, but return the 8-bit integer representing the character.
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 `output_value`, and return the corresponding value.
int [Random.State] |
int [Random] | `Random.int bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int [Misc.Int_literal_converter] |
int [Bigarray] | See `Bigarray.char`.
int [Ast_helper.Const] |
int16_signed [Bigarray] | See `Bigarray.char`.
int16_unsigned [Bigarray] | See `Bigarray.char`.
int32 [Random.State] |
int32 [Random] | `Random.int32 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int32 [Misc.Int_literal_converter] |
int32 [Bigarray] | See `Bigarray.char`.
int32 [Ast_helper.Const] |
int32_of_big_int [Big_int] | Convert a big integer to a 32-bit integer.
int64 [Random.State] |
int64 [Random] | `Random.int64 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int64 [Misc.Int_literal_converter] |
int64 [Bigarray] | See `Bigarray.char`.
int64 [Ast_helper.Const] |
int64_of_big_int [Big_int] | Convert a big integer to a 64-bit integer.
int8_signed [Bigarray] | See `Bigarray.char`.
int8_unsigned [Bigarray] | See `Bigarray.char`.
int_of_big_int [Big_int] | Convert a big integer to a small integer (type `int`).
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_num [Num] |
int_of_string [Pervasives] | Convert the given string to an integer.
int_size [Sys] | Size of an int.
int_tag [Obj] |
integer [Ast_helper.Const] |
integer_num [Num] | `integer_num n` returns the integer closest to `n`.
inter [MoreLabels.Set.S] |
inter [Set.S] | Set intersection.
interactive [Sys] | This reference is initially set to `false` in standalone programs and to `true` if the code is being executed under the interactive toplevel system `ocaml`.
interface [Printast] |
interface [Parser] |
interface [Parse] |
interface_suffix [Config] |
interval [Ast_helper.Pat] |
inv [Complex] | Multiplicative inverse (`1/z`).
invalid_arg [Pervasives] | Raise exception `Invalid_argument` with the given string.
is_active [Warnings] |
is_block [Obj] |
is_char [Uchar] | `is_char u` is `true` iff `u` is a latin1 OCaml character.
is_directory [Sys] | Returns `true` if the given name refers to a directory, `false` if it refers to another kind of file.
is_empty [Stack] | Return `true` if the given stack is empty, `false` otherwise.
is_empty [Queue] | Return `true` if the given queue is empty, `false` otherwise.
is_empty [MoreLabels.Set.S] |
is_empty [MoreLabels.Map.S] |
is_empty [Set.S] | Test whether a set is empty or not.
is_empty [Map.S] | Test whether a map is empty or not.
is_error [Warnings] |
is_implicit [Filename] | Return `true` if the file name is relative and does not start with an explicit reference to the current directory (`./` or `../` in Unix), `false` if it starts with an explicit reference to the root directory or the current directory.
is_in_char_set [CamlinternalFormat] |
is_int [Obj] |
is_int_big_int [Big_int] | Test whether the given big integer is small enough to be representable as a small integer (type `int`) without loss of precision.
is_integer_num [Num] | Test if a number is an integer
is_native [Dynlink] | `true` if the program is native, `false` if the program is bytecode.
is_raise [Printexc.Slot] | `is_raise slot` is `true` when `slot` refers to a raising point in the code, and `false` when it comes from a simple function call.
is_randomized [Hashtbl] | return if the tables are currently created in randomized mode by default
is_relative [Filename] | Return `true` if the file name is relative to the current directory, `false` if it is absolute (i.e.
is_val [Lazy] | `is_val x` returns `true` if `x` has already been forced and did not raise an exception.
is_valid [Uchar] | `is_valid n` is `true` iff `n` is an Unicode scalar value (i.e.
isatty [UnixLabels] | Return `true` if the given file descriptor refers to a terminal or console window, `false` otherwise.
isatty [Unix] | Return `true` if the given file descriptor refers to a terminal or console window, `false` otherwise.
iter [Weak.S] | `iter f t` calls `f` on each element of `t`, in some unspecified order.
iter [Tbl] |
iter [String] | `String.iter f s` applies function `f` in turn to all the characters of `s`.
iter [Stream] | `Stream.iter f s` scans the whole stream s, applying function `f` in turn to each stream element encountered.
iter [StringLabels] | `String.iter f s` applies function `f` in turn to all the characters of `s`.
iter [Stack] | `iter f s` applies `f` in turn to all elements of `s`, from the element at the top of the stack to the element at the bottom of the stack.
iter [Queue] | `iter f q` applies `f` in turn to all elements of `q`, from the least recently entered to the most recently entered.
iter [MoreLabels.Set.S] |
iter [MoreLabels.Map.S] |
iter [MoreLabels.Hashtbl.SeededS] |
iter [MoreLabels.Hashtbl.S] |
iter [MoreLabels.Hashtbl] |
iter [Set.S] | `iter f s` applies `f` in turn to all elements of `s`.
iter [Misc.Stdlib.Option] |
iter [Map.S] | `iter f m` applies `f` to all bindings in map `m`.
iter [ListLabels] | `ListLabels.iter f [a1; ...; an]` applies function `f` in turn to `a1; ...; an`.
iter [List] | `List.iter f [a1; ...; an]` applies function `f` in turn to `a1; ...; an`.
iter [Hashtbl.SeededS] |
iter [Hashtbl.S] |
iter [Hashtbl] | `Hashtbl.iter f tbl` applies `f` to all bindings in table `tbl`.
iter [BytesLabels] | `iter f s` applies function `f` in turn to all the bytes of `s`.
iter [Bytes] | `iter f s` applies function `f` in turn to all the bytes of `s`.
iter [ArrayLabels] | `ArrayLabels.iter f a` applies function `f` in turn to all the elements of `a`.
iter [Array] | `Array.iter f a` applies function `f` in turn to all the elements of `a`.
iter2 [ListLabels] | `ListLabels.iter2 f [a1; ...; an] [b1; ...; bn]` calls in turn `f a1 b1; ...; f an bn`.
iter2 [List] | `List.iter2 f [a1; ...; an] [b1; ...; bn]` calls in turn `f a1 b1; ...; f an bn`.
iter2 [Array] | `Array.iter2 f a b` applies function `f` to all the elements of `a` and `b`.
iteri [String] | Same as `String.iter`, but the function is applied to the index of the element as first argument (counting from 0), and the character itself as second argument.
iteri [StringLabels] | Same as `String.iter`, but the function is applied to the index of the element as first argument (counting from 0), and the character itself as second argument.
iteri [ListLabels] | Same as `ListLabels.iter`, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
iteri [List] | Same as `List.iter`, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
iteri [BytesLabels] | Same as `Bytes.iter`, but the function is applied to the index of the byte as first argument and the byte itself as second argument.
iteri [Bytes] | Same as `Bytes.iter`, but the function is applied to the index of the byte as first argument and the byte itself as second argument.
iteri [ArrayLabels] | Same as `ArrayLabels.iter`, but the function is applied to the index of the element as first argument, and the element itself as second argument.
iteri [Array] | Same as `Array.iter`, but the function is applied with the index of the element as first argument, and the element itself as second argument.
J
join [Thread] | `join th` suspends the execution of the calling thread until the thread `th` has terminated.
junk [Stream] | Remove the first element of the stream, possibly unfreezing it before.
K
kasprintf [Format] | Same as `asprintf` above, but instead of returning the string, passes it to the first argument.
kbprintf [Printf] | Same as `bprintf`, but instead of returning immediately, passes the buffer to its first argument at the end of printing.
keep_asm_file [Clflags] |
keep_docs [Clflags] |
keep_locs [Clflags] |
keep_startup_file [Clflags] |
key_pressed [Graphics] | Return `true` if a keypress is available; that is, if `read_key` would not block.
keys [Identifiable.S.Map] |
kfprintf [Printf] | Same as `fprintf`, but instead of returning immediately, passes the out channel to its first argument at the end of printing.
kfprintf [Format] | Same as `fprintf` above, but instead of returning immediately, passes the formatter to its first argument at the end of printing.
kfscanf [Scanf] |
kill [UnixLabels] | `kill pid sig` sends signal number `sig` to the process with id `pid`.
kill [Unix] | `kill pid sig` sends signal number `sig` to the process with id `pid`.
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.Genarray] | Return the kind of the given big array.
kind_size_in_bytes [Bigarray] | `kind_size_in_bytes k` is the number of bytes used to store an element of type `k`.
kprintf [Printf] | A deprecated synonym for `ksprintf`.
kprintf [Format] |
kscanf [Scanf] | Same as `Scanf.bscanf`, but takes an additional function argument `ef` that is called in case of error: if the scanning process or some conversion fails, the scanning function aborts and calls the error handling function `ef` with the formatted input channel and the exception that aborted the scanning process as arguments.
ksprintf [Printf] | Same as `sprintf` above, but instead of returning the string, passes it to the first argument.
ksprintf [Format] | Same as `sprintf` above, but instead of returning the string, passes it to the first argument.
ksscanf [Scanf] | Same as `Scanf.kscanf` but reads from the given string.
L
last [Longident] |
last_chars [Str] | `last_chars s n` returns the last `n` characters of `s`.
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.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 x n` returns `x *. 2 ** n`.
le_big_int [Big_int] |
le_num [Num] |
length [Weak] | `Weak.length ar` returns the length (number of elements) of `ar`.
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] | `Hashtbl.length tbl` returns the number of bindings in `tbl`.
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] |
letmodule [Ast_helper.Exp] |
lexeme [Lexing] | `Lexing.lexeme lexbuf` returns the string matched by the regular expression.
lexeme_char [Lexing] | `Lexing.lexeme_char lexbuf i` returns character number `i` in the matched string.
lexeme_end [Lexing] | `Lexing.lexeme_end lexbuf` returns the offset in the input stream of the character following the last character of the matched string.
lexeme_end_p [Lexing] | Like `lexeme_end`, but return a complete `position` instead of an offset.
lexeme_start [Lexing] | `Lexing.lexeme_start lexbuf` returns the offset in the input stream of the first character of the matched string.
lexeme_start_p [Lexing] | Like `lexeme_start`, but return a complete `position` instead of an offset.
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 source dest` creates a hard link named `dest` to the file named `source`.
link [Unix] | `link source dest` creates a hard link named `dest` to the file named `source`.
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 (`.cmo` file) or bytecode library file (`.cma` file), and link it with the running program.
loadfile_private [Dynlink] | Same as `loadfile`, except that the compilation units just loaded are hidden (cannot be referenced) from other modules dynamically loaded afterwards.
localtime [UnixLabels] | Convert a time in seconds, as returned by `UnixLabels.time`, into a date and a time.
localtime [Unix] | Convert a time in seconds, as returned by `Unix.time`, into a date and a time.
location [Printexc.Slot] | `location slot` returns the location information of the slot, if available, and `None` otherwise.
location_of_error [Syntaxerr] |
lock [Mutex] | Lock the given mutex.
lockf [UnixLabels] | `lockf fd cmd size` puts a lock on a region of the file opened as `fd`.
lockf [Unix] | `lockf fd cmd size` puts a lock on a region of the file opened as `fd`.
log [Pervasives] | Natural logarithm.
log [Complex] | Natural logarithm (in base `e`).
log10 [Pervasives] | Base 10 logarithm.
log1p [Pervasives] | `log1p x` computes `log(1.0 +. x)` (natural logarithm), giving numerically-accurate results even if `x` is close to `0.0`.
log2 [Misc] |
logand [Nativeint] | Bitwise logical and.
logand [Int64] | Bitwise logical and.
logand [Int32] | Bitwise logical and.
lognot [Nativeint] | Bitwise logical negation
lognot [Int64] | Bitwise logical negation
lognot [Int32] | Bitwise logical negation
logor [Nativeint] | Bitwise logical or.
logor [Int64] | Bitwise logical or.
logor [Int32] | Bitwise logical 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 [Char] | Convert the given character to its equivalent lowercase character, 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 `Unix.lseek`.
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 `UnixLabels.stat`, but in case the file is a symbolic link, return the information for the link itself.
lstat [Unix.LargeFile] |
lstat [Unix] | Same as `Unix.stat`, but in case the file is a symbolic link, return the information for the link itself.
lt_big_int [Big_int] |
lt_num [Num] |
M
magenta [Graphics] |
magic [Obj] |
major [Gc] | Do a minor collection and finish the current major collection cycle.
major_slice [Gc] | `major_slice n` Do a minor collection and a slice of major collection.
make [String] | `String.make n c` returns a fresh string of length `n`, filled with the character `c`.
make [StringLabels] | `String.make n c` returns a fresh string of length `n`, filled with the character `c`.
make [Random.State] | Create a new state and initialize it with the given seed.
make [BytesLabels] | `make n c` returns a new byte sequence of length `n`, filled with the byte `c`.
make [Bytes] | `make n c` returns a new byte sequence of length `n`, filled with the byte `c`.
make [ArrayLabels] | `ArrayLabels.make n x` returns a fresh array of length `n`, initialized with `x`.
make [Array] | `Array.make n x` returns a fresh array of length `n`, initialized with `x`.
make_archive [Clflags] |
make_class [CamlinternalOO] |
make_class_store [CamlinternalOO] |
make_float [ArrayLabels] |
make_float [Array] |
make_formatter [Format] | `make_formatter out flush` returns a new formatter that writes according to the output function `out`, and the flushing function `flush`.
make_image [Graphics] | Convert the given color matrix to an image.
make_iprintf [CamlinternalFormat] |
make_lexer [Genlex] | Construct the lexer function.
make_matrix [ArrayLabels] | `ArrayLabels.make_matrix dimx dimy e` returns a two-dimensional array (an array of arrays) with first dimension `dimx` and second dimension `dimy`.
make_matrix [Array] | `Array.make_matrix dimx dimy e` returns a two-dimensional array (an array of arrays) with first dimension `dimx` and second dimension `dimy`.
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.
map [Tbl] |
map [String] | `String.map f s` applies function `f` in turn to all the characters of `s` (in increasing index order) and stores the results in a new string that is returned.
map [StringLabels] | `String.map f s` applies function `f` in turn to all the characters of `s` and stores the results in a new string that is returned.
map [MoreLabels.Map.S] |
map [Misc.Stdlib.Option] |
map [Map.S] | `map f m` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`.
map [ListLabels] | `ListLabels.map f [a1; ...; an]` applies function `f` to `a1, ..., an`, and builds the list `[f a1; ...; f an]` with the results returned by `f`.
map [List] | `List.map f [a1; ...; an]` applies function `f` to `a1, ..., an`, and builds the list `[f a1; ...; f an]` with the results returned by `f`.
map [Identifiable.S.Tbl] |
map [Identifiable.S.Set] |
map [BytesLabels] | `map f s` applies function `f` in turn to all the bytes of `s` and stores the resulting bytes in a new sequence that is returned as the result.
map [Bytes] | `map f s` applies function `f` in turn to all the bytes of `s` (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.
map [ArrayLabels] | `ArrayLabels.map f a` applies function `f` to all the elements of `a`, and builds an array with the results returned by `f`: `[| f a.(0); f a.(1); ...; f a.(ArrayLabels.length a - 1) |]`.
map [Array] | `Array.map f a` applies function `f` to all the elements of `a`, and builds an array with the results returned by `f`: `[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |]`.
map2 [ListLabels] | `ListLabels.map2 f [a1; ...; an] [b1; ...; bn]` is `[f a1 b1; ...; f an bn]`.
map2 [List] | `List.map2 f [a1; ...; an] [b1; ...; bn]` is `[f a1 b1; ...; f an bn]`.
map2 [Array] | `Array.map2 f a b` applies function `f` to all the elements of `a` and `b`, and builds an array with the results returned by `f`: `[| f a.(0) b.(0); ...; f a.(Array.length a - 1) b.(Array.length b - 1)|]`.
map2_prefix [Misc.Stdlib.List] | `let r1, r2 = map2_prefix f l1 l2` If `l1` is of length n and `l2 = h2 @ t2` with h2 of length n, r1 is `List.map2 f l1 h1` and r2 is t2.
map_end [Misc] |
map_file [Bigarray.Array3] | Memory mapping of a file as a three-dimensional big array.
map_file [Bigarray.Array2] | Memory mapping of a file as a two-dimensional big array.
map_file [Bigarray.Array1] | Memory mapping of a file as a one-dimensional big array.
map_file [Bigarray.Genarray] | Memory mapping of a file as a big array.
map_keys [Identifiable.S.Map] |
map_left_right [Misc] |
map_opt [Ast_mapper] |
mapi [String] | `String.mapi f s` calls `f` with each character of `s` and its index (in increasing index order) and stores the results in a new string that is returned.
mapi [StringLabels] | `String.mapi f s` calls `f` with each character of `s` and its index (in increasing index order) and stores the results in a new string that is returned.
mapi [MoreLabels.Map.S] |
mapi [Map.S] | Same as `Map.S.map`, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [ListLabels] | Same as `ListLabels.map`, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
mapi [List] | Same as `List.map`, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
mapi [BytesLabels] | `mapi f s` calls `f` with each character of `s` and its index (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.
mapi [Bytes] | `mapi f s` calls `f` with each character of `s` and its index (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.
mapi [ArrayLabels] | Same as `ArrayLabels.map`, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapi [Array] | Same as `Array.map`, but the function is applied to the index of the element as first argument, and the element itself as second argument.
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_beginning()` returns the position of the first character of the substring that was matched by the last call to a matching or searching function (see `Str.matched_string` for details).
match_end [Str] | `match_end()` returns the position of the character following the last character of the substring that was matched by the last call to a matching or searching function (see `Str.matched_string` for details).
matched_group [Str] | `matched_group n s` returns the substring of `s` that was matched by the `n`th group `\(...\)` of the regular expression that was matched by the last call to a matching or searching function (see `Str.matched_string` for details).
matched_string [Str] | `matched_string s` returns the substring of `s` that was matched by the last call to one of the following matching or searching functions: `Str.string_match`, `Str.search_forward`, `Str.search_backward`, `Str.string_partial_match`, `Str.global_substitute`, `Str.substitute_first` provided that none of the following functions was called inbetween: `Str.global_replace`, `Str.replace_first`, `Str.split`, `Str.bounded_split`, `Str.split_delim`, `Str.bounded_split_delim`, `Str.full_split`, `Str.bounded_full_split` Note: in the case of `global_substitute` and `substitute_first`, a call to `matched_string` is only valid within the `subst` argument, not after `global_substitute` or `substitute_first` returns.
max [Uchar] | `max` is U+10FFFF.
max [Pervasives] | Return the greater of the two arguments.
max_array_length [Sys] | Maximum length of a normal array.
max_big_int [Big_int] | Return the greater of its two arguments.
max_binding [MoreLabels.Map.S] |
max_binding [Map.S] | Same as `Map.S.min_binding`, but returns the largest binding of the given map.
max_elt [MoreLabels.Set.S] |
max_elt [Set.S] | Same as `Set.S.min_elt`, but returns the largest element of the given set.
max_float [Pervasives] | The largest positive finite value of type `float`.
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_num [Num] | Return the greater of the two arguments.
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 t x` returns `true` if there is at least one instance of `x` in `t`, false otherwise.
mem [Tbl] |
mem [MoreLabels.Set.S] |
mem [MoreLabels.Map.S] |
mem [MoreLabels.Hashtbl.SeededS] |
mem [MoreLabels.Hashtbl.S] |
mem [MoreLabels.Hashtbl] |
mem [Set.S] | `mem x s` tests whether `x` belongs to the set `s`.
mem [Map.S] | `mem x m` returns `true` if `m` contains a binding for `x`, and `false` otherwise.
mem [ListLabels] | `mem a l` is true if and only if `a` is equal to an element of `l`.
mem [List] | `mem a l` is true if and only if `a` is equal to an element of `l`.
mem [Hashtbl.SeededS] |
mem [Hashtbl.S] |
mem [Hashtbl] | `Hashtbl.mem tbl x` checks if `x` is bound in `tbl`.
mem [ArrayLabels] | `mem x a` is true if and only if `x` is equal to an element of `a`.
mem [Array] | `mem a l` is true if and only if `a` is equal to an element of `l`.
mem_assoc [ListLabels] | Same as `ListLabels.assoc`, but simply return true if a binding exists, and false if no bindings exist for the given key.
mem_assoc [List] | Same as `List.assoc`, but simply return true if a binding exists, and false if no bindings exist for the given key.
mem_assq [ListLabels] | Same as `ListLabels.mem_assoc`, but uses physical equality instead of structural equality to compare keys.
mem_assq [List] | Same as `List.mem_assoc`, but uses physical equality instead of structural equality to compare keys.
memoize [Identifiable.S.Tbl] |
memq [ListLabels] | Same as `ListLabels.mem`, but uses physical equality instead of structural equality to compare list elements.
memq [List] | Same as `List.mem`, but uses physical equality instead of structural equality to compare list elements.
memq [ArrayLabels] | Same as `ArrayLabels.mem`, but uses physical equality instead of structural equality to compare list elements.
memq [Array] | Same as `Array.mem`, but uses physical equality instead of structural equality to compare array elements.
merge [Weak.S] | `merge t x` returns an instance of `x` found in `t` if any, or else adds `x` to `t` and return `x`.
merge [Sort] | Merge two lists according to the given predicate.
merge [MoreLabels.Map.S] |
merge [Map.S] | `merge f m1 m2` computes a map whose keys is a subset of keys of `m1` and of `m2`.
merge [ListLabels] | Merge two lists: Assuming that `l1` and `l2` are sorted according to the comparison function `cmp`, `merge cmp l1 l2` will return a sorted list containting all the elements of `l1` and `l2`.
merge [List] | Merge two lists: Assuming that `l1` and `l2` are sorted according to the comparison function `cmp`, `merge cmp l1 l2` will return a sorted list containting all the elements of `l1` and `l2`.
method_ [Ast_helper.Cf] |
method_ [Ast_helper.Ctf] |
min [Uchar] | `min` is U+0000.
min [Pervasives] | Return the smaller of the two arguments.
min_big_int [Big_int] | Return the smaller of its two arguments.
min_binding [MoreLabels.Map.S] |
min_binding [Map.S] | Return the smallest binding of the given map (with respect to the `Ord.compare` ordering), or raise `Not_found` if the map is empty.
min_elt [MoreLabels.Set.S] |
min_elt [Set.S] | Return the smallest element of the given set (with respect to the `Ord.compare` ordering), or raise `Not_found` if the set is empty.
min_float [Pervasives] | The smallest positive, non-zero, non-denormalized value of type `float`.
min_int [Pervasives] | The smallest representable integer.
min_int [Nativeint] | The greatest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
min_int [Int64] | The smallest representable 64-bit integer, -263.
min_int [Int32] | The smallest representable 32-bit integer, -231.
min_num [Num] | Return the smaller of the two arguments.
minor [Gc] | Trigger a minor collection.
minus_big_int [Big_int] | Unary negation.
minus_num [Num] | Unary negation.
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] |
mkdir [UnixLabels] | Create a directory with the given permissions.
mkdir [Unix] | Create a directory with the given permissions (see `Unix.umask`).
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 `Unix.umask`).
mkloc [Location] |
mkmaindll [Config] |
mknoloc [Location] |
mktime [UnixLabels] | Convert a date and time, specified by the `tm` argument, into a time in seconds, as returned by `UnixLabels.time`.
mktime [Unix] | Convert a date and time, specified by the `tm` argument, into a time in seconds, as returned by `Unix.time`.
mod_big_int [Big_int] | Euclidean modulus of two big integers.
mod_float [Pervasives] | `mod_float a b` returns the remainder of `a` with respect to `b`.
mod_num [Num] | Euclidean division: remainder.
model [Config] |
modf [Pervasives] | `modf f` returns the pair of the fractional and integral part of `f`.
modtype [Ast_helper.Str] |
modtype [Ast_helper.Sig] |
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 [Nativeint] | Multiplication.
mul [Int64] | Multiplication.
mul [Int32] | Multiplication.
mul [Complex] | Multiplication
mult_big_int [Big_int] | Multiplication of two big integers.
mult_int_big_int [Big_int] | Multiplication of a big integer by a small integer
mult_num [Num] | Multiplication
N
name_of_input [Scanf.Scanning] | `Scanning.name_of_input ic` returns the name of the character source for the given `!Scanning.in_channel` formatted input channel.
nan [Pervasives] | A special floating-point value denoting the result of an undefined operation such as `0.0 /. 0.0`.
narrow [CamlinternalOO] |
nat_of_num [Num] |
native_c_compiler [Config] |
native_c_libraries [Config] |
native_code [Clflags] |
native_pack_linker [Config] |
nativeint [Random.State] |
nativeint [Random] | `Random.nativeint bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
nativeint [Misc.Int_literal_converter] |
nativeint [Bigarray] | See `Bigarray.char`.
nativeint [Ast_helper.Const] |
nativeint_of_big_int [Big_int] | Convert a big integer to a native integer.
neg [Nativeint] | Unary negation.
neg [Int64] | Unary negation.
neg [Int32] | Unary negation.
neg [Complex] | Unary negation.
neg_infinity [Pervasives] | Negative infinity.
new_ [Ast_helper.Exp] |
new_block [Obj] |
new_channel [Event] | Return a new channel.
new_line [Lexing] | Update the `lex_curr_p` field of the lexbuf to reflect the start of a new line.
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 `t`; describes an empty ghost range.
nopervasives [Clflags] |
noprompt [Clflags] |
nopromptcont [Clflags] |
norm [Complex] | Norm: given `x + i.y`, returns `sqrt(x^2 + y^2)`.
norm2 [Complex] | Norm squared: given `x + i.y`, returns `x^2 + y^2`.
normalise_eol [Misc] | `normalise_eol s` returns a fresh copy of `s` with any '\r' characters removed.
not [Pervasives] | The boolean negation.
npeek [Stream] | `npeek n` returns the list of the `n` first elements of the stream, or all its remaining elements if less than `n` elements are available.
nth [ListLabels] | Return the `n`-th element of the given list.
nth [List] | Return the `n`-th element of the given list.
nth [Buffer] | Get the n-th character of the buffer.
nth_dim [Bigarray.Genarray] | `Genarray.nth_dim a n` returns the `n`-th dimension of the big array `a`.
num_bits_big_int [Big_int] | Return the number of significant bits in the absolute value of the given big integer.
num_digits_big_int [Big_int] | Return the number of machine words used to store the given big integer.
num_dims [Bigarray.Genarray] | Return the number of dimensions of the given big array.
num_of_big_int [Num] |
num_of_int [Num] |
num_of_nat [Num] |
num_of_ratio [Num] |
num_of_string [Num] | Convert a string to a number.
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] | `ocaml_version` is the version of OCaml.
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_char c` is `c` as an Unicode character.
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 i` is `i` as an Unicode character.
of_int [Nativeint] | Convert the given integer (type `int`) to a native integer (type `nativeint`).
of_int [Int64] | Convert the given integer (type `int`) to a 64-bit integer (type `int64`).
of_int [Int32] | Convert the given integer (type `int`) to a 32-bit integer (type `int32`).
of_int32 [Nativeint] | Convert the given 32-bit integer (type `int32`) to a native integer.
of_int32 [Int64] | Convert the given 32-bit integer (type `int32`) to a 64-bit integer (type `int64`).
of_list [Stream] | Return the stream holding the elements of the list in the same order.
of_list [MoreLabels.Set.S] |
of_list [Set.S] | `of_list l` creates a set from a list of elements.
of_list [Identifiable.S.Tbl] |
of_list [Identifiable.S.Map] |
of_list [Identifiable.S.Set] |
of_list [ArrayLabels] | `ArrayLabels.of_list l` returns a fresh array containing the elements of `l`.
of_list [Array] | `Array.of_list l` returns a fresh array containing the elements of `l`.
of_map [Identifiable.S.Tbl] |
of_nativeint [Int64] | Convert the given native integer (type `nativeint`) to a 64-bit integer (type `int64`).
of_set [Identifiable.S.Map] |
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 [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.
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 `1`.
opaque [Clflags] |
opaque_identity [Sys] | For the purposes of optimization, `opaque_identity` behaves like an unknown (and thus possibly side-effecting) function.
open_ [Ast_helper.Str] |
open_ [Ast_helper.Sig] |
open_ [Ast_helper.Exp] |
open_box [Format] | `open_box d` opens a new pretty-printing box with offset `d`.
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_hbox ()` opens a new 'horizontal' pretty-printing box.
open_hovbox [Format] | `open_hovbox d` opens a new 'horizontal-or-vertical' pretty-printing box with offset `d`.
open_hvbox [Format] | `open_hvbox d` opens a new 'horizontal-vertical' pretty-printing box with offset `d`.
open_in [Scanf.Scanning] | `Scanning.open_in fname` returns a `!Scanning.in_channel` formatted input channel for bufferized reading in text mode from file `fname`.
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] | `Scanning.open_in_bin fname` returns a `!Scanning.in_channel` formatted input channel for bufferized reading in binary mode from file `fname`.
open_in_bin [Pervasives] | Same as `open_in`, but the file is opened in binary mode, so that no translation takes place during reads.
open_in_gen [Pervasives] | `open_in_gen mode perm filename` opens the named file for reading, as described above.
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`, but the file is opened in binary mode, so that no translation takes place during writes.
open_out_gen [Pervasives] | `open_out_gen mode perm filename` opens the named file for writing, as described above.
open_process [UnixLabels] | Same as `UnixLabels.open_process_out`, but redirects both the standard input and standard output of the command to pipes connected to the two returned channels.
open_process [Unix] | Same as `Unix.open_process_out`, but redirects both the standard input and standard output of the command to pipes connected to the two returned channels.
open_process [ThreadUnix] |
open_process_full [UnixLabels] | Similar to `UnixLabels.open_process`, but the second argument specifies the environment passed to the command.
open_process_full [Unix] | Similar to `Unix.open_process`, but the second argument specifies the environment passed to the command.
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 `UnixLabels.open_process_in`, but redirect the standard input of the command to a pipe.
open_process_out [Unix] | Same as `Unix.open_process_in`, but redirect the standard input of the command to a pipe.
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_tag t` opens the tag named `t`; the `print_open_tag` function of the formatter is called with `t` as argument; the tag marker `mark_open_tag t` will be flushed into the output device of the formatter.
open_tbox [Format] |
open_temp_file [Filename] | Same as `Filename.temp_file`, but returns both the name of a fresh temporary file, and an output channel opened (atomically) on this file.
open_vbox [Format] | `open_vbox d` opens a new 'vertical' pretty-printing box with offset `d`.
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] |
or_ [Ast_helper.Pat] |
or_big_int [Big_int] | Bitwise logical 'or'.
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 oc buf pos len` writes `len` characters from byte sequence `buf`, starting at offset `pos`, to the given output channel `oc`.
output [Misc.LongString] |
output [Identifiable.S.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_buffer oc b` writes the current contents of buffer `b` on the output channel `oc`.
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` but take a string as argument instead of a byte sequence.
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 boxes allowed have already been opened.
override [Ast_helper.Exp] |
P
pack [Ast_helper.Exp] |
package [Ast_helper.Typ] |
param_format_of_ignored_format [CamlinternalFormat] |
params [CamlinternalOO] |
parent_dir_name [Filename] | The conventional name for the parent of the current directory (e.g.
parse [Longident] |
parse [Clflags.Float_arg_helper] |
parse [Clflags.Int_arg_helper] |
parse [Arg_helper.Make] |
parse [Arg] | `Arg.parse speclist anon_fun usage_msg` parses the command line.
parse_argv [Arg] | `Arg.parse_argv ~current args speclist anon_fun usage_msg` parses the array `args` as if it were the command line.
parse_argv_dynamic [Arg] | Same as `Arg.parse_argv`, except that the `speclist` argument is a reference and may be updated during the parsing.
parse_color_setting [Clflags] |
parse_core_type [Parser] |
parse_dynamic [Arg] | Same as `Arg.parse`, except that the `speclist` argument is a reference and may be updated during the parsing.
parse_expression [Parser] |
parse_no_error [Clflags.Float_arg_helper] |
parse_no_error [Clflags.Int_arg_helper] |
parse_no_error [Arg_helper.Make] |
parse_options [Warnings] |
parse_pattern [Parser] |
partition [MoreLabels.Set.S] |
partition [MoreLabels.Map.S] |
partition [Set.S] | `partition p s` returns a pair of sets `(s1, s2)`, where `s1` is the set of all the elements of `s` that satisfy the predicate `p`, and `s2` is the set of all the elements of `s` that do not satisfy `p`.
partition [Map.S] | `partition p m` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
partition [ListLabels] | `partition p l` returns a pair of lists `(l1, l2)`, where `l1` is the list of all the elements of `l` that satisfy the predicate `p`, and `l2` is the list of all the elements of `l` that do not satisfy `p`.
partition [List] | `partition p l` returns a pair of lists `(l1, l2)`, where `l1` is the list of all the elements of `l` that satisfy the predicate `p`, and `l2` is the list of all the elements of `l` that do not satisfy `p`.
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 `Some` of "the first element" of the stream, or `None` if the stream is empty.
peek [Queue] | `peek q` returns the first element in queue `q`, without removing it from the queue, or raises `Empty` if the queue is empty.
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] | `polar norm arg` returns the complex having norm `norm` and argument `arg`.
poll [Event] | Non-blocking version of `Event.sync`: offer all the communication possibilities specified in the event to the outside world, and if one can take place immediately, perform it and return `Some r` where `r` is the result value of that communication.
poly [Ast_helper.Exp] |
poly [Ast_helper.Typ] |
pop [Stack] | `pop s` removes and returns the topmost element in stack `s`, or raises `Empty` if the stack is empty.
pop [Queue] | `pop` is a synonym for `take`.
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 [Complex] | Power function.
power_big_int_positive_big_int [Big_int] | Exponentiation functions.
power_big_int_positive_int [Big_int] |
power_int_positive_big_int [Big_int] |
power_int_positive_int [Big_int] |
power_num [Num] | Exponentiation
pp_close_box [Format] |
pp_close_tag [Format] |
pp_close_tbox [Format] |
pp_force_newline [Format] |
pp_get_all_formatter_output_functions [Format] |
pp_get_ellipsis_text [Format] |
pp_get_formatter_out_functions [Format] | These functions are the basic ones: usual functions operating on the standard formatter are defined via partial evaluation of these primitives.
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_list ?pp_sep pp_v ppf l` prints items of list `l`, using `pp_v` to print each item, and calling `pp_sep` between items (`pp_sep` defaults to `Format.pp_print_cut`).
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_print_text ppf s` prints `s` with spaces and newlines respectively printed with `Format.pp_print_space` and `Format.pp_force_newline`.
pp_set_all_formatter_output_functions [Format] |
pp_set_ellipsis_text [Format] |
pp_set_formatter_out_channel [Format] |
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 u` is the scalar value before `u` in the set of Unicode scalar values.
pred [Pervasives] | `pred x` is `x - 1`.
pred [Nativeint] | Predecessor.
pred [Int64] | Predecessor.
pred [Int32] | Predecessor.
pred_big_int [Big_int] | Predecessor (subtract 1).
pred_num [Num] | `pred n` is `n-1`
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 [Warnings] |
print [Timings] | Prints all recorded timings to the formatter.
print [Tbl] |
print [Printexc] | `Printexc.print fn x` applies `fn` to `x` and returns the result.
print [Location] |
print [Identifiable.S.Map] |
print [Identifiable.S.Set] |
print [Identifiable.Thing] |
print_as [Format] | `print_as len str` prints `str` in the current box.
print_backtrace [Printexc] | `Printexc.print_backtrace oc` prints an exception backtrace on the output channel `oc`.
print_bool [Format] | Prints a boolean in the current box.
print_break [Format] | `print_break nspaces offset` the 'full' break hint: the pretty-printer may split the line at this point, otherwise it prints `nspaces` spaces.
print_bytes [Pervasives] | Print a byte sequence on standard output.
print_char [Pervasives] | Print a character on standard output.
print_char [Format] | Prints a character in the current box.
print_compact [Location] |
print_config [Config] |
print_cut [Format] | `print_cut ()` the 'cut' break hint: the pretty-printer may split the line at this point, otherwise it prints nothing.
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] | Prints a floating point number in the current box.
print_flush [Format] | Flushes the pretty printer: all opened boxes are closed, and all pending text is displayed.
print_if_newline [Format] | Executes 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] | Prints an integer in the current box.
print_loc [Location] |
print_newline [Pervasives] | Print a newline character on standard output, and flush standard output.
print_newline [Format] | Equivalent to `print_flush` followed by a new line.
print_raw_backtrace [Printexc] | Print a raw backtrace in the same format `Printexc.print_backtrace` uses.
print_space [Format] | `print_space ()` the 'space' break hint: the pretty-printer may split the line at this point, otherwise it prints one space.
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_string str` prints `str` in the current box.
print_tab [Format] |
print_tbreak [Format] |
print_timings [Clflags] |
print_types [Clflags] |
print_warning [Location] |
print_warnings [Lexer] |
printf [Printf] | Same as `Printf.fprintf`, but output on `stdout`.
printf [Format] | Same as `fprintf` above, but output on `std_formatter`.
prohibit [Dynlink] | `prohibit units` prohibits dynamically-linked units from referencing the units named in list `units`.
public_method_label [CamlinternalOO] |
push [Stack] | `push x s` adds the element `x` at the top of stack `s`.
push [Queue] | `push` is a synonym for `add`.
putenv [UnixLabels] | `Unix.putenv name value` sets the value associated to a variable in the process environment.
putenv [Unix] | `Unix.putenv name value` sets the value associated to a variable in the process environment.
Q
quick_stat [Gc] | Same as `stat` except that `live_words`, `live_blocks`, `free_words`, `free_blocks`, `largest_free`, and `fragments` are set to 0.
quo_num [Num] | Euclidean division: quotient.
quomod_big_int [Big_int] | Euclidean division of two big integers.
quote [Str] | `Str.quote s` returns a regexp string that matches exactly `s` and nothing else.
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_errorf [Location] |
raise_notrace [Pervasives] | A faster version `raise` which does not record the backtrace.
randomize [MoreLabels.Hashtbl] |
randomize [Hashtbl] | After a call to `Hashtbl.randomize()`, hash tables are created in randomized mode by default: `Hashtbl.create` returns randomized hash tables, unless the `~random:false` optional parameter is given.
ranlib [Config] |
ratio_of_num [Num] |
raw_backtrace_length [Printexc] | `raw_backtrace_length bckt` returns the number of slots in the backtrace `bckt`.
raw_backtrace_to_string [Printexc] | Return a string from a raw backtrace, in the same format `Printexc.get_backtrace` uses.
rcontains_from [String] | `String.rcontains_from s stop c` tests if character `c` appears in `s` before position `stop+1`.
rcontains_from [StringLabels] | `String.rcontains_from s stop c` tests if character `c` appears in `s` before position `stop+1`.
rcontains_from [BytesLabels] | `rcontains_from s stop c` tests if byte `c` appears in `s` before position `stop+1`.
rcontains_from [Bytes] | `rcontains_from s stop c` tests if byte `c` appears in `s` before position `stop+1`.
read [UnixLabels] | `read fd buff ofs len` reads `len` bytes from descriptor `fd`, storing them in byte sequence `buff`, starting at position `ofs` in `buff`.
read [Unix] | `read fd buff ofs len` reads `len` bytes from descriptor `fd`, storing them in byte sequence `buff`, starting at position `ofs` in `buff`.
read [ThreadUnix] |
read_float [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_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 link.
real_paths [Clflags] |
really_input [Pervasives] | `really_input ic buf pos len` reads `len` characters from channel `ic`, storing them in byte sequence `buf`, starting at character number `pos`.
really_input_string [Pervasives] | `really_input_string ic len` reads `len` characters from channel `ic` and returns them in a new string.
rebind [Ast_helper.Te] |
rec_module [Ast_helper.Str] |
rec_module [Ast_helper.Sig] |
recast [CamlinternalFormat] |
receive [Event] | `receive ch` returns the event consisting in receiving a value from the channel `ch`.
record [Ast_helper.Exp] |
record [Ast_helper.Pat] |
record_backtrace [Printexc] | `Printexc.record_backtrace b` turns recording of exception backtraces on (if `b = true`) or off (if `b = false`).
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`, but the compiled expression will match text in a case-insensitive way: uppercase and lowercase letters will be considered equivalent.
regexp_string [Str] | `Str.regexp_string s` returns a regular expression that matches exactly `s` and nothing else.
regexp_string_case_fold [Str] | `Str.regexp_string_case_fold` is similar to `Str.regexp_string`, but the regexp matches in a case-insensitive way.
register [Callback] | `Callback.register n v` registers the value `v` under the name `n`.
register [Ast_mapper] | Apply the `register_function`.
register_error_of_exn [Location] |
register_exception [Callback] | `Callback.register_exception n exn` registers the exception contained in the exception value `exn` under the name `n`.
register_function [Ast_mapper] |
register_printer [Printexc] | `Printexc.register_printer fn` registers `fn` as an exception printer.
rem [Nativeint] | Integer remainder.
rem [Int64] | Integer remainder.
rem [Int32] | Integer remainder.
remember_mode [Graphics] | Set remember mode on or off.
remove [Weak.S] | `remove t x` removes from `t` one instance of `x`.
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 [Set.S] | `remove x s` returns a set containing all elements of `s`, except `x`.
remove [Map.S] | `remove x m` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
remove [Hashtbl.SeededS] |
remove [Hashtbl.S] |
remove [Hashtbl] | `Hashtbl.remove tbl x` removes the current binding of `x` in `tbl`, restoring the previous binding if it exists.
remove_assoc [ListLabels] | `remove_assoc a l` returns the list of pairs `l` without the first pair with key `a`, if any.
remove_assoc [List] | `remove_assoc a l` returns the list of pairs `l` without the first pair with key `a`, if any.
remove_assq [ListLabels] | Same as `ListLabels.remove_assoc`, but uses physical equality instead of structural equality to compare keys.
remove_assq [List] | Same as `List.remove_assoc`, but uses physical equality instead of structural equality to compare keys.
remove_file [Misc] |
remove_unused_arguments [Clflags] |
rename [UnixLabels] | `rename old new` changes the name of a file from `old` to `new`.
rename [Unix] | `rename old new` changes the name of a file from `old` to `new`.
rename [Sys] | Rename a file.
rename [Identifiable.S.Map] |
replace [MoreLabels.Hashtbl.SeededS] |
replace [MoreLabels.Hashtbl.S] |
replace [MoreLabels.Hashtbl] |
replace [Hashtbl.SeededS] |
replace [Hashtbl.S] |
replace [Hashtbl] | `Hashtbl.replace tbl x y` replaces the current binding of `x` in `tbl` by a binding of `x` to `y`.
replace_first [Str] | Same as `Str.global_replace`, except that only the first substring matching the regular expression is replaced.
replace_matched [Str] | `replace_matched repl s` returns the replacement text `repl` in which `\1`, `\2`, etc.
replace_substring [Misc] |
replicate_list [Misc] |
report_error [Syntaxerr] |
report_error [Location] |
report_error [Lexer] |
report_error [Attr_helper] |
report_exception [Location] |
repr [Obj] |
reset [Timings] | erase all recorded times
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 `n` that was allocated by `Buffer.create` `n`.
reset_base_overrides [Arg_helper.Make] |
reset_fatal [Warnings] |
reshape [Bigarray] | `reshape b [|d1;...;dN|]` converts the big array `b` to a `N`-dimensional array of dimensions `d1`...
reshape_1 [Bigarray] | Specialized version of `Bigarray.reshape` for reshaping to one-dimensional arrays.
reshape_2 [Bigarray] | Specialized version of `Bigarray.reshape` for reshaping to two-dimensional arrays.
reshape_3 [Bigarray] | Specialized version of `Bigarray.reshape` for reshaping to three-dimensional arrays.
resize_window [Graphics] | Resize and erase the graphics window.
restore [Warnings] |
resume [Terminfo] |
rev [ListLabels] | List reversal.
rev [List] | List reversal.
rev_append [ListLabels] | `ListLabels.rev_append l1 l2` reverses `l1` and concatenates it to `l2`.
rev_append [List] | `List.rev_append l1 l2` reverses `l1` and concatenates it to `l2`.
rev_char_set [CamlinternalFormat] |
rev_map [ListLabels] | `ListLabels.rev_map f l` gives the same result as `ListLabels.rev``(``ListLabels.map` `f l)`, but is tail-recursive and more efficient.
rev_map [List] | `List.rev_map f l` gives the same result as `List.rev``(``List.map` `f l)`, but is tail-recursive and more efficient.
rev_map2 [ListLabels] | `ListLabels.rev_map2 f l1 l2` gives the same result as `ListLabels.rev``(``ListLabels.map2` `f l1 l2)`, but is tail-recursive and more efficient.
rev_map2 [List] | `List.rev_map2 f l1 l2` gives the same result as `List.rev``(``List.map2` `f l1 l2)`, but is tail-recursive and more efficient.
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
rgb [Graphics] | `rgb r g b` returns the integer encoding the color with red component `r`, green component `g`, and blue component `b`.
rhs_docs [Docstrings] | Fetch the item documentation for the symbols between two positions.
rhs_docs_lazy [Docstrings] |
rhs_end [Parsing] | See `Parsing.rhs_start`.
rhs_end_pos [Parsing] | Same as `rhs_end`, but return a `position` instead of an offset.
rhs_info [Docstrings] | Fetch the field info following the symbol at a given position.
rhs_loc [Location] | `rhs_loc n` returns the location of the symbol at position `n`, starting at 1, in the current parser rule.
rhs_post_extra_text [Docstrings] | Fetch additional 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 `Parsing.symbol_start` and `Parsing.symbol_end`, but return the offset of the string matching the `n`th item on the right-hand side of the rule, where `n` is the integer parameter to `rhs_start` and `rhs_end`.
rhs_start_pos [Parsing] | Same as `rhs_start`, but return a `position` instead of an offset.
rhs_text [Docstrings] | Fetch the text preceding the symbol at the given position.
rhs_text_lazy [Docstrings] |
rindex [String] | `String.rindex s c` returns the index of the last occurrence of character `c` in string `s`.
rindex [StringLabels] | `String.rindex s c` returns the index of the last occurrence of character `c` in string `s`.
rindex [BytesLabels] | `rindex s c` returns the index of the last occurrence of byte `c` in `s`.
rindex [Bytes] | `rindex s c` returns the index of the last occurrence of byte `c` in `s`.
rindex_from [String] | `String.rindex_from s i c` returns the index of the last occurrence of character `c` in string `s` before position `i+1`.
rindex_from [StringLabels] | `String.rindex_from s i c` returns the index of the last occurrence of character `c` in string `s` before position `i+1`.
rindex_from [BytesLabels] | `rindex_from s i c` returns the index of the last occurrence of byte `c` in `s` before position `i+1`.
rindex_from [Bytes] | `rindex_from s i c` returns the index of the last occurrence of byte `c` in `s` before position `i+1`.
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] | `rmoveto dx dy` translates the current point by the given vector.
round_num [Num] | `round_num n` returns the integer closest to `n`.
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 `OCAMLRUNPARAM` environment variable.
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
scanf [Scanf] | Same as `Scanf.bscanf`, but reads from the predefined formatted input channel `Scanf.Scanning.stdin` that is connected to `!Pervasives.stdin`.
search_backward [Str] | `search_backward r s last` searches the string `s` for a substring matching the regular expression `r`.
search_forward [Str] | `search_forward r s start` searches the string `s` for a substring matching the regular expression `r`.
search_substring [Misc] |
seeded_hash [MoreLabels.Hashtbl] |
seeded_hash [Hashtbl] | A variant of `Hashtbl.hash` that is further parameterized by an integer seed.
seeded_hash_param [MoreLabels.Hashtbl] |
seeded_hash_param [Hashtbl] | A variant of `Hashtbl.hash_param` that is further parameterized by an integer seed.
seek_in [Pervasives.LargeFile] |
seek_in [Pervasives] | `seek_in chan pos` sets the current reading position to `pos` for channel `chan`.
seek_out [Pervasives.LargeFile] |
seek_out [Pervasives] | `seek_out chan pos` sets the current writing position to `pos` for channel `chan`.
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 thead 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 ch v` returns the event consisting in sending the value `v` over the channel `ch`.
send [CamlinternalOO] |
send [Ast_helper.Exp] |
send_substring [UnixLabels] | Same as `send`, but take the data from a string instead of a byte sequence.
send_substring [Unix] | Same as `send`, but take the data from a string instead of a byte sequence.
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`, but take the data from a string instead of a byte sequence.
sendto_substring [Unix] | Same as `sendto`, but take the data from a string instead of a byte sequence.
sendto_substring [ThreadUnix] |
sequence [Ast_helper.Exp] |
set [Weak] | `Weak.set ar n (Some el)` sets the `n`th cell of `ar` to be a (full) pointer to `el`; `Weak.set ar n None` sets the `n`th cell of `ar` to empty.
set [String] | `String.set s n c` modifies byte sequence `s` in place, replacing the byte at index `n` with `c`.
set [StringLabels] | `String.set s n c` modifies byte sequence `s` in place, replacing the byte at index `n` with `c`.
set [Misc.LongString] |
set [Gc] | `set r` changes the GC parameters according to the `control` record `r`.
set [Consistbl] |
set [BytesLabels] | `set s n c` modifies `s` in place, replacing the byte at index `n` with `c`.
set [Bytes] | `set s n c` modifies `s` in place, replacing the byte at index `n` with `c`.
set [Bigarray.Array3] | `Array3.set a x y v`, or alternatively `a.{x,y,z} <- v`, stores the value `v` at coordinates (`x`, `y`, `z`) in `a`.
set [Bigarray.Array2] | `Array2.set a x y v`, or alternatively `a.{x,y} <- v`, stores the value `v` at coordinates (`x`, `y`) in `a`.
set [Bigarray.Array1] | `Array1.set a x v`, also written `a.{x} <- v`, stores the value `v` at index `x` in `a`.
set [Bigarray.Genarray] | Assign an element of a generic big array.
set [ArrayLabels] | `ArrayLabels.set a n x` modifies array `a` in place, replacing element number `n` with `x`.
set [Array] | `Array.set a n x` modifies array `a` in place, replacing element number `n` with `x`.
set_all_formatter_output_functions [Format] |
set_approx_printing [Arith_status] | Get or set the flag `approx_printing`.
set_base_default [Arg_helper.Make] |
set_binary_mode_in [Pervasives] | `set_binary_mode_in ic true` sets the channel `ic` to binary mode: no translations take place during input.
set_binary_mode_out [Pervasives] | `set_binary_mode_out oc true` sets the channel `oc` to binary mode: no translations take place during output.
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 `Ephemeron.K1.set_data`
set_data [Ephemeron.Kn] | Same as `Ephemeron.K1.set_data`
set_data [Ephemeron.K2] | Same as `Ephemeron.K1.set_data`
set_data [Ephemeron.K1] | `Ephemeron.K1.set_data eph el` sets the data of `eph` to be a (full) data to `el`
set_double_field [Obj] |
set_dumped_pass [Clflags] |
set_ellipsis_text [Format] | Set the text of the ellipsis printed when too many boxes are opened (a single dot, `.`, by default).
set_error_when_null_denominator [Arith_status] | Get or set the flag `null_denominator`.
set_field [Obj] | When using flambda:
set_floating_docstrings [Docstrings] | Docstrings not immediately adjacent to a token
set_floating_precision [Arith_status] | Get or set the parameter `floating_precision`.
set_font [Graphics] | Set the font used for drawing text.
set_formatter_out_channel [Format] | Redirect the pretty-printer output to the given channel.
set_formatter_out_functions [Format] | `set_formatter_out_functions f` Redirect the pretty-printer output to the functions `f.out_string` and `f.out_flush` as described in `set_formatter_output_functions`.
set_formatter_output_functions [Format] | `set_formatter_output_functions out flush` redirects the pretty-printer output functions to the functions `out` and `flush`.
set_formatter_tag_functions [Format] | `set_formatter_tag_functions tag_funs` changes the meaning of opening and closing tags to use the functions in `tag_funs`.
set_key [Obj.Ephemeron] | Same as `Ephemeron.K1.set_key`
set_key [Ephemeron.Kn] | Same as `Ephemeron.K1.set_key`
set_key [Ephemeron.K1] | `Ephemeron.K1.set_key eph el` sets the key of `eph` to be a (full) key to `el`
set_key1 [Ephemeron.K2] | Same as `Ephemeron.K1.set_key`
set_key2 [Ephemeron.K2] | Same as `Ephemeron.K1.get_key`
set_line_width [Graphics] | Set the width of points and lines drawn with the functions above.
set_margin [Format] | `set_margin d` sets the right margin to `d` (in characters): the pretty-printer splits lines that overflow the right margin according to the break hints given.
set_mark_tags [Format] | `set_mark_tags b` turns on or off the output of tag markers.
set_max_boxes [Format] | `set_max_boxes max` sets the maximum number of boxes simultaneously opened.
set_max_indent [Format] | `set_max_indent d` sets the maximum indentation limit of lines to `d` (in characters): once this limit is reached, new boxes are rejected to the left, if they do not fit on the current line.
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_normalize_ratio [Arith_status] | Get or set the flag `normalize_ratio`.
set_normalize_ratio_when_printing [Arith_status] | Get or set the flag `normalize_ratio_when_printing`.
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_print_tags b` turns on or off the printing of tags.
set_signal [Sys] | Same as `Sys.signal` but return value is ignored.
set_state [Random] | Set the state of the generator used by the basic functions.
set_styles [Misc.Color] |
set_tab [Format] |
set_tag [Obj] |
set_tags [Format] | `set_tags b` turns on or off the treatment of tags (default is off).
set_temp_dir_name [Filename] | Change the temporary directory returned by `Filename.get_temp_dir_name` and used by `Filename.temp_file` and `Filename.open_temp_file`.
set_text_size [Graphics] | Set the character size used for drawing text.
set_trace [Parsing] | Control debugging support for `ocamlyacc`-generated parsers.
set_uncaught_exception_handler [Printexc] | `Printexc.set_uncaught_exception_handler fn` registers `fn` as the handler for uncaught exceptions.
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 groups` sets the supplementary group IDs for the calling process.
setgroups [Unix] | `setgroups groups` sets the supplementary group IDs for the calling process.
setinstvar [Ast_helper.Exp] |
setitimer [UnixLabels] | `setitimer t s` sets the interval timer `t` and returns its previous status.
setitimer [Unix] | `setitimer t s` sets the interval timer `t` and returns its previous status.
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 `Unix.setsockopt` for a socket option whose value is a floating-point number.
setsockopt_float [Unix] | Same as `Unix.setsockopt` for a socket option whose value is a floating-point number.
setsockopt_int [UnixLabels] | Same as `Unix.setsockopt` for an integer-valued socket option.
setsockopt_int [Unix] | Same as `Unix.setsockopt` for an integer-valued socket option.
setsockopt_optint [UnixLabels] | Same as `Unix.setsockopt` for a socket option whose value is an `int option`.
setsockopt_optint [Unix] | Same as `Unix.setsockopt` for a socket option whose value is an `int option`.
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 [Nativeint] | `Nativeint.shift_left x y` shifts `x` to the left by `y` bits.
shift_left [Int64] | `Int64.shift_left x y` shifts `x` to the left by `y` bits.
shift_left [Int32] | `Int32.shift_left x y` shifts `x` to the left by `y` bits.
shift_left_big_int [Big_int] | `shift_left_big_int b n` returns `b` shifted left by `n` bits.
shift_right [Nativeint] | `Nativeint.shift_right x y` shifts `x` to the right by `y` bits.
shift_right [Int64] | `Int64.shift_right x y` shifts `x` to the right by `y` bits.
shift_right [Int32] | `Int32.shift_right x y` shifts `x` to the right by `y` bits.
shift_right_big_int [Big_int] | `shift_right_big_int b n` returns `b` shifted right by `n` bits.
shift_right_logical [Nativeint] | `Nativeint.shift_right_logical x y` shifts `x` to the right by `y` bits.
shift_right_logical [Int64] | `Int64.shift_right_logical x y` shifts `x` to the right by `y` bits.
shift_right_logical [Int32] | `Int32.shift_right_logical x y` shifts `x` to the right by `y` bits.
shift_right_towards_zero_big_int [Big_int] | `shift_right_towards_zero_big_int b n` returns `b` shifted right by `n` bits.
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 `UnixLabels.open_connection`; that is, transmit an end-of-file condition to the server reading on the other side of the connection.
shutdown_connection [Unix] | ``Shut down'' a connection established with `Unix.open_connection`; that is, transmit an end-of-file condition to the server reading on the other side of the connection.
sigabrt [Sys] | Abnormal termination
sigalrm [Sys] | Timeout
sigbus [Sys] | Bus error
sigchld [Sys] | Child process terminated
sigcont [Sys] | Continue
sigfpe [Sys] | Arithmetic exception
sighup [Sys] | Hangup on controlling terminal
sigill [Sys] | Invalid hardware instruction
sigint [Sys] | Interactive interrupt (ctrl-C)
sigkill [Sys] | Termination (cannot be ignored)
sigmask [Thread] | `sigmask cmd sigs` changes the set of blocked signals for the calling thread.
sign_big_int [Big_int] | Return `0` if the given big integer is zero, `1` if it is positive, and `-1` if it is negative.
sign_num [Num] | Return `-1`, `0` or `1` according to the sign of the argument.
signal [Sys] | Set the behavior of the system on receipt of a given signal.
signal [Condition] | `signal c` restarts one of the processes waiting on the condition variable `c`.
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 cmd sigs` changes the set of blocked signals.
sigprocmask [Unix] | `sigprocmask cmd sigs` changes the set of blocked signals.
sigprof [Sys] | Profiling interrupt
sigquit [Sys] | Interactive termination
sigsegv [Sys] | Invalid memory reference
sigstop [Sys] | Stop
sigsuspend [UnixLabels] | `sigsuspend sigs` atomically sets the blocked signals to `sigs` and waits for a non-ignored, non-blocked signal to be delivered.
sigsuspend [Unix] | `sigsuspend sigs` atomically sets the blocked signals to `sigs` and waits for a non-ignored, non-blocked signal to be delivered.
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_rounds [Clflags] |
sin [Pervasives] | Sine.
single_write [UnixLabels] | Same as `write`, but attempts to write only once.
single_write [Unix] | Same as `write`, but attempts to write only once.
single_write_substring [UnixLabels] | Same as `single_write`, but take the data from a string instead of a byte sequence.
single_write_substring [Unix] | Same as `single_write`, but take the data from a string instead of a byte sequence.
singleton [MoreLabels.Set.S] |
singleton [MoreLabels.Map.S] |
singleton [Set.S] | `singleton x` returns the one-element set containing only `x`.
singleton [Map.S] | `singleton x y` returns the one-element map that contains a binding `y` for `x`.
sinh [Pervasives] | Hyperbolic sine.
size [Obj] |
size [Nativeint] | The size in bits of a native integer.
size_in_bytes [Bigarray.Array3] | `size_in_bytes a` is the number of elements in `a` multiplied by `a`'s `Bigarray.kind_size_in_bytes`.
size_in_bytes [Bigarray.Array2] | `size_in_bytes a` is the number of elements in `a` multiplied by `a`'s `Bigarray.kind_size_in_bytes`.
size_in_bytes [Bigarray.Array1] | `size_in_bytes a` is the number of elements in `a` multiplied by `a`'s `Bigarray.kind_size_in_bytes`.
size_in_bytes [Bigarray.Genarray] | `size_in_bytes a` is the number of elements in `a` multiplied by `a`'s `Bigarray.kind_size_in_bytes`.
size_x [Graphics] | See `Graphics.size_y`.
size_y [Graphics] | Return the size of the graphics window.
skip_sharp_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_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.
some_if_all_elements_are_some [Misc.Stdlib.List] | If all elements of the given list are `Some _` then `Some xs` is returned with the `xs` being the contents of those `Some`s, with order preserved.
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 `ListLabels.sort`, but also remove duplicates.
sort_uniq [List] | Same as `List.sort`, but also remove duplicates.
sound [Graphics] | `sound freq dur` plays a sound at frequency `freq` (in hertz) for a duration `dur` (in milliseconds).
source [Consistbl] |
spellcheck [Misc] | `spellcheck env name` takes a list of names `env` that exist in the current environment and an erroneous `name`, and returns a list of suggestions taken from `env`, that are close enough to `name` that it may be a typo for one of them.
split [Str] | `split r s` splits `s` into substrings, taking as delimiters the substrings that match `r`, and returns the list of substrings.
split [MoreLabels.Set.S] |
split [MoreLabels.Map.S] |
split [Set.S] | `split x s` returns a triple `(l, present, r)`, where `l` is the set of elements of `s` that are strictly less than `x`; `r` is the set of elements of `s` that are strictly greater than `x`; `present` is `false` if `s` contains no element equal to `x`, or `true` if `s` contains an element equal to `x`.
split [Misc.Stdlib.String] | Splits the given string at every occurrence of the given separator.
split [Misc] | `String.split string char` splits the string `string` at every char `char`, and returns the list of sub-strings between the chars.
split [Map.S] | `split x m` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of `m` whose key is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some v` if `m` binds `v` to `x`.
split [ListLabels] | Transform a list of pairs into a pair of lists: `split [(a1,b1); ...; (an,bn)]` is `([a1; ...; an], [b1; ...; bn])`.
split [List] | Transform a list of pairs into a pair of lists: `split [(a1,b1); ...; (an,bn)]` is `([a1; ...; an], [b1; ...; bn])`.
split_at [Misc.Stdlib.List] | `split_at n l` returns the pair `before, after` where `before` is the `n` first elements of `l` and `after` the remaining ones.
split_delim [Str] | Same as `Str.split` but occurrences of the delimiter at the beginning and at the end of the string are recognized and returned as empty strings in the result.
split_last [Misc] |
sprintf [Printf] | Same as `Printf.fprintf`, but instead of printing on an output channel, return a string containing the result of formatting the arguments.
sprintf [Format] | Same as `printf` above, but instead of printing on a formatter, returns a string containing the result of formatting the arguments.
sqrt [Pervasives] | Square root.
sqrt [Complex] | Square root.
sqrt_big_int [Big_int] | `sqrt_big_int a` returns the integer square root of `a`, that is, the largest big integer `r` such that `r * r <= a`.
square_big_int [Big_int] | Return the square of the given big integer
square_num [Num] | Squaring
sscanf [Scanf] | Same as `Scanf.bscanf`, but reads from the given string.
sscanf_format [Scanf] | Same as `Scanf.bscanf_format`, but reads from the given string.
stable_sort [ListLabels] | Same as `ListLabels.sort`, but the sorting algorithm is guaranteed to be stable (i.e.
stable_sort [List] | Same as `List.sort`, but the sorting algorithm is guaranteed to be stable (i.e.
stable_sort [ArrayLabels] | Same as `ArrayLabels.sort`, but the sorting algorithm is stable (i.e.
stable_sort [Array] | Same as `Array.sort`, but the sorting algorithm is stable (i.e.
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 `stat` record.
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] | `Hashtbl.stats tbl` returns statistics about the table `tbl`: number of buckets, size of the biggest bucket, distribution of buckets by size.
stats [CamlinternalOO] |
stats_alive [Ephemeron.SeededS] | same as `Hashtbl.SeededS.stats` but only count the alive bindings
stats_alive [Ephemeron.S] | same as `Hashtbl.SeededS.stats` but only count the alive bindings
std_formatter [Format] | The standard formatter used by the formatting functions above.
std_include_dir [Clflags] |
std_include_flag [Clflags] |
stdbuf [Format] | The string buffer in which `str_formatter` writes.
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 `!Scanning.stdin`, the scanning buffer reading from `!Pervasives.stdin`.
stdin [UnixLabels] | File descriptor for standard input.
stdin [Unix] | File descriptor for standard input.
stdin [Scanf.Scanning] | The standard input notion for the `Scanf` module.
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 use with formatting functions below for output to the `stdbuf` string buffer.
strict_formats [Clflags] |
strict_sequence [Clflags] |
string [Digest] | Return the digest of the given string.
string [Ast_helper.Const] |
string_after [Str] | `string_after s n` returns the substring of all characters of `s` that follow position `n` (including the character at position `n`).
string_before [Str] | `string_before s n` returns the substring of all characters of `s` that precede position `n` (excluding the character at position `n`).
string_match [Str] | `string_match r s start` tests whether a substring of `s` that starts at position `start` matches the regular expression `r`.
string_of_big_int [Big_int] | Return the string representation of the given big integer, in decimal (base 10).
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_num [Num] | Convert a number to a string, using fractional notation.
string_of_structure [Pprintast] |
string_partial_match [Str] | Similar to `Str.string_match`, but also returns true if the argument string is a prefix of a string that matches.
string_tag [Obj] |
strput_acc [CamlinternalFormat] |
structure [Printast] |
structure [Pprintast] |
structure [Ast_invariants] |
structure [Ast_helper.Cl] |
structure [Ast_helper.Mod] |
sub [String] | `String.sub s start len` returns a fresh string of length `len`, containing the substring of `s` that starts at position `start` and has length `len`.
sub [StringLabels] | `String.sub s start len` returns a fresh string of length `len`, containing the substring of `s` that starts at position `start` and has length `len`.
sub [Nativeint] | Subtraction.
sub [Int64] | Subtraction.
sub [Int32] | Subtraction.
sub [Complex] | Subtraction
sub [BytesLabels] | `sub s start len` returns a new byte sequence of length `len`, containing the subsequence of `s` that starts at position `start` and has length `len`.
sub [Bytes] | `sub s start len` returns a new byte sequence of length `len`, containing the subsequence of `s` that starts at position `start` and has length `len`.
sub [Buffer] | `Buffer.sub b off len` returns a copy of `len` bytes from the current contents of the buffer `b`, starting at offset `off`.
sub [Bigarray.Array1] | Extract a sub-array of the given one-dimensional big array.
sub [ArrayLabels] | `ArrayLabels.sub a start len` returns a fresh array of length `len`, containing the elements number `start` to `start + len - 1` of array `a`.
sub [Array] | `Array.sub a start len` returns a fresh array of length `len`, containing the elements number `start` to `start + len - 1` of array `a`.
sub_big_int [Big_int] | Subtraction.
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_num [Num] | Subtraction
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` but return a string instead of a byte sequence.
sub_string [Bytes] | Same as `sub` but return a string instead of a byte sequence.
subbytes [Digest] | `Digest.subbytes s ofs len` returns the digest of the subsequence of `s` starting at index `ofs` and containing `len` bytes.
subset [MoreLabels.Set.S] |
subset [Set.S] | `subset s1 s2` tests whether the set `s1` is a subset of the set `s2`.
substitute_first [Str] | Same as `Str.global_substitute`, except that only the first substring matching the regular expression is replaced.
substring [Digest] | `Digest.substring s ofs len` returns the digest of the substring of `s` starting at index `ofs` and containing `len` characters.
succ [Uchar] | `succ u` is the scalar value after `u` in the set of Unicode scalar values.
succ [Pervasives] | `succ x` is `x + 1`.
succ [Nativeint] | Successor.
succ [Int64] | Successor.
succ [Int32] | Successor.
succ_big_int [Big_int] | Successor (add 1).
succ_num [Num] | `succ n` is `n+1`
symbol_docs [Docstrings] | Fetch the item documentation for the current symbol.
symbol_docs_lazy [Docstrings] |
symbol_end [Parsing] | See `Parsing.symbol_start`.
symbol_end_pos [Parsing] | Same as `symbol_end`, but return a `position` instead of an offset.
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` and `Parsing.symbol_end` are to be called in the action part of a grammar rule only.
symbol_start_pos [Parsing] | Same as `symbol_start`, but return a `position` instead of an offset.
symbol_text [Docstrings] | Fetch the text preceding the current symbol.
symbol_text_lazy [Docstrings] |
symlink [UnixLabels] | `symlink source dest` creates the file `dest` as a symbolic link to the file `source`.
symlink [Unix] | `symlink ?to_dir source dest` creates the file `dest` as a symbolic link to the file `source`.
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 [Queue] | `take q` removes and returns the first element in queue `q`, or raises `Empty` if the queue is empty.
tan [Pervasives] | Tangent.
tanh [Pervasives] | 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: `TCOOFF` suspends output, `TCOON` restarts output, `TCIOFF` transmits a STOP character to suspend input, and `TCION` transmits a START character to restart input.
tcflow [Unix] | Suspend or restart reception or transmission of data on the given file descriptor, depending on the second argument: `TCOOFF` suspends output, `TCOON` restarts output, `TCIOFF` transmits a STOP character to suspend input, and `TCION` transmits a START character to restart input.
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: `TCIFLUSH` flushes data received but not read, `TCOFLUSH` flushes data written but not transmitted, and `TCIOFLUSH` flushes both.
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: `TCIFLUSH` flushes data received but not read, `TCOFLUSH` flushes data written but not transmitted, and `TCIOFLUSH` flushes both.
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 `TMPDIR` environment variable, or "/tmp" if the variable is not set.
temp_file [Filename] | `temp_file prefix suffix` returns the name of a fresh temporary file in the temporary directory.
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 [Timings] | `time pass f arg` Record the runtime of `f arg`
time [Sys] | Return the processor time, in seconds, used by the program since the beginning of execution.
timed_read [ThreadUnix] | See `ThreadUnix.timed_write`.
timed_write [ThreadUnix] | Behave as `ThreadUnix.read` and `ThreadUnix.write`, except that `Unix_error(ETIMEDOUT,_,_)` is raised if no data is available for reading or ready for writing after `d` seconds.
timed_write_substring [ThreadUnix] | See `ThreadUnix.timed_write`.
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] | `Marshal.to_buffer buff ofs len v flags` marshals the value `v`, storing its byte representation in the sequence `buff`, starting at index `ofs`, and writing at most `len` bytes.
to_bytes [Marshal] | `Marshal.to_bytes v flags` returns a byte sequence containing the representation of `v`.
to_bytes [Buffer] | Return a copy of the current contents of the buffer.
to_channel [Marshal] | `Marshal.to_channel chan v flags` writes the representation of `v` on channel `chan`.
to_char [Uchar] | `to_char u` is `u` as an OCaml latin1 character.
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 u` is `u` as an integer.
to_int [Nativeint] | Convert the given native integer (type `nativeint`) to an integer (type `int`).
to_int [Int64] | Convert the given 64-bit integer (type `int64`) to an integer (type `int`).
to_int [Int32] | Convert the given 32-bit integer (type `int32`) to an integer (type `int`).
to_int32 [Nativeint] | Convert the given native integer to a 32-bit integer (type `int32`).
to_int32 [Int64] | Convert the given 64-bit integer (type `int64`) to a 32-bit integer (type `int32`).
to_list [Identifiable.S.Tbl] |
to_list [ArrayLabels] | `ArrayLabels.to_list a` returns the list of all the elements of `a`.
to_list [Array] | `Array.to_list a` returns the list of all the elements of `a`.
to_map [Identifiable.S.Tbl] |
to_nativeint [Int64] | Convert the given 64-bit integer (type `int64`) to a native integer.
to_string [Printexc] | `Printexc.to_string e` returns a string representation of the exception `e`.
to_string [Nativeint] | Return the string representation of its argument, in decimal.
to_string [Marshal] | Same as `to_bytes` but return the result as a string instead of a byte sequence.
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.S.Set] |
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 `"ocamlc"`, `"ocamlopt"`, `"ocamldoc"`, `"ocamldep"`, `"ocaml"`, ...
top [Stack] | `top s` returns the topmost element in stack `s`, or raises `Empty` if the stack is empty.
top [Queue] | `top` is a synonym for `peek`.
top_phrase [Printast] |
top_phrase [Pprintast] |
toplevel_phrase [Pprintast] |
toplevel_phrase [Parser] |
toplevel_phrase [Parse] |
total_size [Marshal] | See `Marshal.header_size`.
trans [CamlinternalFormat] |
transfer [Queue] | `transfer q1 q2` adds all of `q1`'s elements at the end of the queue `q2`, then clears `q1`.
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.S.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 `Unix.truncate`.
truncate [Unix] | Truncates the named file to the given size.
truncate [Pervasives] | Same as `int_of_float`.
truncate [Obj] |
try_ [Ast_helper.Exp] |
try_finally [Misc] |
try_lock [Mutex] | Same as `Mutex.lock`, but does not suspend the calling thread if the mutex is already locked: just return `false` immediately in that case.
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] |
typeof_ [Ast_helper.Mty] |
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] |
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.
uncapitalize [BytesLabels] | Return a copy of the argument, with the first byte set to lowercase.
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 [Bytes] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.
unescaped [Scanf] | `unescaped s` return a copy of `s` with escape sequences (according to the lexical conventions of OCaml) replaced by their corresponding special characters.
union [MoreLabels.Set.S] |
union [MoreLabels.Map.S] |
union [Set.S] | Set union.
union [Map.S] | `union f m1 m2` computes a map whose keys is the union of keys of `m1` and of `m2`.
union_left [Identifiable.S.Map] | `union_left m1 m2 = union_right m2 m1`
union_merge [Identifiable.S.Map] |
union_right [Identifiable.S.Map] | `union_right m1 m2` contains all bindings from `m1` and `m2`.
unit_big_int [Big_int] | The big integer `1`.
unix [Sys] | True if `Sys.os_type = "Unix"`.
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_get [Bigarray.Array3] | Like `Bigarray.Array3.get`, but bounds checking is not always performed.
unsafe_get [Bigarray.Array2] | Like `Bigarray.Array2.get`, but bounds checking is not always performed.
unsafe_get [Bigarray.Array1] | Like `Bigarray.Array1.get`, but bounds checking is not always performed.
unsafe_of_string [Bytes] | Unsafely convert a shared string to a byte sequence that should not be mutated.
unsafe_set [Bigarray.Array3] | Like `Bigarray.Array3.set`, but bounds checking is not always performed.
unsafe_set [Bigarray.Array2] | Like `Bigarray.Array2.set`, but bounds checking is not always performed.
unsafe_set [Bigarray.Array1] | Like `Bigarray.Array1.set`, but bounds checking is not always performed.
unsafe_string [Clflags] |
unsafe_to_string [Bytes] | Unsafely convert a byte sequence into a string.
unset_data [Obj.Ephemeron] | Same as `Ephemeron.K1.unset_data`
unset_data [Ephemeron.Kn] | Same as `Ephemeron.K1.unset_data`
unset_data [Ephemeron.K2] | Same as `Ephemeron.K1.unset_data`
unset_data [Ephemeron.K1] | `Ephemeron.K1.unset_key eph el` sets the key of `eph` to be an empty key.
unset_key [Obj.Ephemeron] | Same as `Ephemeron.K1.unset_key`
unset_key [Ephemeron.Kn] | Same as `Ephemeron.K1.unset_key`
unset_key [Ephemeron.K1] | `Ephemeron.K1.unset_key eph el` sets the key of `eph` to be an empty key.
unset_key1 [Ephemeron.K2] | Same as `Ephemeron.K1.unset_key`
unset_key2 [Ephemeron.K2] | Same as `Ephemeron.K1.unset_key`
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 [Char] | Convert the given character to its equivalent uppercase character, 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] | `Arg.usage speclist usage_msg` prints to standard error an error message that includes the list of valid options.
usage_string [Arg] | Returns the message that would have been printed by `Arg.usage`, if provided with the same parameters.
use_file [Parser] |
use_file [Parse] |
use_inlining_arguments_set [Clflags] | Set all the inlining arguments for a round.
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] |
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 c m` atomically unlocks the mutex `m` and suspends the calling process on the condition variable `c`.
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_pid p` suspends the execution of the calling thread until the process specified by the process identifier `p` terminates.
wait_read [Thread] | See `Thread.wait_write`.
wait_signal [Thread] | `wait_signal sigs` suspends the execution of the calling thread until the process receives one of the signals specified in the list `sigs`.
wait_timed_read [Thread] | See `Thread.wait_timed_read`.
wait_timed_write [Thread] | Suspend the execution of the calling thread until at least one character is available for reading (`wait_read`) or one character can be written without blocking (`wait_write`) on the given Unix file descriptor.
wait_write [Thread] | This function does nothing in this implementation.
waitpid [UnixLabels] | Same as `UnixLabels.wait`, but waits for the child process whose pid is given.
waitpid [Unix] | Same as `Unix.wait`, but waits for the child process whose pid is given.
waitpid [ThreadUnix] |
warn_bad_docstrings [Docstrings] | Emit warnings for unattached and ambiguous docstrings
warn_on_literal_pattern [Builtin_attributes] |
warning_attribute [Builtin_attributes] |
warning_enter_scope [Builtin_attributes] |
warning_leave_scope [Builtin_attributes] |
warning_printer [Location] | Hook for intercepting warnings.
while_ [Ast_helper.Exp] |
white [Graphics] |
widen [CamlinternalOO] |
win32 [Sys] | True if `Sys.os_type = "Win32"`.
window_id [GraphicsX11] | Return the unique identifier of the OCaml graphics window.
with_ [Ast_helper.Mty] |
with_default_loc [Ast_helper] | Set the `default_loc` within the scope of the execution of the provided function.
with_frame_pointers [Config] |
with_warning_attribute [Builtin_attributes] |
word_size [Sys] | Size of one word on the machine currently executing the OCaml program, in bits: 32 or 64.
wrap [Event] | `wrap ev fn` returns the event that performs the same communications as `ev`, then applies the post-processing function `fn` on the return value.
wrap_abort [Event] | `wrap_abort ev fn` returns the event that performs the same communications as `ev`, but if it is not selected the function `fn` is called after the synchronization.
write [UnixLabels] | `write fd buff ofs len` writes `len` bytes to descriptor `fd`, taking them from byte sequence `buff`, starting at position `ofs` in `buff`.
write [Unix] | `write fd buff ofs len` writes `len` bytes to descriptor `fd`, taking them from byte sequence `buff`, starting at position `ofs` in `buff`.
write [ThreadUnix] |
write_substring [UnixLabels] | Same as `write`, but take the data from a string instead of a byte sequence.
write_substring [Unix] | Same as `write`, but take the data from a string instead of a byte sequence.
write_substring [ThreadUnix] |
X
xor_big_int [Big_int] | Bitwise logical 'exclusive or'.
Y
yellow [Graphics] |
yield [Thread] | Re-schedule the calling thread without suspending it.
Z
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 `0`.
zero_big_int [Big_int] | The big integer `0`.
zero_to_n [Numbers.Int] | `zero_to_n n` is the set of numbers {0, ..., n} (inclusive).