OCaml library : Index of values

# Index of values

( * ) [Stdlib] | Integer multiplication.
( ** ) [Stdlib] | Exponentiation.
( *. ) [Stdlib] | Floating-point multiplication.
(!) [Stdlib] | `!r` returns the current contents of reference `r`.
(!=) [Stdlib] | Negation of `(==)`.
(&&) [Bool] | `e0 && e1` is the lazy boolean conjunction of expressions `e0` and `e1`.
(&&) [Stdlib] | The boolean 'and'.
(&) [Stdlib] |
(+) [Stdlib] | Integer addition.
(+.) [Stdlib] | Floating-point addition.
(-) [Stdlib] | Integer subtraction.
(-.) [Stdlib] | Floating-point subtraction.
(/) [Stdlib] | Integer division.
(/.) [Stdlib] | Floating-point division.
(:=) [Stdlib] | `r := a` stores the value of `a` in reference `r`.
(<) [Stdlib] | See `(>=)`.
(<=) [Stdlib] | See `(>=)`.
(<>) [Stdlib] | Negation of `(=)`.
(=) [Stdlib] | `e1 = e2` tests for structural equality of `e1` and `e2`.
(==) [Stdlib] | `e1 == e2` tests for physical equality of `e1` and `e2`.
(>) [Stdlib] | See `(>=)`.
(>=) [Stdlib] | Structural ordering functions.
(@) [Stdlib] | List concatenation.
(@@) [Stdlib] | Application operator: `g @@ f @@ x` is exactly equivalent to `g (f (x))`.
(^) [Stdlib] | String concatenation.
(^^) [Stdlib] | `f1 ^^ f2` catenates format strings `f1` and `f2`.
(asr) [Stdlib] | `n asr m` shifts `n` to the right by `m` bits.
(land) [Stdlib] | Bitwise logical and.
(lor) [Stdlib] | Bitwise logical or.
(lsl) [Stdlib] | `n lsl m` shifts `n` to the left by `m` bits.
(lsr) [Stdlib] | `n lsr m` shifts `n` to the right by `m` bits.
(lxor) [Stdlib] | Bitwise logical exclusive or.
(mod) [Stdlib] | Integer remainder.
(or) [Stdlib] |
(|>) [Stdlib] | Reverse-application operator: `x |> f |> g` is exactly equivalent to `g (f (x))`.
(||) [Bool] | `e0 || e1` is the lazy boolean disjunction of expressions `e0` and `e1`.
(||) [Stdlib] | The boolean 'or'.
(~+) [Stdlib] | Unary addition.
(~+.) [Stdlib] | Unary addition.
(~-) [Stdlib] | Unary negation.
(~-.) [Stdlib] | Unary negation.
__FILE__ [Stdlib] | `__FILE__` returns the name of the file currently being parsed by the compiler.
__FUNCTION__ [Stdlib] | `__FUNCTION__` returns the name of the current function or method, including any enclosing modules or classes.
__LINE_OF__ [Stdlib] | `__LINE_OF__ 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__ [Stdlib] | `__LINE__` returns the line number at which this expression appears in the file currently being parsed by the compiler.
__LOC_OF__ [Stdlib] | `__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__ [Stdlib] | `__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__ [Stdlib] | `__MODULE__` returns the module name of the file being parsed by the compiler.
__POS_OF__ [Stdlib] | `__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__ [Stdlib] | `__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.
_exit [UnixLabels] | Terminate the calling process immediately, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure.
_exit [Unix] | Terminate the calling process immediately, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure.
A
abs [Nativeint] | Return the absolute value of its argument.
abs [Int64] | Return the absolute value of its argument.
abs [Int32] | Return the absolute value of its argument.
abs [Int] | `abs x` is the absolute value of `x`.
abs [Float] | `abs f` returns the absolute value of `f`.
abs [Stdlib] | Return the absolute value of the argument.
abs_float [Stdlib] | `abs_float f` returns the absolute value of `f`.
abstract_tag [Obj] |
accept [ThreadUnix] |
accept [UnixLabels] | Accept connections on the given socket.
accept [Unix] | Accept connections on the given socket.
access [UnixLabels] | Check that the process has the given permissions over the named file.
access [Unix] | Check that the process has the given permissions over the named file.
acos [Float] | Arc cosine.
acos [Stdlib] | Arc cosine.
acosh [Float] | Hyperbolic arc cosine.
acosh [Stdlib] | Hyperbolic arc cosine.
acquire [Semaphore.Binary] | `acquire s` blocks the calling thread until the semaphore `s` has value 1 (is available), then atomically sets it to 0 and returns.
acquire [Semaphore.Counting] | `acquire s` blocks the calling thread until the value of semaphore `s` is not zero, then atomically decrements the value of `s` and returns.
adapt_filename [Dynlink] | In bytecode, the identity function.
add [Weak.S] | `add t x` adds `x` to `t`.
add [Set.S] | `add x s` returns a set containing all elements of `s`, plus `x`.
add [Queue] | `add x q` adds the element `x` at the end of the queue `q`.
add [Nativeint] | Addition.
add [MoreLabels.Set.S] | `add x s` returns a set containing all elements of `s`, plus `x`.
add [MoreLabels.Map.S] | `add ~key ~data m` returns a map containing the same bindings as `m`, plus a binding of `key` to `data`.
add [MoreLabels.Hashtbl.SeededS] |
add [MoreLabels.Hashtbl.S] |
add [MoreLabels.Hashtbl] | `Hashtbl.add tbl ~key ~data` adds a binding of `key` to `data` in table `tbl`.
add [Map.S] | `add key data m` returns a map containing the same bindings as `m`, plus a binding of `key` to `data`.
add [Int64] | Addition.
add [Int32] | Addition.
add [Int] | `add x y` is the addition `x + y`.
add [Hashtbl.SeededS] |
add [Hashtbl.S] |
add [Hashtbl] | `Hashtbl.add tbl key data` adds a binding of `key` to `data` in table `tbl`.
add [Float] | Floating-point addition.
add [Ephemeron.Kn.Bucket] | Add an ephemeron to the bucket.
add [Ephemeron.K2.Bucket] | Add an ephemeron to the bucket.
add [Ephemeron.K1.Bucket] | Add an ephemeron to the bucket.
add [Ephemeron.SeededS] |
add [Ephemeron.S] |
add [Complex] | 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_in_char_set [CamlinternalFormat] |
add_initializer [CamlinternalOO] |
add_int16_be [Buffer] | `add_int16_be b i` appends a binary big-endian signed 16-bit integer `i` to `b`.
add_int16_le [Buffer] | `add_int16_le b i` appends a binary little-endian signed 16-bit integer `i` to `b`.
add_int16_ne [Buffer] | `add_int16_ne b i` appends a binary native-endian signed 16-bit integer `i` to `b`.
add_int32_be [Buffer] | `add_int32_be b i` appends a binary big-endian 32-bit integer `i` to `b`.
add_int32_le [Buffer] | `add_int32_le b i` appends a binary little-endian 32-bit integer `i` to `b`.
add_int32_ne [Buffer] | `add_int32_ne b i` appends a binary native-endian 32-bit integer `i` to `b`.
add_int64_be [Buffer] | `add_int64_be b i` appends a binary big-endian 64-bit integer `i` to `b`.
add_int64_le [Buffer] | `add_int64_ne b i` appends a binary little-endian 64-bit integer `i` to `b`.
add_int64_ne [Buffer] | `add_int64_ne b i` appends a binary native-endian 64-bit integer `i` to `b`.
add_int8 [Buffer] | `add_int8 b i` appends a binary signed 8-bit integer `i` to `b`.
add_offset [Obj] |
add_seq [Stack] | Add the elements from the sequence on the top of the stack.
add_seq [Set.S] | Add the given elements to the set, in order.
add_seq [Queue] | Add the elements from a sequence to the end of the queue.
add_seq [MoreLabels.Set.S] | Add the given elements to the set, in order.
add_seq [MoreLabels.Map.S] | Add the given bindings to the map, in order.
add_seq [MoreLabels.Hashtbl.SeededS] |
add_seq [MoreLabels.Hashtbl.S] |
add_seq [MoreLabels.Hashtbl] | Add the given bindings to the table, using `MoreLabels.Hashtbl.add`
add_seq [Map.S] | Add the given bindings to the map, in order.
add_seq [Hashtbl.SeededS] |
add_seq [Hashtbl.S] |
add_seq [Hashtbl] | Add the given bindings to the table, using `Hashtbl.add`
add_seq [Ephemeron.SeededS] |
add_seq [Ephemeron.S] |
add_seq [Buffer] | Add chars to the buffer
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_symbolic_output_item [Format] | `add_symbolic_output_item sob itm` adds item `itm` to buffer `sob`.
add_uint16_be [Buffer] | `add_uint16_be b i` appends a binary big-endian unsigned 16-bit integer `i` to `b`.
add_uint16_le [Buffer] | `add_uint16_le b i` appends a binary little-endian unsigned 16-bit integer `i` to `b`.
add_uint16_ne [Buffer] | `add_uint16_ne b i` appends a binary native-endian unsigned 16-bit integer `i` to `b`.
add_uint8 [Buffer] | `add_uint8 b i` appends a binary unsigned 8-bit integer `i` to `b`.
add_utf_16be_uchar [Buffer] | `add_utf_16be_uchar b u` appends the UTF-16BE encoding of `u` at the end of buffer `b`.
add_utf_16le_uchar [Buffer] | `add_utf_16le_uchar b u` appends the UTF-16LE encoding of `u` at the end of buffer `b`.
add_utf_8_uchar [Buffer] | `add_utf_8_uchar b u` appends the UTF-8 encoding of `u` at the end of buffer `b`.
alarm [UnixLabels] | Schedule a `SIGALRM` signal after the given number of seconds.
alarm [Unix] | Schedule a `SIGALRM` signal after the given number of seconds.
align [Arg] | Align the documentation strings by inserting spaces at the first alignment separator (tab or, if tab is not found, space), according to the length of the keyword.
all_units [Dynlink] | Return the list of compilation units that form the main program together with those that have been dynamically loaded via `loadfile` (and not via `loadfile_private`).
allocated_bytes [Gc] | Return the total number of bytes allocated since the program was started.
allow_only [Dynlink] | `allow_only units` sets the list of allowed units to be the intersection of the existing allowed units and the given list of 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.
append [Seq] | `append xs ys` is the concatenation of the sequences `xs` and `ys`.
append [ListLabels] | Concatenate two lists.
append [List] | Concatenate two lists.
append [Float.ArrayLabels] | `append v1 v2` returns a fresh floatarray containing the concatenation of the floatarrays `v1` and `v2`.
append [Float.Array] | `append v1 v2` returns a fresh floatarray containing the concatenation of the floatarrays `v1` and `v2`.
append [ArrayLabels] | `append v1 v2` returns a fresh array containing the concatenation of the arrays `v1` and `v2`.
append [Array] | `append v1 v2` returns a fresh array containing the concatenation of the arrays `v1` and `v2`.
arg [Complex] | Argument.
argv [Sys] | The command line arguments given to the process.
array0_of_genarray [Bigarray] | Return the zero-dimensional Bigarray corresponding to the given generic Bigarray.
array1_of_genarray [Bigarray] | Return the one-dimensional Bigarray corresponding to the given generic Bigarray.
array2_of_genarray [Bigarray] | Return the two-dimensional Bigarray corresponding to the given generic Bigarray.
array3_of_genarray [Bigarray] | Return the three-dimensional Bigarray corresponding to the given generic Bigarray.
asin [Float] | Arc sine.
asin [Stdlib] | Arc sine.
asinh [Float] | Hyperbolic arc sine.
asinh [Stdlib] | Hyperbolic arc sine.
asprintf [Format] | Same as `printf` above, but instead of printing on a formatter, returns a string containing the result of formatting the arguments.
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`.
assoc_opt [ListLabels] | `assoc_opt a l` returns the value associated with key `a` in the list of pairs `l`.
assoc_opt [List] | `assoc_opt 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.
assq_opt [ListLabels] | Same as `ListLabels.assoc_opt`, but uses physical equality instead of structural equality to compare keys.
assq_opt [List] | Same as `List.assoc_opt`, but uses physical equality instead of structural equality to compare keys.
at_exit [Stdlib] | Register the given function to be called at program termination time.
atan [Float] | Arc tangent.
atan [Stdlib] | Arc tangent.
atan2 [Float] | `atan2 y x` returns the arc tangent of `y /. x`.
atan2 [Stdlib] | `atan2 y x` returns the arc tangent of `y /. x`.
atanh [Float] | Hyperbolic arc tangent.
atanh [Stdlib] | Hyperbolic arc tangent.
B
backend_type [Sys] | Backend type currently executing the OCaml program.
backtrace_slots [Printexc] | Returns the slots of a raw backtrace, or `None` if none of them contain useful information.
backtrace_slots_of_raw_entry [Printexc] | Returns the slots of a single raw backtrace entry, or `None` if this entry lacks debug information.
backtrace_status [Printexc] | `Printexc.backtrace_status()` returns `true` if exception backtraces are currently recorded, `false` if not.
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 `Scanf.Scanning.in_channel` formatted input channel.
big_endian [Sys] | Whether the machine currently executing the Caml program is big-endian.
bind [UnixLabels] | Bind a socket to an address.
bind [Unix] | Bind a socket to an address.
bind [Result] | `bind r f` is `f v` if `r` is `Ok v` and `r` if `r` is `Error _`.
bind [Option] | `bind o f` is `f v` if `o` is `Some v` and `None` if `o` is `None`.
bindings [MoreLabels.Map.S] | Return the list of all bindings of the given map.
bindings [Map.S] | Return the list of all bindings of the given map.
bits [Random.State] |
bits [Random] | Return 30 random bits in a nonnegative integer.
bits32 [Random.State] |
bits32 [Random] | `Random.bits32 ()` returns 32 random bits as an integer between `Int32.min_int` and `Int32.max_int`.
bits64 [Random.State] |
bits64 [Random] | `Random.bits64 ()` returns 64 random bits as an integer between `Int64.min_int` and `Int64.max_int`.
bits_of_float [Int64] | Return the internal representation of the given float according to the IEEE 754 floating-point 'double format' bit layout.
bits_of_float [Int32] | Return the internal representation of the given float according to the IEEE 754 floating-point 'single format' bit layout.
blit [Weak] | `Weak.blit ar1 off1 ar2 off2 len` copies `len` weak pointers from `ar1` (starting at `off1`) to `ar2` (starting at `off2`).
blit [String] | `blit src src_pos dst dst_pos len` copies `len` bytes from the string `src`, starting at index `src_pos`, to byte sequence `dst`, starting at character number `dst_pos`.
blit [StringLabels] | `blit ~src ~src_pos ~dst ~dst_pos ~len` copies `len` bytes from the string `src`, starting at index `src_pos`, to byte sequence `dst`, starting at character number `dst_pos`.
blit [Float.ArrayLabels] | `blit ~src ~src_pos ~dst ~dst_pos ~len` copies `len` elements from floatarray `src`, starting at element number `src_pos`, to floatarray `dst`, starting at element number `dst_pos`.
blit [Float.Array] | `blit src src_pos dst dst_pos len` copies `len` elements from floatarray `src`, starting at element number `src_pos`, to floatarray `dst`, starting at element number `dst_pos`.
blit [BytesLabels] | `blit ~src ~src_pos ~dst ~dst_pos ~len` copies `len` bytes from sequence `src`, starting at index `src_pos`, to sequence `dst`, starting at index `dst_pos`.
blit [Bytes] | `blit src src_pos dst dst_pos len` copies `len` bytes from sequence `src`, starting at index `src_pos`, to sequence `dst`, starting at index `dst_pos`.
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 Bigarray to the second Bigarray.
blit [Bigarray.Array2] | Copy the first Bigarray to the second Bigarray.
blit [Bigarray.Array1] | Copy the first Bigarray to the second Bigarray.
blit [Bigarray.Array0] | Copy the first Bigarray to the second Bigarray.
blit [Bigarray.Genarray] | Copy all elements of a Bigarray in another Bigarray.
blit [ArrayLabels] | `blit ~src ~src_pos ~dst ~dst_pos ~len` copies `len` elements from array `src`, starting at element number `src_pos`, to array `dst`, starting at element number `dst_pos`.
blit [Array] | `blit src src_pos dst dst_pos len` copies `len` elements from array `src`, starting at element number `src_pos`, to array `dst`, starting at element number `dst_pos`.
blit_data [Obj.Ephemeron] | Same as `Stdlib.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_key [Obj.Ephemeron] | Same as `Stdlib.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 [BytesLabels] | `blit ~src ~src_pos ~dst ~dst_pos ~len` copies `len` bytes from string `src`, starting at index `src_pos`, to byte sequence `dst`, starting at index `dst_pos`.
blit_string [Bytes] | `blit src src_pos dst dst_pos len` copies `len` bytes from string `src`, starting at index `src_pos`, to byte sequence `dst`, starting at index `dst_pos`.
bom [Uchar] | `bom` is U+FEFF, the byte order mark (BOM) character.
bool [Random.State] |
bool [Random] | `Random.bool ()` returns `true` or `false` with probability 0.5 each.
bool_of_string [Stdlib] | Same as `bool_of_string_opt`, but raise `Invalid_argument "bool_of_string"` instead of returning `None`.
bool_of_string_opt [Stdlib] | 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] |
bytes [Digest] | Return the digest of the given byte sequence.
C
c_layout [Bigarray] |
capitalize [String] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set..
capitalize [StringLabels] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set..
capitalize [BytesLabels] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.
capitalize [Bytes] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.
capitalize_ascii [String] | `capitalize_ascii s` is `s` with the first character set to uppercase, using the US-ASCII character set.
capitalize_ascii [StringLabels] | `capitalize_ascii s` is `s` with the first character set to uppercase, using the US-ASCII character set.
capitalize_ascii [BytesLabels] | Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set.
capitalize_ascii [Bytes] | Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set.
cardinal [Set.S] | Return the number of elements of a set.
cardinal [MoreLabels.Set.S] | Return the number of elements of a set.
cardinal [MoreLabels.Map.S] | Return the number of bindings of a map.
cardinal [Map.S] | Return the number of bindings of a map.
cat [String] | `cat s1 s2` concatenates s1 and s2 (`s1 ^ s2`).
cat [StringLabels] | `cat s1 s2` concatenates s1 and s2 (`s1 ^ s2`).
cat [BytesLabels] | `cat s1 s2` concatenates `s1` and `s2` and returns the result as a new byte sequence.
cat [Bytes] | `cat s1 s2` concatenates `s1` and `s2` and returns the result as a 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.
cbrt [Float] | Cube root.
ceil [Float] | Round above to an integer value.
ceil [Stdlib] | Round above to an integer value.
change_layout [Bigarray.Array3] | `Array3.change_layout a layout` returns a Bigarray with the specified `layout`, sharing the data with `a` (and hence having the same dimensions as `a`).
change_layout [Bigarray.Array2] | `Array2.change_layout a layout` returns a Bigarray with the specified `layout`, sharing the data with `a` (and hence having the same dimensions as `a`).
change_layout [Bigarray.Array1] | `Array1.change_layout a layout` returns a Bigarray with the specified `layout`, sharing the data with `a` (and hence having the same dimension as `a`).
change_layout [Bigarray.Array0] | `Array0.change_layout a layout` returns a Bigarray with the specified `layout`, sharing the data with `a`.
change_layout [Bigarray.Genarray] | `Genarray.change_layout a layout` returns a Bigarray with the specified `layout`, sharing the data with `a` (and hence having the same dimensions as `a`).
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, Bigarrays of kind `float32_elt` and `float64_elt` are accessed using the OCaml type `float`.
char_of_iconv [CamlinternalFormat] |
char_of_int [Stdlib] | Return the character with the given ASCII code.
chdir [UnixLabels] | Change the process working directory.
chdir [Unix] | Change the process working directory.
chdir [Sys] | Change the current working directory of the process.
check [Weak] | `Weak.check ar n` returns `true` if the `n`th cell of `ar` is full, `false` if it is empty.
check_data [Obj.Ephemeron] | Same as `Stdlib.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_geometry [Format] | Check if the formatter geometry is valid: `1 < max_indent < margin`
check_key [Obj.Ephemeron] | Same as `Stdlib.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_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 [Event] | `choose evl` returns the event that is the alternative of all the events in the list `evl`.
choose [Set.S] | Return one element of the given set, or raise `Not_found` if the set is empty.
choose [MoreLabels.Set.S] | Return one element of the given set, or raise `Not_found` if the set is empty.
choose [MoreLabels.Map.S] | Return one binding of the given map, or raise `Not_found` if the map is empty.
choose [Map.S] | Return one binding of the given map, or raise `Not_found` if the map is empty.
choose_opt [Set.S] | Return one element of the given set, or `None` if the set is empty.
choose_opt [MoreLabels.Set.S] | Return one element of the given set, or `None` if the set is empty.
choose_opt [MoreLabels.Map.S] | Return one binding of the given map, or `None` if the map is empty.
choose_opt [Map.S] | Return one binding of the given map, or `None` if the map is empty.
chop_extension [Filename] | Same as `Filename.remove_extension`, but raise `Invalid_argument` if the given name has an empty extension.
chop_suffix [Filename] | `chop_suffix name suff` removes the suffix `suff` from the filename `name`.
chop_suffix_opt [Filename] | `chop_suffix_opt ~suffix filename` removes the suffix from the `filename` if possible, or returns `None` if the filename does not end with the suffix.
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.
classify_float [Float] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
classify_float [Stdlib] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
clean [Ephemeron.SeededS] | remove all dead bindings.
clean [Ephemeron.S] | remove all dead bindings.
clear [Weak.S] | Remove all elements from the table.
clear [Stack] | Discard all elements from a stack.
clear [Queue] | Discard all elements from a queue.
clear [MoreLabels.Hashtbl.SeededS] |
clear [MoreLabels.Hashtbl.S] |
clear [MoreLabels.Hashtbl] | Empty a hash table.
clear [Hashtbl.SeededS] |
clear [Hashtbl.S] |
clear [Hashtbl] | Empty a hash table.
clear [Ephemeron.Kn.Bucket] | Remove all ephemerons from the bucket.
clear [Ephemeron.K2.Bucket] | Remove all ephemerons from the bucket.
clear [Ephemeron.K1.Bucket] | Remove all ephemerons from the bucket.
clear [Ephemeron.SeededS] |
clear [Ephemeron.S] |
clear [Buffer] | Empty the buffer.
clear_close_on_exec [UnixLabels] | Clear the ``close-on-exec'' flag on the given descriptor.
clear_close_on_exec [Unix] | Clear the ``close-on-exec'' flag on the given descriptor.
clear_nonblock [UnixLabels] | Clear the ``non-blocking'' flag on the given descriptor.
clear_nonblock [Unix] | Clear the ``non-blocking'' flag on the given descriptor.
clear_parser [Parsing] | Empty the parser stack.
clear_symbolic_output_buffer [Format] | `clear_symbolic_output_buffer sob` resets buffer `sob`.
close [UnixLabels] | Close a file descriptor.
close [Unix] | Close a file descriptor.
close [Out_channel] | Close the given channel, flushing all buffered write operations.
close [In_channel] | Close the given channel.
close_box [Format] | Closes the most recently open pretty-printing box.
close_in [Scanf.Scanning] | Closes the `in_channel` associated with the given `Scanf.Scanning.in_channel` formatted input channel.
close_in [Stdlib] | Close the given channel.
close_in_noerr [Stdlib] | Same as `close_in`, but ignore all errors.
close_noerr [Out_channel] | Same as `Out_channel.close`, but ignore all errors.
close_noerr [In_channel] | Same as `In_channel.close`, but ignore all errors.
close_out [Stdlib] | Close the given channel, flushing all buffered write operations.
close_out_noerr [Stdlib] | 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_stag [Format] | `pp_close_stag ppf ()` closes the most recently opened semantic tag `t`.
close_tag [Format] |
close_tbox [Format] | Closes the most recently opened tabulation box.
closedir [UnixLabels] | Close a directory descriptor.
closedir [Unix] | Close a directory descriptor.
closure_tag [Obj] |
code [Char] | Return the ASCII code of the argument.
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)]`.
combine [ArrayLabels] | `combine [|a1; ...; an|] [|b1; ...; bn|]` is `[|(a1,b1); ...; (an,bn)|]`.
combine [Array] | `combine [|a1; ...; an|] [|b1; ...; bn|]` is `[|(a1,b1); ...; (an,bn)|]`.
command [Sys] | Execute the given shell command and return its exit code.
compact [Gc] | Perform a full major collection and compact the heap.
compare [Unit] | `compare u1 u2` is `0`.
compare [Uchar] | `compare u u'` is `Stdlib.compare u u'`.
compare [String] | `compare s0 s1` sorts `s0` and `s1` in lexicographical order.
compare [StringLabels] | `compare s0 s1` sorts `s0` and `s1` in lexicographical order.
compare [Set.OrderedType] | A total ordering function over the set elements.
compare [Set.S] | Total ordering between sets.
compare [Seq] | Provided the function `cmp` defines a preorder on elements, `compare cmp xs ys` compares the sequences `xs` and `ys` according to the lexicographic preorder.
compare [Result] | `compare ~ok ~error r0 r1` totally orders `r0` and `r1` using `ok` and `error` to respectively compare values wrapped by `Ok _` and `Error _`.
compare [Option] | `compare cmp o0 o1` is a total order on options using `cmp` to compare values wrapped by `Some _`.
compare [Nativeint] | The comparison function for native integers, with the same specification as `compare`.
compare [MoreLabels.Set.OrderedType] | A total ordering function over the set elements.
compare [MoreLabels.Set.S] | Total ordering between sets.
compare [MoreLabels.Map.OrderedType] | A total ordering function over the keys.
compare [MoreLabels.Map.S] | Total ordering between maps.
compare [Map.OrderedType] | A total ordering function over the keys.
compare [Map.S] | Total ordering between maps.
compare [ListLabels] | `compare cmp [a1; ...; an] [b1; ...; bm]` performs a lexicographic comparison of the two input lists, using the same `'a -> 'a -> int` interface as `compare`:
compare [List] | `compare cmp [a1; ...; an] [b1; ...; bm]` performs a lexicographic comparison of the two input lists, using the same `'a -> 'a -> int` interface as `compare`:
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 [Int] | `compare x y` is `compare` `x y` but more efficient.
compare [Float] | `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 [Either] | `compare ~left ~right e0 e1` totally orders `e0` and `e1` using `left` and `right` to respectively compare values wrapped by `Left _` and `Right _`.
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 [Bool] | `compare b0 b1` is a total order on boolean values.
compare [Stdlib] | `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_and_set [Atomic] | `compare_and_set r seen v` sets the new value of `r` to `v` only if its current value is physically equal to `seen` -- the comparison and the set occur atomically.
compare_and_set [CamlinternalAtomic] |
compare_length_with [ListLabels] | Compare the length of a list to an integer.
compare_length_with [List] | Compare the length of a list to an integer.
compare_lengths [ListLabels] | Compare the lengths of two lists.
compare_lengths [List] | Compare the lengths of two lists.
complex32 [Bigarray] | See `Bigarray.char`.
complex64 [Bigarray] | See `Bigarray.char`.
concat [String] | `concat sep ss` concatenates the list of strings `ss`, inserting the separator string `sep` between each.
concat [StringLabels] | `concat ~sep ss` concatenates the list of strings `ss`, inserting the separator string `sep` between each.
concat [Seq] | If `xss` is a sequence of sequences, then `concat xss` is its concatenation.
concat [ListLabels] | Concatenate a list of lists.
concat [List] | Concatenate a list of lists.
concat [Float.ArrayLabels] | Same as `Float.ArrayLabels.append`, but concatenates a list of floatarrays.
concat [Float.Array] | Same as `Float.Array.append`, but concatenates a list of floatarrays.
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] |
concat_map [Seq] | `concat_map f xs` is equivalent to `concat (map f xs)`.
concat_map [ListLabels] | `concat_map ~f l` gives the same result as `ListLabels.concat``(``ListLabels.map` `f l)`.
concat_map [List] | `concat_map f l` gives the same result as `List.concat``(``List.map` `f l)`.
conj [Complex] | Conjugate: given the complex `x + i.y`, returns `x - i.y`.
connect [ThreadUnix] |
connect [UnixLabels] | Connect a socket to an address.
connect [Unix] | Connect a socket to an address.
cons [Seq] | `cons x xs` is the sequence that begins with the element `x`, followed with the sequence `xs`.
cons [ListLabels] | `cons x xs` is `x :: xs`
cons [List] | `cons x xs` is `x :: xs`
const [Fun] | `const c` is a function that always returns the value `c`.
contains [String] | `contains s c` is `String.contains_from` `s 0 c`.
contains [StringLabels] | `contains s c` is `String.contains_from` `s 0 c`.
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] | `contains_from s start c` is `true` if and only if `c` appears in `s` after position `start`.
contains_from [StringLabels] | `contains_from s start c` is `true` if and only if `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 [CamlinternalOO] |
copy [String] | Return a copy of the given string.
copy [StringLabels] | Return a copy of the given string.
copy [Stack] | Return a copy of the given stack.
copy [Random.State] | Return a copy of the given state.
copy [Queue] | Return a copy of the given queue.
copy [Oo] | `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] | Return a copy of the given hashtable.
copy [Hashtbl.SeededS] |
copy [Hashtbl.S] |
copy [Hashtbl] | Return a copy of the given hashtable.
copy [Float.ArrayLabels] | `copy a` returns a copy of `a`, that is, a fresh floatarray containing the same elements as `a`.
copy [Float.Array] | `copy a` returns a copy of `a`, that is, a fresh floatarray containing the same elements as `a`.
copy [Ephemeron.SeededS] |
copy [Ephemeron.S] |
copy [BytesLabels] | Return a new byte sequence that contains the same bytes as the argument.
copy [Bytes] | Return a new byte sequence that contains the same bytes as the argument.
copy [ArrayLabels] | `copy a` returns a copy of `a`, that is, a fresh array containing the same elements as `a`.
copy [Array] | `copy a` returns a copy of `a`, that is, a fresh array containing the same elements as `a`.
copy_sign [Float] | `copy_sign x y` returns a float whose absolute value is that of `x` and whose sign is that of `y`.
copysign [Stdlib] | `copysign x y` returns a float whose absolute value is that of `x` and whose sign is that of `y`.
cos [Float] | Cosine.
cos [Stdlib] | Cosine.
cosh [Float] | Hyperbolic cosine.
cosh [Stdlib] | Hyperbolic cosine.
count [Weak.S] | Count the number of elements in the table.
count [Stream] | Return the current count of the stream elements, i.e.
counters [Gc] | Return `(minor_words, promoted_words, major_words)`.
create [Mutex] | Return a new mutex.
create [Condition] | Return a new condition variable.
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 [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 [String] | `create n` returns a fresh byte sequence of length `n`.
create [StringLabels] | `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 [MoreLabels.Hashtbl.SeededS] |
create [MoreLabels.Hashtbl.S] |
create [MoreLabels.Hashtbl] | `Hashtbl.create n` creates a new, empty hash table, with initial size `n`.
create [Hashtbl.SeededS] |
create [Hashtbl.S] |
create [Hashtbl] | `Hashtbl.create n` creates a new, empty hash table, with initial size `n`.
create [Float.ArrayLabels] | `create n` returns a fresh floatarray of length `n`, with uninitialized data.
create [Float.Array] | `create n` returns a fresh floatarray of length `n`, with uninitialized data.
create [Ephemeron.Kn] | Same as `Ephemeron.K1.create`
create [Ephemeron.K2] | Same as `Ephemeron.K1.create`
create [Ephemeron.SeededS] |
create [Ephemeron.S] |
create [Ephemeron.K1] | `Ephemeron.K1.create ()` creates an ephemeron with one key.
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 dimensions, 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 dimensions, 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.Array0] | `Array0.create kind layout` returns a new Bigarray of zero dimension.
create [Bigarray.Genarray] | `Genarray.create kind layout dimensions` returns a new Bigarray 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_char_set [CamlinternalFormat] |
create_float [ArrayLabels] | `create_float n` returns a fresh float array of length `n`, with uninitialized data.
create_float [Array] | `create_float n` returns a fresh float array of length `n`, with uninitialized data.
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 ~stdin ~stdout ~stderr` forks a new process that executes the program in file `prog`, with arguments `args`.
create_process [Unix] | `create_process prog args stdin stdout 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 ~stdin ~stdout ~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 stdin stdout stderr` works as `Unix.create_process`, except that the extra argument `env` specifies the environment passed to the program.
create_table [CamlinternalOO] |
current [Arg] | Position (in `Sys.argv`) of the argument being processed.
current_dir_name [Filename] | The conventional name for the current directory (e.g.
custom_tag [Obj] |
cycle [Seq] | `cycle xs` is the infinite sequence that consists of an infinite number of repetitions of the sequence `xs`.
cygwin [Sys] | True if `Sys.os_type = "Cygwin"`.
D
data_size [Marshal] | See `Marshal.header_size`.
decr [Atomic] | `decr r` atomically decrements the value of `r` by `1`.
decr [Stdlib] | Decrement the integer contained in the given reference.
decr [CamlinternalAtomic] |
default_uncaught_exception_handler [Thread] | `Thread.default_uncaught_exception_handler` will print the thread's id, exception and backtrace (if available).
default_uncaught_exception_handler [Printexc] | `Printexc.default_uncaught_exception_handler` prints the exception and backtrace on standard error output.
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`.
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.
development_version [Sys] | `true` if this is a development version, `false` otherwise.
diff [Set.S] | Set difference: `diff s1 s2` contains the elements of `s1` that are not in `s2`.
diff [MoreLabels.Set.S] | Set difference: `diff s1 s2` contains the elements of `s1` that are not in `s2`.
dim [Bigarray.Array1] | Return the size (dimension) of the given one-dimensional Bigarray.
dim1 [Bigarray.Array3] | Return the first dimension of the given three-dimensional Bigarray.
dim1 [Bigarray.Array2] | Return the first dimension of the given two-dimensional Bigarray.
dim2 [Bigarray.Array3] | Return the second dimension of the given three-dimensional Bigarray.
dim2 [Bigarray.Array2] | Return the second dimension of the given two-dimensional Bigarray.
dim3 [Bigarray.Array3] | Return the third dimension of the given three-dimensional Bigarray.
dims [Bigarray.Genarray] | `Genarray.dims a` returns all dimensions of the Bigarray `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 [Set.S] | Test if two sets are disjoint.
disjoint [MoreLabels.Set.S] | Test if two sets are disjoint.
div [Nativeint] | Integer division.
div [Int64] | Integer division.
div [Int32] | Integer division.
div [Int] | `div x y` is the division `x / y`.
div [Float] | Floating-point division.
div [Complex] | Division
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.
double_array_tag [Obj] |
double_field [Obj] |
double_tag [Obj] |
dprintf [Format] | Same as `Format.fprintf`, except the formatter is the last argument.
drop [Seq] | `drop n xs` is the sequence `xs`, deprived of its first `n` elements.
drop_while [Seq] | `drop_while p xs` is the sequence `xs`, deprived of the prefix `take_while p xs`.
dummy_class [CamlinternalOO] |
dummy_pos [Lexing] | A value of type `position`, guaranteed to be different from any valid position.
dummy_table [CamlinternalOO] |
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 ~src ~dst` duplicates `src` to `dst`, closing `dst` if already opened.
dup2 [Unix] | `dup2 src dst` duplicates `src` to `dst`, closing `dst` if already opened.
E
elements [Set.S] | Return the list of all elements of the given set.
elements [MoreLabels.Set.S] | Return the list of all elements of the given set.
empty [String] | The empty string.
empty [Stream] | Return `()` if the stream is empty, else raise `Stream.Failure`.
empty [StringLabels] | The empty string.
empty [Set.S] | The empty set.
empty [Seq] | `empty` is the empty sequence.
empty [MoreLabels.Set.S] | The empty set.
empty [MoreLabels.Map.S] | The empty map.
empty [Map.S] | The empty map.
empty [BytesLabels] | A byte sequence of size 0.
empty [Bytes] | A byte sequence of size 0.
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 `Scanf.Scanning.in_channel` formatted input channel.
ends_with [String] | `ends_with suffix s` is `true` if and only if `s` ends with `suffix`.
ends_with [StringLabels] | `ends_with ~suffix s` is `true` if and only if `s` ends with `suffix`.
ends_with [BytesLabels] | `ends_with suffix s` is `true` if and only if `s` ends with `suffix`.
ends_with [Bytes] | `ends_with suffix s` is `true` if and only if `s` ends with `suffix`.
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] | The difference between `1.0` and the smallest exactly representable floating-point number greater than `1.0`.
epsilon_float [Stdlib] | The difference between `1.0` and the smallest exactly representable floating-point number greater than `1.0`.
equal [Unit] | `equal u1 u2` is `true`.
equal [Uchar] | `equal u u'` is `u = u'`.
equal [String] | `equal s0 s1` is `true` if and only if `s0` and `s1` are character-wise equal.
equal [StringLabels] | `equal s0 s1` is `true` if and only if `s0` and `s1` are character-wise equal.
equal [Set.S] | `equal s1 s2` tests whether the sets `s1` and `s2` are equal, that is, contain equal elements.
equal [Seq] | Provided the function `eq` defines an equality on elements, `equal eq xs ys` determines whether the sequences `xs` and `ys` are pointwise equal.
equal [Result] | `equal ~ok ~error r0 r1` tests equality of `r0` and `r1` using `ok` and `error` to respectively compare values wrapped by `Ok _` and `Error _`.
equal [Option] | `equal eq o0 o1` is `true` if and only if `o0` and `o1` are both `None` or if they are `Some v0` and `Some v1` and `eq v0 v1` is `true`.
equal [Nativeint] | The equal function for native ints.
equal [MoreLabels.Set.S] | `equal s1 s2` tests whether the sets `s1` and `s2` are equal, that is, contain equal elements.
equal [MoreLabels.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 [MoreLabels.Hashtbl.SeededHashedType] | The equality predicate used to compare keys.
equal [MoreLabels.Hashtbl.HashedType] | The equality predicate used to compare keys.
equal [Map.S] | `equal cmp m1 m2` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
equal [ListLabels] | `equal eq [a1; ...; an] [b1; ..; bm]` holds when the two input lists have the same length, and for each pair of elements `ai`, `bi` at the same position we have `eq ai bi`.
equal [List] | `equal eq [a1; ...; an] [b1; ..; bm]` holds when the two input lists have the same length, and for each pair of elements `ai`, `bi` at the same position we have `eq ai bi`.
equal [Int64] | The equal function for int64s.
equal [Int32] | The equal function for int32s.
equal [Int] | `equal x y` is `true` if and only if `x = y`.
equal [Hashtbl.SeededHashedType] | The equality predicate used to compare keys.
equal [Hashtbl.HashedType] | The equality predicate used to compare keys.
equal [Float] | The equal function for floating-point numbers, compared using `Float.compare`.
equal [Either] | `equal ~left ~right e0 e1` tests equality of `e0` and `e1` using `left` and `right` to respectively compare values wrapped by `Left _` and `Right _`.
equal [Digest] | The equal function for 16-character digest.
equal [Char] | The equal function for chars.
equal [BytesLabels] | The equality function for byte sequences.
equal [Bytes] | The equality function for byte sequences.
equal [Bool] | `equal b0 b1` is `true` if and only if `b0` and `b1` are both `true` or both `false`.
erase_rel [CamlinternalFormatBasics] |
erf [Float] | Error function.
erfc [Float] | Complementary error function (`erfc x = 1 - erf x`).
err_formatter [Format] | A formatter to write to standard error.
error [Result] | `error e` is `Error e`.
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.
escaped [String] | `escaped s` is `s` with special characters represented by escape sequences, following the lexical conventions of OCaml.
escaped [StringLabels] | `escaped s` is `s` 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.
eventlog_pause [Gc] | `eventlog_pause ()` will pause the collection of traces in the runtime.
eventlog_resume [Gc] | `eventlog_resume ()` will resume the collection of traces in the runtime.
exchange [Atomic] | Set a new value for the atomic reference, and return the current value.
exchange [CamlinternalAtomic] |
executable_name [Sys] | The name of the file containing the executable currently running.
execv [ThreadUnix] |
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.
execve [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.
execvp [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.
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 [String] | `exists p s` checks if at least one character of `s` satisfies the predicate `p`.
exists [StringLabels] | `exists p s` checks if at least one character of `s` satisfies the predicate `p`.
exists [Set.S] | `exists f s` checks if at least one element of the set satisfies the predicate `f`.
exists [Seq] | `exists xs p` determines whether at least one element `x` of the sequence `xs` satisfies `p x`.
exists [MoreLabels.Set.S] | `exists ~f s` checks if at least one element of the set satisfies the predicate `f`.
exists [MoreLabels.Map.S] | `exists ~f m` checks if at least one binding of the map satisfies the predicate `f`.
exists [Map.S] | `exists f m` checks if at least one binding of the map satisfies the predicate `f`.
exists [ListLabels] | `exists ~f [a1; ...; an]` checks if at least one element of the list satisfies the predicate `f`.
exists [List] | `exists f [a1; ...; an]` checks if at least one element of the list satisfies the predicate `f`.
exists [Float.ArrayLabels] | `exists f [|a1; ...; an|]` checks if at least one element of the floatarray satisfies the predicate `f`.
exists [Float.Array] | `exists f [|a1; ...; an|]` checks if at least one element of the floatarray satisfies the predicate `f`.
exists [BytesLabels] | `exists p s` checks if at least one character of `s` satisfies the predicate `p`.
exists [Bytes] | `exists p s` checks if at least one character of `s` satisfies the predicate `p`.
exists [ArrayLabels] | `exists ~f [|a1; ...; an|]` checks if at least one element of the array satisfies the predicate `f`.
exists [Array] | `exists f [|a1; ...; an|]` checks if at least one element of the array satisfies the predicate `f`.
exists2 [Seq] | `exists2 p xs ys` determines whether some pair `(x, y)` of elements drawn synchronously from the sequences `xs` and `ys` satisfies `p x y`.
exists2 [ListLabels] | Same as `ListLabels.exists`, but for a two-argument predicate.
exists2 [List] | Same as `List.exists`, but for a two-argument predicate.
exists2 [ArrayLabels] | Same as `ArrayLabels.exists`, but for a two-argument predicate.
exists2 [Array] | Same as `Array.exists`, but for a two-argument predicate.
exit [Thread] | Terminate prematurely the currently executing thread.
exit [Stdlib] | Terminate the process, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure.
exn_slot_id [Printexc] | `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_name exn` returns the internal name of the constructor used to create the exception value `exn`.
exp [Float] | Exponential.
exp [Complex] | Exponentiation.
exp [Stdlib] | Exponential.
exp2 [Float] | Base 2 exponential function.
expm1 [Float] | `expm1 x` computes `exp x -. 1.0`, giving numerically-accurate results even if `x` is close to `0.0`.
expm1 [Stdlib] | `expm1 x` computes `exp x -. 1.0`, giving numerically-accurate results even if `x` is close to `0.0`.
extend [BytesLabels] | `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.
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 [Filename] | `extension name` is the shortest suffix `ext` of `name0` where:
extension_constructor [Obj] |
extension_id [Obj] |
extension_name [Obj] |
F
failwith [Stdlib] | Raise exception `Failure` with the given string.
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 [Float.ArrayLabels] | Same as `Float.ArrayLabels.sort` or `Float.ArrayLabels.stable_sort`, whichever is faster on typical input.
fast_sort [Float.Array] | Same as `Float.Array.sort` or `Float.Array.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.
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.
fetch_and_add [Atomic] | `fetch_and_add r n` atomically increments the value of `r` by `n`, and returns the current value (before the increment).
fetch_and_add [CamlinternalAtomic] |
field [Obj] |
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] | `fill s pos len c` modifies byte sequence `s` in place, replacing `len` bytes by `c`, starting at `pos`.
fill [StringLabels] | `fill s ~pos ~len c` modifies byte sequence `s` in place, replacing `len` bytes by `c`, starting at `pos`.
fill [Float.ArrayLabels] | `fill a ~pos ~len x` modifies the floatarray `a` in place, storing `x` in elements number `pos` to `pos + len - 1`.
fill [Float.Array] | `fill a pos len x` modifies the floatarray `a` in place, storing `x` in elements number `pos` to `pos + len - 1`.
fill [BytesLabels] | `fill s ~pos ~len c` modifies `s` in place, replacing `len` characters with `c`, starting at `pos`.
fill [Bytes] | `fill s pos len c` modifies `s` in place, replacing `len` characters with `c`, starting at `pos`.
fill [Bigarray.Array3] | Fill the given Bigarray with the given value.
fill [Bigarray.Array2] | Fill the given Bigarray with the given value.
fill [Bigarray.Array1] | Fill the given Bigarray with the given value.
fill [Bigarray.Array0] | Fill the given Bigarray with the given value.
fill [Bigarray.Genarray] | Set all elements of a Bigarray to a given value.
fill [ArrayLabels] | `fill a ~pos ~len x` modifies the array `a` in place, storing `x` in elements number `pos` to `pos + len - 1`.
fill [Array] | `fill a pos len x` modifies the array `a` in place, storing `x` in elements number `pos` to `pos + len - 1`.
filter [Set.S] | `filter f s` returns the set of all elements in `s` that satisfy predicate `f`.
filter [Seq] | `filter p xs` is the sequence of the elements `x` of `xs` that satisfy `p x`.
filter [MoreLabels.Set.S] | `filter ~f s` returns the set of all elements in `s` that satisfy predicate `f`.
filter [MoreLabels.Map.S] | `filter ~f m` returns the map with all the bindings in `m` that satisfy predicate `p`.
filter [Map.S] | `filter f m` returns the map with all the bindings in `m` that satisfy predicate `p`.
filter [ListLabels] | `filter ~f l` returns all the elements of the list `l` that satisfy the predicate `f`.
filter [List] | `filter f l` returns all the elements of the list `l` that satisfy the predicate `f`.
filter_map [Set.S] | `filter_map f s` returns the set of all `v` such that `f x = Some v` for some element `x` of `s`.
filter_map [Seq] | `filter_map f xs` is the sequence of the elements `y` such that `f x = Some y`, where `x` ranges over `xs`.
filter_map [MoreLabels.Set.S] | `filter_map ~f s` returns the set of all `v` such that `f x = Some v` for some element `x` of `s`.
filter_map [MoreLabels.Map.S] | `filter_map ~f m` applies the function `f` to every binding of `m`, and builds a map from the results.
filter_map [Map.S] | `filter_map f m` applies the function `f` to every binding of `m`, and builds a map from the results.
filter_map [ListLabels] | `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 [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_inplace [MoreLabels.Hashtbl.SeededS] |
filter_map_inplace [MoreLabels.Hashtbl.S] |
filter_map_inplace [MoreLabels.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`.
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`.
filter_map_inplace [Ephemeron.SeededS] |
filter_map_inplace [Ephemeron.S] |
filteri [ListLabels] | Same as `ListLabels.filter`, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
filteri [List] | Same as `List.filter`, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
final_tag [Obj] |
finalise [Gc] | `finalise f v` registers `f` as a finalisation function for `v`.
finalise_last [Gc] | same as `Gc.finalise` except the value is not given as argument.
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 [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 [Seq] | `find p xs` returns `Some x`, where `x` is the first element of the sequence `xs` that satisfies `p x`, if there is such an element.
find [MoreLabels.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 [MoreLabels.Map.S] | `find x m` returns the current value of `x` in `m`, or raises `Not_found` if no binding for `x` exists.
find [MoreLabels.Hashtbl.SeededS] |
find [MoreLabels.Hashtbl.S] |
find [MoreLabels.Hashtbl] | `Hashtbl.find tbl x` returns the current binding of `x` in `tbl`, or raises `Not_found` if no such binding exists.
find [Map.S] | `find x m` returns the current value of `x` in `m`, or raises `Not_found` if no binding for `x` exists.
find [ListLabels] | `find ~f l` returns the first element of the list `l` that satisfies the predicate `f`.
find [List] | `find f l` returns the first element of the list `l` that satisfies the predicate `f`.
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 [Ephemeron.Kn.Bucket] | Returns the data of the most-recently added ephemeron with the given keys, or `None` if there is no such ephemeron.
find [Ephemeron.K2.Bucket] | Returns the data of the most-recently added ephemeron with the given keys, or `None` if there is no such ephemeron.
find [Ephemeron.K1.Bucket] | Returns the data of the most-recently added ephemeron with the given key, or `None` if there is no such ephemeron.
find [Ephemeron.SeededS] |
find [Ephemeron.S] |
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] | `Hashtbl.find_all tbl x` returns the list of all data associated with `x` in `tbl`.
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_all [Ephemeron.SeededS] |
find_all [Ephemeron.S] |
find_first [Set.S] | `find_first f s`, where `f` is a monotonically increasing function, returns the lowest element `e` of `s` such that `f e`, or raises `Not_found` if no such element exists.
find_first [MoreLabels.Set.S] | `find_first ~f s`, where `f` is a monotonically increasing function, returns the lowest element `e` of `s` such that `f e`, or raises `Not_found` if no such element exists.
find_first [MoreLabels.Map.S] | `find_first ~f m`, where `f` is a monotonically increasing function, returns the binding of `m` with the lowest key `k` such that `f k`, or raises `Not_found` if no such key exists.
find_first [Map.S] | `find_first f m`, where `f` is a monotonically increasing function, returns the binding of `m` with the lowest key `k` such that `f k`, or raises `Not_found` if no such key exists.
find_first_opt [Set.S] | `find_first_opt f s`, where `f` is a monotonically increasing function, returns an option containing the lowest element `e` of `s` such that `f e`, or `None` if no such element exists.
find_first_opt [MoreLabels.Set.S] | `find_first_opt ~f s`, where `f` is a monotonically increasing function, returns an option containing the lowest element `e` of `s` such that `f e`, or `None` if no such element exists.
find_first_opt [MoreLabels.Map.S] | `find_first_opt ~f m`, where `f` is a monotonically increasing function, returns an option containing the binding of `m` with the lowest key `k` such that `f k`, or `None` if no such key exists.
find_first_opt [Map.S] | `find_first_opt f m`, where `f` is a monotonically increasing function, returns an option containing the binding of `m` with the lowest key `k` such that `f k`, or `None` if no such key exists.
find_last [Set.S] | `find_last f s`, where `f` is a monotonically decreasing function, returns the highest element `e` of `s` such that `f e`, or raises `Not_found` if no such element exists.
find_last [MoreLabels.Set.S] | `find_last ~f s`, where `f` is a monotonically decreasing function, returns the highest element `e` of `s` such that `f e`, or raises `Not_found` if no such element exists.
find_last [MoreLabels.Map.S] | `find_last ~f m`, where `f` is a monotonically decreasing function, returns the binding of `m` with the highest key `k` such that `f k`, or raises `Not_found` if no such key exists.
find_last [Map.S] | `find_last f m`, where `f` is a monotonically decreasing function, returns the binding of `m` with the highest key `k` such that `f k`, or raises `Not_found` if no such key exists.
find_last_opt [Set.S] | `find_last_opt f s`, where `f` is a monotonically decreasing function, returns an option containing the highest element `e` of `s` such that `f e`, or `None` if no such element exists.
find_last_opt [MoreLabels.Set.S] | `find_last_opt ~f s`, where `f` is a monotonically decreasing function, returns an option containing the highest element `e` of `s` such that `f e`, or `None` if no such element exists.
find_last_opt [MoreLabels.Map.S] | `find_last_opt ~f m`, where `f` is a monotonically decreasing function, returns an option containing the binding of `m` with the highest key `k` such that `f k`, or `None` if no such key exists.
find_last_opt [Map.S] | `find_last_opt f m`, where `f` is a monotonically decreasing function, returns an option containing the binding of `m` with the highest key `k` such that `f k`, or `None` if no such key exists.
find_left [Either] | `find_left (Left v)` is `Some v`, `find_left (Right _)` is `None`
find_map [Seq] | `find_map f xs` returns `Some y`, where `x` is the first element of the sequence `xs` such that `f x = Some _`, if there is such an element, and where `y` is defined by `f x = Some y`.
find_map [ListLabels] | `find_map ~f l` applies `f` to the elements of `l` in order, and returns the first result of the form `Some v`, or `None` if none exist.
find_map [List] | `find_map f l` applies `f` to the elements of `l` in order, and returns the first result of the form `Some v`, or `None` if none exist.
find_map [ArrayLabels] | `find_map ~f a` applies `f` to the elements of `a` in order, and returns the first result of the form `Some v`, or `None` if none exist.
find_map [Array] | `find_map f a` applies `f` to the elements of `a` in order, and returns the first result of the form `Some v`, or `None` if none exist.
find_opt [Weak.S] | `find_opt t x` returns an instance of `x` found in `t` or `None` if there is no such element.
find_opt [Set.S] | `find_opt x s` returns the element of `s` equal to `x` (according to `Ord.compare`), or `None` if no such element exists.
find_opt [MoreLabels.Set.S] | `find_opt x s` returns the element of `s` equal to `x` (according to `Ord.compare`), or `None` if no such element exists.
find_opt [MoreLabels.Map.S] | `find_opt x m` returns `Some v` if the current value of `x` in `m` is `v`, or `None` if no binding for `x` exists.
find_opt [MoreLabels.Hashtbl.SeededS] |
find_opt [MoreLabels.Hashtbl.S] |
find_opt [MoreLabels.Hashtbl] | `Hashtbl.find_opt tbl x` returns the current binding of `x` in `tbl`, or `None` if no such binding exists.
find_opt [Map.S] | `find_opt x m` returns `Some v` if the current value of `x` in `m` is `v`, or `None` if no binding for `x` exists.
find_opt [ListLabels] | `find ~f l` returns the first element of the list `l` that satisfies the predicate `f`.
find_opt [List] | `find f l` returns the first element of the list `l` that satisfies the predicate `f`.
find_opt [Hashtbl.SeededS] |
find_opt [Hashtbl.S] |
find_opt [Hashtbl] | `Hashtbl.find_opt tbl x` returns the current binding of `x` in `tbl`, or `None` if no such binding exists.
find_opt [Ephemeron.SeededS] |
find_opt [Ephemeron.S] |
find_opt [ArrayLabels] | `find_opt ~f a` returns the first element of the array `a` that satisfies the predicate `f`, or `None` if there is no value that satisfies `f` in the array `a`.
find_opt [Array] | `find_opt f a` returns the first element of the array `a` that satisfies the predicate `f`, or `None` if there is no value that satisfies `f` in the array `a`.
find_right [Either] | `find_right (Right v)` is `Some v`, `find_right (Left _)` is `None`
first_chars [Str] | `first_chars s n` returns the first `n` characters of `s`.
first_non_constant_constructor_tag [Obj] |
flat_map [Seq] | `flat_map f xs` is equivalent to `concat (map f xs)`.
flatten [ListLabels] | Same as `ListLabels.concat`.
flatten [List] | Same as `List.concat`.
flip [Fun] | `flip f` reverses the argument order of the binary function `f`.
float [Random.State] |
float [Random] | `Random.float bound` returns a random floating-point number between 0 and `bound` (inclusive).
float [Stdlib] | Same as `float_of_int`.
float32 [Bigarray] | See `Bigarray.char`.
float64 [Bigarray] | See `Bigarray.char`.
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 [Stdlib] | Convert an integer to floating-point.
float_of_string [Stdlib] | Same as `float_of_string_opt`, but raise `Failure "float_of_string"` instead of returning `None`.
float_of_string_opt [Stdlib] | Convert the given string to a float.
floor [Float] | Round below to an integer value.
floor [Stdlib] | Round below to an integer value.
flush [Out_channel] | Flush the buffer associated with the given output channel, performing all pending writes on that channel.
flush [Stdlib] | Flush the buffer associated with the given output channel, performing all pending writes on that channel.
flush_all [Out_channel] | Flush all open output channels; ignore errors.
flush_all [Stdlib] | Flush all open output channels; ignore errors.
flush_input [Lexing] | Discard the contents of the buffer and reset the current position to 0.
flush_str_formatter [Format] | Returns the material printed with `str_formatter`, flushes the formatter and resets the corresponding buffer.
flush_symbolic_output_buffer [Format] | `flush_symbolic_output_buffer sob` returns the contents of buffer `sob` and resets buffer `sob`.
fma [Float] | `fma x y z` returns `x * y + z`, with a best effort for computing this expression with a single rounding, using either hardware instructions (providing full IEEE compliance) or a software emulation.
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 [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 [Set.S] | `fold f s init` computes `(f xN ... (f x2 (f x1 init))...)`, where `x1 ... xN` are the elements of `s`, in increasing order.
fold [Result] | `fold ~ok ~error r` is `ok v` if `r` is `Ok v` and `error e` if `r` is `Error e`.
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 [Option] | `fold ~none ~some o` is `none` if `o` is `None` and `some v` if `o` is `Some v`.
fold [MoreLabels.Set.S] | `fold ~f s init` computes `(f xN ... (f x2 (f x1 init))...)`, where `x1 ... xN` are the elements of `s`, in increasing order.
fold [MoreLabels.Map.S] | `fold ~f m ~init` computes `(f kN dN ... (f k1 d1 init)...)`, where `k1 ... kN` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
fold [MoreLabels.Hashtbl.SeededS] |
fold [MoreLabels.Hashtbl.S] |
fold [MoreLabels.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 [Map.S] | `fold f m init` computes `(f kN dN ... (f k1 d1 init)...)`, 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 [Ephemeron.SeededS] |
fold [Ephemeron.S] |
fold [Either] | `fold ~left ~right (Left v)` is `left v`, and `fold ~left ~right (Right v)` is `right v`.
fold_left [String] | `fold_left f x s` computes `f (... (f (f x s.[0]) s.[1]) ...) s.[n-1]`, where `n` is the length of the string `s`.
fold_left [StringLabels] | `fold_left f x s` computes `f (... (f (f x s.[0]) s.[1]) ...) s.[n-1]`, where `n` is the length of the string `s`.
fold_left [Seq] | `fold_left f _ xs` invokes `f _ x` successively for every element `x` of the sequence `xs`, from left to right.
fold_left [ListLabels] | `fold_left ~f ~init [b1; ...; bn]` is `f (... (f (f init b1) b2) ...) bn`.
fold_left [List] | `fold_left f init [b1; ...; bn]` is `f (... (f (f init b1) b2) ...) bn`.
fold_left [Float.ArrayLabels] | `fold_left ~f x ~init` computes `f (... (f (f x init.(0)) init.(1)) ...) init.(n-1)`, where `n` is the length of the floatarray `init`.
fold_left [Float.Array] | `fold_left f x init` computes `f (... (f (f x init.(0)) init.(1)) ...) init.(n-1)`, where `n` is the length of the floatarray `init`.
fold_left [BytesLabels] | `fold_left f x s` computes `f (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1))`, where `n` is the length of `s`.
fold_left [Bytes] | `fold_left f x s` computes `f (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1))`, where `n` is the length of `s`.
fold_left [ArrayLabels] | `fold_left ~f ~init a` computes `f (... (f (f init a.(0)) a.(1)) ...) a.(n-1)`, where `n` is the length of the array `a`.
fold_left [Array] | `fold_left f init a` computes `f (... (f (f init a.(0)) a.(1)) ...) a.(n-1)`, where `n` is the length of the array `a`.
fold_left2 [Seq] | `fold_left2 f _ xs ys` invokes `f _ x y` successively for every pair `(x, y)` of elements drawn synchronously from the sequences `xs` and `ys`.
fold_left2 [ListLabels] | `fold_left2 ~f ~init [a1; ...; an] [b1; ...; bn]` is `f (... (f (f init a1 b1) a2 b2) ...) an bn`.
fold_left2 [List] | `fold_left2 f init [a1; ...; an] [b1; ...; bn]` is `f (... (f (f init a1 b1) a2 b2) ...) an bn`.
fold_left_map [ListLabels] | `fold_left_map` is a combination of `fold_left` and `map` that threads an accumulator through calls to `f`.
fold_left_map [List] | `fold_left_map` is a combination of `fold_left` and `map` that threads an accumulator through calls to `f`.
fold_left_map [ArrayLabels] | `fold_left_map` is a combination of `ArrayLabels.fold_left` and `ArrayLabels.map` that threads an accumulator through calls to `f`.
fold_left_map [Array] | `fold_left_map` is a combination of `Array.fold_left` and `Array.map` that threads an accumulator through calls to `f`.
fold_lefti [Seq] | `fold_lefti f _ xs` invokes `f _ i x` successively for every element `x` located at index `i` of the sequence `xs`.
fold_right [String] | `fold_right f s x` computes `f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...))`, where `n` is the length of the string `s`.
fold_right [StringLabels] | `fold_right f s x` computes `f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...))`, where `n` is the length of the string `s`.
fold_right [ListLabels] | `fold_right ~f [a1; ...; an] ~init` is `f a1 (f a2 (... (f an init) ...))`.
fold_right [List] | `fold_right f [a1; ...; an] init` is `f a1 (f a2 (... (f an init) ...))`.
fold_right [Float.ArrayLabels] | `fold_right f a init` computes `f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))`, where `n` is the length of the floatarray `a`.
fold_right [Float.Array] | `fold_right f a init` computes `f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))`, where `n` is the length of the floatarray `a`.
fold_right [BytesLabels] | `fold_right f s x` computes `f (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...))`, where `n` is the length of `s`.
fold_right [Bytes] | `fold_right f s x` computes `f (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...))`, where `n` is the length of `s`.
fold_right [ArrayLabels] | `fold_right ~f a ~init` computes `f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))`, where `n` is the length of the array `a`.
fold_right [Array] | `fold_right f a init` computes `f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))`, where `n` is the length of the array `a`.
fold_right2 [ListLabels] | `fold_right2 ~f [a1; ...; an] [b1; ...; bn] ~init` is `f a1 b1 (f a2 b2 (... (f an bn init) ...))`.
fold_right2 [List] | `fold_right2 f [a1; ...; an] [b1; ...; bn] init` is `f a1 b1 (f a2 b2 (... (f an bn init) ...))`.
for_all [String] | `for_all p s` checks if all characters in `s` satisfy the predicate `p`.
for_all [StringLabels] | `for_all p s` checks if all characters in `s` satisfy the predicate `p`.
for_all [Set.S] | `for_all f s` checks if all elements of the set satisfy the predicate `f`.
for_all [Seq] | `for_all p xs` determines whether all elements `x` of the sequence `xs` satisfy `p x`.
for_all [MoreLabels.Set.S] | `for_all ~f s` checks if all elements of the set satisfy the predicate `f`.
for_all [MoreLabels.Map.S] | `for_all ~f m` checks if all the bindings of the map satisfy the predicate `f`.
for_all [Map.S] | `for_all f m` checks if all the bindings of the map satisfy the predicate `f`.
for_all [ListLabels] | `for_all ~f [a1; ...; an]` checks if all elements of the list satisfy the predicate `f`.
for_all [List] | `for_all f [a1; ...; an]` checks if all elements of the list satisfy the predicate `f`.
for_all [Float.ArrayLabels] | `for_all ~f [|a1; ...; an|]` checks if all elements of the floatarray satisfy the predicate `f`.
for_all [Float.Array] | `for_all f [|a1; ...; an|]` checks if all elements of the floatarray satisfy the predicate `f`.
for_all [Either] | `for_all ~left ~right (Left v)` is `left v`, and `for_all ~left ~right (Right v)` is `right v`.
for_all [BytesLabels] | `for_all p s` checks if all characters in `s` satisfy the predicate `p`.
for_all [Bytes] | `for_all p s` checks if all characters in `s` satisfy the predicate `p`.
for_all [ArrayLabels] | `for_all ~f [|a1; ...; an|]` checks if all elements of the array satisfy the predicate `f`.
for_all [Array] | `for_all f [|a1; ...; an|]` checks if all elements of the array satisfy the predicate `f`.
for_all2 [Seq] | `for_all2 p xs ys` determines whether all pairs `(x, y)` of elements drawn synchronously from the sequences `xs` and `ys` satisfy `p x y`.
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_all2 [ArrayLabels] | Same as `ArrayLabels.for_all`, but for a two-argument predicate.
for_all2 [Array] | Same as `Array.for_all`, but for a two-argument predicate.
force [CamlinternalLazy] |
force [Lazy] | `force x` forces the suspension `x` and returns its result.
force_lazy_block [CamlinternalLazy] |
force_newline [Format] | Force a new line in the current pretty-printing box.
force_val [CamlinternalLazy] |
force_val [Lazy] | `force_val x` forces the suspension `x` and returns its result.
force_val_lazy_block [CamlinternalLazy] |
forever [Seq] | `forever f` is an infinite sequence where every element is produced (on demand) by the function call `f()`.
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 [Stdlib] | `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_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 writing to the corresponding output channel `oc`.
formatter_of_out_functions [Format] | `formatter_of_out_functions out_funs` returns a new formatter that writes with the set of output functions `out_funs`.
formatter_of_symbolic_output_buffer [Format] | `formatter_of_symbolic_output_buffer sob` returns a symbolic formatter that outputs to `symbolic_output_buffer` `sob`.
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 [Float] | `frexp f` returns the pair of the significant and the exponent of `f`.
frexp [Stdlib] | `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 `Scanf.Scanning.in_channel` formatted input channel which reads from the regular `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 `Scanf.Scanning.open_in` above.
from_file_bin [Scanf.Scanning] | An alias for `Scanf.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 `Scanf.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 `Scanf.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` evaluates `v` first (as any function would) and returns an already-forced suspension of its result.
fscanf [Scanf] |
fst [Stdlib] | Return the first component of a pair.
fstat [UnixLabels.LargeFile] |
fstat [UnixLabels] | Return the information for the file associated with the given descriptor.
fstat [Unix.LargeFile] |
fstat [Unix] | Return the information for the file associated with the given descriptor.
fsync [UnixLabels] | Flush file buffers to disk.
fsync [Unix] | Flush file buffers to disk.
ftruncate [UnixLabels.LargeFile] | See `ftruncate`.
ftruncate [UnixLabels] | Truncates the file corresponding to the given descriptor to the given size.
ftruncate [Unix.LargeFile] | See `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_int [Random.State] |
full_int [Random] | `Random.full_int bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
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.
G
genarray_of_array0 [Bigarray] | Return the generic Bigarray corresponding to the given zero-dimensional Bigarray.
genarray_of_array1 [Bigarray] | Return the generic Bigarray corresponding to the given one-dimensional Bigarray.
genarray_of_array2 [Bigarray] | Return the generic Bigarray corresponding to the given two-dimensional Bigarray.
genarray_of_array3 [Bigarray] | Return the generic Bigarray corresponding to the given three-dimensional Bigarray.
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 [String] | `get s i` is the character at index `i` in `s`.
get [StringLabels] | `get s i` is the character at index `i` in `s`.
get [Option] | `get o` is `v` if `o` is `Some v` and raise otherwise.
get [Gc] | Return the current values of the GC parameters in a `control` record.
get [Float.ArrayLabels] | `get a n` returns the element number `n` of floatarray `a`.
get [Float.Array] | `get a n` returns the element number `n` of floatarray `a`.
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.Array0] | `Array0.get a` returns the only element in `a`.
get [Bigarray.Genarray] | Read an element of a generic Bigarray.
get [Atomic] | Get the current value of the atomic reference.
get [ArrayLabels] | `get a n` returns the element number `n` of array `a`.
get [Array] | `get a n` returns the element number `n` of array `a`.
get [CamlinternalAtomic] |
get_all_formatter_output_functions [Format] |
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_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 `Stdlib.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 `Stdlib.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 [Result] | `get_error r` is `e` if `r` is `Error e` and raise otherwise.
get_formatter_out_functions [Format] | Return the current output functions of the pretty-printer, including line splitting and indentation functions.
get_formatter_output_functions [Format] | Return the current output functions of the standard pretty-printer.
get_formatter_stag_functions [Format] | Return the current semantic tag operation functions of the standard pretty-printer.
get_formatter_tag_functions [Format] |
get_geometry [Format] | Return the current geometry of the formatter
get_int16_be [String] | `get_int16_be b i` is `b`'s big-endian signed 16-bit integer starting at character index `i`.
get_int16_be [StringLabels] | `get_int16_be b i` is `b`'s big-endian signed 16-bit integer starting at character index `i`.
get_int16_be [BytesLabels] | `get_int16_be b i` is `b`'s big-endian signed 16-bit integer starting at byte index `i`.
get_int16_be [Bytes] | `get_int16_be b i` is `b`'s big-endian signed 16-bit integer starting at byte index `i`.
get_int16_le [String] | `get_int16_le b i` is `b`'s little-endian signed 16-bit integer starting at character index `i`.
get_int16_le [StringLabels] | `get_int16_le b i` is `b`'s little-endian signed 16-bit integer starting at character index `i`.
get_int16_le [BytesLabels] | `get_int16_le b i` is `b`'s little-endian signed 16-bit integer starting at byte index `i`.
get_int16_le [Bytes] | `get_int16_le b i` is `b`'s little-endian signed 16-bit integer starting at byte index `i`.
get_int16_ne [String] | `get_int16_ne b i` is `b`'s native-endian signed 16-bit integer starting at character index `i`.
get_int16_ne [StringLabels] | `get_int16_ne b i` is `b`'s native-endian signed 16-bit integer starting at character index `i`.
get_int16_ne [BytesLabels] | `get_int16_ne b i` is `b`'s native-endian signed 16-bit integer starting at byte index `i`.
get_int16_ne [Bytes] | `get_int16_ne b i` is `b`'s native-endian signed 16-bit integer starting at byte index `i`.
get_int32_be [String] | `get_int32_be b i` is `b`'s big-endian 32-bit integer starting at character index `i`.
get_int32_be [StringLabels] | `get_int32_be b i` is `b`'s big-endian 32-bit integer starting at character index `i`.
get_int32_be [BytesLabels] | `get_int32_be b i` is `b`'s big-endian 32-bit integer starting at byte index `i`.
get_int32_be [Bytes] | `get_int32_be b i` is `b`'s big-endian 32-bit integer starting at byte index `i`.
get_int32_le [String] | `get_int32_le b i` is `b`'s little-endian 32-bit integer starting at character index `i`.
get_int32_le [StringLabels] | `get_int32_le b i` is `b`'s little-endian 32-bit integer starting at character index `i`.
get_int32_le [BytesLabels] | `get_int32_le b i` is `b`'s little-endian 32-bit integer starting at byte index `i`.
get_int32_le [Bytes] | `get_int32_le b i` is `b`'s little-endian 32-bit integer starting at byte index `i`.
get_int32_ne [String] | `get_int32_ne b i` is `b`'s native-endian 32-bit integer starting at character index `i`.
get_int32_ne [StringLabels] | `get_int32_ne b i` is `b`'s native-endian 32-bit integer starting at character index `i`.
get_int32_ne [BytesLabels] | `get_int32_ne b i` is `b`'s native-endian 32-bit integer starting at byte index `i`.
get_int32_ne [Bytes] | `get_int32_ne b i` is `b`'s native-endian 32-bit integer starting at byte index `i`.
get_int64_be [String] | `get_int64_be b i` is `b`'s big-endian 64-bit integer starting at character index `i`.
get_int64_be [StringLabels] | `get_int64_be b i` is `b`'s big-endian 64-bit integer starting at character index `i`.
get_int64_be [BytesLabels] | `get_int64_be b i` is `b`'s big-endian 64-bit integer starting at byte index `i`.
get_int64_be [Bytes] | `get_int64_be b i` is `b`'s big-endian 64-bit integer starting at byte index `i`.
get_int64_le [String] | `get_int64_le b i` is `b`'s little-endian 64-bit integer starting at character index `i`.
get_int64_le [StringLabels] | `get_int64_le b i` is `b`'s little-endian 64-bit integer starting at character index `i`.
get_int64_le [BytesLabels] | `get_int64_le b i` is `b`'s little-endian 64-bit integer starting at byte index `i`.
get_int64_le [Bytes] | `get_int64_le b i` is `b`'s little-endian 64-bit integer starting at byte index `i`.
get_int64_ne [String] | `get_int64_ne b i` is `b`'s native-endian 64-bit integer starting at character index `i`.
get_int64_ne [StringLabels] | `get_int64_ne b i` is `b`'s native-endian 64-bit integer starting at character index `i`.
get_int64_ne [BytesLabels] | `get_int64_ne b i` is `b`'s native-endian 64-bit integer starting at byte index `i`.
get_int64_ne [Bytes] | `get_int64_ne b i` is `b`'s native-endian 64-bit integer starting at byte index `i`.
get_int8 [String] | `get_int8 b i` is `b`'s signed 8-bit integer starting at character index `i`.
get_int8 [StringLabels] | `get_int8 b i` is `b`'s signed 8-bit integer starting at character index `i`.
get_int8 [BytesLabels] | `get_int8 b i` is `b`'s signed 8-bit integer starting at byte index `i`.
get_int8 [Bytes] | `get_int8 b i` is `b`'s signed 8-bit integer starting at byte index `i`.
get_key [Obj.Ephemeron] | Same as `Stdlib.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 `Stdlib.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 tag-marking operations.
get_max_boxes [Format] | Returns the maximum number of pretty-printing boxes allowed before ellipsis.
get_max_indent [Format] | Return the maximum indentation limit (in characters).
get_method [CamlinternalOO] |
get_method_label [CamlinternalOO] |
get_method_labels [CamlinternalOO] |
get_minor_free [Gc] | Return the current size of the free space inside the minor heap.
get_ok [Result] | `get_ok r` is `v` if `r` is `Ok v` and raise otherwise.
get_print_tags [Format] | Return the current status of tag-printing operations.
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_next_slot [Printexc] | `get_raw_backtrace_next_slot slot` returns the next slot inlined, if any.
get_raw_backtrace_slot [Printexc] | `get_raw_backtrace_slot bckt pos` returns the slot in position `pos` in the backtrace `bckt`.
get_state [Random] | Return the current state of the generator used by the basic functions.
get_symbolic_output_buffer [Format] | `get_symbolic_output_buffer sob` returns the contents of buffer `sob`.
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_uint16_be [String] | `get_uint16_be b i` is `b`'s big-endian unsigned 16-bit integer starting at character index `i`.
get_uint16_be [StringLabels] | `get_uint16_be b i` is `b`'s big-endian unsigned 16-bit integer starting at character index `i`.
get_uint16_be [BytesLabels] | `get_uint16_be b i` is `b`'s big-endian unsigned 16-bit integer starting at byte index `i`.
get_uint16_be [Bytes] | `get_uint16_be b i` is `b`'s big-endian unsigned 16-bit integer starting at byte index `i`.
get_uint16_le [String] | `get_uint16_le b i` is `b`'s little-endian unsigned 16-bit integer starting at character index `i`.
get_uint16_le [StringLabels] | `get_uint16_le b i` is `b`'s little-endian unsigned 16-bit integer starting at character index `i`.
get_uint16_le [BytesLabels] | `get_uint16_le b i` is `b`'s little-endian unsigned 16-bit integer starting at byte index `i`.
get_uint16_le [Bytes] | `get_uint16_le b i` is `b`'s little-endian unsigned 16-bit integer starting at byte index `i`.
get_uint16_ne [String] | `get_uint16_ne b i` is `b`'s native-endian unsigned 16-bit integer starting at character index `i`.
get_uint16_ne [StringLabels] | `get_uint16_ne b i` is `b`'s native-endian unsigned 16-bit integer starting at character index `i`.
get_uint16_ne [BytesLabels] | `get_uint16_ne b i` is `b`'s native-endian unsigned 16-bit integer starting at byte index `i`.
get_uint16_ne [Bytes] | `get_uint16_ne b i` is `b`'s native-endian unsigned 16-bit integer starting at byte index `i`.
get_uint8 [String] | `get_uint8 b i` is `b`'s unsigned 8-bit integer starting at character index `i`.
get_uint8 [StringLabels] | `get_uint8 b i` is `b`'s unsigned 8-bit integer starting at character index `i`.
get_uint8 [BytesLabels] | `get_uint8 b i` is `b`'s unsigned 8-bit integer starting at byte index `i`.
get_uint8 [Bytes] | `get_uint8 b i` is `b`'s unsigned 8-bit integer starting at byte index `i`.
get_utf_16be_uchar [String] | `get_utf_16be_uchar b i` decodes an UTF-16BE character at index `i` in `b`.
get_utf_16be_uchar [StringLabels] | `get_utf_16be_uchar b i` decodes an UTF-16BE character at index `i` in `b`.
get_utf_16be_uchar [BytesLabels] | `get_utf_16be_uchar b i` decodes an UTF-16BE character at index `i` in `b`.
get_utf_16be_uchar [Bytes] | `get_utf_16be_uchar b i` decodes an UTF-16BE character at index `i` in `b`.
get_utf_16le_uchar [String] | `get_utf_16le_uchar b i` decodes an UTF-16LE character at index `i` in `b`.
get_utf_16le_uchar [StringLabels] | `get_utf_16le_uchar b i` decodes an UTF-16LE character at index `i` in `b`.
get_utf_16le_uchar [BytesLabels] | `get_utf_16le_uchar b i` decodes an UTF-16LE character at index `i` in `b`.
get_utf_16le_uchar [Bytes] | `get_utf_16le_uchar b i` decodes an UTF-16LE character at index `i` in `b`.
get_utf_8_uchar [String] | `get_utf_8_uchar b i` decodes an UTF-8 character at index `i` in `b`.
get_utf_8_uchar [StringLabels] | `get_utf_8_uchar b i` decodes an UTF-8 character at index `i` in `b`.
get_utf_8_uchar [BytesLabels] | `get_utf_8_uchar b i` decodes an UTF-8 character at index `i` in `b`.
get_utf_8_uchar [Bytes] | `get_utf_8_uchar b i` decodes an UTF-8 character at index `i` in `b`.
get_value [Semaphore.Counting] | `get_value s` returns the current value of semaphore `s`.
get_variable [CamlinternalOO] |
get_variables [CamlinternalOO] |
getaddrinfo [UnixLabels] | `getaddrinfo host service opts` returns a list of `UnixLabels.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, unless the process has special privileges.
getenv [Unix] | Return the value associated to a variable in the process environment, unless the process has special privileges.
getenv [Sys] | Return the value associated to a variable in the process environment.
getenv_opt [Sys] | Return the value associated to a variable in the process environment or `None` if the variable is unbound.
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.
getgrgid [Unix] | Find an entry in `group` with the given group id.
getgrnam [UnixLabels] | Find an entry in `group` with the given name.
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.
gethostbyaddr [Unix] | Find an entry in `hosts` with the given address.
gethostbyname [UnixLabels] | Find an entry in `hosts` with the given name.
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.
getprotobyname [Unix] | Find an entry in `protocols` with the given name.
getprotobynumber [UnixLabels] | Find an entry in `protocols` with the given protocol number.
getprotobynumber [Unix] | Find an entry in `protocols` with the given protocol number.
getpwnam [UnixLabels] | Find an entry in `passwd` with the given name.
getpwnam [Unix] | Find an entry in `passwd` with the given name.
getpwuid [UnixLabels] | Find an entry in `passwd` with the given user id.
getpwuid [Unix] | Find an entry in `passwd` with the given user id.
getservbyname [UnixLabels] | Find an entry in `services` with the given name.
getservbyname [Unix] | Find an entry in `services` with the given name.
getservbyport [UnixLabels] | Find an entry in `services` with the given service number.
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 `UnixLabels.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 `UnixLabels.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 `UnixLabels.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.
group [Seq] | Provided the function `eq` defines an equality on elements, `group eq xs` is the sequence of the maximal runs of adjacent duplicate elements of the sequence `xs`.
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).
guard [Event] | `guard fn` returns the event that, when synchronized, computes `fn()` and behaves as the resulting event.
H
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_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.SeededHashedType] | A seeded hashing function on keys.
hash [MoreLabels.Hashtbl.HashedType] | A hashing function on keys.
hash [MoreLabels.Hashtbl] | `Hashtbl.hash x` associates a nonnegative integer to any value of any type.
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 [Float] | The hash function for floating-point numbers.
hash_param [MoreLabels.Hashtbl] | `Hashtbl.hash_param meaningful total x` computes a hash value for `x`, with the same properties as for `hash`.
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.
huge_fallback_count [Gc] | Return the number of times we tried to map huge pages and had to fall back to small pages.
hypot [Float] | `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.
hypot [Stdlib] | `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`.
ibprintf [Printf] | Same as `Printf.bprintf`, but does not print anything.
id [Thread] | Return the identifier of the given thread.
id [Oo] | Return an integer identifying this object, unique for the current execution of the program.
id [Obj.Extension_constructor] |
id [Fun] | `id` is the identity function.
ifprintf [Printf] | Same as `Printf.fprintf`, but does not print anything.
ifprintf [Format] | Same as `fprintf` above, but does not print anything.
ignore [Stdlib] | Discard the value of its argument and return `()`.
ikbprintf [Printf] | Same as `kbprintf` above, but does not print anything.
ikfprintf [Printf] | Same as `kfprintf` above, but does not print anything.
ikfprintf [Format] | Same as `kfprintf` above, but does not print anything.
in_channel_length [Stdlib.LargeFile] |
in_channel_length [Stdlib] | Return the size (number of characters) of the regular file on which the given channel is opened.
in_channel_of_descr [UnixLabels] | Create an input channel reading from the given descriptor.
in_channel_of_descr [Unix] | Create an input channel reading from the given descriptor.
incr [Atomic] | `incr r` atomically increments the value of `r` by `1`.
incr [Stdlib] | Increment the integer contained in the given reference.
incr [CamlinternalAtomic] |
index [String] | `index s c` is `String.index_from` `s 0 c`.
index [StringLabels] | `index s c` is `String.index_from` `s 0 c`.
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] | `index_from s i c` is the index of the first occurrence of `c` in `s` after position `i`.
index_from [StringLabels] | `index_from s i c` is the index of the first occurrence of `c` in `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`.
index_from_opt [String] | `index_from_opt s i c` is the index of the first occurrence of `c` in `s` after position `i` (if any).
index_from_opt [StringLabels] | `index_from_opt s i c` is the index of the first occurrence of `c` in `s` after position `i` (if any).
index_from_opt [BytesLabels] | `index_from_opt s i c` returns the index of the first occurrence of byte `c` in `s` after position `i` or `None` if `c` does not occur in `s` after position `i`.
index_from_opt [Bytes] | `index_from_opt s i c` returns the index of the first occurrence of byte `c` in `s` after position `i` or `None` if `c` does not occur in `s` after position `i`.
index_opt [String] | `index_opt s c` is `String.index_from_opt` `s 0 c`.
index_opt [StringLabels] | `index_opt s c` is `String.index_from_opt` `s 0 c`.
index_opt [BytesLabels] | `index_opt s c` returns the index of the first occurrence of byte `c` in `s` or `None` if `c` does not occur in `s`.
index_opt [Bytes] | `index_opt s c` returns the index of the first occurrence of byte `c` in `s` or `None` if `c` does not occur in `s`.
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 [Float] | Positive infinity.
infinity [Stdlib] | Positive infinity.
infix_tag [Obj] |
info [Obj.Closure] |
inherits [CamlinternalOO] |
init [String] | `init n f` is a string of length `n` with index `i` holding the character `f i` (called in increasing index order).
init [StringLabels] | `init n ~f` is a string of length `n` with index `i` holding the character `f i` (called in increasing index order).
init [Seq] | `init n f` is the sequence `f 0; f 1; ...; f (n-1)`.
init [Random] | Initialize the generator, using the argument as a seed.
init [ListLabels] | `init ~len ~f` is `f 0; f 1; ...; f (len-1)`, evaluated left to right.
init [List] | `init len f` is `f 0; f 1; ...; f (len-1)`, evaluated left to right.
init [Float.ArrayLabels] | `init n ~f` returns a fresh floatarray of length `n`, with element number `i` initialized to the result of `f i`.
init [Float.Array] | `init n f` returns a fresh floatarray of length `n`, with element number `i` initialized to the result of `f i`.
init [BytesLabels] | `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 [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 [Bigarray.Array3] | `Array3.init kind layout dim1 dim2 dim3 f` returns a new Bigarray `b` of three dimensions, whose size is `dim1` in the first dimension, `dim2` in the second dimension, and `dim3` in the third.
init [Bigarray.Array2] | `Array2.init kind layout dim1 dim2 f` returns a new Bigarray `b` of two dimensions, whose size is `dim2` in the first dimension and `dim2` in the second dimension.
init [Bigarray.Array1] | `Array1.init kind layout dim f` returns a new Bigarray `b` of one dimension, whose size is `dim`.
init [Bigarray.Array0] | `Array0.init kind layout v` behaves like `Array0.create kind layout` except that the element is additionally initialized to the value `v`.
init [Bigarray.Genarray] | `Genarray.init kind layout dimensions f` returns a new Bigarray `b` 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`).
init [ArrayLabels] | `init n ~f` returns a fresh array of length `n`, with element number `i` initialized to the result of `f i`.
init [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_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.
input [In_channel] | `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 [Stdlib] | `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_all [In_channel] | `input_all ic` reads all remaining data from `ic`.
input_binary_int [Stdlib] | Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel.
input_byte [In_channel] | Same as `In_channel.input_char`, but return the 8-bit integer representing the character.
input_byte [Stdlib] | Same as `input_char`, but return the 8-bit integer representing the character.
input_char [In_channel] | Read one character from the given input channel.
input_char [Stdlib] | Read one character from the given input channel.
input_line [In_channel] | `input_line ic` reads characters from `ic` until a newline or the end of file is reached.
input_line [Stdlib] | Read characters from the given input channel, until a newline character is encountered.
input_value [Stdlib] | 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 [Bigarray] | See `Bigarray.char`.
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 [Bigarray] | See `Bigarray.char`.
int64 [Random.State] |
int64 [Random] | `Random.int64 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int64 [Bigarray] | See `Bigarray.char`.
int8_signed [Bigarray] | See `Bigarray.char`.
int8_unsigned [Bigarray] | See `Bigarray.char`.
int_of_char [Stdlib] | Return the ASCII code of the argument.
int_of_float [Stdlib] | Truncate the given floating-point number to an integer.
int_of_string [Stdlib] | Same as `int_of_string_opt`, but raise `Failure "int_of_string"` instead of returning `None`.
int_of_string_opt [Stdlib] | Convert the given string to an integer.
int_size [Sys] | Size of `int`, in bits.
int_tag [Obj] |
inter [Set.S] | Set intersection.
inter [MoreLabels.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`.
interleave [Seq] | `interleave xs ys` is the sequence that begins with the first element of `xs`, continues with the first element of `ys`, and so on.
ints [Seq] | `ints i` is the infinite sequence of the integers beginning at `i` and counting up.
inv [Complex] | Multiplicative inverse (`1/z`).
invalid_arg [Stdlib] | Raise exception `Invalid_argument` with the given string.
is_block [Obj] |
is_buffered [Out_channel] | `is_buffered oc` returns whether the channel `oc` is buffered (see `Out_channel.set_buffered`).
is_char [Uchar] | `is_char u` is `true` if and only if `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 [Set.S] | Test whether a set is empty or not.
is_empty [Seq] | `is_empty xs` determines whether the sequence `xs` is empty.
is_empty [Queue] | Return `true` if the given queue is empty, `false` otherwise.
is_empty [MoreLabels.Set.S] | Test whether a set is empty or not.
is_empty [MoreLabels.Map.S] | Test whether a map is empty or not.
is_empty [Map.S] | Test whether a map is empty or not.
is_error [Result] | `is_error r` is `true` if and only if `r` is `Error _`.
is_finite [Float] | `is_finite x` is `true` if and only if `x` is finite i.e., not infinite and not `Float.nan`.
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_inet6_addr [UnixLabels] | Whether the given `inet_addr` is an IPv6 address.
is_inet6_addr [Unix] | Whether the given `inet_addr` is an IPv6 address.
is_infinite [Float] | `is_infinite x` is `true` if and only if `x` is `Float.infinity` or `Float.neg_infinity`.
is_inline [Printexc.Slot] | `is_inline slot` is `true` when `slot` refers to a call that got inlined by the compiler, and `false` when it comes from any other context.
is_int [Obj] |
is_integer [Float] | `is_integer x` is `true` if and only if `x` is an integer.
is_left [Either] | `is_left (Left v)` is `true`, `is_left (Right v)` is `false`.
is_nan [Float] | `is_nan x` is `true` if and only if `x` is not a number (see `Float.nan`).
is_native [Dynlink] | `true` if the program is native, `false` if the program is bytecode.
is_none [Option] | `is_none o` is `true` if and only if `o` is `None`.
is_ok [Result] | `is_ok r` is `true` if and only if `r` is `Ok _`.
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 [MoreLabels.Hashtbl] | Return `true` if the tables are currently created in randomized mode by default, `false` otherwise.
is_randomized [Hashtbl] | Return `true` if the tables are currently created in randomized mode by default, `false` otherwise.
is_relative [Filename] | Return `true` if the file name is relative to the current directory, `false` if it is absolute (i.e.
is_right [Either] | `is_right (Left v)` is `false`, `is_right (Right v)` is `true`.
is_some [Option] | `is_some o` is `true` if and only if `o` is `Some o`.
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` if and only if `n` is a Unicode scalar value (i.e.
is_valid_utf_16be [String] | `is_valid_utf_16be b` is `true` if and only if `b` contains valid UTF-16BE data.
is_valid_utf_16be [StringLabels] | `is_valid_utf_16be b` is `true` if and only if `b` contains valid UTF-16BE data.
is_valid_utf_16be [BytesLabels] | `is_valid_utf_16be b` is `true` if and only if `b` contains valid UTF-16BE data.
is_valid_utf_16be [Bytes] | `is_valid_utf_16be b` is `true` if and only if `b` contains valid UTF-16BE data.
is_valid_utf_16le [String] | `is_valid_utf_16le b` is `true` if and only if `b` contains valid UTF-16LE data.
is_valid_utf_16le [StringLabels] | `is_valid_utf_16le b` is `true` if and only if `b` contains valid UTF-16LE data.
is_valid_utf_16le [BytesLabels] | `is_valid_utf_16le b` is `true` if and only if `b` contains valid UTF-16LE data.
is_valid_utf_16le [Bytes] | `is_valid_utf_16le b` is `true` if and only if `b` contains valid UTF-16LE data.
is_valid_utf_8 [String] | `is_valid_utf_8 b` is `true` if and only if `b` contains valid UTF-8 data.
is_valid_utf_8 [StringLabels] | `is_valid_utf_8 b` is `true` if and only if `b` contains valid UTF-8 data.
is_valid_utf_8 [BytesLabels] | `is_valid_utf_8 b` is `true` if and only if `b` contains valid UTF-8 data.
is_valid_utf_8 [Bytes] | `is_valid_utf_8 b` is `true` if and only if `b` contains valid UTF-8 data.
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 [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] | `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 [Set.S] | `iter f s` applies `f` in turn to all elements of `s`.
iter [Seq] | `iter f xs` invokes `f x` successively for every element `x` of the sequence `xs`, from left to right.
iter [Result] | `iter f r` is `f v` if `r` is `Ok v` and `()` otherwise.
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 [Option] | `iter f o` is `f v` if `o` is `Some v` and `()` otherwise.
iter [MoreLabels.Set.S] | `iter ~f s` applies `f` in turn to all elements of `s`.
iter [MoreLabels.Map.S] | `iter ~f m` applies `f` to all bindings in map `m`.
iter [MoreLabels.Hashtbl.SeededS] |
iter [MoreLabels.Hashtbl.S] |
iter [MoreLabels.Hashtbl] | `Hashtbl.iter ~f tbl` applies `f` to all bindings in table `tbl`.
iter [Map.S] | `iter f m` applies `f` to all bindings in map `m`.
iter [ListLabels] | `iter ~f [a1; ...; an]` applies function `f` in turn to `a1; ...; an`.
iter [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 [Float.ArrayLabels] | `iter ~f a` applies function `f` in turn to all the elements of `a`.
iter [Float.Array] | `iter f a` applies function `f` in turn to all the elements of `a`.
iter [Ephemeron.SeededS] |
iter [Ephemeron.S] |
iter [Either] | `iter ~left ~right (Left v)` is `left v`, and `iter ~left ~right (Right v)` is `right v`.
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] | `iter ~f a` applies function `f` in turn to all the elements of `a`.
iter [Array] | `iter f a` applies function `f` in turn to all the elements of `a`.
iter2 [Seq] | `iter2 f xs ys` invokes `f x y` successively for every pair `(x, y)` of elements drawn synchronously from the sequences `xs` and `ys`.
iter2 [ListLabels] | `iter2 ~f [a1; ...; an] [b1; ...; bn]` calls in turn `f a1 b1; ...; f an bn`.
iter2 [List] | `iter2 f [a1; ...; an] [b1; ...; bn]` calls in turn `f a1 b1; ...; f an bn`.
iter2 [Float.ArrayLabels] | `Array.iter2 ~f a b` applies function `f` to all the elements of `a` and `b`.
iter2 [Float.Array] | `Array.iter2 f a b` applies function `f` to all the elements of `a` and `b`.
iter2 [ArrayLabels] | `iter2 ~f a b` applies function `f` to all the elements of `a` and `b`.
iter2 [Array] | `iter2 f a b` applies function `f` to all the elements of `a` and `b`.
iter_error [Result] | `iter_error f r` is `f e` if `r` is `Error e` and `()` otherwise.
iterate [Seq] | `iterate f x` is the infinite sequence whose elements are `x`, `f x`, `f (f x)`, and so on.
iteri [String] | `iteri` is like `String.iter`, but the function is also given the corresponding character index.
iteri [StringLabels] | `iteri` is like `StringLabels.iter`, but the function is also given the corresponding character index.
iteri [Seq] | `iteri f xs` invokes `f i x` successively for every element `x` located at index `i` in the sequence `xs`.
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 [Float.ArrayLabels] | Same as `Float.ArrayLabels.iter`, but the function is applied with the index of the element as first argument, and the element itself as second argument.
iteri [Float.Array] | Same as `Float.Array.iter`, but the function is applied with the index of the element as first argument, and the element itself as second argument.
iteri [BytesLabels] | Same as `BytesLabels.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 to 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.
join [Result] | `join rr` is `r` if `rr` is `Ok r` and `rr` if `rr` is `Error _`.
join [Option] | `join oo` is `Some v` if `oo` is `Some (Some v)` and `None` otherwise.
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.
kdprintf [Format] | Same as `Format.dprintf` above, but instead of returning immediately, passes the suspended printer to its first argument at the end of printing.
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 [Thread] | This function was supposed to terminate prematurely the thread whose handle is given.
kill [UnixLabels] | `kill ~pid ~signal` sends signal number `signal` to the process with id `pid`.
kill [Unix] | `kill pid signal` sends signal number `signal` to the process with id `pid`.
kind [Bigarray.Array3] | Return the kind of the given Bigarray.
kind [Bigarray.Array2] | Return the kind of the given Bigarray.
kind [Bigarray.Array1] | Return the kind of the given Bigarray.
kind [Bigarray.Array0] | Return the kind of the given Bigarray.
kind [Bigarray.Genarray] | Return the kind of the given Bigarray.
kind_size_in_bytes [Bigarray] | `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_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 Bigarray.
layout [Bigarray.Array2] | Return the layout of the given Bigarray.
layout [Bigarray.Array1] | Return the layout of the given Bigarray.
layout [Bigarray.Array0] | Return the layout of the given Bigarray.
layout [Bigarray.Genarray] | Return the layout of the given Bigarray.
lazy_from_fun [Lazy] |
lazy_from_val [Lazy] |
lazy_is_val [Lazy] |
lazy_tag [Obj] |
ldexp [Float] | `ldexp x n` returns `x *. 2 ** n`.
ldexp [Stdlib] | `ldexp x n` returns `x *. 2 ** n`.
left [Either] | `left v` is `Left v`.
length [Weak] | `Weak.length ar` returns the length (number of elements) of `ar`.
length [String] | `length s` is the length (number of bytes/characters) of `s`.
length [StringLabels] | `length s` is the length (number of bytes/characters) of `s`.
length [Stack] | Return the number of elements in a stack.
length [Seq] | `length xs` is the length of the sequence `xs`.
length [Queue] | Return the number of elements in a queue.
length [Out_channel] | Return the size (number of characters) of the regular file on which the given channel is opened.
length [Obj.Ephemeron] | return the number of keys
length [MoreLabels.Hashtbl.SeededS] |
length [MoreLabels.Hashtbl.S] |
length [MoreLabels.Hashtbl] | `Hashtbl.length tbl` returns the number of bindings in `tbl`.
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 [In_channel] | Return the size (number of characters) of the regular file on which the given channel is opened.
length [Hashtbl.SeededS] |
length [Hashtbl.S] |
length [Hashtbl] | `Hashtbl.length tbl` returns the number of bindings in `tbl`.
length [Float.ArrayLabels] | Return the length (number of elements) of the given floatarray.
length [Float.Array] | Return the length (number of elements) of the given floatarray.
length [Ephemeron.Kn.Bucket] | Returns an upper bound on the length of the bucket.
length [Ephemeron.K2.Bucket] | Returns an upper bound on the length of the bucket.
length [Ephemeron.K1.Bucket] | Returns an upper bound on the length of the bucket.
length [Ephemeron.SeededS] |
length [Ephemeron.S] |
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.
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.
link [UnixLabels] | `link ?follow ~src ~dst` creates a hard link named `dst` to the file named `src`.
link [Unix] | `link ?follow src dst` creates a hard link named `dst` to the file named `src`.
listen [UnixLabels] | Set up a socket for receiving connection requests.
listen [Unix] | Set up a socket for receiving connection requests.
lnot [Stdlib] | Bitwise logical negation.
loadfile [Dynlink] | In bytecode: load the given bytecode object file (`.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.
lock [Mutex] | Lock the given mutex.
lockf [UnixLabels] | `lockf fd ~mode ~len` puts a lock on a region of the file opened as `fd`.
lockf [Unix] | `lockf fd mode len` puts a lock on a region of the file opened as `fd`.
log [Float] | Natural logarithm.
log [Complex] | Natural logarithm (in base `e`).
log [Stdlib] | Natural logarithm.
log10 [Float] | Base 10 logarithm.
log10 [Stdlib] | Base 10 logarithm.
log1p [Float] | `log1p x` computes `log(1.0 +. x)` (natural logarithm), giving numerically-accurate results even if `x` is close to `0.0`.
log1p [Stdlib] | `log1p x` computes `log(1.0 +. x)` (natural logarithm), giving numerically-accurate results even if `x` is close to `0.0`.
log2 [Float] | Base 2 logarithm.
logand [Nativeint] | Bitwise logical and.
logand [Int64] | Bitwise logical and.
logand [Int32] | Bitwise logical and.
logand [Int] | `logand x y` is the bitwise logical and of `x` and `y`.
lognot [Nativeint] | Bitwise logical negation.
lognot [Int64] | Bitwise logical negation.
lognot [Int32] | Bitwise logical negation.
lognot [Int] | `lognot x` is the bitwise logical negation of `x`.
logor [Nativeint] | Bitwise logical or.
logor [Int64] | Bitwise logical or.
logor [Int32] | Bitwise logical or.
logor [Int] | `logor x y` is the bitwise logical or of `x` and `y`.
logxor [Nativeint] | Bitwise logical exclusive or.
logxor [Int64] | Bitwise logical exclusive or.
logxor [Int32] | Bitwise logical exclusive or.
logxor [Int] | `logxor x y` is the bitwise logical exclusive or of `x` and `y`.
lookup_tables [CamlinternalOO] |
lowercase [String] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
lowercase [StringLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
lowercase [Char] | Convert the given character to its equivalent lowercase character, using the ISO Latin-1 (8859-1) character set.
lowercase [BytesLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
lowercase [Bytes] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
lowercase_ascii [String] | `lowercase_ascii s` is `s` with all uppercase letters translated to lowercase, using the US-ASCII character set.
lowercase_ascii [StringLabels] | `lowercase_ascii s` is `s` with all uppercase letters translated to lowercase, using the US-ASCII character set.
lowercase_ascii [Char] | Convert the given character to its equivalent lowercase character, using the US-ASCII character set.
lowercase_ascii [BytesLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set.
lowercase_ascii [Bytes] | Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set.
lseek [UnixLabels.LargeFile] | See `lseek`.
lseek [UnixLabels] | Set the current position for a file descriptor, and return the resulting offset (from the beginning of the file).
lseek [Unix.LargeFile] | See `lseek`.
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.
M
magic [Obj] |
main_program_units [Dynlink] | Return the list of compilation units that form the main program (i.e.
major [Gc] | Do a minor collection and finish the current major collection cycle.
major_slice [Gc] | `major_slice n` Do a minor collection and a slice of major collection.
make [Semaphore.Binary] | `make b` returns a new binary semaphore.
make [Semaphore.Counting] | `make n` returns a new counting semaphore, with initial value `n`.
make [String] | `make n c` is a string of length `n` with each index holding the character `c`.
make [StringLabels] | `make n c` is a string of length `n` with each index holding the character `c`.
make [Random.State] | Create a new state and initialize it with the given seed.
make [Float.ArrayLabels] | `make n x` returns a fresh floatarray of length `n`, initialized with `x`.
make [Float.Array] | `make n x` returns a fresh floatarray of length `n`, initialized with `x`.
make [Ephemeron.Kn.Bucket] | Create a new bucket.
make [Ephemeron.Kn] | Same as `Ephemeron.K1.make`
make [Ephemeron.K2.Bucket] | Create a new bucket.
make [Ephemeron.K2] | Same as `Ephemeron.K1.make`
make [Ephemeron.K1.Bucket] | Create a new bucket.
make [Ephemeron.K1] | `Ephemeron.K1.make k d` creates an ephemeron with key `k` and data `d`.
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 [Atomic] | Create an atomic reference.
make [ArrayLabels] | `make n x` returns a fresh array of length `n`, initialized with `x`.
make [Array] | `make n x` returns a fresh array of length `n`, initialized with `x`.
make [CamlinternalAtomic] |
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 outputs with function `out`, and flushes with function `flush`.
make_iprintf [CamlinternalFormat] |
make_lexer [Genlex] | Construct the lexer function.
make_matrix [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] | `make_matrix dimx dimy e` returns a two-dimensional array (an array of arrays) with first dimension `dimx` and second dimension `dimy`.
make_printf [CamlinternalFormat] |
make_self_init [Random.State] | Create a new state and initialize it with a system-dependent low-entropy seed.
make_symbolic_output_buffer [Format] | `make_symbolic_output_buffer ()` returns a fresh buffer for symbolic output.
map [String] | `map f s` is the string resulting from applying `f` to all the characters of `s` in increasing order.
map [StringLabels] | `map f s` is the string resulting from applying `f` to all the characters of `s` in increasing order.
map [Set.S] | `map f s` is the set whose elements are `f a0`,`f a1`...
map [Seq] | `map f xs` is the image of the sequence `xs` through the transformation `f`.
map [Result] | `map f r` is `Ok (f v)` if `r` is `Ok v` and `r` if `r` is `Error _`.
map [Option] | `map f o` is `None` if `o` is `None` and `Some (f v)` is `o` is `Some v`.
map [MoreLabels.Set.S] | `map ~f s` is the set whose elements are `f a0`,`f a1`...
map [MoreLabels.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 [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] | `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] | `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 [Lazy] | `map f x` returns a suspension that, when forced, forces `x` and applies `f` to its value.
map [Float.ArrayLabels] | `map ~f a` applies function `f` to all the elements of `a`, and builds a floatarray with the results returned by `f`.
map [Float.Array] | `map f a` applies function `f` to all the elements of `a`, and builds a floatarray with the results returned by `f`.
map [Either] | `map ~left ~right (Left v)` is `Left (left v)`, `map ~left ~right (Right v)` is `Right (right v)`.
map [BytesLabels] | `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 [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] | `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.(length a - 1) |]`.
map [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.(length a - 1) |]`.
map2 [Seq] | `map2 f xs ys` is the sequence of the elements `f x y`, where the pairs `(x, y)` are drawn synchronously from the sequences `xs` and `ys`.
map2 [ListLabels] | `map2 ~f [a1; ...; an] [b1; ...; bn]` is `[f a1 b1; ...; f an bn]`.
map2 [List] | `map2 f [a1; ...; an] [b1; ...; bn]` is `[f a1 b1; ...; f an bn]`.
map2 [Float.ArrayLabels] | `map2 ~f a b` applies function `f` to all the elements of `a` and `b`, and builds a floatarray with the results returned by `f`: `[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|]`.
map2 [Float.Array] | `map2 f a b` applies function `f` to all the elements of `a` and `b`, and builds a floatarray with the results returned by `f`: `[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|]`.
map2 [ArrayLabels] | `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.(length a - 1) b.(length b - 1)|]`.
map2 [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.(length a - 1) b.(length b - 1)|]`.
map_error [Result] | `map_error f r` is `Error (f e)` if `r` is `Error e` and `r` if `r` is `Ok _`.
map_file [UnixLabels] | Memory mapping of a file as a Bigarray.
map_file [Unix] | Memory mapping of a file as a Bigarray.
map_from_array [Float.ArrayLabels] | `map_from_array ~f a` applies function `f` to all the elements of `a`, and builds a floatarray with the results returned by `f`.
map_from_array [Float.Array] | `map_from_array f a` applies function `f` to all the elements of `a`, and builds a floatarray with the results returned by `f`.
map_left [Either] | `map_left f e` is `Left (f v)` if `e` is `Left v` and `e` if `e` is `Right _`.
map_product [Seq] | The sequence `map_product f xs ys` is the image through `f` of the Cartesian product of the sequences `xs` and `ys`.
map_right [Either] | `map_right f e` is `Right (f v)` if `e` is `Right v` and `e` if `e` is `Left _`.
map_to_array [Float.ArrayLabels] | `map_to_array ~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.(length a - 1) |]`.
map_to_array [Float.Array] | `map_to_array 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.(length a - 1) |]`.
map_val [Lazy] | `map_val f x` applies `f` directly if `x` is already forced, otherwise it behaves as `map f x`.
mapi [String] | `mapi f s` is like `String.map` but the index of the character is also passed to `f`.
mapi [StringLabels] | `mapi ~f s` is like `StringLabels.map` but the index of the character is also passed to `f`.
mapi [Seq] | `mapi` is analogous to `map`, but applies the function `f` to an index and an element.
mapi [MoreLabels.Map.S] | Same as `MoreLabels.Map.S.map`, but the function receives as arguments both the key and the associated value for each binding of the map.
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 [Float.ArrayLabels] | Same as `Float.ArrayLabels.map`, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapi [Float.Array] | Same as `Float.Array.map`, but the function is applied to the index of the element as first argument, 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.
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 in between: `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 [Nativeint] | Return the greater of the two arguments.
max [Int64] | Return the greater of the two arguments.
max [Int32] | Return the greater of the two arguments.
max [Int] | Return the greater of the two arguments.
max [Float] | `max x y` returns the maximum of `x` and `y`.
max [Stdlib] | Return the greater of the two arguments.
max_array_length [Sys] | Maximum length of a normal array (i.e.
max_binding [MoreLabels.Map.S] | Same as `MoreLabels.Map.S.min_binding`, but returns the binding with the largest key in the given map.
max_binding [Map.S] | Same as `Map.S.min_binding`, but returns the binding with the largest key in the given map.
max_binding_opt [MoreLabels.Map.S] | Same as `MoreLabels.Map.S.min_binding_opt`, but returns the binding with the largest key in the given map.
max_binding_opt [Map.S] | Same as `Map.S.min_binding_opt`, but returns the binding with the largest key in the given map.
max_elt [Set.S] | Same as `Set.S.min_elt`, but returns the largest element of the given set.
max_elt [MoreLabels.Set.S] | Same as `MoreLabels.Set.S.min_elt`, but returns the largest element of the given set.
max_elt_opt [Set.S] | Same as `Set.S.min_elt_opt`, but returns the largest element of the given set.
max_elt_opt [MoreLabels.Set.S] | Same as `MoreLabels.Set.S.min_elt_opt`, but returns the largest element of the given set.
max_ephe_length [Obj.Ephemeron] | Maximum length of an ephemeron, ie the maximum number of keys an ephemeron could contain
max_float [Float] | The largest positive finite value of type `float`.
max_float [Stdlib] | The largest positive finite value of type `float`.
max_floatarray_length [Sys] | Maximum length of a floatarray.
max_int [Nativeint] | The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
max_int [Int64] | The greatest representable 64-bit integer, 263 - 1.
max_int [Int32] | The greatest representable 32-bit integer, 231 - 1.
max_int [Int] | `max_int` is the greatest representable integer, `2{^[Sys.int_size - 1]} - 1`.
max_int [Stdlib] | The greatest representable integer.
max_num [Float] | `max_num x y` returns the maximum of `x` and `y` treating `nan` as missing values.
max_string_length [Sys] | Maximum length of strings and byte sequences.
mem [Weak.S] | `mem t x` returns `true` if there is at least one instance of `x` in `t`, false otherwise.
mem [Set.S] | `mem x s` tests whether `x` belongs to the set `s`.
mem [MoreLabels.Set.S] | `mem x s` tests whether `x` belongs to the set `s`.
mem [MoreLabels.Map.S] | `mem x m` returns `true` if `m` contains a binding for `x`, and `false` otherwise.
mem [MoreLabels.Hashtbl.SeededS] |
mem [MoreLabels.Hashtbl.S] |
mem [MoreLabels.Hashtbl] | `Hashtbl.mem tbl x` checks if `x` is bound in `tbl`.
mem [Map.S] | `mem x m` returns `true` if `m` contains a binding for `x`, and `false` otherwise.
mem [ListLabels] | `mem a ~set` is true if and only if `a` is equal to an element of `set`.
mem [List] | `mem a set` is true if and only if `a` is equal to an element of `set`.
mem [Hashtbl.SeededS] |
mem [Hashtbl.S] |
mem [Hashtbl] | `Hashtbl.mem tbl x` checks if `x` is bound in `tbl`.
mem [Float.ArrayLabels] | `mem a ~set` is true if and only if there is an element of `set` that is structurally equal to `a`, i.e.
mem [Float.Array] | `mem a set` is true if and only if there is an element of `set` that is structurally equal to `a`, i.e.
mem [Ephemeron.SeededS] |
mem [Ephemeron.S] |
mem [ArrayLabels] | `mem a ~set` is true if and only if `a` is structurally equal to an element of `l` (i.e.
mem [Array] | `mem a set` is true if and only if `a` is structurally equal to an element of `l` (i.e.
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.
mem_ieee [Float.ArrayLabels] | Same as `Float.ArrayLabels.mem`, but uses IEEE equality instead of structural equality.
mem_ieee [Float.Array] | Same as `Float.Array.mem`, but uses IEEE equality instead of structural equality.
memoize [Seq] | The sequence `memoize xs` has the same elements as the sequence `xs`.
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 list 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 [MoreLabels.Map.S] | `merge ~f m1 m2` computes a map whose keys are a subset of the keys of `m1` and of `m2`.
merge [Map.S] | `merge f m1 m2` computes a map whose keys are a subset of the 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 containing 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 containing all the elements of `l1` and `l2`.
min [Uchar] | `min` is U+0000.
min [Nativeint] | Return the smaller of the two arguments.
min [Int64] | Return the smaller of the two arguments.
min [Int32] | Return the smaller of the two arguments.
min [Int] | Return the smaller of the two arguments.
min [Float] | `min x y` returns the minimum of `x` and `y`.
min [Stdlib] | Return the smaller of the two arguments.
min_binding [MoreLabels.Map.S] | Return the binding with the smallest key in a given map (with respect to the `Ord.compare` ordering), or raise `Not_found` if the map is empty.
min_binding [Map.S] | Return the binding with the smallest key in a given map (with respect to the `Ord.compare` ordering), or raise `Not_found` if the map is empty.
min_binding_opt [MoreLabels.Map.S] | Return the binding with the smallest key in the given map (with respect to the `Ord.compare` ordering), or `None` if the map is empty.
min_binding_opt [Map.S] | Return the binding with the smallest key in the given map (with respect to the `Ord.compare` ordering), or `None` if the map is empty.
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_elt [MoreLabels.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_elt_opt [Set.S] | Return the smallest element of the given set (with respect to the `Ord.compare` ordering), or `None` if the set is empty.
min_elt_opt [MoreLabels.Set.S] | Return the smallest element of the given set (with respect to the `Ord.compare` ordering), or `None` if the set is empty.
min_float [Float] | The smallest positive, non-zero, non-denormalized value of type `float`.
min_float [Stdlib] | The smallest positive, non-zero, non-denormalized value of type `float`.
min_int [Nativeint] | The smallest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
min_int [Int64] | The smallest representable 64-bit integer, -263.
min_int [Int32] | The smallest representable 32-bit integer, -231.
min_int [Int] | `min_int` is the smallest representable integer, `-2{^[Sys.int_size - 1]}`.
min_int [Stdlib] | The smallest representable integer.
min_max [Float] | `min_max x y` is `(min x y, max x y)`, just more efficient.
min_max_num [Float] | `min_max_num x y` is `(min_num x y, max_num x y)`, just more efficient.
min_num [Float] | `min_num x y` returns the minimum of `x` and `y` treating `nan` as missing values.
minor [Gc] | Trigger a minor collection.
minor_words [Gc] | Number of words allocated in the minor heap since the program was started.
minus_one [Nativeint] | The native integer -1.
minus_one [Int64] | The 64-bit integer -1.
minus_one [Int32] | The 32-bit integer -1.
minus_one [Int] | `minus_one` is the integer `-1`.
minus_one [Float] | The floating-point -1.
mkdir [UnixLabels] | Create a directory with the given permissions (see `UnixLabels.umask`).
mkdir [Unix] | Create a directory with the given permissions (see `Unix.umask`).
mkdir [Sys] | Create a directory with the given permissions.
mkfifo [UnixLabels] | Create a named pipe with the given permissions (see `UnixLabels.umask`).
mkfifo [Unix] | Create a named pipe with the given permissions (see `Unix.umask`).
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_float [Stdlib] | `mod_float a b` returns the remainder of `a` with respect to `b`.
modf [Float] | `modf f` returns the pair of the fractional and integral part of `f`.
modf [Stdlib] | `modf f` returns the pair of the fractional and integral part of `f`.
mul [Nativeint] | Multiplication.
mul [Int64] | Multiplication.
mul [Int32] | Multiplication.
mul [Int] | `mul x y` is the multiplication `x * y`.
mul [Float] | Floating-point multiplication.
mul [Complex] | Multiplication
N
name [Printexc.Slot] | `name slot` returns the name of the function or definition enclosing the location referred to by the slot.
name [Obj.Extension_constructor] |
name_of_input [Scanf.Scanning] | `Scanning.name_of_input ic` returns the name of the character source for the given `Scanf.Scanning.in_channel` formatted input channel.
nan [Float] | A special floating-point value denoting the result of an undefined operation such as `0.0 /. 0.0`.
nan [Stdlib] | A special floating-point value denoting the result of an undefined operation such as `0.0 /. 0.0`.
narrow [CamlinternalOO] |
nativebits [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.
nativebits [Random] | `Random.nativebits ()` returns 32 or 64 random bits (depending on the bit width of the platform) as an integer between `Nativeint.min_int` and `Nativeint.max_int`.
nativeint [Random.State] |
nativeint [Random] | `Random.nativeint bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
nativeint [Bigarray] | See `Bigarray.char`.
neg [Nativeint] | Unary negation.
neg [Int64] | Unary negation.
neg [Int32] | Unary negation.
neg [Int] | `neg x` is `~-x`.
neg [Float] | Unary negation.
neg [Complex] | Unary negation.
neg_infinity [Float] | Negative infinity.
neg_infinity [Stdlib] | Negative infinity.
negate [Fun] | `negate p` is the negation of the predicate function `p`.
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] |
next [Stream] | Return the first element of the stream and remove it from the stream.
next_after [Float] | `next_after x y` returns the next representable floating-point value following `x` in the direction of `y`.
nice [UnixLabels] | Change the process priority.
nice [Unix] | Change the process priority.
no_scan_tag [Obj] |
none [Option] | `none` is `None`.
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`.
not [Bool] | `not b` is the boolean negation of `b`.
not [Stdlib] | 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 Bigarray `a`.
nth_opt [ListLabels] | Return the `n`-th element of the given list.
nth_opt [List] | Return the `n`-th element of the given list.
null [Filename] | `null` is `"/dev/null"` on POSIX and `"NUL"` on Windows.
null_tracker [Gc.Memprof] | Default callbacks simply return `None` or `()`
num_dims [Bigarray.Genarray] | Return the number of dimensions of the given Bigarray.
O
obj [Obj] |
object_tag [Obj] |
ocaml_release [Sys] |
ocaml_version [Sys] | `ocaml_version` is the version of OCaml.
of_array [Bigarray.Array3] | Build a three-dimensional Bigarray initialized from the given array of arrays of arrays.
of_array [Bigarray.Array2] | Build a two-dimensional Bigarray initialized from the given array of arrays.
of_array [Bigarray.Array1] | Build a one-dimensional Bigarray initialized from the given array.
of_bytes [String] | Return a new string that contains the same bytes as the given byte sequence.
of_bytes [Stream] | Return the stream of the characters of the bytes parameter.
of_bytes [StringLabels] | Return a new string that contains the same bytes as the given byte sequence.
of_channel [Stream] | Return the stream of the characters read from the input channel.
of_char [Uchar] | `of_char c` is `c` as a Unicode character.
of_dispenser [Seq] | `of_dispenser it` is the sequence of the elements produced by the dispenser `it`.
of_float [Nativeint] | Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0).
of_float [Int64] | Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0).
of_float [Int32] | Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0).
of_float [Int] | `of_float x` truncates `x` to an integer.
of_int [Uchar] | `of_int i` is `i` as a 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_int [Float] | Convert an integer to floating-point.
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 [Set.S] | `of_list l` creates a set from a list of elements.
of_list [MoreLabels.Set.S] | `of_list l` creates a set from a list of elements.
of_list [Float.ArrayLabels] | `of_list l` returns a fresh floatarray containing the elements of `l`.
of_list [Float.Array] | `of_list l` returns a fresh floatarray containing the elements of `l`.
of_list [ArrayLabels] | `of_list l` returns a fresh array containing the elements of `l`.
of_list [Array] | `of_list l` returns a fresh array containing the elements of `l`.
of_nativeint [Int64] | Convert the given native integer (type `nativeint`) to a 64-bit integer (type `int64`).
of_seq [String] | `of_seq s` is a string made of the sequence's characters.
of_seq [StringLabels] | `of_seq s` is a string made of the sequence's characters.
of_seq [Stack] | Create a stack from the sequence.
of_seq [Set.S] | Build a set from the given bindings
of_seq [Queue] | Create a queue from a sequence.
of_seq [MoreLabels.Set.S] | Build a set from the given bindings
of_seq [MoreLabels.Map.S] | Build a map from the given bindings
of_seq [MoreLabels.Hashtbl.SeededS] |
of_seq [MoreLabels.Hashtbl.S] |
of_seq [MoreLabels.Hashtbl] | Build a table from the given bindings.
of_seq [Map.S] | Build a map from the given bindings
of_seq [ListLabels] | Create a list from a sequence.
of_seq [List] | Create a list from a sequence.
of_seq [Hashtbl.SeededS] |
of_seq [Hashtbl.S] |
of_seq [Hashtbl] | Build a table from the given bindings.
of_seq [Float.ArrayLabels] | Create an array from the generator.
of_seq [Float.Array] | Create an array from the generator.
of_seq [Ephemeron.SeededS] |
of_seq [Ephemeron.S] |
of_seq [BytesLabels] | Create a string from the generator
of_seq [Bytes] | Create a string from the generator
of_seq [Buffer] | Create a buffer from the generator
of_seq [ArrayLabels] | Create an array from the generator
of_seq [Array] | Create an array from the generator
of_string [Stream] | Return the stream of the characters of the string parameter.
of_string [Nativeint] | Convert the given string to a native integer.
of_string [Int64] | Convert the given string to a 64-bit integer.
of_string [Int32] | Convert the given string to a 32-bit integer.
of_string [Float] | Convert the given string to a float.
of_string [BytesLabels] | Return a new byte sequence that contains the same bytes as the given string.
of_string [Bytes] | Return a new byte sequence that contains the same bytes as the given string.
of_string_opt [Nativeint] | Same as `of_string`, but return `None` instead of raising.
of_string_opt [Int64] | Same as `of_string`, but return `None` instead of raising.
of_string_opt [Int32] | Same as `of_string`, but return `None` instead of raising.
of_string_opt [Float] | Same as `of_string`, but returns `None` instead of raising.
of_val [Obj.Extension_constructor] |
of_value [Bigarray.Array0] | Build a zero-dimensional Bigarray initialized from the given value.
ok [Result] | `ok v` is `Ok v`.
once [Seq] | The sequence `once xs` has the same elements as the sequence `xs`.
one [Nativeint] | The native integer 1.
one [Int64] | The 64-bit integer 1.
one [Int32] | The 32-bit integer 1.
one [Int] | `one` is the integer `1`.
one [Float] | The floating-point 1.
one [Complex] | The complex number `1`.
opaque_identity [Sys] | For the purposes of optimization, `opaque_identity` behaves like an unknown (and thus possibly side-effecting) function.
open_bin [Out_channel] | Open the named file for writing, and return a new output channel on that file, positioned at the beginning of the file.
open_bin [In_channel] | Open the named file for reading, and return a new input channel on that file, positioned at the beginning of the file.
open_box [Format] | `pp_open_box ppf d` opens a new compacting pretty-printing box with offset `d` in the formatter `ppf`.
open_box_of_string [CamlinternalFormat] |
open_connection [ThreadUnix] |
open_connection [UnixLabels] | Connect to a server at the given address.
open_connection [Unix] | Connect to a server at the given address.
open_gen [Out_channel] | `open_gen mode perm filename` opens the named file for writing, as described above.
open_gen [In_channel] | `open_gen mode perm filename` opens the named file for reading, as described above.
open_hbox [Format] | `pp_open_hbox ppf ()` opens a new 'horizontal' pretty-printing box.
open_hovbox [Format] | `pp_open_hovbox ppf d` opens a new 'horizontal-or-vertical' pretty-printing box with offset `d`.
open_hvbox [Format] | `pp_open_hvbox ppf d` opens a new 'horizontal/vertical' pretty-printing box with offset `d`.
open_in [Scanf.Scanning] | `Scanning.open_in fname` returns a `Scanf.Scanning.in_channel` formatted input channel for bufferized reading in text mode from file `fname`.
open_in [Stdlib] | Open the named file for reading, and return a new input channel on that file, positioned at the beginning of the file.
open_in_bin [Scanf.Scanning] | `Scanning.open_in_bin fname` returns a `Scanf.Scanning.in_channel` formatted input channel for bufferized reading in binary mode from file `fname`.
open_in_bin [Stdlib] | Same as `open_in`, but the file is opened in binary mode, so that no translation takes place during reads.
open_in_gen [Stdlib] | `open_in_gen mode perm filename` opens the named file for reading, as described above.
open_out [Stdlib] | Open the named file for writing, and return a new output channel on that file, positioned at the beginning of the file.
open_out_bin [Stdlib] | Same as `open_out`, but the file is opened in binary mode, so that no translation takes place during writes.
open_out_gen [Stdlib] | `open_out_gen mode perm filename` opens the named file for writing, as described above.
open_process [ThreadUnix] |
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_args [UnixLabels] | Same as `UnixLabels.open_process_args_out`, but redirects both the standard input and standard output of the new process to pipes connected to the two returned channels.
open_process_args [Unix] | Same as `Unix.open_process_args_out`, but redirects both the standard input and standard output of the new process to pipes connected to the two returned channels.
open_process_args_full [UnixLabels] | Similar to `UnixLabels.open_process_args`, but the third argument specifies the environment passed to the new process.
open_process_args_full [Unix] | Similar to `Unix.open_process_args`, but the third argument specifies the environment passed to the new process.
open_process_args_in [UnixLabels] | `open_process_args_in prog args` runs the program `prog` with arguments `args`.
open_process_args_in [Unix] | `open_process_args_in prog args` runs the program `prog` with arguments `args`.
open_process_args_out [UnixLabels] | Same as `UnixLabels.open_process_args_in`, but redirect the standard input of the new process to a pipe.
open_process_args_out [Unix] | Same as `Unix.open_process_args_in`, but redirect the standard input of the new process to a pipe.
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 [ThreadUnix] |
open_process_in [UnixLabels] | High-level pipe and process management.
open_process_in [Unix] | High-level pipe and process management.
open_process_out [ThreadUnix] |
open_process_out [UnixLabels] | Same as `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_stag [Format] | `pp_open_stag ppf t` opens the semantic tag named `t`.
open_tag [Format] |
open_tbox [Format] | `open_tbox ()` opens a new tabulation box.
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_text [Out_channel] | Same as `Out_channel.open_bin`, but the file is opened in text mode, so that newline translation takes place during writes.
open_text [In_channel] | Same as `In_channel.open_bin`, but the file is opened in text mode, so that newline translation takes place during reads.
open_vbox [Format] | `pp_open_vbox ppf 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.
os_type [Sys] | Operating system currently executing the OCaml program.
out_channel_length [Stdlib.LargeFile] |
out_channel_length [Stdlib] | Return the size (number of characters) of the regular file on which the given channel is opened.
out_channel_of_descr [UnixLabels] | Create an output channel writing on the given descriptor.
out_channel_of_descr [Unix] | Create an output channel writing on the given descriptor.
out_of_heap_tag [Obj] |
output [Out_channel] | `output oc buf pos len` writes `len` characters from byte sequence `buf`, starting at offset `pos`, to the given output channel `oc`.
output [Digest] | Write a digest on the given output channel.
output [Stdlib] | `output oc buf pos len` writes `len` characters from byte sequence `buf`, starting at offset `pos`, to the given output channel `oc`.
output_acc [CamlinternalFormat] |
output_binary_int [Stdlib] | Write one integer in binary format (4 bytes, big-endian) on the given output channel.
output_buffer [Buffer] | `output_buffer oc b` writes the current contents of buffer `b` on the output channel `oc`.
output_byte [Out_channel] | Write one 8-bit integer (as the single character with that code) on the given output channel.
output_byte [Stdlib] | Write one 8-bit integer (as the single character with that code) on the given output channel.
output_bytes [Out_channel] | Write the byte sequence on the given output channel.
output_bytes [Stdlib] | Write the byte sequence on the given output channel.
output_char [Out_channel] | Write the character on the given output channel.
output_char [Stdlib] | Write the character on the given output channel.
output_string [Out_channel] | Write the string on the given output channel.
output_string [Stdlib] | Write the string on the given output channel.
output_substring [Out_channel] | Same as `Out_channel.output` but take a string as argument instead of a byte sequence.
output_substring [Stdlib] | Same as `output` but take a string as argument instead of a byte sequence.
output_value [Stdlib] | Write the representation of a structured value of any type to a channel.
over_max_boxes [Format] | Tests if the maximum number of pretty-printing boxes allowed have already been opened.
P
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 [Arg] | `Arg.parse speclist anon_fun usage_msg` parses the command line.
parse_and_expand_argv_dynamic [Arg] | Same as `Arg.parse_argv_dynamic`, except that the `argv` argument is a reference and may be updated during the parsing of `Expand` arguments.
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_dynamic [Arg] | Same as `Arg.parse`, except that the `speclist` argument is a reference and may be updated during the parsing.
parse_expand [Arg] | Same as `Arg.parse`, except that the `Expand` arguments are allowed and the `Arg.current` reference is not updated.
partition [Set.S] | `partition f s` returns a pair of sets `(s1, s2)`, where `s1` is the set of all the elements of `s` that satisfy the predicate `f`, and `s2` is the set of all the elements of `s` that do not satisfy `f`.
partition [Seq] | `partition p xs` returns a pair of the subsequence of the elements of `xs` that satisfy `p` and the subsequence of the elements of `xs` that do not satisfy `p`.
partition [MoreLabels.Set.S] | `partition ~f s` returns a pair of sets `(s1, s2)`, where `s1` is the set of all the elements of `s` that satisfy the predicate `f`, and `s2` is the set of all the elements of `s` that do not satisfy `f`.
partition [MoreLabels.Map.S] | `partition ~f m` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `m` that satisfy the predicate `f`, and `m2` is the map with all the bindings of `m` that do not satisfy `f`.
partition [Map.S] | `partition f m` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `m` that satisfy the predicate `f`, and `m2` is the map with all the bindings of `m` that do not satisfy `f`.
partition [ListLabels] | `partition ~f l` returns a pair of lists `(l1, l2)`, where `l1` is the list of all the elements of `l` that satisfy the predicate `f`, and `l2` is the list of all the elements of `l` that do not satisfy `f`.
partition [List] | `partition f l` returns a pair of lists `(l1, l2)`, where `l1` is the list of all the elements of `l` that satisfy the predicate `f`, and `l2` is the list of all the elements of `l` that do not satisfy `f`.
partition_map [Seq] | `partition_map f xs` returns a pair of sequences `(ys, zs)`, where:
partition_map [ListLabels] | `partition_map f l` returns a pair of lists `(l1, l2)` such that, for each element `x` of the input list `l`: if `f x` is `Left y1`, then `y1` is in `l1`, and, if `f x` is `Right y2`, then `y2` is in `l2`. The output elements are included in `l1` and `l2` in the same relative order as the corresponding input elements in `l`.
partition_map [List] | `partition_map f l` returns a pair of lists `(l1, l2)` such that, for each element `x` of the input list `l`: if `f x` is `Left y1`, then `y1` is in `l1`, and, if `f x` is `Right y2`, then `y2` is in `l2`. The output elements are included in `l1` and `l2` in the same relative order as the corresponding input elements in `l`.
pause [UnixLabels] | Wait until a non-ignored, non-blocked signal is delivered.
pause [Unix] | Wait until a non-ignored, non-blocked signal is delivered.
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 `Queue.Empty` if the queue is empty.
peek_opt [Queue] | `peek_opt q` returns the first element in queue `q`, without removing it from the queue, or returns `None` if the queue is empty.
pi [Float] | The constant pi.
pipe [ThreadUnix] |
pipe [UnixLabels] | Create a pipe.
pipe [Unix] | Create a pipe.
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.
pop [Stack] | `pop s` removes and returns the topmost element in stack `s`, or raises `Stack.Empty` if the stack is empty.
pop [Queue] | `pop` is a synonym for `take`.
pop_opt [Stack] | `pop_opt s` removes and returns the topmost element in stack `s`, or returns `None` if the stack is empty.
pos [Out_channel] | Return the current writing position for the given channel.
pos [In_channel] | Return the current reading position for the given channel.
pos_in [Stdlib.LargeFile] |
pos_in [Stdlib] | Return the current reading position for the given channel.
pos_out [Stdlib.LargeFile] |
pos_out [Stdlib] | Return the current writing position for the given channel.
pow [Float] | Exponentiation.
pow [Complex] | Power function.
pp_close_box [Format] |
pp_close_stag [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] |
pp_get_formatter_output_functions [Format] |
pp_get_formatter_stag_functions [Format] |
pp_get_formatter_tag_functions [Format] |
pp_get_geometry [Format] |
pp_get_margin [Format] |
pp_get_mark_tags [Format] |
pp_get_max_boxes [Format] |
pp_get_max_indent [Format] |
pp_get_print_tags [Format] |
pp_open_box [Format] |
pp_open_hbox [Format] |
pp_open_hovbox [Format] |
pp_open_hvbox [Format] |
pp_open_stag [Format] |
pp_open_tag [Format] |
pp_open_tbox [Format] |
pp_open_vbox [Format] |
pp_over_max_boxes [Format] |
pp_print_as [Format] |
pp_print_bool [Format] |
pp_print_break [Format] |
pp_print_bytes [Format] |
pp_print_char [Format] |
pp_print_custom_break [Format] | `pp_print_custom_break ppf ~fits:(s1, n, s2) ~breaks:(s3, m, s4)` emits a custom break hint: the pretty-printer may split the line at this point.
pp_print_cut [Format] |
pp_print_either [Format] | `pp_print_either ~left ~right ppf e` prints `e` on `ppf` using `left` if `e` is `Either.Left _` and `right` if `e` is `Either.Right _`.
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_option [Format] | `pp_print_option ?none pp_v ppf o` prints `o` on `ppf` using `pp_v` if `o` is `Some v` and `none` if it is `None`.
pp_print_result [Format] | `pp_print_result ~ok ~error ppf r` prints `r` on `ppf` using `ok` if `r` is `Ok _` and `error` if `r` is `Error _`.
pp_print_seq [Format] | `pp_print_seq ?pp_sep pp_v ppf s` prints items of sequence `s`, using `pp_v` to print each item, and calling `pp_sep` between items (`pp_sep` defaults to `Format.pp_print_cut`.
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 using `Format.pp_print_space` and `Format.pp_force_newline`.
pp_safe_set_geometry [Format] |
pp_set_all_formatter_output_functions [Format] |
pp_set_ellipsis_text [Format] |
pp_set_formatter_out_channel [Format] | Redirecting the standard formatter output
pp_set_formatter_out_functions [Format] |
pp_set_formatter_output_functions [Format] |
pp_set_formatter_stag_functions [Format] |
pp_set_formatter_tag_functions [Format] | This function will erase non-string tag formatting functions.
pp_set_geometry [Format] |
pp_set_margin [Format] |
pp_set_mark_tags [Format] |
pp_set_max_boxes [Format] |
pp_set_max_indent [Format] |
pp_set_print_tags [Format] |
pp_set_tab [Format] |
pp_set_tags [Format] |
pp_update_geometry [Format] | `pp_update_geometry ppf (fun geo -> { geo with ... })` lets you update a formatter's geometry in a way that is robust to extension of the `geometry` record with new fields.
pred [Uchar] | `pred u` is the scalar value before `u` in the set of Unicode scalar values.
pred [Nativeint] | Predecessor.
pred [Int64] | Predecessor.
pred [Int32] | Predecessor.
pred [Int] | `pred x` is `sub x 1`.
pred [Float] | `pred x` returns the floating-point number right before `x` i.e., the greatest floating-point number smaller than `x`.
pred [Stdlib] | `pred x` is `x - 1`.
prerr_bytes [Stdlib] | Print a byte sequence on standard error.
prerr_char [Stdlib] | Print a character on standard error.
prerr_endline [Stdlib] | Print a string, followed by a newline character on standard error and flush standard error.
prerr_float [Stdlib] | Print a floating-point number, in decimal, on standard error.
prerr_int [Stdlib] | Print an integer, in decimal, on standard error.
prerr_newline [Stdlib] | Print a newline character on standard error, and flush standard error.
prerr_string [Stdlib] | Print a string on standard error.
print [Printexc] | `Printexc.print fn x` applies `fn` to `x` and returns the result.
print_as [Format] | `pp_print_as ppf len s` prints `s` in the current pretty-printing box.
print_backtrace [Printexc] | `Printexc.print_backtrace oc` prints an exception backtrace on the output channel `oc`.
print_bool [Format] | Print a boolean in the current pretty-printing box.
print_break [Format] | `pp_print_break ppf nspaces offset` emits a 'full' break hint: the pretty-printer may split the line at this point, otherwise it prints `nspaces` spaces.
print_bytes [Format] | `pp_print_bytes ppf b` prints `b` in the current pretty-printing box.
print_bytes [Stdlib] | Print a byte sequence on standard output.
print_char [Format] | Print a character in the current pretty-printing box.
print_char [Stdlib] | Print a character on standard output.
print_cut [Format] | `pp_print_cut ppf ()` emits a 'cut' break hint: the pretty-printer may split the line at this point, otherwise it prints nothing.
print_endline [Stdlib] | Print a string, followed by a newline character, on standard output and flush standard output.
print_float [Format] | Print a floating point number in the current pretty-printing box.
print_float [Stdlib] | Print a floating-point number, in decimal, on standard output.
print_flush [Format] | End of pretty-printing: resets the pretty-printer to initial state.
print_if_newline [Format] | Execute the next formatting command if the preceding line has just been split.
print_int [Format] | Print an integer in the current pretty-printing box.
print_int [Stdlib] | Print an integer, in decimal, on standard output.
print_newline [Format] | End of pretty-printing: resets the pretty-printer to initial state.
print_newline [Stdlib] | Print a newline character on standard output, and flush standard output.
print_raw_backtrace [Printexc] | Print a raw backtrace in the same format `Printexc.print_backtrace` uses.
print_space [Format] | `pp_print_space ppf ()` emits a '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 [Format] | `pp_print_string ppf s` prints `s` in the current pretty-printing box.
print_string [Stdlib] | Print a string on standard output.
print_tab [Format] | `print_tab ()` emits a 'next' tabulation break hint: if not already set on a tabulation marker, the insertion point moves to the first tabulation marker on the right, or the pretty-printer splits the line and insertion point moves to the leftmost tabulation marker.
print_tbreak [Format] | `print_tbreak nspaces offset` emits a 'full' tabulation break hint.
printf [Printf] | Same as `Printf.fprintf`, but output on `stdout`.
printf [Format] | Same as `fprintf` above, but output on `std_formatter`.
process_full_pid [UnixLabels] | Return the pid of a process opened via `UnixLabels.open_process_full` or `UnixLabels.open_process_args_full`.
process_full_pid [Unix] | Return the pid of a process opened via `Unix.open_process_full` or `Unix.open_process_args_full`.
process_in_pid [UnixLabels] | Return the pid of a process opened via `UnixLabels.open_process_in` or `UnixLabels.open_process_args_in`.
process_in_pid [Unix] | Return the pid of a process opened via `Unix.open_process_in` or `Unix.open_process_args_in`.
process_out_pid [UnixLabels] | Return the pid of a process opened via `UnixLabels.open_process_out` or `UnixLabels.open_process_args_out`.
process_out_pid [Unix] | Return the pid of a process opened via `Unix.open_process_out` or `Unix.open_process_args_out`.
process_pid [UnixLabels] | Return the pid of a process opened via `UnixLabels.open_process` or `UnixLabels.open_process_args`.
process_pid [Unix] | Return the pid of a process opened via `Unix.open_process` or `Unix.open_process_args`.
product [Seq] | `product xs ys` is the Cartesian product of the sequences `xs` and `ys`.
prohibit [Dynlink] | `prohibit units` prohibits dynamically-linked units from referencing the units named in list `units` by removing such units from the allowed units list.
protect [Fun] | `protect ~finally work` invokes `work ()` and then `finally ()` before `work ()` returns with its value or an exception.
public_dynamically_loaded_units [Dynlink] | Return the list of compilation units that have been dynamically loaded via `loadfile` (and not via `loadfile_private`).
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] | `putenv name value` sets the value associated to a variable in the process environment.
putenv [Unix] | `putenv name value` sets the value associated to a variable in the process environment.
Q
query [Ephemeron.Kn] | Same as `Ephemeron.K1.query`
query [Ephemeron.K2] | Same as `Ephemeron.K1.query`
query [Ephemeron.K1] | `Ephemeron.K1.query eph key` returns `Some x` (where `x` is the ephemeron's data) if `key` is physically equal to `eph`'s key, and `None` if `eph` is empty or `key` is not equal to `eph`'s key.
quick_stat [Gc] | Same as `stat` except that `live_words`, `live_blocks`, `free_words`, `free_blocks`, `largest_free`, and `fragments` are set to 0.
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_command [Filename] | `quote_command cmd args` returns a quoted command line, suitable for use as an argument to `Sys.command`, `Unix.system`, and the `Unix.open_process` functions.
R
raise [Stdlib] | Raise the given exception value
raise_notrace [Stdlib] | A faster version `raise` which does not record the backtrace.
raise_with_backtrace [Printexc] | Reraise the exception using the given raw_backtrace for the origin of the exception
randomize [MoreLabels.Hashtbl] | After a call to `Hashtbl.randomize()`, hash tables are created in randomized mode by default: `MoreLabels.Hashtbl.create` returns randomized hash tables, unless the `~random:false` optional parameter is given.
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.
raw_backtrace_entries [Printexc] |
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.
raw_field [Obj] |
rcontains_from [String] | `rcontains_from s stop c` is `true` if and only if `c` appears in `s` before position `stop+1`.
rcontains_from [StringLabels] | `rcontains_from s stop c` is `true` if and only if `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`.
reachable_words [Obj] | Computes the total size (in words, including the headers) of all heap blocks accessible from the argument.
read [ThreadUnix] |
read [UnixLabels] | `read fd ~buf ~pos ~len` reads `len` bytes from descriptor `fd`, storing them in byte sequence `buf`, starting at position `pos` in `buf`.
read [Unix] | `read fd buf pos len` reads `len` bytes from descriptor `fd`, storing them in byte sequence `buf`, starting at position `pos` in `buf`.
read_arg [Arg] | `Arg.read_arg file` reads newline-terminated command line arguments from file `file`.
read_arg0 [Arg] | Identical to `Arg.read_arg` but assumes null character terminated command line arguments.
read_float [Stdlib] | Same as `read_float_opt`, but raise `Failure "float_of_string"` instead of returning `None`.
read_float_opt [Stdlib] | Flush standard output, then read one line from standard input and convert it to a floating-point number.
read_int [Stdlib] | Same as `read_int_opt`, but raise `Failure "int_of_string"` instead of returning `None`.
read_int_opt [Stdlib] | Flush standard output, then read one line from standard input and convert it to an integer.
read_line [Stdlib] | Flush standard output, then read characters from standard input until a newline character is encountered.
readdir [UnixLabels] | Return the next entry in a directory.
readdir [Unix] | Return the next entry in a directory.
readdir [Sys] | Return the names of all files present in the given directory.
readlink [UnixLabels] | Read the contents of a symbolic link.
readlink [Unix] | Read the contents of a symbolic link.
really_input [In_channel] | `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 [Stdlib] | `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 [In_channel] | `really_input_string ic len` reads `len` characters from channel `ic` and returns them in a new string.
really_input_string [Stdlib] | `really_input_string ic len` reads `len` characters from channel `ic` and returns them in a new string.
realpath [UnixLabels] | `realpath p` is an absolute pathname for `p` obtained by resolving all extra `/` characters, relative path segments and symbolic links.
realpath [Unix] | `realpath p` is an absolute pathname for `p` obtained by resolving all extra `/` characters, relative path segments and symbolic links.
rebuild [MoreLabels.Hashtbl] | Return a copy of the given hashtable.
rebuild [Hashtbl] | Return a copy of the given hashtable.
recast [CamlinternalFormat] |
receive [Event] | `receive ch` returns the event consisting in receiving a value from the channel `ch`.
record_backtrace [Printexc] | `Printexc.record_backtrace b` turns recording of exception backtraces on (if `b = true`) or off (if `b = false`).
recv [ThreadUnix] |
recv [UnixLabels] | Receive data from a connected socket.
recv [Unix] | Receive data from a connected socket.
recvfrom [ThreadUnix] |
recvfrom [UnixLabels] | Receive data from an unconnected socket.
recvfrom [Unix] | Receive data from an unconnected socket.
ref [Stdlib] | 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_exception [Callback] | `Callback.register_exception n exn` registers the exception contained in the exception value `exn` under the name `n`.
register_printer [Printexc] | `Printexc.register_printer fn` registers `fn` as an exception printer.
release [Semaphore.Binary] | `release s` sets the value of semaphore `s` to 1, putting it in the "available" state.
release [Semaphore.Counting] | `release s` increments the value of semaphore `s`.
rem [Nativeint] | Integer remainder.
rem [Int64] | Integer remainder.
rem [Int32] | Integer remainder.
rem [Int] | `rem x y` is the remainder `x mod y`.
rem [Float] | `rem a b` returns the remainder of `a` with respect to `b`.
remove [Weak.S] | `remove t x` removes from `t` one instance of `x`.
remove [Sys] | Remove the given file name from the file system.
remove [Set.S] | `remove x s` returns a set containing all elements of `s`, except `x`.
remove [MoreLabels.Set.S] | `remove x s` returns a set containing all elements of `s`, except `x`.
remove [MoreLabels.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 [MoreLabels.Hashtbl.SeededS] |
remove [MoreLabels.Hashtbl.S] |
remove [MoreLabels.Hashtbl] | `Hashtbl.remove tbl x` removes the current binding of `x` in `tbl`, restoring the previous binding if it exists.
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 [Ephemeron.Kn.Bucket] | `remove b k` removes from `b` the most-recently added ephemeron with keys `k`, or does nothing if there is no such ephemeron.
remove [Ephemeron.K2.Bucket] | `remove b k1 k2` removes from `b` the most-recently added ephemeron with keys `k1` and `k2`, or does nothing if there is no such ephemeron.
remove [Ephemeron.K1.Bucket] | `remove b k` removes from `b` the most-recently added ephemeron with key `k`, or does nothing if there is no such ephemeron.
remove [Ephemeron.SeededS] |
remove [Ephemeron.S] |
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_extension [Filename] | Return the given file name without its extension, as defined in `Filename.extension`.
rename [UnixLabels] | `rename ~src ~dst` changes the name of a file from `src` to `dst`, moving it between directories if needed.
rename [Unix] | `rename src dst` changes the name of a file from `src` to `dst`, moving it between directories if needed.
rename [Sys] | Rename a file.
rep [Uchar] | `rep` is U+FFFD, the replacement character.
repeat [Seq] | `repeat x` is the infinite sequence where the element `x` is repeated indefinitely.
replace [MoreLabels.Hashtbl.SeededS] |
replace [MoreLabels.Hashtbl.S] |
replace [MoreLabels.Hashtbl] | `Hashtbl.replace tbl ~key ~data` replaces the current binding of `key` in `tbl` by a binding of `key` to `data`.
replace [Hashtbl.SeededS] |
replace [Hashtbl.S] |
replace [Hashtbl] | `Hashtbl.replace tbl key data` replaces the current binding of `key` in `tbl` by a binding of `key` to `data`.
replace [Ephemeron.SeededS] |
replace [Ephemeron.S] |
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_seq [MoreLabels.Hashtbl.SeededS] |
replace_seq [MoreLabels.Hashtbl.S] |
replace_seq [MoreLabels.Hashtbl] | Add the given bindings to the table, using `MoreLabels.Hashtbl.replace`
replace_seq [Hashtbl.SeededS] |
replace_seq [Hashtbl.S] |
replace_seq [Hashtbl] | Add the given bindings to the table, using `Hashtbl.replace`
replace_seq [Ephemeron.SeededS] |
replace_seq [Ephemeron.S] |
repr [Sys.Immediate64.Make] |
repr [Obj] |
reset [MoreLabels.Hashtbl.SeededS] |
reset [MoreLabels.Hashtbl.S] |
reset [MoreLabels.Hashtbl] | Empty a hash table and shrink the size of the bucket table to its initial size.
reset [Hashtbl.SeededS] |
reset [Hashtbl.S] |
reset [Hashtbl] | Empty a hash table and shrink the size of the bucket table to its initial size.
reset [Ephemeron.SeededS] |
reset [Ephemeron.S] |
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`.
reshape [Bigarray] | `reshape b [|d1;...;dN|]` converts the Bigarray `b` to a `N`-dimensional array of dimensions `d1`...
reshape_0 [Bigarray] | Specialized version of `Bigarray.reshape` for reshaping to zero-dimensional arrays.
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.
return [Seq] | `return x` is the sequence whose sole element is `x`.
rev [ListLabels] | List reversal.
rev [List] | List reversal.
rev_append [ListLabels] | `rev_append l1 l2` reverses `l1` and concatenates it with `l2`.
rev_append [List] | `rev_append l1 l2` reverses `l1` and concatenates it with `l2`.
rev_char_set [CamlinternalFormat] |
rev_map [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] | `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] | `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] | `rev_map2 f l1 l2` gives the same result as `List.rev``(``List.map2` `f l1 l2)`, but is tail-recursive and more efficient.
rewinddir [UnixLabels] | Reposition the descriptor to the beginning of the directory
rewinddir [Unix] | Reposition the descriptor to the beginning of the directory
rhs_end [Parsing] | See `Parsing.rhs_start`.
rhs_end_pos [Parsing] | Same as `rhs_end`, but return a `position` instead of an offset.
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.
right [Either] | `right v` is `Right v`.
rindex [String] | `rindex s c` is `String.rindex_from` `s (length s - 1) c`.
rindex [StringLabels] | `rindex s c` is `String.rindex_from` `s (length s - 1) c`.
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] | `rindex_from s i c` is the index of the last occurrence of `c` in `s` before position `i+1`.
rindex_from [StringLabels] | `rindex_from s i c` is the index of the last occurrence of `c` in `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`.
rindex_from_opt [String] | `rindex_from_opt s i c` is the index of the last occurrence of `c` in `s` before position `i+1` (if any).
rindex_from_opt [StringLabels] | `rindex_from_opt s i c` is the index of the last occurrence of `c` in `s` before position `i+1` (if any).
rindex_from_opt [BytesLabels] | `rindex_from_opt s i c` returns the index of the last occurrence of byte `c` in `s` before position `i+1` or `None` if `c` does not occur in `s` before position `i+1`.
rindex_from_opt [Bytes] | `rindex_from_opt s i c` returns the index of the last occurrence of byte `c` in `s` before position `i+1` or `None` if `c` does not occur in `s` before position `i+1`.
rindex_opt [String] | `rindex_opt s c` is `String.rindex_from_opt` `s (length s - 1) c`.
rindex_opt [StringLabels] | `rindex_opt s c` is `String.rindex_from_opt` `s (length s - 1) c`.
rindex_opt [BytesLabels] | `rindex_opt s c` returns the index of the last occurrence of byte `c` in `s` or `None` if `c` does not occur in `s`.
rindex_opt [Bytes] | `rindex_opt s c` returns the index of the last occurrence of byte `c` in `s` or `None` if `c` does not occur in `s`.
rmdir [UnixLabels] | Remove an empty directory.
rmdir [Unix] | Remove an empty directory.
rmdir [Sys] | Remove an empty directory.
round [Float] | `round x` rounds `x` to the nearest integer with ties (fractional values of 0.5) rounded away from zero, regardless of the current rounding direction.
run_initializers [CamlinternalOO] |
run_initializers_opt [CamlinternalOO] |
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_warnings_enabled [Sys] | Return whether runtime warnings are currently enabled.
S
safe_set_geometry [Format] | `pp_set_geometry ppf ~max_indent ~margin` sets both the margin and maximum indentation limit for `ppf`.
scan [Seq] | If `xs` is a sequence `[x0; x1; x2; ...]`, then `scan f a0 xs` is a sequence of accumulators `[a0; a1; a2; ...]` where `a1` is `f a0 x0`, `a2` is `f a1 x1`, and so on.
scanf [Scanf] | Same as `Scanf.bscanf`, but reads from the predefined formatted input channel `Scanf.Scanning.stdin` that is connected to `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`.
seeded_hash [MoreLabels.Hashtbl] | A variant of `MoreLabels.Hashtbl.hash` that is further parameterized by an integer seed.
seeded_hash [Hashtbl] | A variant of `Hashtbl.hash` that is further parameterized by an integer seed.
seeded_hash_param [MoreLabels.Hashtbl] | A variant of `MoreLabels.Hashtbl.hash_param` that is further parameterized by an integer seed.
seeded_hash_param [Hashtbl] | A variant of `Hashtbl.hash_param` that is further parameterized by an integer seed.
seek [Out_channel] | `seek chan pos` sets the current writing position to `pos` for channel `chan`.
seek [In_channel] | `seek chan pos` sets the current reading position to `pos` for channel `chan`.
seek_in [Stdlib.LargeFile] |
seek_in [Stdlib] | `seek_in chan pos` sets the current reading position to `pos` for channel `chan`.
seek_out [Stdlib.LargeFile] |
seek_out [Stdlib] | `seek_out chan pos` sets the current writing position to `pos` for channel `chan`.
select [ThreadUnix] |
select [Event] | 'Synchronize' on an alternative of events.
select [Thread] | Same function as `Unix.select`.
select [UnixLabels] | Wait until some input/output operations become possible on some channels.
select [Unix] | Wait until some input/output operations become possible on some channels.
self [Thread] | Return the handle for the thread currently executing.
self_init [Random] | Initialize the generator with a random seed chosen in a system-dependent way.
send [ThreadUnix] |
send [Event] | `send ch v` returns the event consisting in sending the value `v` over the channel `ch`.
send [UnixLabels] | Send data over a connected socket.
send [Unix] | Send data over a connected socket.
send [CamlinternalOO] |
send_substring [ThreadUnix] |
send_substring [UnixLabels] | Same as `send`, 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.
sendcache [CamlinternalOO] |
sendself [CamlinternalOO] |
sendto [ThreadUnix] |
sendto [UnixLabels] | Send data over an unconnected socket.
sendto [Unix] | Send data over an unconnected socket.
sendto_substring [ThreadUnix] |
sendto_substring [UnixLabels] | Same as `sendto`, 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.
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] | `set s n c` modifies byte sequence `s` in place, replacing the byte at index `n` with `c`.
set [StringLabels] | `set s n c` modifies byte sequence `s` in place, replacing the byte at index `n` with `c`.
set [Gc] | `set r` changes the GC parameters according to the `control` record `r`.
set [Float.ArrayLabels] | `set a n x` modifies floatarray `a` in place, replacing element number `n` with `x`.
set [Float.Array] | `set a n x` modifies floatarray `a` in place, replacing element number `n` with `x`.
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.Array0] | `Array0.set a x v` stores the value `v` in `a`.
set [Bigarray.Genarray] | Assign an element of a generic Bigarray.
set [Atomic] | Set a new value for the atomic reference.
set [ArrayLabels] | `set a n x` modifies array `a` in place, replacing element number `n` with `x`.
set [Array] | `set a n x` modifies array `a` in place, replacing element number `n` with `x`.
set [CamlinternalAtomic] |
set_all_formatter_output_functions [Format] |
set_allowed_units [Dynlink] | Set the list of compilation units that may be referenced from units that are dynamically loaded in the future to be exactly the given value.
set_binary_mode [Out_channel] | `set_binary_mode oc true` sets the channel `oc` to binary mode: no translations take place during output.
set_binary_mode [In_channel] | `set_binary_mode ic true` sets the channel `ic` to binary mode: no translations take place during input.
set_binary_mode_in [Stdlib] | `set_binary_mode_in ic true` sets the channel `ic` to binary mode: no translations take place during input.
set_binary_mode_out [Stdlib] | `set_binary_mode_out oc true` sets the channel `oc` to binary mode: no translations take place during output.
set_buffered [Out_channel] | `set_buffered oc true` sets the channel `oc` to buffered mode.
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_data [Obj.Ephemeron] | Same as `Stdlib.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_ellipsis_text [Format] | Set the text of the ellipsis printed when too many pretty-printing boxes are open (a single dot, `.`, by default).
set_field [Obj] | When using flambda:
set_filename [Lexing] | Set filename in the initial tracked position to `file` in `lexbuf`.
set_formatter_out_channel [Format] | Redirect the standard pretty-printer output to the given channel.
set_formatter_out_functions [Format] | `pp_set_formatter_out_functions ppf out_funs` Set all the pretty-printer output functions of `ppf` to those of argument `out_funs`,
set_formatter_output_functions [Format] | `pp_set_formatter_output_functions ppf out flush` redirects the standard pretty-printer output functions to the functions `out` and `flush`.
set_formatter_stag_functions [Format] | `pp_set_formatter_stag_functions ppf tag_funs` changes the meaning of opening and closing semantic tag operations to use the functions in `tag_funs` when printing on `ppf`.
set_formatter_tag_functions [Format] |
set_geometry [Format] |
set_int16_be [BytesLabels] | `set_int16_be b i v` sets `b`'s big-endian signed 16-bit integer starting at byte index `i` to `v`.
set_int16_be [Bytes] | `set_int16_be b i v` sets `b`'s big-endian signed 16-bit integer starting at byte index `i` to `v`.
set_int16_le [BytesLabels] | `set_int16_le b i v` sets `b`'s little-endian signed 16-bit integer starting at byte index `i` to `v`.
set_int16_le [Bytes] | `set_int16_le b i v` sets `b`'s little-endian signed 16-bit integer starting at byte index `i` to `v`.
set_int16_ne [BytesLabels] | `set_int16_ne b i v` sets `b`'s native-endian signed 16-bit integer starting at byte index `i` to `v`.
set_int16_ne [Bytes] | `set_int16_ne b i v` sets `b`'s native-endian signed 16-bit integer starting at byte index `i` to `v`.
set_int32_be [BytesLabels] | `set_int32_be b i v` sets `b`'s big-endian 32-bit integer starting at byte index `i` to `v`.
set_int32_be [Bytes] | `set_int32_be b i v` sets `b`'s big-endian 32-bit integer starting at byte index `i` to `v`.
set_int32_le [BytesLabels] | `set_int32_le b i v` sets `b`'s little-endian 32-bit integer starting at byte index `i` to `v`.
set_int32_le [Bytes] | `set_int32_le b i v` sets `b`'s little-endian 32-bit integer starting at byte index `i` to `v`.
set_int32_ne [BytesLabels] | `set_int32_ne b i v` sets `b`'s native-endian 32-bit integer starting at byte index `i` to `v`.
set_int32_ne [Bytes] | `set_int32_ne b i v` sets `b`'s native-endian 32-bit integer starting at byte index `i` to `v`.
set_int64_be [BytesLabels] | `set_int64_be b i v` sets `b`'s big-endian 64-bit integer starting at byte index `i` to `v`.
set_int64_be [Bytes] | `set_int64_be b i v` sets `b`'s big-endian 64-bit integer starting at byte index `i` to `v`.
set_int64_le [BytesLabels] | `set_int64_le b i v` sets `b`'s little-endian 64-bit integer starting at byte index `i` to `v`.
set_int64_le [Bytes] | `set_int64_le b i v` sets `b`'s little-endian 64-bit integer starting at byte index `i` to `v`.
set_int64_ne [BytesLabels] | `set_int64_ne b i v` sets `b`'s native-endian 64-bit integer starting at byte index `i` to `v`.
set_int64_ne [Bytes] | `set_int64_ne b i v` sets `b`'s native-endian 64-bit integer starting at byte index `i` to `v`.
set_int8 [BytesLabels] | `set_int8 b i v` sets `b`'s signed 8-bit integer starting at byte index `i` to `v`.
set_int8 [Bytes] | `set_int8 b i v` sets `b`'s signed 8-bit integer starting at byte index `i` to `v`.
set_key [Obj.Ephemeron] | Same as `Stdlib.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.set_key`
set_margin [Format] | `pp_set_margin ppf 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] | `pp_set_mark_tags ppf b` turns on or off the tag-marking operations.
set_max_boxes [Format] | `pp_set_max_boxes ppf max` sets the maximum number of pretty-printing boxes simultaneously open.
set_max_indent [Format] | `pp_set_max_indent ppf d` sets the maximum indentation limit of lines to `d` (in characters): once this limit is reached, new pretty-printing boxes are rejected to the left, unless the enclosing box fully fits 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_position [Lexing] | Set the initial tracked input position for `lexbuf` to a custom value.
set_print_tags [Format] | `pp_set_print_tags ppf b` turns on or off the tag-printing operations.
set_raw_field [Obj] |
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_tab [Format] | Sets a tabulation marker at current insertion point.
set_tag [Obj] |
set_tags [Format] | `pp_set_tags ppf b` turns on or off the treatment of semantic 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_trace [Parsing] | Control debugging support for `ocamlyacc`-generated parsers.
set_uint16_be [BytesLabels] | `set_uint16_be b i v` sets `b`'s big-endian unsigned 16-bit integer starting at byte index `i` to `v`.
set_uint16_be [Bytes] | `set_uint16_be b i v` sets `b`'s big-endian unsigned 16-bit integer starting at byte index `i` to `v`.
set_uint16_le [BytesLabels] | `set_uint16_le b i v` sets `b`'s little-endian unsigned 16-bit integer starting at byte index `i` to `v`.
set_uint16_le [Bytes] | `set_uint16_le b i v` sets `b`'s little-endian unsigned 16-bit integer starting at byte index `i` to `v`.
set_uint16_ne [BytesLabels] | `set_uint16_ne b i v` sets `b`'s native-endian unsigned 16-bit integer starting at byte index `i` to `v`.
set_uint16_ne [Bytes] | `set_uint16_ne b i v` sets `b`'s native-endian unsigned 16-bit integer starting at byte index `i` to `v`.
set_uint8 [BytesLabels] | `set_uint8 b i v` sets `b`'s unsigned 8-bit integer starting at byte index `i` to `v`.
set_uint8 [Bytes] | `set_uint8 b i v` sets `b`'s unsigned 8-bit integer starting at byte index `i` to `v`.
set_uncaught_exception_handler [Thread] | `Thread.set_uncaught_exception_handler fn` registers `fn` as the handler for uncaught exceptions.
set_uncaught_exception_handler [Printexc] | `Printexc.set_uncaught_exception_handler fn` registers `fn` as the handler for uncaught exceptions.
set_utf_16be_uchar [BytesLabels] | `set_utf_16be_uchar b i u` UTF-16BE encodes `u` at index `i` in `b` and returns the number of bytes `n` that were written starting at `i`.
set_utf_16be_uchar [Bytes] | `set_utf_16be_uchar b i u` UTF-16BE encodes `u` at index `i` in `b` and returns the number of bytes `n` that were written starting at `i`.
set_utf_16le_uchar [BytesLabels] | `set_utf_16le_uchar b i u` UTF-16LE encodes `u` at index `i` in `b` and returns the number of bytes `n` that were written starting at `i`.
set_utf_16le_uchar [Bytes] | `set_utf_16le_uchar b i u` UTF-16LE encodes `u` at index `i` in `b` and returns the number of bytes `n` that were written starting at `i`.
set_utf_8_uchar [BytesLabels] | `set_utf_8_uchar b i u` UTF-8 encodes `u` at index `i` in `b` and returns the number of bytes `n` that were written starting at `i`.
set_utf_8_uchar [Bytes] | `set_utf_8_uchar b i u` UTF-8 encodes `u` at index `i` in `b` and returns the number of bytes `n` that were written starting at `i`.
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.
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 `UnixLabels.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 `UnixLabels.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 `UnixLabels.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.
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 [Int] | `shift_left x n` shifts `x` to the 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 [Int] | `shift_right x n` shifts `x` to the 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_logical [Int] | `shift_right x n` shifts `x` to the right by `n` bits.
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_bit [Float] | `sign_bit x` is `true` if and only if the sign bit of `x` is set.
signal [Condition] | `signal c` restarts one of the processes waiting on the condition variable `c`.
signal [Sys] | Set the behavior of the system on receipt of a given signal.
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 ~mode sigs` changes the set of blocked signals.
sigprocmask [Unix] | `sigprocmask mode 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
sin [Float] | Sine.
sin [Stdlib] | Sine.
single_write [UnixLabels] | Same as `UnixLabels.write`, but attempts to write only once.
single_write [Unix] | Same as `Unix.write`, but attempts to write only once.
single_write_substring [UnixLabels] | Same as `UnixLabels.single_write`, but take the data from a string instead of a byte sequence.
single_write_substring [Unix] | Same as `Unix.single_write`, but take the data from a string instead of a byte sequence.
singleton [Set.S] | `singleton x` returns the one-element set containing only `x`.
singleton [MoreLabels.Set.S] | `singleton x` returns the one-element set containing only `x`.
singleton [MoreLabels.Map.S] | `singleton x y` returns the one-element map that contains a binding `y` for `x`.
singleton [Map.S] | `singleton x y` returns the one-element map that contains a binding `y` for `x`.
sinh [Float] | Hyperbolic sine.
sinh [Stdlib] | 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.Array0] | `size_in_bytes a` is `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`.
sleep [ThreadUnix] |
sleep [UnixLabels] | Stop execution for the given number of seconds.
sleep [Unix] | Stop execution for the given number of seconds.
sleepf [UnixLabels] | Stop execution for the given number of seconds.
sleepf [Unix] | Stop execution for the given number of seconds.
slice [Bigarray.Array1] | Extract a scalar (zero-dimensional slice) of the given one-dimensional Bigarray.
slice_left [Bigarray.Array2] | Extract a row (one-dimensional slice) of the given two-dimensional Bigarray.
slice_left [Bigarray.Genarray] | Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of the first (left-most) coordinates.
slice_left_1 [Bigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the first two coordinates.
slice_left_2 [Bigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional Bigarray by fixing the first coordinate.
slice_right [Bigarray.Array2] | Extract a column (one-dimensional slice) of the given two-dimensional Bigarray.
slice_right [Bigarray.Genarray] | Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of the last (right-most) coordinates.
slice_right_1 [Bigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the last two coordinates.
slice_right_2 [Bigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional Bigarray by fixing the last coordinate.
snd [Stdlib] | Return the second component of a pair.
socket [ThreadUnix] |
socket [UnixLabels] | Create a new socket in the given domain, and with the given kind.
socket [Unix] | Create a new socket in the given domain, and with the given kind.
socketpair [UnixLabels] | Create a pair of unnamed sockets, connected together.
socketpair [Unix] | Create a pair of unnamed sockets, connected together.
some [Option] | `some v` is `Some v`.
sort [ListLabels] | Sort a list in increasing order according to a comparison function.
sort [List] | Sort a list in increasing order according to a comparison function.
sort [Float.ArrayLabels] | Sort a floatarray in increasing order according to a comparison function.
sort [Float.Array] | Sort a floatarray in increasing order according to a comparison function.
sort [ArrayLabels] | Sort an array in increasing order according to a comparison function.
sort [Array] | Sort an array in increasing order according to a comparison function.
sort_uniq [ListLabels] | Same as `ListLabels.sort`, but also remove duplicates.
sort_uniq [List] | Same as `List.sort`, but also remove duplicates.
sorted_merge [Seq] | If the sequences `xs` and `ys` are sorted according to the total preorder `cmp`, then `sorted_merge cmp xs ys` is the sorted sequence obtained by merging the sequences `xs` and `ys`.
split [Str] | `split r s` splits `s` into substrings, taking as delimiters the substrings that match `r`, and returns the list of substrings.
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 [Seq] | `split` is an alias for `unzip`.
split [MoreLabels.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 [MoreLabels.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 [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 [ArrayLabels] | `split [|(a1,b1); ...; (an,bn)|]` is `([|a1; ...; an|], [|b1; ...; bn|])`.
split [Array] | `split [|(a1,b1); ...; (an,bn)|]` is `([|a1; ...; an|], [|b1; ...; bn|])`.
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_on_char [String] | `split_on_char sep s` is the list of all (possibly empty) substrings of `s` that are delimited by the character `sep`.
split_on_char [StringLabels] | `split_on_char ~sep s` is the list of all (possibly empty) substrings of `s` that are delimited by the character `sep`.
split_on_char [BytesLabels] | `split_on_char sep s` returns the list of all (possibly empty) subsequences of `s` that are delimited by the `sep` character.
split_on_char [Bytes] | `split_on_char sep s` returns the list of all (possibly empty) subsequences of `s` that are delimited by the `sep` character.
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 [Float] | Square root.
sqrt [Complex] | Square root.
sqrt [Stdlib] | Square root.
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 [Float.ArrayLabels] | Same as `Float.ArrayLabels.sort`, but the sorting algorithm is stable (i.e.
stable_sort [Float.Array] | Same as `Float.Array.sort`, but the sorting algorithm is 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.
start [Gc.Memprof] | Start the sampling with the given parameters.
starts_with [String] | `starts_with` `~``prefix s` is `true` if and only if `s` starts with `prefix`.
starts_with [StringLabels] | `starts_with` `~``prefix s` is `true` if and only if `s` starts with `prefix`.
starts_with [BytesLabels] | `starts_with` `~``prefix s` is `true` if and only if `s` starts with `prefix`.
starts_with [Bytes] | `starts_with` `~``prefix s` is `true` if and only if `s` starts with `prefix`.
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 [CamlinternalOO] |
stats [Weak.S] | Return statistics on the table.
stats [MoreLabels.Hashtbl.SeededS] |
stats [MoreLabels.Hashtbl.S] |
stats [MoreLabels.Hashtbl] | `Hashtbl.stats tbl` returns statistics about the table `tbl`: number of buckets, size of the biggest bucket, distribution of buckets by size.
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 [Ephemeron.SeededS] |
stats [Ephemeron.S] |
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 to write to standard output.
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 [Out_channel] | The standard error output for the process.
stderr [Stdlib] | The standard error output for the process.
stdib [Scanf.Scanning] | A deprecated alias for `Scanf.Scanning.stdin`, the scanning buffer reading from `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 [In_channel] | The standard input for the process.
stdin [Stdlib] | The standard input for the process.
stdout [UnixLabels] | File descriptor for standard output.
stdout [Unix] | File descriptor for standard output.
stdout [Out_channel] | The standard output for the process.
stdout [Stdlib] | The standard output for the process.
stop [Gc.Memprof] | Stop the sampling.
str_formatter [Format] | A formatter to output to the `Format.stdbuf` string buffer.
string [Digest] | Return the digest of the given string.
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_bool [Stdlib] | Return the string representation of a boolean.
string_of_float [Stdlib] | Return the string representation of a floating-point number.
string_of_fmt [CamlinternalFormat] |
string_of_fmtty [CamlinternalFormat] |
string_of_format [Stdlib] | Converts a format string into a string.
string_of_formatting_lit [CamlinternalFormat] |
string_of_inet_addr [UnixLabels] | Return the printable representation of the given Internet address.
string_of_inet_addr [Unix] | Return the printable representation of the given Internet address.
string_of_int [Stdlib] | Return the string representation of an integer, in decimal.
string_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] |
sub [String] | `sub s pos len` is a string of length `len`, containing the substring of `s` that starts at position `pos` and has length `len`.
sub [StringLabels] | `sub s ~pos ~len` is a string of length `len`, containing the substring of `s` that starts at position `pos` and has length `len`.
sub [Nativeint] | Subtraction.
sub [Int64] | Subtraction.
sub [Int32] | Subtraction.
sub [Int] | `sub x y` is the subtraction `x - y`.
sub [Float.ArrayLabels] | `sub a ~pos ~len` returns a fresh floatarray of length `len`, containing the elements number `pos` to `pos + len - 1` of floatarray `a`.
sub [Float.Array] | `sub a pos len` returns a fresh floatarray of length `len`, containing the elements number `pos` to `pos + len - 1` of floatarray `a`.
sub [Float] | Floating-point subtraction.
sub [Complex] | Subtraction
sub [BytesLabels] | `sub s ~pos ~len` returns a new byte sequence of length `len`, containing the subsequence of `s` that starts at position `pos` and has length `len`.
sub [Bytes] | `sub s pos len` returns a new byte sequence of length `len`, containing the subsequence of `s` that starts at position `pos` 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 Bigarray.
sub [ArrayLabels] | `sub a ~pos ~len` returns a fresh array of length `len`, containing the elements number `pos` to `pos + len - 1` of array `a`.
sub [Array] | `sub a pos len` returns a fresh array of length `len`, containing the elements number `pos` to `pos + len - 1` of array `a`.
sub_left [Bigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the first dimension.
sub_left [Bigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the first dimension.
sub_left [Bigarray.Genarray] | Extract a sub-array of the given Bigarray by restricting the first (left-most) dimension.
sub_right [Bigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the second dimension.
sub_right [Bigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the second dimension.
sub_right [Bigarray.Genarray] | Extract a sub-array of the given Bigarray by restricting the last (right-most) dimension.
sub_string [BytesLabels] | Same as `BytesLabels.sub` but return a string instead of a byte sequence.
sub_string [Bytes] | Same as `Bytes.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 [Set.S] | `subset s1 s2` tests whether the set `s1` is a subset of the set `s2`.
subset [MoreLabels.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 [Nativeint] | Successor.
succ [Int64] | Successor.
succ [Int32] | Successor.
succ [Int] | `succ x` is `add x 1`.
succ [Float] | `succ x` returns the floating point number right after `x` i.e., the smallest floating-point number greater than `x`.
succ [Stdlib] | `succ x` is `x + 1`.
symbol_end [Parsing] | See `Parsing.symbol_start`.
symbol_end_pos [Parsing] | Same as `symbol_end`, but return a `position` instead of an offset.
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.
symlink [UnixLabels] | `symlink ?to_dir ~src ~dst` creates the file `dst` as a symbolic link to the file `src`.
symlink [Unix] | `symlink ?to_dir src dst` creates the file `dst` as a symbolic link to the file `src`.
symm [CamlinternalFormat] |
sync [Event] | 'Synchronize' on an event: offer all the communication possibilities specified in the event to the outside world, and block until one of the communications succeed.
system [ThreadUnix] |
system [UnixLabels] | Execute the given command, wait until it terminates, and return its termination status.
system [Unix] | Execute the given command, wait until it terminates, and return its termination status.
T
tag [Obj] |
take [Seq] | `take n xs` is the sequence of the first `n` elements of `xs`.
take [Queue] | `take q` removes and returns the first element in queue `q`, or raises `Queue.Empty` if the queue is empty.
take_opt [Queue] | `take_opt q` removes and returns the first element in queue `q`, or returns `None` if the queue is empty.
take_while [Seq] | `take_while p xs` is the longest prefix of the sequence `xs` where every element `x` satisfies `p x`.
tan [Float] | Tangent.
tan [Stdlib] | Tangent.
tanh [Float] | Hyperbolic tangent.
tanh [Stdlib] | Hyperbolic tangent.
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.
time [UnixLabels] | Return the current time since 00:00:00 GMT, Jan.
time [Unix] | Return the current time since 00:00:00 GMT, Jan.
time [Sys] | Return the processor time, in seconds, used by the program since the beginning of execution.
timed_read [ThreadUnix] | 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 [String] | Return a new byte sequence that contains the same bytes as the given string.
to_bytes [StringLabels] | Return a new byte sequence that contains the same bytes as the given string.
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_dispenser [Seq] | `to_dispenser xs` is a fresh dispenser on the sequence `xs`.
to_float [Nativeint] | Convert the given native integer to a floating-point number.
to_float [Int64] | Convert the given 64-bit integer to a floating-point number.
to_float [Int32] | Convert the given 32-bit integer to a floating-point number.
to_float [Int] | `to_float x` is `x` as a floating point number.
to_float [Bool] | `to_float b` is `0.` if `b` is `false` and `1.` if `b` is `true`.
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_int [Float] | Truncate the given floating-point number to an integer.
to_int [Bool] | `to_int b` is `0` if `b` is `false` and `1` if `b` is `true`.
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 [Result] | `to_list r` is `[v]` if `r` is `Ok v` and `[]` otherwise.
to_list [Option] | `to_list o` is `[]` if `o` is `None` and `[v]` if `o` is `Some v`.
to_list [Float.ArrayLabels] | `to_list a` returns the list of all the elements of `a`.
to_list [Float.Array] | `to_list a` returns the list of all the elements of `a`.
to_list [ArrayLabels] | `to_list a` returns the list of all the elements of `a`.
to_list [Array] | `to_list a` returns the list of all the elements of `a`.
to_nativeint [Int64] | Convert the given 64-bit integer (type `int64`) to a native integer.
to_option [Result] | `to_option r` is `r` as an option, mapping `Ok v` to `Some v` and `Error _` to `None`.
to_result [Option] | `to_result ~none o` is `Ok v` if `o` is `Some v` and `Error none` otherwise.
to_rev_seq [Set.S] | Iterate on the whole set, in descending order
to_rev_seq [MoreLabels.Set.S] | Iterate on the whole set, in descending order
to_rev_seq [MoreLabels.Map.S] | Iterate on the whole map, in descending order of keys
to_rev_seq [Map.S] | Iterate on the whole map, in descending order of keys
to_seq [String] | `to_seq s` is a sequence made of the string's characters in increasing order.
to_seq [StringLabels] | `to_seq s` is a sequence made of the string's characters in increasing order.
to_seq [Stack] | Iterate on the stack, top to bottom.
to_seq [Set.S] | Iterate on the whole set, in ascending order
to_seq [Result] | `to_seq r` is `r` as a sequence.
to_seq [Queue] | Iterate on the queue, in front-to-back order.
to_seq [Option] | `to_seq o` is `o` as a sequence.
to_seq [MoreLabels.Set.S] | Iterate on the whole set, in ascending order
to_seq [MoreLabels.Map.S] | Iterate on the whole map, in ascending order of keys
to_seq [MoreLabels.Hashtbl.SeededS] |
to_seq [MoreLabels.Hashtbl.S] |
to_seq [MoreLabels.Hashtbl] | Iterate on the whole table.
to_seq [Map.S] | Iterate on the whole map, in ascending order of keys
to_seq [ListLabels] | Iterate on the list.
to_seq [List] | Iterate on the list.
to_seq [Hashtbl.SeededS] |
to_seq [Hashtbl.S] |
to_seq [Hashtbl] | Iterate on the whole table.
to_seq [Float.ArrayLabels] | Iterate on the floatarray, in increasing order.
to_seq [Float.Array] | Iterate on the floatarray, in increasing order.
to_seq [Ephemeron.SeededS] |
to_seq [Ephemeron.S] |
to_seq [BytesLabels] | Iterate on the string, in increasing index order.
to_seq [Bytes] | Iterate on the string, in increasing index order.
to_seq [Buffer] | Iterate on the buffer, in increasing order.
to_seq [ArrayLabels] | Iterate on the array, in increasing order.
to_seq [Array] | Iterate on the array, in increasing order.
to_seq_from [Set.S] | `to_seq_from x s` iterates on a subset of the elements of `s` in ascending order, from `x` or above.
to_seq_from [MoreLabels.Set.S] | `to_seq_from x s` iterates on a subset of the elements of `s` in ascending order, from `x` or above.
to_seq_from [MoreLabels.Map.S] | `to_seq_from k m` iterates on a subset of the bindings of `m`, in ascending order of keys, from key `k` or above.
to_seq_from [Map.S] | `to_seq_from k m` iterates on a subset of the bindings of `m`, in ascending order of keys, from key `k` or above.
to_seq_keys [MoreLabels.Hashtbl.SeededS] |
to_seq_keys [MoreLabels.Hashtbl.S] |
to_seq_keys [MoreLabels.Hashtbl] | Same as `Seq.map fst (to_seq m)`
to_seq_keys [Hashtbl.SeededS] |
to_seq_keys [Hashtbl.S] |
to_seq_keys [Hashtbl] | Same as `Seq.map fst (to_seq m)`
to_seq_keys [Ephemeron.SeededS] |
to_seq_keys [Ephemeron.S] |
to_seq_values [MoreLabels.Hashtbl.SeededS] |
to_seq_values [MoreLabels.Hashtbl.S] |
to_seq_values [MoreLabels.Hashtbl] | Same as `Seq.map snd (to_seq m)`
to_seq_values [Hashtbl.SeededS] |
to_seq_values [Hashtbl.S] |
to_seq_values [Hashtbl] | Same as `Seq.map snd (to_seq m)`
to_seq_values [Ephemeron.SeededS] |
to_seq_values [Ephemeron.S] |
to_seqi [String] | `to_seqi s` is like `String.to_seq` but also tuples the corresponding index.
to_seqi [StringLabels] | `to_seqi s` is like `StringLabels.to_seq` but also tuples the corresponding index.
to_seqi [Float.ArrayLabels] | Iterate on the floatarray, in increasing order, yielding indices along elements.
to_seqi [Float.Array] | Iterate on the floatarray, in increasing order, yielding indices along elements.
to_seqi [BytesLabels] | Iterate on the string, in increasing order, yielding indices along chars
to_seqi [Bytes] | Iterate on the string, in increasing order, yielding indices along chars
to_seqi [Buffer] | Iterate on the buffer, in increasing order, yielding indices along chars.
to_seqi [ArrayLabels] | Iterate on the array, in increasing order, yielding indices along elements.
to_seqi [Array] | Iterate on the array, in increasing order, yielding indices along elements.
to_string [Unit] | `to_string b` is `"()"`.
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 [Int] | `to_string x` is the written representation of `x` in decimal.
to_string [Float] | Return the string representation of a floating-point number.
to_string [BytesLabels] | Return a new string that contains the same bytes as the given byte sequence.
to_string [Bytes] | Return a new string that contains the same bytes as the given byte sequence.
to_string [Bool] | `to_string b` is `"true"` if `b` is `true` and `"false"` if `b` is `false`.
to_string_default [Printexc] | `Printexc.to_string_default e` returns a string representation of the exception `e`, ignoring all registered exception printers.
top [Stack] | `top s` returns the topmost element in stack `s`, or raises `Stack.Empty` if the stack is empty.
top [Queue] | `top` is a synonym for `peek`.
top_opt [Stack] | `top_opt s` returns the topmost element in stack `s`, or `None` if the stack is empty.
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`.
transpose [Seq] | If `xss` is a matrix (a sequence of rows), then `transpose xss` is the sequence of the columns of the matrix `xss`.
trim [String] | `trim s` is `s` without leading and trailing whitespace.
trim [StringLabels] | `trim s` is `s` 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.
trunc [Float] | `trunc x` rounds `x` to the nearest integer whose absolute value is less than or equal to `x`.
truncate [UnixLabels.LargeFile] | See `truncate`.
truncate [UnixLabels] | Truncates the named file to the given size.
truncate [Unix.LargeFile] | See `truncate`.
truncate [Unix] | Truncates the named file to the given size.
truncate [Obj] |
truncate [Buffer] | `truncate b len` truncates the length of `b` to `len` Note: the internal byte sequence is not shortened.
truncate [Stdlib] | Same as `int_of_float`.
try_acquire [Semaphore.Binary] | `try_acquire s` immediately returns `false` if the semaphore `s` has value 0.
try_acquire [Semaphore.Counting] | `try_acquire s` immediately returns `false` if the value of semaphore `s` is zero.
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.
type_format [CamlinternalFormat] |
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] |
uncapitalize [String] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.
uncapitalize [StringLabels] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.
uncapitalize [BytesLabels] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.
uncapitalize [Bytes] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.
uncapitalize_ascii [String] | `uncapitalize_ascii s` is `s` with the first character set to lowercase, using the US-ASCII character set.
uncapitalize_ascii [StringLabels] | `uncapitalize_ascii s` is `s` with the first character set to lowercase, using the US-ASCII character set.
uncapitalize_ascii [BytesLabels] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.
uncapitalize_ascii [Bytes] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.
uncons [Seq] | If `xs` is empty, then `uncons xs` is `None`.
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.
unfold [Seq] | `unfold` constructs a sequence out of a step function and an initial state.
union [Set.S] | Set union.
union [MoreLabels.Set.S] | Set union.
union [MoreLabels.Map.S] | `union ~f m1 m2` computes a map whose keys are a subset of the keys of `m1` and of `m2`.
union [Map.S] | `union f m1 m2` computes a map whose keys are a subset of the keys of `m1` and of `m2`.
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.
unsafe_environment [UnixLabels] | Return the process environment, as an array of strings with the format ``variable=value''.
unsafe_environment [Unix] | Return the process environment, as an array of strings with the format ``variable=value''.
unsafe_get [Bigarray.Array3] | Like `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_getenv [UnixLabels] | Return the value associated to a variable in the process environment.
unsafe_getenv [Unix] | Return the value associated to a variable in the process environment.
unsafe_of_string [BytesLabels] | Unsafely convert a shared string to a byte sequence that should not be mutated.
unsafe_of_string [Bytes] | Unsafely convert a shared string to a byte sequence that should not be mutated.
unsafe_set [Bigarray.Array3] | Like `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_to_string [BytesLabels] | Unsafely convert a byte sequence into a string.
unsafe_to_string [Bytes] | Unsafely convert a byte sequence into a string.
unset_data [Obj.Ephemeron] | Same as `Stdlib.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_data eph el` sets the key of `eph` to be an empty key.
unset_key [Obj.Ephemeron] | Same as `Stdlib.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`
unsigned_compare [Nativeint] | Same as `Nativeint.compare`, except that arguments are interpreted as unsigned native integers.
unsigned_compare [Int64] | Same as `Int64.compare`, except that arguments are interpreted as unsigned 64-bit integers.
unsigned_compare [Int32] | Same as `Int32.compare`, except that arguments are interpreted as unsigned 32-bit integers.
unsigned_div [Nativeint] | Same as `Nativeint.div`, except that arguments and result are interpreted as unsigned native integers.
unsigned_div [Int64] | Same as `Int64.div`, except that arguments and result are interpreted as unsigned 64-bit integers.
unsigned_div [Int32] | Same as `Int32.div`, except that arguments and result are interpreted as unsigned 32-bit integers.
unsigned_rem [Nativeint] | Same as `Nativeint.rem`, except that arguments and result are interpreted as unsigned native integers.
unsigned_rem [Int64] | Same as `Int64.rem`, except that arguments and result are interpreted as unsigned 64-bit integers.
unsigned_rem [Int32] | Same as `Int32.rem`, except that arguments and result are interpreted as unsigned 32-bit integers.
unsigned_to_int [Nativeint] | Same as `Nativeint.to_int`, but interprets the argument as an unsigned integer.
unsigned_to_int [Int64] | Same as `Int64.to_int`, but interprets the argument as an unsigned integer.
unsigned_to_int [Int32] | Same as `Int32.to_int`, but interprets the argument as an unsigned integer.
unzip [Seq] | `unzip` transforms a sequence of pairs into a pair of sequences.
update [MoreLabels.Map.S] | `update ~key ~f m` returns a map containing the same bindings as `m`, except for the binding of `key`.
update [Map.S] | `update key f m` returns a map containing the same bindings as `m`, except for the binding of `key`.
update_geometry [Format] |
update_mod [CamlinternalMod] |
uppercase [String] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
uppercase [StringLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
uppercase [Char] | Convert the given character to its equivalent uppercase character, using the ISO Latin-1 (8859-1) character set.
uppercase [BytesLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
uppercase [Bytes] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
uppercase_ascii [String] | `uppercase_ascii s` is `s` with all lowercase letters translated to uppercase, using the US-ASCII character set.
uppercase_ascii [StringLabels] | `uppercase_ascii s` is `s` with all lowercase letters translated to uppercase, using the US-ASCII character set.
uppercase_ascii [Char] | Convert the given character to its equivalent uppercase character, using the US-ASCII character set.
uppercase_ascii [BytesLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set.
uppercase_ascii [Bytes] | Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set.
usage [Arg] | `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_printers [Printexc] | `Printexc.use_printers e` returns `None` if there are no registered printers and `Some s` with else as the resulting string otherwise.
utf_16_byte_length [Uchar] | `utf_16_byte_length u` is the number of bytes needed to encode `u` in UTF-16.
utf_8_byte_length [Uchar] | `utf_8_byte_length u` is the number of bytes needed to encode `u` in UTF-8.
utf_decode [Uchar] | `utf_decode n u` is a valid UTF decode for `u` that consumed `n` elements from the source for decoding.
utf_decode_invalid [Uchar] | `utf_decode_invalid n` is an invalid UTF decode that consumed `n` elements from the source to error.
utf_decode_is_valid [Uchar] | `utf_decode_is_valid d` is `true` if and only if `d` holds a valid decode.
utf_decode_length [Uchar] | `utf_decode_length d` is the number of elements from the source that were consumed by the decode `d`.
utf_decode_uchar [Uchar] | `utf_decode_uchar d` is the Unicode character decoded by `d` if `utf_decode_is_valid d` is `true` and `Uchar.rep` otherwise.
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
value [Result] | `value r ~default` is `v` if `r` is `Ok v` and `default` otherwise.
value [Option] | `value o ~default` is `v` if `o` is `Some v` and `default` otherwise.
W
wait [ThreadUnix] |
wait [Condition] | `wait c m` atomically unlocks the mutex `m` and suspends the calling process on the condition variable `c`.
wait [UnixLabels] | Wait until one of the children processes die, and return its pid and termination status.
wait [Unix] | Wait until one of the children processes die, and return its pid and termination status.
wait_pid [Thread] | Same function as `Unix.waitpid`.
wait_read [Thread] | This function does nothing in the current implementation of the threading library and can be removed from all user programs.
wait_signal [Thread] | `wait_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_write`.
wait_timed_write [Thread] | Suspend the execution of the calling thread until at least one character or EOF is available for reading (`wait_timed_read`) or one character can be written without blocking (`wait_timed_write`) on the given Unix file descriptor.
wait_write [Thread] | This function does nothing in the current implementation of the threading library and can be removed from all user programs.
waitpid [ThreadUnix] |
waitpid [UnixLabels] | Same as `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.
widen [CamlinternalOO] |
win32 [Sys] | True if `Sys.os_type = "Win32"`.
with_open_bin [Out_channel] | `with_open_bin fn f` opens a channel `oc` on file `fn` and returns `f oc`.
with_open_bin [In_channel] | `with_open_bin fn f` opens a channel `ic` on file `fn` and returns `f ic`.
with_open_gen [Out_channel] | Like `Out_channel.with_open_bin`, but can specify the opening mode and file permission, in case the file must be created (see `Out_channel.open_gen`).
with_open_gen [In_channel] | Like `In_channel.with_open_bin`, but can specify the opening mode and file permission, in case the file must be created (see `In_channel.open_gen`).
with_open_text [Out_channel] | Like `Out_channel.with_open_bin`, but the channel is opened in text mode (see `Out_channel.open_text`).
with_open_text [In_channel] | Like `In_channel.with_open_bin`, but the channel is opened in text mode (see `In_channel.open_text`).
with_positions [Lexing] | Tell whether the lexer buffer keeps track of position fields `lex_curr_p` / `lex_start_p`, as determined by the corresponding optional argument for functions that create lexer buffers (whose default value is `true`).
with_tag [Obj] |
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 [ThreadUnix] |
write [UnixLabels] | `write fd ~buf ~pos ~len` writes `len` bytes to descriptor `fd`, taking them from byte sequence `buf`, starting at position `pos` in `buff`.
write [Unix] | `write fd buf pos len` writes `len` bytes to descriptor `fd`, taking them from byte sequence `buf`, starting at position `pos` in `buff`.
write_arg [Arg] | `Arg.write_arg file args` writes the arguments `args` newline-terminated into the file `file`.
write_arg0 [Arg] | Identical to `Arg.write_arg` but uses the null character for terminator instead of newline.
write_substring [ThreadUnix] |
write_substring [UnixLabels] | Same as `UnixLabels.write`, but take the data from a string instead of a byte sequence.
write_substring [Unix] | Same as `Unix.write`, but take the data from a string instead of a byte sequence.
Y
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 [Int] | `zero` is the integer `0`.
zero [Float] | The floating point 0.
zero [Complex] | The complex number `0`.
zip [Seq] | `zip xs ys` is the sequence of pairs `(x, y)` drawn synchronously from the sequences `xs` and `ys`.