# Index of values

 ( * ) [Stdlib] Integer multiplication. ( ** ) [Stdlib] Exponentiation. ( *. ) [Stdlib] Floating-point multiplication. (!) [Stdlib] `!r` returns the current contents of reference `r`. (!=) [Stdlib] Negation of `(==)`. (&&) [Stdlib] The boolean 'and'. (&&) [Bool] `e0 && e1` is the lazy boolean conjunction of expressions `e0` and `e1`. (+) [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] `l0 @ l1` appends `l1` to `l0`. (@@) [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. (|>) [Stdlib] Reverse-application operator: `x |> f |> g` is exactly equivalent to `g (f (x))`. (||) [Stdlib] The boolean 'or'. (||) [Bool] `e0 || e1` is the lazy boolean disjunction of expressions `e0` and `e1`. (~+) [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 [Stdlib] `abs x` is the absolute value of `x`. abs [Nativeint] `abs x` is the absolute value of `x`. abs [Int64] `abs x` is the absolute value of `x`. abs [Int32] `abs x` is the absolute value of `x`. abs [Int] `abs x` is the absolute value of `x`. abs [Float] `abs f` returns the absolute value of `f`. abs_float [Stdlib] `abs_float f` returns the absolute value of `f`. abstract_tag [Obj] 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 [Stdlib] Arc cosine. acos [Float] Arc cosine. acosh [Stdlib] Hyperbolic arc cosine. acosh [Float] 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_to_list [MoreLabels.Map.S] `add_to_list ~key ~data m` is `m` with `key` mapped to `l` such that `l` is `data :: Map.find key m` if `key` was bound in `m` and `[v]` otherwise. add_to_list [Map.S] `add_to_list key data m` is `m` with `key` mapped to `l` such that `l` is `data :: Map.find key m` if `key` was bound in `m` and `[v]` otherwise. 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_user_event [Runtime_events.Callbacks] `add_user_event ty callback t` extends `t` to additionally subscribe to user events of type `ty`. 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 number of bytes allocated by this domain and potentially a previous domain. 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] `append l0 l1` appends `l1` to `l0`. append [List] `append l0 l1` appends `l1` to `l0`. 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 [Stdlib] Arc sine. asin [Float] Arc sine. asinh [Stdlib] Hyperbolic arc sine. asinh [Float] 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. at_exit [Domain] `at_exit f` registers `f` to be called when the current domain exits. atan [Stdlib] Arc tangent. atan [Float] Arc tangent. atan2 [Stdlib] `atan2 y x` returns the arc tangent of `y /. x`. atan2 [Float] `atan2 y x` returns the arc tangent of `y /. x`. atanh [Stdlib] Hyperbolic arc tangent. atanh [Float] 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. before_first_spawn [Domain] `before_first_spawn f` registers `f` to be called before the first domain is spawned by the program. 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] Same as `Bytes.blit_string` which should be preferred. blit [StringLabels] Same as `Bytes.blit_string` which should be preferred. 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 byte sequence `src`, starting at index `src_pos`, to byte sequence `dst`, starting at index `dst_pos`. blit [Bytes] `blit src src_pos dst dst_pos len` copies `len` bytes from byte sequence `src`, starting at index `src_pos`, to byte 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] blit_key [Obj.Ephemeron] blit_string [BytesLabels] `blit_string ~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_string 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`). broadcast [Condition] `broadcast c` wakes up all threads 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. bscanf_opt [Scanf] Same as `Scanf.bscanf`, but returns `None` in case of scanning failure. bufput_acc [CamlinternalFormat] bytes [Digest] Return the digest of the given byte sequence. C c_layout [Bigarray] 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 [Stdlib] Round above to an integer value. ceil [Float] 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] check_geometry [Format] Check if the formatter geometry is valid: `1 < max_indent < margin` check_key [Obj.Ephemeron] 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 [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 [Event] `choose evl` returns the event that is the alternative of all the events in the list `evl`. 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 [Stdlib] Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number. classify_float [Float] Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number. clean [Ephemeron.SeededS] remove all dead bindings. clean [Ephemeron.S] remove all dead bindings. clear [Weak.S] Remove all elements from the table. clear [Stack] Discard all elements from a stack. clear [Queue] Discard all elements from a queue. clear [MoreLabels.Hashtbl.SeededS] clear [MoreLabels.Hashtbl.S] clear [MoreLabels.Hashtbl] 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 [Stdlib] Close the given channel. close_in [Scanf.Scanning] Closes the `in_channel` associated with the given `Scanf.Scanning.in_channel` formatted input 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_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 [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 [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_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_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] complex64 [Bigarray] compression_supported [Marshal] Indicates whether the compressed data format is supported. 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 [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`. cont_tag [Obj] 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. continue [Effect.Deep] `continue k x` resumes the continuation `k` by passing `x` to `k`. continue_with [Effect.Shallow] `continue_with k v h` resumes the continuation `k` with value `v` with the handler `h`. convert_raw_backtrace_slot [Printexc] Extracts the user-friendly `backtrace_slot` from a low-level `raw_backtrace_slot`. copy [CamlinternalOO] 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 [Stdlib] Cosine. cos [Float] Cosine. cosh [Stdlib] Hyperbolic cosine. cosh [Float] Hyperbolic cosine. count [Weak.S] Count the number of elements in the table. counters [Gc] Return `(minor_words, promoted_words, major_words)` for the current domain or potentially previous domains. cpu_relax [Domain] If busy-waiting, calling cpu_relax () between iterations will improve performance on some CPU architectures 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 domain. 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 [Stack] Return a new stack, initially empty. create [Runtime_events.Callbacks] Create a `Callback` that optionally subscribes to one or more runtime events. create [Queue] Return a new queue, initially empty. create [Obj.Ephemeron] `create n` returns an ephemeron with `n` keys. create [Mutex] Return a new mutex. create [MoreLabels.Hashtbl.SeededS] create [MoreLabels.Hashtbl.S] create [MoreLabels.Hashtbl] `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.SeededS] create [Ephemeron.S] create [Condition] `create()` creates and returns a new condition variable. create [BytesLabels] `create n` returns a new byte sequence of length `n`. create [Bytes] `create n` returns a new byte sequence of length `n`. create [Buffer] `create n` returns a fresh buffer, initially empty. create [Bigarray.Array3] `Array3.create kind layout dim1 dim2 dim3` returns a new Bigarray of three 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_alarm [Gc] `create_alarm f` will arrange for `f` to be called at the end of each major GC cycle, not caused by `f` itself, starting with the current cycle or the next one. create_char_set [CamlinternalFormat] create_cursor [Runtime_events] `create_cursor path_pid` creates a cursor to read from an runtime_events. 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_object [CamlinternalOO] create_object_and_run_initializers [CamlinternalOO] create_object_opt [CamlinternalOO] create_process [UnixLabels] `create_process ~prog ~args ~stdin ~stdout ~stderr` creates a new process that executes the program in file `prog`, with arguments `args`. create_process [Unix] `create_process prog args stdin stdout stderr` creates 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] decr [Stdlib] Decrement the integer contained in the given reference. decr [Atomic] `decr r` atomically decrements the value of `r` by `1`. 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] discontinue [Effect.Deep] `discontinue k e` resumes the continuation `k` by raising the exception `e` in `k`. discontinue_with [Effect.Shallow] `discontinue_with k e h` resumes the continuation `k` by raising the exception `e` with the handler `h`. discontinue_with_backtrace [Effect.Shallow] `discontinue_with k e bt h` resumes the continuation `k` by raising the exception `e` with the handler `h` using the raw backtrace `bt` as the origin of the exception. discontinue_with_backtrace [Effect.Deep] `discontinue_with_backtrace k e bt` resumes the continuation `k` by raising the exception `e` in `k` using `bt` as the origin for the exception. 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 [Stack] `drop s` removes the topmost element in stack `s`, or raises `Stack.Empty` if the stack is empty. 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 [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 `get_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] The initial domain's 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_resume [Gc] exchange [Atomic] Set a new value for the atomic reference, and return the current value. executable_name [Sys] The name of the file containing the executable currently running. execv [UnixLabels] `execv ~prog ~args` execute the program in file `prog`, with the arguments `args`, and the current process environment. execv [Unix] `execv prog args` execute the program in file `prog`, with the arguments `args`, and the current process environment. 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 [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] Raise the `Thread.Exit` exception. 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 [Stdlib] Exponential. exp [Float] Exponential. exp [Complex] Exponentiation. exp2 [Float] Base 2 exponential function. expm1 [Stdlib] `expm1 x` computes `exp x -. 1.0`, giving numerically-accurate results even if `x` is close to `0.0`. expm1 [Float] `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: 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). fiber [Effect.Shallow] `fiber f` constructs a continuation that runs the computation `f`. 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 [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`. 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. 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_index [Seq] `find_index p xs` returns `Some i`, where `i` is the index of the first element of the sequence `xs` that satisfies `p x`, if there is such an element. find_index [ListLabels] `find_index ~f xs` returns `Some i`, where `i` is the index of the first element of the list `xs` that satisfies `f x`, if there is such an element. find_index [List] `find_index f xs` returns `Some i`, where `i` is the index of the first element of the list `xs` that satisfies `f x`, if there is such an element. find_index [Float.ArrayLabels] `find_index ~f a` returns `Some i`, where `i` is the index of the first element of the array `a` that satisfies `f x`, if there is such an element. find_index [Float.Array] `find_index f a` returns `Some i`, where `i` is the index of the first element of the array `a` that satisfies `f x`, if there is such an element. find_index [ArrayLabels] `find_index ~f a` returns `Some i`, where `i` is the index of the first element of the array `a` that satisfies `f x`, if there is such an element. find_index [Array] `find_index f a` returns `Some i`, where `i` is the index of the first element of the array `a` that satisfies `f x`, if there is such an element. 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 [Float.ArrayLabels] find_map [Float.Array] 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_mapi [Seq] Same as `find_map`, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. find_mapi [ListLabels] Same as `find_map`, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. find_mapi [List] Same as `find_map`, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. find_mapi [Float.ArrayLabels] Same as `find_map`, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. find_mapi [Float.Array] Same as `find_map`, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. find_mapi [ArrayLabels] Same as `find_map`, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. find_mapi [Array] Same as `find_map`, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. 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 [Float.ArrayLabels] find_opt [Float.Array] 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 [Stdlib] Same as `float_of_int`. float [Random.State] float [Random] `Random.float bound` returns a random floating-point number between 0 and `bound` (inclusive). float32 [Bigarray] float64 [Bigarray] 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 [Stdlib] Round below to an integer value. floor [Float] Round below to an integer value. flush [Stdlib] Flush the buffer associated with the given output channel, performing all pending writes on that channel. flush [Out_channel] Flush the buffer associated with the given output channel, performing all pending writes on that channel. flush_all [Stdlib] Flush all open output channels; ignore errors. flush_all [Out_channel] 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` of the current domain, 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 [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_lines [In_channel] `fold_lines f init ic` reads lines from `ic` using `In_channel.input_line` until the end of file is reached, and successively passes each line to function `f` in the style of a fold. 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 [Lazy] `force x` forces the suspension `x` and returns its result. force_gen [CamlinternalLazy] force_lazy_block [CamlinternalLazy] force_newline [Format] Force a new line in the current pretty-printing box. force_val [Lazy] `force_val x` forces the suspension `x` and returns its result. forcing_tag [Obj] 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] free_cursor [Runtime_events] Free a previously created runtime_events cursor freeze_char_set [CamlinternalFormat] frexp [Stdlib] `frexp f` returns the pair of the significant and the exponent of `f`. frexp [Float] `frexp f` returns the pair of the significant and the exponent of `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. 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 [Domain.DLS] `get k` returns `v` if a value `v` is associated to the key `k` on the calling domain's domain-local state. 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_backtrace [Printexc] `Printexc.get_backtrace ()` returns a string containing the same exception backtrace that `Printexc.print_backtrace` would print. 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_callstack [Effect.Shallow] `get_callstack c n` returns a description of the top of the call stack on the continuation `c`, with at most `n` entries. get_callstack [Effect.Deep] `get_callstack c n` returns a description of the top of the call stack on the continuation `c`, 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_data [Obj.Ephemeron] get_data_copy [Obj.Ephemeron] get_ellipsis_text [Format] Return the text of the ellipsis. get_err_formatter [Format] `get_err_formatter ()` returns the current domain's formatter used to write to standard error. 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_geometry [Format] Return the current geometry of the formatter get_id [Domain] `get_id d` returns the identifier of the domain `d` 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] get_key_copy [Obj.Ephemeron] 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 of this domain. 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] `get_state()` returns a fresh copy of the current state of the domain-local generator (which is used by the basic functions). get_std_formatter [Format] `get_std_formatter ()` returns the current domain's standard formatter used to write to standard output. get_stdbuf [Format] `get_stdbuf ()` returns the current domain's string buffer in which the current domain's string formatter writes. get_str_formatter [Format] The current domain's formatter to output to the current domains string buffer. 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 [String] An unseeded hash function for strings, with the same output value as `Hashtbl.hash`. hash [StringLabels] An unseeded hash function for strings, with the same output value as `Hashtbl.hash`. hash [Nativeint] An unseeded hash function for native ints, with the same output value as `Hashtbl.hash`. 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 [Int64] An unseeded hash function for 64-bit ints, with the same output value as `Hashtbl.hash`. hash [Int32] An unseeded hash function for 32-bit ints, with the same output value as `Hashtbl.hash`. hash [Int] An unseeded hash function for ints, with the same output value as `Hashtbl.hash`. 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] An unseeded hash function for floats, with the same output value as `Hashtbl.hash`. hash [Char] An unseeded hash function for characters, with the same output value as `Hashtbl.hash`. hash [Bool] An unseeded hash function for booleans, with the same output value as `Hashtbl.hash`. 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. 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. 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. 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 [Stdlib] Increment the integer contained in the given reference. incr [Atomic] `incr r` atomically increments the value of `r` by `1`. 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 [Stdlib] Positive infinity. infinity [Float] 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 domain-local 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 [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 [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_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 [Stdlib] Same as `input_char`, but return the 8-bit integer representing the character. input_byte [In_channel] Same as `In_channel.input_char`, but return the 8-bit integer representing the character. input_char [Stdlib] Read one character from the given input channel. input_char [In_channel] Read one character from the given input channel. input_line [Stdlib] Read characters from the given input channel, until a newline character is encountered. input_line [In_channel] `input_line ic` reads characters from `ic` until a newline or the end of file is reached. input_lines [In_channel] `input_lines ic` reads lines using `In_channel.input_line` until the end of file is reached. input_value [Stdlib] Read the representation of a structured value, as produced by `output_value`, and return the corresponding value. int [Runtime_events.Type] An event containing an integer value int [Random.State] int [Random] `Random.int bound` returns a random integer between 0 (inclusive) and `bound` (exclusive). int [Bigarray] int16_signed [Bigarray] int16_unsigned [Bigarray] int32 [Random.State] int32 [Random] `Random.int32 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive). int32 [Bigarray] int64 [Random.State] int64 [Random] `Random.int64 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive). int64 [Bigarray] int8_signed [Bigarray] int8_unsigned [Bigarray] 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_empty [ListLabels] `is_empty l` is true if and only if `l` has no elements. is_empty [List] `is_empty l` is true if and only if `l` has no elements. 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_main_domain [Domain] `is_main_domain ()` returns true if called from the initial domain. 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_regular_file [Sys] Returns `true` if the given name refers to a regular file, `false` if it refers to another kind of file. 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. isatty [Out_channel] `isatty oc` is `true` if `oc` refers to a terminal or console window, `false` otherwise. isatty [In_channel] `isatty ic` is `true` if `ic` 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 [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 [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. join [Domain] `join d` blocks until domain `d` runs to completion. 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. 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`. 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_tag [Obj] ldexp [Stdlib] `ldexp x n` returns `x *. 2 ** n`. ldexp [Float] `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. lifecycle_name [Runtime_events] Return a string representation of a given lifecycle event type 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 [Stdlib] Natural logarithm. log [Float] Natural logarithm. log [Complex] Natural logarithm (in base `e`). log10 [Stdlib] Base 10 logarithm. log10 [Float] Base 10 logarithm. log1p [Stdlib] `log1p x` computes `log(1.0 +. x)` (natural logarithm), giving numerically-accurate results even if `x` is close to `0.0`. log1p [Float] `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_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 [Type.Id] `make ()` is a new type identifier. 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 [Semaphore.Binary] `make b` returns a new binary semaphore. make [Semaphore.Counting] `make n` returns a new counting semaphore, with initial value `n`. 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_class [CamlinternalOO] make_class_store [CamlinternalOO] 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_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 random seed chosen in a system-dependent way. make_symbolic_output_buffer [Format] `make_symbolic_output_buffer ()` returns a fresh buffer for symbolic output. make_synchronized_formatter [Format] `make_synchronized_formatter out flush` returns the key to the domain-local state that holds the domain-local formatter that outputs with function `out`, and flushes with function `flush`. 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)` if `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_inplace [Float.ArrayLabels] `map_inplace f a` applies function `f` to all elements of `a`, and updates their values in place. map_inplace [Float.Array] `map_inplace f a` applies function `f` to all elements of `a`, and updates their values in place. map_inplace [ArrayLabels] `map_inplace ~f a` applies function `f` to all elements of `a`, and updates their values in place. map_inplace [Array] `map_inplace f a` applies function `f` to all elements of `a`, and updates their values in place. 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. mapi_inplace [Float.ArrayLabels] Same as `Float.ArrayLabels.map_inplace`, but the function is applied to the index of the element as first argument, and the element itself as second argument. mapi_inplace [Float.Array] Same as `Float.Array.map_inplace`, but the function is applied to the index of the element as first argument, and the element itself as second argument. mapi_inplace [ArrayLabels] Same as `ArrayLabels.map_inplace`, but the function is applied to the index of the element as first argument, and the element itself as second argument. mapi_inplace [Array] Same as `Array.map_inplace`, 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). match_with [Effect.Deep] `match_with f v h` runs the computation `f v` in the handler `h`. 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 [Stdlib] Return the greater of the two arguments. 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_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 [Stdlib] The largest positive finite value of type `float`. max_float [Float] The largest positive finite value of type `float`. max_floatarray_length [Sys] Maximum length of a floatarray. max_int [Stdlib] The greatest representable integer. max_int [Nativeint] The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform. max_int [Int64] The greatest representable 64-bit integer, 263 - 1. max_int [Int32] The greatest representable 32-bit integer, 231 - 1. max_int [Int] `max_int` is the greatest representable integer, `2{^[Sys.int_size - 1]} - 1`. 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 [Stdlib] Return the smaller of the two arguments. 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_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 [Stdlib] The smallest positive, non-zero, non-denormalized value of type `float`. min_float [Float] The smallest positive, non-zero, non-denormalized value of type `float`. min_int [Stdlib] The smallest representable integer. min_int [Nativeint] The smallest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform. min_int [Int64] The smallest representable 64-bit integer, -263. min_int [Int32] The smallest representable 32-bit integer, -231. min_int [Int] `min_int` is the smallest representable integer, `-2{^[Sys.int_size - 1]}`. 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 by this domain or potentially previous domains. 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 [Stdlib] `modf f` returns the pair of the fractional and integral part of `f`. modf [Float] `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 [Runtime_events.User] `name t` is the uniquely identifying name of event `t` 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 [Stdlib] A special floating-point value denoting the result of an undefined operation such as `0.0 /. 0.0`. nan [Float] 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] 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 [Stdlib] Negative infinity. neg_infinity [Float] 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_key [Domain.DLS] `new_key f` returns a new key bound to initialiser `f` for accessing , domain-local variables. 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_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 [Stdlib] The boolean negation. not [Bool] `not b` is the boolean negation of `b`. 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_release` is the version of OCaml. 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_binary_string [Random.State] Deserializes a byte sequence obtained by calling `Random.State.to_binary_string`. of_bytes [String] Return a new string that contains the same bytes as the given byte sequence. of_bytes [StringLabels] Return a new string that contains the same bytes as the given byte sequence. 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 [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 [MoreLabels.Map.S] `of_list bs` adds the bindings of `bs` to the empty map, in list order (if a key is bound twice in `bs` the last one takes over). of_list [Map.S] `of_list bs` adds the bindings of `bs` to the empty map, in list order (if a key is bound twice in `bs` the last one takes over). 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 [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 [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 [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 [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_bin [Stdlib] Same as `open_in`, but the file is opened in binary mode, so that no translation takes place during reads. 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_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 [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] `open_process_args prog args` runs the program `prog` with arguments `args`. open_process_args [Unix] `open_process_args prog args` runs the program `prog` with arguments `args`. 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] Same as `UnixLabels.open_process_args`, but redirects only the standard output of the new process. open_process_args_in [Unix] Same as `Unix.open_process_args`, but redirects only the standard output of the new process. open_process_args_out [UnixLabels] Same as `UnixLabels.open_process_args`, but redirects only the standard input of the new process. open_process_args_out [Unix] Same as `Unix.open_process_args`, but redirects only the standard input of the new process. open_process_full [UnixLabels] Similar to `UnixLabels.open_process`, but the second argument specifies the environment passed to the command. open_process_full [Unix] Similar to `Unix.open_process`, but the second argument specifies the environment passed to the command. open_process_in [UnixLabels] High-level pipe and process management. open_process_in [Unix] High-level pipe and process management. open_process_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_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 [Stdlib] `output oc buf pos len` writes `len` characters from byte sequence `buf`, starting at offset `pos`, to the given output channel `oc`. 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_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 [Stdlib] Write one 8-bit integer (as the single character with that code) on the given output channel. output_byte [Out_channel] Write one 8-bit integer (as the single character with that code) on the given output channel. output_bytes [Stdlib] Write the byte sequence on the given output channel. output_bytes [Out_channel] Write the byte sequence on the given output channel. output_char [Stdlib] Write the character on the given output channel. output_char [Out_channel] Write the character on the given output channel. output_string [Stdlib] Write the string on the given output channel. output_string [Out_channel] Write the string on the given output channel. output_substring [Stdlib] Same as `output` but take a string as argument instead of a byte sequence. output_substring [Out_channel] Same as `Out_channel.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. pause [Runtime_events] `pause ()` will pause the collection of events in the runtime. 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. perform [Effect] `perform e` performs an effect `e`. pi [Float] The constant pi. 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_tbox [Format] pp_force_newline [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_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_tbox [Format] pp_open_vbox [Format] pp_over_max_boxes [Format] pp_print_array [Format] `pp_print_array ?pp_sep pp_v ppf a` prints items of array `a`, using `pp_v` to print each item, and calling `pp_sep` between items (`pp_sep` defaults to `Format.pp_print_cut`). 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_iter [Format] `pp_print_iter ~pp_sep iter pp_v ppf v` formats on `ppf` the iterations of `iter` over a collection `v` of values using `pp_v`. 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_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_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 [Stdlib] `pred x` is `x - 1`. 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`. 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 [Stdlib] Print a byte sequence on standard output. print_bytes [Format] `pp_print_bytes ppf b` prints `b` in the current pretty-printing box. print_char [Stdlib] Print a character on standard output. print_char [Format] Print a character in the current pretty-printing box. 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 [Stdlib] Print a floating-point number, in decimal, on standard output. print_float [Format] Print a floating point number in the current pretty-printing box. print_flush [Format] End of pretty-printing: resets the pretty-printer to initial state. print_if_newline [Format] Execute the next formatting command if the preceding line has just been split. print_int [Stdlib] Print an integer, in decimal, on standard output. print_int [Format] Print an integer in the current pretty-printing box. print_newline [Stdlib] Print a newline character on standard output, and flush standard output. print_newline [Format] End of pretty-printing: resets the pretty-printer to initial state. print_raw_backtrace [Printexc] Print a raw backtrace in the same format `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) of the total program into the channel argument. print_string [Stdlib] Print a string on standard output. print_string [Format] `pp_print_string ppf s` prints `s` in the current pretty-printing box. 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 `get_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 [Mutex] `protect mutex f` runs `f()` in a critical section where `mutex` is locked (using `Mutex.lock`); it then takes care of releasing `mutex`, whether `f()` returned a value or raised an exception. protect [Fun] `protect ~finally work` invokes `work ()` and then `finally ()` before `work ()` returns with its value or an exception. provably_equal [Type.Id] `provably_equal i0 i1` is `Some Equal` if identifier `i0` is equal to `i1` and `None` otherwise. 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. quiet_nan [Float] Quiet NaN. 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 [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. read_poll [Runtime_events] `read_poll cursor callbacks max_option` calls the corresponding functions on `callbacks` for up to `max_option` events read off `cursor`'s runtime_events and returns the number of events read. 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 [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 [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_string [Stdlib] `really_input_string ic len` reads `len` characters from channel `ic` and returns them in a new string. really_input_string [In_channel] `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`. recommended_domain_count [Domain] The recommended maximum number of domains which should be running simultaneously (including domains already running). record_backtrace [Printexc] `Printexc.record_backtrace b` turns recording of exception backtraces on (if `b = true`) or off (if `b = false`). recv [UnixLabels] Receive data from a connected socket. recv [Unix] Receive data from a connected socket. 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 [Runtime_events.User] `register name tag ty` registers a new event with an unique `name`, carrying a `tag` and values of type `ty` register [Runtime_events.Type] Registers a custom type by providing an encoder and a decoder. 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 or directory. 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. resume [Runtime_events] `resume ()` will resume the collection of events in the runtime. 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 more efficient. rev_map [List] `rev_map f l` gives the same result as `List.rev`` (``List.map`` f l)`, but is more efficient. rev_map2 [ListLabels] `rev_map2 ~f l1 l2` gives the same result as `ListLabels.rev`` (``ListLabels.map2`` f l1 l2)`, but is more efficient. rev_map2 [List] `rev_map2 f l1 l2` gives the same result as `List.rev`` (``List.map2`` f l1 l2)`, but is 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] 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_counter_name [Runtime_events] Return a string representation of a given runtime counter type runtime_parameters [Sys] Return the value of the runtime parameters, in the same format as the contents of the `OCAMLRUNPARAM` environment variable. runtime_phase_name [Runtime_events] Return a string representation of a given runtime phase event type 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`. scanf_opt [Scanf] Same as `Scanf.scanf`, but returns `None` in case of scanning failure. 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 [String] A seeded hash function for strings, with the same output value as `Hashtbl.seeded_hash`. seeded_hash [StringLabels] A seeded hash function for strings, with the same output value as `Hashtbl.seeded_hash`. seeded_hash [Nativeint] A seeded hash function for native ints, with the same output value as `Hashtbl.seeded_hash`. seeded_hash [MoreLabels.Hashtbl.SeededHashedType] A seeded hashing function on keys. seeded_hash [MoreLabels.Hashtbl] A variant of `MoreLabels.Hashtbl.hash` that is further parameterized by an integer seed. seeded_hash [Int64] A seeded hash function for 64-bit ints, with the same output value as `Hashtbl.seeded_hash`. seeded_hash [Int32] A seeded hash function for 32-bit ints, with the same output value as `Hashtbl.seeded_hash`. seeded_hash [Int] A seeded hash function for ints, with the same output value as `Hashtbl.seeded_hash`. seeded_hash [Hashtbl.SeededHashedType] A seeded hashing function on keys. seeded_hash [Hashtbl] A variant of `Hashtbl.hash` that is further parameterized by an integer seed. seeded_hash [Float] A seeded hash function for floats, with the same output value as `Hashtbl.seeded_hash`. seeded_hash [Char] A seeded hash function for characters, with the same output value as `Hashtbl.seeded_hash`. seeded_hash [Bool] A seeded hash function for booleans, with the same output value as `Hashtbl.seeded_hash`. 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 [UnixLabels] Wait until some input/output operations become possible on some channels. select [Unix] Wait until some input/output operations become possible on some channels. select [Thread] Same function as `Unix.select`. select [Event] 'Synchronize' on an alternative of events. self [Thread] Return the handle for the thread currently executing. self [Domain] `self ()` is the identifier of the currently running domain self_init [Random] Initialize the domain-local generator with a random seed chosen in a system-dependent way. send [CamlinternalOO] send [UnixLabels] Send data over a connected socket. send [Unix] Send data over a connected socket. send [Event] `send ch v` returns the event consisting in sending the value `v` over the channel `ch`. 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 [UnixLabels] Send data over an unconnected socket. sendto [Unix] Send data over an unconnected socket. 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 [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 [Domain.DLS] `set k v` updates the calling domain's domain-local state to associate the key `k` with value `v`. 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_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] 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_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] 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_state s` updates the current state of the domain-local generator (which is used by the basic functions) by copying the state `s` into it. set_tab [Format] Sets a tabulation marker at current insertion point. 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 [Sys] Set the behavior of the system on receipt of a given signal. signal [Condition] `signal c` wakes up one of the threads waiting on the condition variable `c`, if there is one. signaling_nan [Float] Signaling NaN. 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 [Stdlib] Sine. sin [Float] 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 [Stdlib] Hyperbolic sine. sinh [Float] 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 [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 [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`. span [Runtime_events.Type] An event that has a beginning and an end spawn [Domain] `spawn f` creates a new domain that runs in parallel with the current domain. 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 [Random.State] Draw a fresh PRNG state from the given PRNG state. split [Random] Draw a fresh PRNG state from the current state of the domain-local generator used by the default functions. 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 [Stdlib] Square root. sqrt [Float] Square root. sqrt [Complex] 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. sscanf_opt [Scanf] Same as `Scanf.sscanf`, but returns `None` in case of scanning failure. 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 [Runtime_events] `start ()` will start the collection of events in the runtime if not already started. 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 that represent the program's total memory stats. 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 initial domain's standard formatter to write to standard output. stdbuf [Format] The initial domain's string buffer in which `str_formatter` writes. stderr [UnixLabels] File descriptor for standard error. stderr [Unix] File descriptor for standard error. stderr [Stdlib] The standard error output for the process. stderr [Out_channel] The standard error output for the process. stdin [UnixLabels] File descriptor for standard input. stdin [Unix] File descriptor for standard input. stdin [Stdlib] The standard input for the process. stdin [Scanf.Scanning] The standard input notion for the `Scanf` module. stdin [In_channel] The standard input for the process. stdout [UnixLabels] File descriptor for standard output. stdout [Unix] File descriptor for standard output. stdout [Stdlib] The standard output for the process. stdout [Out_channel] The standard output for the process. stop [Gc.Memprof] Stop the sampling. str_formatter [Format] The initial domain's 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 a 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 [Stdlib] `succ x` is `x + 1`. 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`. symbol_end [Parsing] 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. synchronized_formatter_of_out_channel [Format] `synchronized_formatter_of_out_channel oc` returns the key to the domain-local state that holds the domain-local formatter for writing to the corresponding output channel `oc`. 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 [Runtime_events.User] `tag t` is the associated tag of event `t`, when it is known. 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 [Stdlib] Tangent. tan [Float] Tangent. tanh [Stdlib] Hyperbolic tangent. tanh [Float] 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 [Filename] `temp_dir prefix suffix` creates and returns the name of a fresh temporary directory with permissions `perms` (defaults to 0o700) inside `temp_dir`. 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. 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_binary_string [Random.State] Serializes the PRNG state into an immutable sequence of bytes. 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_int64 [Runtime_events.Timestamp] to_list [Set.S] `to_list s` is `Set.S.elements`` s`. 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 [MoreLabels.Set.S] `to_list s` is `MoreLabels.Set.S.elements`` s`. to_list [MoreLabels.Map.S] `to_list m` is `MoreLabels.Map.S.bindings`` m`. to_list [Map.S] `to_list m` is `Map.S.bindings`` m`. 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 [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_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_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 a 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] 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 [Stdlib] Same as `int_of_float`. truncate [Buffer] `truncate b len` truncates the length of `b` to `len` Note: the internal byte sequence is not shortened. 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. try_with [Effect.Deep] `try_with f v h` runs the computation `f v` under the handler `h`. type_format [CamlinternalFormat] U uid [Type.Id] `uid id` is a runtime unique identifier for `id`. 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_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`. unit [Runtime_events.Type] An event that has no data associated with it 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] unset_key [Obj.Ephemeron] 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_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 [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 [Condition] The call `wait c m` is permitted only if `m` is the mutex associated with the condition variable `c`, and only if `m` is currently locked. wait_pid [Thread] Same function as `Unix.waitpid`. 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] 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. 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 [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 [Runtime_events.User] `write t v` records a new event `t` with value `v` 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 [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`.