|  | 
| ( * ) [Stdlib] |  | 
| ( ** ) [Stdlib] |  | 
| ( *. ) [Stdlib] | 
Floating-point multiplication. | 
| (!) [Stdlib] | 
!rreturns the current contents of referencer.
 | 
| (!=) [Stdlib] |  | 
| (&&) [Bool] | 
e0 && e1is the lazy boolean conjunction of expressionse0ande1.
 | 
| (&&) [Stdlib] |  | 
| (&) [Stdlib] | 
 | 
| (+) [Stdlib] |  | 
| (+.) [Stdlib] |  | 
| (-) [Stdlib] |  | 
| (-.) [Stdlib] | 
Floating-point subtraction. | 
| (/) [Stdlib] |  | 
| (/.) [Stdlib] |  | 
| (:=) [Stdlib] | 
r := astores the value ofain referencer.
 | 
| (<) [Stdlib] |  | 
| (<=) [Stdlib] |  | 
| (<>) [Stdlib] |  | 
| (=) [Stdlib] | 
e1 = e2tests for structural equality ofe1ande2.
 | 
| (==) [Stdlib] | 
e1 == e2tests for physical equality ofe1ande2.
 | 
| (>) [Stdlib] |  | 
| (>=) [Stdlib] | 
Structural ordering functions. | 
| (@) [Stdlib] |  | 
| (@@) [Stdlib] | 
Application operator: g @@ f @@ xis exactly equivalent tog (f (x)). | 
| (^) [Stdlib] |  | 
| (^^) [Stdlib] | 
f1 ^^ f2catenates format stringsf1andf2.
 | 
| (asr) [Stdlib] | 
n asr mshiftsnto the right bymbits.
 | 
| (land) [Stdlib] |  | 
| (lor) [Stdlib] |  | 
| (lsl) [Stdlib] | 
n lsl mshiftsnto the left bymbits.
 | 
| (lsr) [Stdlib] | 
n lsr mshiftsnto the right bymbits.
 | 
| (lxor) [Stdlib] | 
Bitwise logical exclusive or. | 
| (mod) [Stdlib] |  | 
| (or) [Stdlib] | 
 | 
| (|>) [Stdlib] | 
Reverse-application operator: x |> f |> gis exactly equivalent
 tog (f (x)). | 
| (||) [Bool] | 
e0 || e1is the lazy boolean disjunction of expressionse0ande1.
 | 
| (||) [Stdlib] |  | 
| (~+) [Stdlib] |  | 
| (~+.) [Stdlib] |  | 
| (~-) [Stdlib] |  | 
| (~-.) [Stdlib] |  | 
| __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__ exprreturns a pair(line, expr), wherelineis the
    line number at which the expressionexprappears 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__ exprreturns a pair(loc, expr)wherelocis the
    location ofexprin 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__ exprreturns a pair(loc,expr), wherelocis a
    tuple(file,lnum,cnum,enum)corresponding to the location at
    which the expressionexprappears in the file currently being
    parsed by the compiler.
 | 
| __POS__ [Stdlib] | 
__POS__returns a tuple(file,lnum,cnum,enum), corresponding
    to the location at which this expression appears in the file
    currently being parsed by the compiler.
 | 
| _exit [UnixLabels] | 
Terminate the calling process immediately, returning the given
   status code to the operating system: usually 0 to indicate no
   errors, and a small positive integer to indicate failure. | 
| _exit [Unix] | 
Terminate the calling process immediately, returning the given
   status code to the operating system: usually 0 to indicate no
   errors, and a small positive integer to indicate failure. | 
| A | 
| abs [Nativeint] | 
Return the absolute value of its argument. | 
| abs [Int64] | 
Return the absolute value of its argument. | 
| abs [Int32] | 
Return the absolute value of its argument. | 
| abs [Int] | 
abs xis the absolute value ofx.
 | 
| abs [Float] | 
abs freturns the absolute value off.
 | 
| abs [Stdlib] | 
Return the absolute value of the argument. | 
| abs_float [Stdlib] | 
abs_float freturns the absolute value off.
 | 
| abstract_tag [Obj] |  | 
| accept [ThreadUnix] |  | 
| accept [UnixLabels] | 
Accept connections on the given socket. | 
| accept [Unix] | 
Accept connections on the given socket. | 
| access [UnixLabels] | 
Check that the process has the given permissions over the named file. | 
| access [Unix] | 
Check that the process has the given permissions over the named file. | 
| acos [Float] |  | 
| acos [Stdlib] |  | 
| acosh [Float] |  | 
| acosh [Stdlib] |  | 
| acquire [Semaphore.Binary] | 
acquire sblocks the calling thread until the semaphoreshas value 1 (is available), then atomically sets it to 0
    and returns.
 | 
| acquire [Semaphore.Counting] | 
acquire sblocks the calling thread until the value of semaphoresis not zero, then atomically decrements the value ofsand returns.
 | 
| adapt_filename [Dynlink] | 
In bytecode, the identity function. | 
| add [Weak.S] |  | 
| add [Set.S] | 
add x sreturns a set containing all elements ofs,
       plusx.
 | 
| add [Queue] | 
add x qadds the elementxat the end of the queueq.
 | 
| add [Nativeint] |  | 
| add [MoreLabels.Set.S] | 
add x sreturns a set containing all elements ofs,
         plusx.
 | 
| add [MoreLabels.Map.S] | 
add ~key ~data mreturns a map containing the same bindings asm, plus a binding ofkeytodata.
 | 
| add [MoreLabels.Hashtbl.SeededS] |  | 
| add [MoreLabels.Hashtbl.S] |  | 
| add [MoreLabels.Hashtbl] | 
Hashtbl.add tbl ~key ~dataadds a binding ofkeytodatain tabletbl.
 | 
| add [Map.S] | 
add key data mreturns a map containing the same bindings asm, plus a binding ofkeytodata.
 | 
| add [Int64] |  | 
| add [Int32] |  | 
| add [Int] | 
add x yis the additionx + y.
 | 
| add [Hashtbl.SeededS] |  | 
| add [Hashtbl.S] |  | 
| add [Hashtbl] | 
Hashtbl.add tbl key dataadds a binding ofkeytodatain tabletbl.
 | 
| add [Float] |  | 
| 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] |  | 
| add_buffer [Buffer] | 
add_buffer b1 b2appends the current contents of bufferb2at the end of bufferb1.
 | 
| add_bytes [Buffer] | 
add_bytes b sappends the byte sequencesat the end of bufferb.
 | 
| add_channel [Buffer] | 
add_channel b ic nreads at mostncharacters from the
   input channelicand stores them at the end of bufferb.
 | 
| add_char [Buffer] | 
add_char b cappends the charactercat the end of bufferb.
 | 
| add_in_char_set [CamlinternalFormat] |  | 
| add_initializer [CamlinternalOO] |  | 
| add_int16_be [Buffer] | 
add_int16_be b iappends a binary big-endian signed 16-bit
    integeritob.
 | 
| add_int16_le [Buffer] | 
add_int16_le b iappends a binary little-endian signed 16-bit
    integeritob.
 | 
| add_int16_ne [Buffer] | 
add_int16_ne b iappends a binary native-endian signed 16-bit
    integeritob.
 | 
| add_int32_be [Buffer] | 
add_int32_be b iappends a binary big-endian 32-bit integeritob.
 | 
| add_int32_le [Buffer] | 
add_int32_le b iappends a binary little-endian 32-bit integeritob.
 | 
| add_int32_ne [Buffer] | 
add_int32_ne b iappends a binary native-endian 32-bit integeritob.
 | 
| add_int64_be [Buffer] | 
add_int64_be b iappends a binary big-endian 64-bit integeritob.
 | 
| add_int64_le [Buffer] | 
add_int64_ne b iappends a binary little-endian 64-bit integeritob.
 | 
| add_int64_ne [Buffer] | 
add_int64_ne b iappends a binary native-endian 64-bit integeritob.
 | 
| add_int8 [Buffer] | 
add_int8 b iappends a binary signed 8-bit integeritob.
 | 
| 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_seq [Map.S] | 
Add the given bindings to the map, in order. | 
| add_seq [Hashtbl.SeededS] | 
 | 
| add_seq [Hashtbl.S] | 
 | 
| add_seq [Hashtbl] |  | 
| add_seq [Ephemeron.SeededS] |  | 
| add_seq [Ephemeron.S] |  | 
| add_seq [Buffer] |  | 
| add_string [Buffer] | 
add_string b sappends the stringsat the end of bufferb.
 | 
| add_subbytes [Buffer] | 
add_subbytes b s ofs lentakeslencharacters from offsetofsin byte sequencesand appends them at the end of bufferb.
 | 
| add_substitute [Buffer] | 
add_substitute b f sappends the string patternsat the end
   of bufferbwith substitution.
 | 
| add_substring [Buffer] | 
add_substring b s ofs lentakeslencharacters from offsetofsin stringsand appends them at the end of bufferb.
 | 
| add_symbolic_output_item [Format] | 
add_symbolic_output_item sob itmadds itemitmto buffersob.
 | 
| add_uint16_be [Buffer] | 
add_uint16_be b iappends a binary big-endian unsigned 16-bit
    integeritob.
 | 
| add_uint16_le [Buffer] | 
add_uint16_le b iappends a binary little-endian unsigned 16-bit
    integeritob.
 | 
| add_uint16_ne [Buffer] | 
add_uint16_ne b iappends a binary native-endian unsigned 16-bit
    integeritob.
 | 
| add_uint8 [Buffer] | 
add_uint8 b iappends a binary unsigned 8-bit integeritob.
 | 
| add_utf_16be_uchar [Buffer] | 
add_utf_16be_uchar b uappends the
    UTF-16BE encoding ofuat the end of bufferb.
 | 
| add_utf_16le_uchar [Buffer] | 
add_utf_16le_uchar b uappends the
    UTF-16LE encoding ofuat the end of bufferb.
 | 
| add_utf_8_uchar [Buffer] | 
add_utf_8_uchar b uappends the 
    UTF-8 encoding ofuat the end of bufferb.
 | 
| alarm [UnixLabels] | 
Schedule a SIGALRMsignal after the given number of seconds. | 
| alarm [Unix] | 
Schedule a SIGALRMsignal 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 vialoadfile_private). | 
| allocated_bytes [Gc] | 
Return the total number of bytes allocated since the program was
   started. | 
| allow_only [Dynlink] | 
allow_only unitssets 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 vreturns an event that is always ready for
   synchronization.
 | 
| append [Seq] | 
append xs ysis the concatenation of the sequencesxsandys.
 | 
| append [ListLabels] |  | 
| append [List] |  | 
| append [Float.ArrayLabels] | 
append v1 v2returns a fresh floatarray containing the
      concatenation of the floatarraysv1andv2.
 | 
| append [Float.Array] | 
append v1 v2returns a fresh floatarray containing the
      concatenation of the floatarraysv1andv2.
 | 
| append [ArrayLabels] | 
append v1 v2returns a fresh array containing the
   concatenation of the arraysv1andv2.
 | 
| append [Array] | 
append v1 v2returns a fresh array containing the
   concatenation of the arraysv1andv2.
 | 
| arg [Complex] |  | 
| argv [Sys] | 
The command line arguments given to the process. | 
| array0_of_genarray [Bigarray] | 
Return the zero-dimensional Bigarray corresponding to the given
   generic Bigarray. | 
| array1_of_genarray [Bigarray] | 
Return the one-dimensional Bigarray corresponding to the given
   generic Bigarray. | 
| array2_of_genarray [Bigarray] | 
Return the two-dimensional Bigarray corresponding to the given
   generic Bigarray. | 
| array3_of_genarray [Bigarray] | 
Return the three-dimensional Bigarray corresponding to the given
   generic Bigarray. | 
| asin [Float] |  | 
| asin [Stdlib] |  | 
| asinh [Float] |  | 
| asinh [Stdlib] |  | 
| asprintf [Format] | 
Same as printfabove, but instead of printing on a formatter,
  returns a string containing the result of formatting the arguments. | 
| assoc [ListLabels] | 
assoc a lreturns the value associated with keyain the list of
   pairsl.
 | 
| assoc [List] | 
assoc a lreturns the value associated with keyain the list of
   pairsl.
 | 
| assoc_opt [ListLabels] | 
assoc_opt a lreturns the value associated with keyain the list of
    pairsl.
 | 
| assoc_opt [List] | 
assoc_opt a lreturns the value associated with keyain the list of
    pairsl.
 | 
| assq [ListLabels] | 
Same as ListLabels.assoc, but uses physical equality instead of
   structural equality to compare keys. | 
| assq [List] | 
Same as List.assoc, but uses physical equality instead of
   structural equality to compare keys. | 
| assq_opt [ListLabels] | 
Same as ListLabels.assoc_opt, but uses physical equality instead of
   structural equality to compare keys. | 
| assq_opt [List] | 
Same as List.assoc_opt, but uses physical equality instead of
   structural equality to compare keys. | 
| at_exit [Stdlib] | 
Register the given function to be called at program termination
   time. | 
| atan [Float] |  | 
| atan [Stdlib] |  | 
| atan2 [Float] | 
atan2 y xreturns the arc tangent ofy /. x.
 | 
| atan2 [Stdlib] | 
atan2 y xreturns the arc tangent ofy /. x.
 | 
| atanh [Float] |  | 
| atanh [Stdlib] |  | 
| B | 
| backend_type [Sys] | 
Backend type  currently executing the OCaml program. | 
| backtrace_slots [Printexc] | 
Returns the slots of a raw backtrace, or Noneif none of them
    contain useful information. | 
| backtrace_slots_of_raw_entry [Printexc] | 
Returns the slots of a single raw backtrace entry, or Noneif this
    entry lacks debug information. | 
| backtrace_status [Printexc] | 
Printexc.backtrace_status()returnstrueif exception
    backtraces are currently recorded,falseif not.
 | 
| basename [Filename] | 
Split a file name into directory name / base file name. | 
| beginning_of_input [Scanf.Scanning] | 
Scanning.beginning_of_input ictests the beginning of input condition
    of the givenScanf.Scanning.in_channelformatted 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 fisf vifrisOk vandrifrisError _.
 | 
| bind [Option] | 
bind o fisf vifoisSome vandNoneifoisNone.
 | 
| 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] |  | 
| bits64 [Random.State] |  | 
| bits64 [Random] |  | 
| 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 lencopieslenweak pointers
   fromar1(starting atoff1) toar2(starting atoff2).
 | 
| blit [String] | 
blit src src_pos dst dst_pos lencopieslenbytes
    from the stringsrc, starting at indexsrc_pos,
    to byte sequencedst, starting at character numberdst_pos.
 | 
| blit [StringLabels] | 
blit ~src ~src_pos ~dst ~dst_pos ~lencopieslenbytes
    from the stringsrc, starting at indexsrc_pos,
    to byte sequencedst, starting at character numberdst_pos.
 | 
| blit [Float.ArrayLabels] | 
blit ~src ~src_pos ~dst ~dst_pos ~lencopieslenelements
      from floatarraysrc, starting at element numbersrc_pos,
      to floatarraydst, starting at element numberdst_pos.
 | 
| blit [Float.Array] | 
blit src src_pos dst dst_pos lencopieslenelements
      from floatarraysrc, starting at element numbersrc_pos,
      to floatarraydst, starting at element numberdst_pos.
 | 
| blit [BytesLabels] | 
blit ~src ~src_pos ~dst ~dst_pos ~lencopieslenbytes from sequencesrc, starting at indexsrc_pos, to sequencedst, starting at
    indexdst_pos.
 | 
| blit [Bytes] | 
blit src src_pos dst dst_pos lencopieslenbytes from sequencesrc, starting at indexsrc_pos, to sequencedst, starting at
    indexdst_pos.
 | 
| blit [Buffer] | 
Buffer.blit src srcoff dst dstoff lencopieslencharacters from
   the current contents of the buffersrc, starting at offsetsrcofftodst, starting at characterdstoff.
 | 
| 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 ~lencopieslenelements
   from arraysrc, starting at element numbersrc_pos, to arraydst,
   starting at element numberdst_pos.
 | 
| blit [Array] | 
blit src src_pos dst dst_pos lencopieslenelements
   from arraysrc, starting at element numbersrc_pos, to arraydst,
   starting at element numberdst_pos.
 | 
| blit_data [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.blit_data | 
| blit_data [Ephemeron.Kn] |  | 
| blit_data [Ephemeron.K2] |  | 
| blit_data [Ephemeron.K1] | 
Ephemeron.K1.blit_data eph1 eph2sets the data ofeph2with
      the data ofeph1.
 | 
| blit_key [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.blit_key | 
| blit_key [Ephemeron.Kn] |  | 
| blit_key [Ephemeron.K1] | 
Ephemeron.K1.blit_key eph1 eph2sets the key ofeph2with
      the key ofeph1.
 | 
| blit_key1 [Ephemeron.K2] |  | 
| blit_key12 [Ephemeron.K2] |  | 
| blit_key2 [Ephemeron.K2] |  | 
| blit_string [BytesLabels] | 
blit ~src ~src_pos ~dst ~dst_pos ~lencopieslenbytes from stringsrc, starting at indexsrc_pos, to byte sequencedst,
    starting at indexdst_pos.
 | 
| blit_string [Bytes] | 
blit src src_pos dst dst_pos lencopieslenbytes from stringsrc, starting at indexsrc_pos, to byte sequencedst,
    starting at indexdst_pos.
 | 
| bom [Uchar] |  | 
| bool [Random.State] |  | 
| bool [Random] | 
Random.bool ()returnstrueorfalsewith probability 0.5 each.
 | 
| bool_of_string [Stdlib] | 
Same as bool_of_string_opt, but raiseInvalid_argument "bool_of_string"instead of returningNone. | 
| 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 mostnsubstrings,
   wherenis 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 moduleBuffer). | 
| bprintf [Format] | 
 | 
| broadcast [Condition] | 
broadcast crestarts all processes waiting on the
   condition variablec.
 | 
| bscanf [Scanf] |  | 
| bscanf_format [Scanf] | 
bscanf_format ic fmt freads a format string token from the formatted
    input channelic, according to the given format stringfmt, and
    appliesfto the resulting format string value.
 | 
| bufput_acc [CamlinternalFormat] |  | 
| bytes [Digest] | 
Return the digest of the given byte sequence. | 
| C | 
| c_layout [Bigarray] |  | 
| capitalize [String] | 
Return a copy of the argument, with the first character set to uppercase,
    using the ISO Latin-1 (8859-1) character set.. | 
| capitalize [StringLabels] | 
Return a copy of the argument, with the first character set to uppercase,
    using the ISO Latin-1 (8859-1) character set.. | 
| capitalize [BytesLabels] | 
Return a copy of the argument, with the first character set to uppercase,
   using the ISO Latin-1 (8859-1) character set. | 
| capitalize [Bytes] | 
Return a copy of the argument, with the first character set to uppercase,
   using the ISO Latin-1 (8859-1) character set. | 
| capitalize_ascii [String] | 
capitalize_ascii sisswith the first character set to
    uppercase, using the US-ASCII character set.
 | 
| capitalize_ascii [StringLabels] | 
capitalize_ascii sisswith 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 s2concatenates s1 and s2 (s1 ^ s2).
 | 
| cat [StringLabels] | 
cat s1 s2concatenates s1 and s2 (s1 ^ s2).
 | 
| cat [BytesLabels] | 
cat s1 s2concatenatess1ands2and returns the result
    as a new byte sequence.
 | 
| cat [Bytes] | 
cat s1 s2concatenatess1ands2and returns the result
    as a new byte sequence.
 | 
| catch [Printexc] | 
Printexc.catch fn xis similar toPrintexc.print, but
   aborts the program with exit code 2 after printing the
   uncaught exception.
 | 
| catch_break [Sys] | 
catch_breakgoverns whether interactive interrupt (ctrl-C)
   terminates the program or raises theBreakexception.
 | 
| cbrt [Float] |  | 
| ceil [Float] | 
Round above to an integer value. | 
| ceil [Stdlib] | 
Round above to an integer value. | 
| change_layout [Bigarray.Array3] | 
Array3.change_layout a layoutreturns a Bigarray with the
      specifiedlayout, sharing the data witha(and hence having
      the same dimensions asa).
 | 
| change_layout [Bigarray.Array2] | 
Array2.change_layout a layoutreturns a Bigarray with the
      specifiedlayout, sharing the data witha(and hence having
      the same dimensions asa).
 | 
| change_layout [Bigarray.Array1] | 
Array1.change_layout a layoutreturns a Bigarray with the
      specifiedlayout, sharing the data witha(and hence having
      the same dimension asa).
 | 
| change_layout [Bigarray.Array0] | 
Array0.change_layout a layoutreturns a Bigarray with the
      specifiedlayout, sharing the data witha.
 | 
| change_layout [Bigarray.Genarray] | 
Genarray.change_layout a layoutreturns a Bigarray with the
      specifiedlayout, sharing the data witha(and hence having
      the same dimensions asa).
 | 
| channel [Digest] | 
If lenis nonnegative,Digest.channel ic lenreadslencharacters from channelicand returns their digest, or raisesEnd_of_fileif end-of-file is reached beforelencharacters
   are read. | 
| char [Bigarray] | 
As shown by the types of the values above,
   Bigarrays of kind float32_eltandfloat64_eltare
   accessed using the OCaml typefloat. | 
| 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 nreturnstrueif thenth cell ofaris
   full,falseif it is empty.
 | 
| check_data [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.check_data | 
| check_data [Ephemeron.Kn] |  | 
| check_data [Ephemeron.K2] |  | 
| check_data [Ephemeron.K1] | 
Ephemeron.K1.check_data ephreturnstrueif the data of theephis full,falseif it is empty.
 | 
| check_geometry [Format] | 
Check if the formatter geometry is valid: 1 < max_indent < margin | 
| check_key [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.check_key | 
| check_key [Ephemeron.Kn] |  | 
| check_key [Ephemeron.K1] | 
Ephemeron.K1.check_key ephreturnstrueif the key of theephis full,falseif it is empty.
 | 
| check_key1 [Ephemeron.K2] |  | 
| check_key2 [Ephemeron.K2] |  | 
| check_suffix [Filename] | 
check_suffix name suffreturnstrueif the filenamenameends with the suffixsuff.
 | 
| chmod [UnixLabels] | 
Change the permissions of the named file. | 
| chmod [Unix] | 
Change the permissions of the named file. | 
| choose [Event] | 
choose evlreturns the event that is the alternative of
   all the events in the listevl.
 | 
| choose [Set.S] | 
Return one element of the given set, or raise Not_foundif
       the set is empty. | 
| choose [MoreLabels.Set.S] | 
Return one element of the given set, or raise Not_foundif
         the set is empty. | 
| choose [MoreLabels.Map.S] | 
Return one binding of the given map, or raise Not_foundif
         the map is empty. | 
| choose [Map.S] | 
Return one binding of the given map, or raise Not_foundif
       the map is empty. | 
| choose_opt [Set.S] | 
Return one element of the given set, or Noneif
        the set is empty. | 
| choose_opt [MoreLabels.Set.S] | 
Return one element of the given set, or Noneif
          the set is empty. | 
| choose_opt [MoreLabels.Map.S] | 
Return one binding of the given map, or Noneif
         the map is empty. | 
| choose_opt [Map.S] | 
Return one binding of the given map, or Noneif
       the map is empty. | 
| chop_extension [Filename] |  | 
| chop_suffix [Filename] | 
chop_suffix name suffremoves the suffixsufffrom
    the filenamename.
 | 
| chop_suffix_opt [Filename] | 
chop_suffix_opt ~suffix filenameremoves the suffix from
    thefilenameif possible, or returnsNoneif the
    filename does not end with the suffix.
 | 
| chown [UnixLabels] | 
Change the owner uid and owner gid of the named file. | 
| chown [Unix] | 
Change the owner uid and owner gid of the named file. | 
| chr [Char] | 
Return the character with the given ASCII code. | 
| chroot [UnixLabels] | 
Change the process root directory. | 
| chroot [Unix] | 
Change the process root directory. | 
| classify_float [Float] | 
Return the class of the given floating-point number:
    normal, subnormal, zero, infinite, or not a number. | 
| classify_float [Stdlib] | 
Return the class of the given floating-point number:
   normal, subnormal, zero, infinite, or not a number. | 
| clean [Ephemeron.SeededS] | 
remove all dead bindings. | 
| clean [Ephemeron.S] | 
remove all dead bindings. | 
| clear [Weak.S] | 
Remove all elements from the table. | 
| clear [Stack] | 
Discard all elements from a stack. | 
| clear [Queue] | 
Discard all elements from a queue. | 
| clear [MoreLabels.Hashtbl.SeededS] |  | 
| clear [MoreLabels.Hashtbl.S] |  | 
| clear [MoreLabels.Hashtbl] |  | 
| clear [Hashtbl.SeededS] |  | 
| clear [Hashtbl.S] |  | 
| clear [Hashtbl] |  | 
| 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] |  | 
| 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] |  | 
| clear_symbolic_output_buffer [Format] | 
clear_symbolic_output_buffer sobresets buffersob.
 | 
| close [UnixLabels] |  | 
| close [Unix] |  | 
| close [Out_channel] | 
Close the given channel, flushing all buffered write operations. | 
| close [In_channel] |  | 
| close_box [Format] | 
Closes the most recently open pretty-printing box. | 
| close_in [Scanf.Scanning] |  | 
| close_in [Stdlib] |  | 
| close_in_noerr [Stdlib] | 
Same as close_in, but ignore all errors. | 
| close_noerr [Out_channel] |  | 
| close_noerr [In_channel] |  | 
| 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_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_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 tagt.
 | 
| close_tag [Format] | 
 | 
| close_tbox [Format] | 
Closes the most recently opened tabulation box. | 
| closedir [UnixLabels] | 
Close a directory descriptor. | 
| closedir [Unix] | 
Close a directory descriptor. | 
| closure_tag [Obj] |  | 
| code [Char] | 
Return the ASCII code of the argument. | 
| combine [ListLabels] | 
Transform a pair of lists into a list of pairs:
   combine [a1; ...; an] [b1; ...; bn]is[(a1,b1); ...; (an,bn)]. | 
| combine [List] | 
Transform a pair of lists into a list of pairs:
   combine [a1; ...; an] [b1; ...; bn]is[(a1,b1); ...; (an,bn)]. | 
| combine [ArrayLabels] | 
combine [|a1; ...; an|] [|b1; ...; bn|]is[|(a1,b1); ...; (an,bn)|].
 | 
| combine [Array] | 
combine [|a1; ...; an|] [|b1; ...; bn|]is[|(a1,b1); ...; (an,bn)|].
 | 
| command [Sys] | 
Execute the given shell command and return its exit code. | 
| compact [Gc] | 
Perform a full major collection and compact the heap. | 
| compare [Unit] |  | 
| compare [Uchar] | 
compare u u'isStdlib.compare u u'.
 | 
| compare [String] | 
compare s0 s1sortss0ands1in lexicographical order.
 | 
| compare [StringLabels] | 
compare s0 s1sortss0ands1in 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 cmpdefines a preorder on elements,compare cmp xs yscompares the sequencesxsandysaccording to the lexicographic preorder. | 
| compare [Result] | 
compare ~ok ~error r0 r1totally ordersr0andr1usingokanderrorto respectively compare values wrapped byOk _ andError _.
 | 
| compare [Option] | 
compare cmp o0 o1is a total order on options usingcmpto compare
    values wrapped bySome _.
 | 
| 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 -> intinterface ascompare:
 | 
| compare [List] | 
compare cmp [a1; ...; an] [b1; ...; bm]performs
    a lexicographic comparison of the two input lists,
    using the same'a -> 'a -> intinterface ascompare:
 | 
| 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 yiscompare x ybut more efficient.
 | 
| compare [Float] | 
compare x yreturns0ifxis equal toy, a negative integer ifxis less thany, and a positive integer ifxis greater thany.
 | 
| compare [Either] | 
compare ~left ~right e0 e1totally orderse0ande1usingleftandrightto respectively compare values wrapped byLeft _ andRight _.
 | 
| compare [Digest] | 
The comparison function for 16-character digest, with the same
    specification as compareand the implementation
    shared withString.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 b1is a total order on boolean values.
 | 
| compare [Stdlib] | 
compare x yreturns0ifxis equal toy,
   a negative integer ifxis less thany, and a positive integer
   ifxis greater thany.
 | 
| compare_and_set [Atomic] | 
compare_and_set r seen vsets the new value ofrtovonly
    if its current value is physically equal toseen-- the
    comparison and the set occur atomically.
 | 
| compare_and_set [CamlinternalAtomic] |  | 
| compare_length_with [ListLabels] | 
Compare the length of a list to an integer. | 
| compare_length_with [List] | 
Compare the length of a list to an integer. | 
| compare_lengths [ListLabels] | 
Compare the lengths of two lists. | 
| compare_lengths [List] | 
Compare the lengths of two lists. | 
| complex32 [Bigarray] |  | 
| complex64 [Bigarray] |  | 
| concat [String] | 
concat sep ssconcatenates the list of stringsss, inserting
    the separator stringsepbetween each.
 | 
| concat [StringLabels] | 
concat ~sep ssconcatenates the list of stringsss, inserting
    the separator stringsepbetween each.
 | 
| concat [Seq] | 
If xssis a sequence of sequences,
    thenconcat xssis its concatenation. | 
| concat [ListLabels] | 
Concatenate a list of lists. | 
| concat [List] | 
Concatenate a list of lists. | 
| concat [Float.ArrayLabels] |  | 
| concat [Float.Array] |  | 
| concat [Filename] | 
concat dir filereturns a file name that designates filefilein directorydir.
 | 
| concat [BytesLabels] | 
concat ~sep slconcatenates the list of byte sequencessl,
    inserting the separator byte sequencesepbetween each, and
    returns the result as a new byte sequence.
 | 
| concat [Bytes] | 
concat sep slconcatenates the list of byte sequencessl,
    inserting the separator byte sequencesepbetween each, and
    returns the result as a new byte sequence.
 | 
| concat [ArrayLabels] |  | 
| concat [Array] |  | 
| concat_fmt [CamlinternalFormatBasics] |  | 
| concat_fmtty [CamlinternalFormatBasics] |  | 
| concat_map [Seq] | 
concat_map f xsis equivalent toconcat (map f xs).
 | 
| concat_map [ListLabels] |  | 
| concat_map [List] |  | 
| conj [Complex] | 
Conjugate: given the complex x + i.y, returnsx - i.y. | 
| connect [ThreadUnix] |  | 
| connect [UnixLabels] | 
Connect a socket to an address. | 
| connect [Unix] | 
Connect a socket to an address. | 
| cons [Seq] | 
cons x xsis the sequence that begins with the elementx,
    followed with the sequencexs.
 | 
| cons [ListLabels] |  | 
| cons [List] |  | 
| const [Fun] | 
const cis a function that always returns the valuec.
 | 
| contains [String] |  | 
| contains [StringLabels] |  | 
| contains [BytesLabels] | 
contains s ctests if bytecappears ins.
 | 
| contains [Bytes] | 
contains s ctests if bytecappears ins.
 | 
| contains_from [String] | 
contains_from s start cistrueif and only ifcappears insafter positionstart.
 | 
| contains_from [StringLabels] | 
contains_from s start cistrueif and only ifcappears insafter positionstart.
 | 
| contains_from [BytesLabels] | 
contains_from s start ctests if bytecappears insafter
    positionstart.
 | 
| contains_from [Bytes] | 
contains_from s start ctests if bytecappears insafter
    positionstart.
 | 
| contents [Buffer] | 
Return a copy of the current contents of the buffer. | 
| convert_raw_backtrace_slot [Printexc] | 
Extracts the user-friendly backtrace_slotfrom a low-levelraw_backtrace_slot. | 
| copy [CamlinternalOO] |  | 
| copy [String] | 
Return a copy of the given string. | 
| copy [StringLabels] | 
Return a copy of the given string. | 
| copy [Stack] | 
Return a copy of the given stack. | 
| copy [Random.State] | 
Return a copy of the given state. | 
| copy [Queue] | 
Return a copy of the given queue. | 
| copy [Oo] | 
Oo.copy oreturns a copy of objecto, that is a fresh
   object with the same methods and instance variables aso.
 | 
| 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 areturns a copy ofa, that is, a fresh floatarray
      containing the same elements asa.
 | 
| copy [Float.Array] | 
copy areturns a copy ofa, that is, a fresh floatarray
      containing the same elements asa.
 | 
| 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 areturns a copy ofa, that is, a fresh array
   containing the same elements asa.
 | 
| copy [Array] | 
copy areturns a copy ofa, that is, a fresh array
   containing the same elements asa.
 | 
| copy_sign [Float] | 
copy_sign x yreturns a float whose absolute value is that ofxand whose sign is that ofy.
 | 
| copysign [Stdlib] | 
copysign x yreturns a float whose absolute value is that ofxand whose sign is that ofy.
 | 
| cos [Float] |  | 
| cos [Stdlib] |  | 
| cosh [Float] |  | 
| cosh [Stdlib] |  | 
| count [Weak.S] | 
Count the number of elements in the table. | 
| count [Stream] | 
Return the current count of the stream elements, i.e. | 
| counters [Gc] | 
Return (minor_words, promoted_words, major_words). | 
| create [Mutex] |  | 
| create [Condition] | 
Return a new condition variable. | 
| create [Thread] | 
Thread.create funct argcreates a new thread of control,
   in which the function applicationfunct argis executed concurrently with the other threads of the program.
 | 
| create [Weak.S] | 
create ncreates a new empty weak hash set, of initial
        sizen.
 | 
| create [Weak] | 
Weak.create nreturns a new weak array of lengthn.
 | 
| create [String] | 
create nreturns a fresh byte sequence of lengthn.
 | 
| create [StringLabels] | 
create nreturns a fresh byte sequence of lengthn.
 | 
| create [Stack] | 
Return a new stack, initially empty. | 
| create [Queue] | 
Return a new queue, initially empty. | 
| create [Obj.Ephemeron] | 
create nreturns an ephemeron withnkeys.
 | 
| create [MoreLabels.Hashtbl.SeededS] |  | 
| create [MoreLabels.Hashtbl.S] |  | 
| create [MoreLabels.Hashtbl] | 
Hashtbl.create ncreates a new, empty hash table, with
     initial sizen.
 | 
| create [Hashtbl.SeededS] |  | 
| create [Hashtbl.S] |  | 
| create [Hashtbl] | 
Hashtbl.create ncreates a new, empty hash table, with
   initial sizen.
 | 
| create [Float.ArrayLabels] | 
create nreturns a fresh floatarray of lengthn,
      with uninitialized data.
 | 
| create [Float.Array] | 
create nreturns a fresh floatarray of lengthn,
      with uninitialized data.
 | 
| create [Ephemeron.Kn] |  | 
| create [Ephemeron.K2] |  | 
| create [Ephemeron.SeededS] |  | 
| create [Ephemeron.S] |  | 
| create [Ephemeron.K1] | 
Ephemeron.K1.create ()creates an ephemeron with one key.
 | 
| create [BytesLabels] | 
create nreturns a new byte sequence of lengthn.
 | 
| create [Bytes] | 
create nreturns a new byte sequence of lengthn.
 | 
| create [Buffer] | 
create nreturns a fresh buffer, initially empty.
 | 
| create [Bigarray.Array3] | 
Array3.create kind layout dim1 dim2 dim3returns a new Bigarray of
     three dimensions, whose size isdim1in the first dimension,dim2in the second dimension, anddim3in the third.
 | 
| create [Bigarray.Array2] | 
Array2.create kind layout dim1 dim2returns a new Bigarray of
     two dimensions, whose size isdim1in the first dimension
     anddim2in the second dimension.
 | 
| create [Bigarray.Array1] | 
Array1.create kind layout dimreturns a new Bigarray of
     one dimension, whose size isdim.
 | 
| create [Bigarray.Array0] | 
Array0.create kind layoutreturns a new Bigarray of zero dimension.
 | 
| create [Bigarray.Genarray] | 
Genarray.create kind layout dimensionsreturns a new Bigarray
     whose element kind is determined by the parameterkind(one offloat32,float64,int8_signed, etc) and whose layout is
     determined by the parameterlayout(one ofc_layoutorfortran_layout).
 | 
| create [ArrayLabels] | 
 | 
| create [Array] | 
 | 
| create_alarm [Gc] | 
create_alarm fwill arrange forfto be called at the end of each
   major GC cycle, starting with the current cycle or the next one.
 | 
| create_char_set [CamlinternalFormat] |  | 
| create_float [ArrayLabels] | 
create_float nreturns a fresh float array of lengthn,
    with uninitialized data.
 | 
| create_float [Array] | 
create_float nreturns a fresh float array of lengthn,
    with uninitialized data.
 | 
| create_matrix [ArrayLabels] | 
 | 
| create_matrix [Array] | 
 | 
| create_object [CamlinternalOO] |  | 
| create_object_and_run_initializers [CamlinternalOO] |  | 
| create_object_opt [CamlinternalOO] |  | 
| create_process [UnixLabels] | 
create_process ~prog ~args ~stdin ~stdout ~stderrforks a new process that executes the program
   in fileprog, with argumentsargs.
 | 
| create_process [Unix] | 
create_process prog args stdin stdout stderrforks a new process that executes the program
   in fileprog, with argumentsargs.
 | 
| create_process_env [UnixLabels] | 
create_process_env ~prog ~args ~env ~stdin ~stdout ~stderrworks asUnixLabels.create_process, except that the extra argumentenvspecifies the environment passed to the program.
 | 
| create_process_env [Unix] | 
create_process_env prog args env stdin stdout stderrworks asUnix.create_process, except that the extra argumentenvspecifies 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 xsis the infinite sequence that consists of an infinite
    number of repetitions of the sequencexs.
 | 
| cygwin [Sys] | 
True if Sys.os_type = "Cygwin". | 
| D | 
| data_size [Marshal] |  | 
| decr [Atomic] | 
decr ratomically decrements the value ofrby1.
 | 
| decr [Stdlib] | 
Decrement the integer contained in the given reference. | 
| decr [CamlinternalAtomic] |  | 
| default_uncaught_exception_handler [Thread] | 
Thread.default_uncaught_exception_handlerwill print the thread's id,
    exception and backtrace (if available).
 | 
| default_uncaught_exception_handler [Printexc] | 
Printexc.default_uncaught_exception_handlerprints the exception and
    backtrace on standard error output.
 | 
| delay [Thread] | 
delay dsuspends the execution of the calling thread fordseconds.
 | 
| delete_alarm [Gc] | 
delete_alarm awill stop the calls to the function associated
   toa.
 | 
| 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] | 
trueif this is a development version,falseotherwise.
 | 
| diff [Set.S] | 
Set difference: diff s1 s2contains the elements ofs1that are not ins2. | 
| diff [MoreLabels.Set.S] | 
Set difference: diff s1 s2contains the elements ofs1that are not ins2. | 
| 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 areturns all dimensions of the Bigarraya,
     as an array of integers of lengthGenarray.num_dims a.
 | 
| dir_sep [Filename] | 
The directory separator (e.g. | 
| dirname [Filename] |  | 
| disjoint [Set.S] | 
Test if two sets are disjoint. | 
| disjoint [MoreLabels.Set.S] | 
Test if two sets are disjoint. | 
| div [Nativeint] |  | 
| div [Int64] |  | 
| div [Int32] |  | 
| div [Int] | 
div x yis the divisionx / y.
 | 
| div [Float] |  | 
| div [Complex] |  | 
| 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] |  | 
| drop [Seq] | 
drop n xsis the sequencexs, deprived of its firstnelements.
 | 
| drop_while [Seq] | 
drop_while p xsis the sequencexs, deprived of the prefixtake_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 ~dstduplicatessrctodst, closingdstif already
   opened.
 | 
| dup2 [Unix] | 
dup2 src dstduplicatessrctodst, closingdstif 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] |  | 
| empty [Stream] |  | 
| empty [StringLabels] |  | 
| empty [Set.S] |  | 
| empty [Seq] | 
emptyis the empty sequence.
 | 
| empty [MoreLabels.Set.S] |  | 
| empty [MoreLabels.Map.S] |  | 
| empty [Map.S] |  | 
| 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] |  | 
| ends_with [String] | 
ends_with suffix sistrueif and only ifsends withsuffix.
 | 
| ends_with [StringLabels] | 
ends_with ~suffix sistrueif and only ifsends withsuffix.
 | 
| ends_with [BytesLabels] | 
ends_with suffix sistrueif and only ifsends withsuffix.
 | 
| ends_with [Bytes] | 
ends_with suffix sistrueif and only ifsends withsuffix.
 | 
| 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] |  | 
| eprintf [Format] | 
Same as fprintfabove, but output onerr_formatter. | 
| epsilon [Float] | 
The difference between 1.0and the smallest exactly representable
    floating-point number greater than1.0. | 
| epsilon_float [Stdlib] | 
The difference between 1.0and the smallest exactly representable
    floating-point number greater than1.0. | 
| equal [Unit] |  | 
| equal [Uchar] |  | 
| equal [String] | 
equal s0 s1istrueif and only ifs0ands1are character-wise
    equal.
 | 
| equal [StringLabels] | 
equal s0 s1istrueif and only ifs0ands1are character-wise
    equal.
 | 
| equal [Set.S] | 
equal s1 s2tests whether the setss1ands2are
       equal, that is, contain equal elements.
 | 
| equal [Seq] | 
Provided the function eqdefines an equality on elements,equal eq xs ysdetermines whether the sequencesxsandysare pointwise equal. | 
| equal [Result] | 
equal ~ok ~error r0 r1tests equality ofr0andr1usingokanderrorto respectively compare values wrapped byOk _andError _.
 | 
| equal [Option] | 
equal eq o0 o1istrueif and only ifo0ando1are bothNoneor if they areSome v0andSome v1andeq v0 v1istrue.
 | 
| equal [Nativeint] | 
The equal function for native ints. | 
| equal [MoreLabels.Set.S] | 
equal s1 s2tests whether the setss1ands2are
         equal, that is, contain equal elements.
 | 
| equal [MoreLabels.Map.S] | 
equal ~cmp m1 m2tests whether the mapsm1andm2are
         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 m2tests whether the mapsm1andm2are
       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 elementsai,biat the same position we haveeq 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 elementsai,biat the same position we haveeq ai bi.
 | 
| equal [Int64] | 
The equal function for int64s. | 
| equal [Int32] | 
The equal function for int32s. | 
| equal [Int] | 
equal x yistrueif and only ifx = 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 e1tests equality ofe0ande1usingleftandrightto respectively compare values wrapped byLeft _andRight _.
 | 
| 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 b1istrueif and only ifb0andb1are bothtrueor bothfalse.
 | 
| erase_rel [CamlinternalFormatBasics] |  | 
| erf [Float] |  | 
| erfc [Float] | 
Complementary error function (erfc x = 1 - erf x). | 
| err_formatter [Format] | 
A formatter to write to standard error. | 
| error [Result] |  | 
| 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 sisswith special characters represented by escape
    sequences, following the lexical conventions of OCaml.
 | 
| escaped [StringLabels] | 
escaped sisswith special characters represented by escape
    sequences, following the lexical conventions of OCaml.
 | 
| escaped [Char] | 
Return a string representing the given character,
    with special characters escaped following the lexical conventions
    of OCaml. | 
| escaped [BytesLabels] | 
Return a copy of the argument, with special characters represented
    by escape sequences, following the lexical conventions of OCaml. | 
| escaped [Bytes] | 
Return a copy of the argument, with special characters represented
    by escape sequences, following the lexical conventions of OCaml. | 
| establish_server [UnixLabels] | 
Establish a server on the given address. | 
| establish_server [Unix] | 
Establish a server on the given address. | 
| eventlog_pause [Gc] | 
eventlog_pause ()will pause the collection of traces in the
   runtime.
 | 
| eventlog_resume [Gc] | 
eventlog_resume ()will resume the collection of traces in the
   runtime.
 | 
| exchange [Atomic] | 
Set a new value for the atomic reference, and return the current value. | 
| exchange [CamlinternalAtomic] |  | 
| executable_name [Sys] | 
The name of the file containing the executable currently running. | 
| execv [ThreadUnix] |  | 
| execv [UnixLabels] | 
execv ~prog ~argsexecute the program in fileprog, with
   the argumentsargs, and the current process environment.
 | 
| execv [Unix] | 
execv prog argsexecute the program in fileprog, with
   the argumentsargs, and the current process environment.
 | 
| execve [ThreadUnix] |  | 
| execve [UnixLabels] | 
Same as UnixLabels.execv, except that the third argument provides the
   environment to the program executed. | 
| execve [Unix] | 
Same as Unix.execv, except that the third argument provides the
   environment to the program executed. | 
| execvp [ThreadUnix] |  | 
| execvp [UnixLabels] |  | 
| execvp [Unix] | 
Same as Unix.execv, except that
   the program is searched in the path. | 
| execvpe [UnixLabels] |  | 
| execvpe [Unix] | 
Same as Unix.execve, except that
   the program is searched in the path. | 
| exists [String] | 
exists p schecks if at least one character ofssatisfies the predicatep.
 | 
| exists [StringLabels] | 
exists p schecks if at least one character ofssatisfies the predicatep.
 | 
| exists [Set.S] | 
exists f schecks if at least one element of
       the set satisfies the predicatef.
 | 
| exists [Seq] | 
exists xs pdetermines whether at least one elementxof the sequencexssatisfiesp x.
 | 
| exists [MoreLabels.Set.S] | 
exists ~f schecks if at least one element of
         the set satisfies the predicatef.
 | 
| exists [MoreLabels.Map.S] | 
exists ~f mchecks if at least one binding of the map
          satisfies the predicatef.
 | 
| exists [Map.S] | 
exists f mchecks if at least one binding of the map
        satisfies the predicatef.
 | 
| exists [ListLabels] | 
exists ~f [a1; ...; an]checks if at least one element of
   the list satisfies the predicatef.
 | 
| exists [List] | 
exists f [a1; ...; an]checks if at least one element of
   the list satisfies the predicatef.
 | 
| exists [Float.ArrayLabels] | 
exists f [|a1; ...; an|]checks if at least one element of
      the floatarray satisfies the predicatef.
 | 
| exists [Float.Array] | 
exists f [|a1; ...; an|]checks if at least one element of
      the floatarray satisfies the predicatef.
 | 
| exists [BytesLabels] | 
exists p schecks if at least one character ofssatisfies the predicatep.
 | 
| exists [Bytes] | 
exists p schecks if at least one character ofssatisfies the predicatep.
 | 
| exists [ArrayLabels] | 
exists ~f [|a1; ...; an|]checks if at least one element of
    the array satisfies the predicatef.
 | 
| exists [Array] | 
exists f [|a1; ...; an|]checks if at least one element of
    the array satisfies the predicatef.
 | 
| exists2 [Seq] | 
exists2 p xs ysdetermines whether some pair(x, y)of elements
    drawn synchronously from the sequencesxsandyssatisfiesp x y.
 | 
| exists2 [ListLabels] |  | 
| exists2 [List] |  | 
| exists2 [ArrayLabels] |  | 
| exists2 [Array] |  | 
| exit [Thread] | 
Terminate prematurely the currently executing thread. | 
| exit [Stdlib] | 
Terminate the process, returning the given status code
   to the operating system: usually 0 to indicate no errors,
   and a small positive integer to indicate failure. | 
| exn_slot_id [Printexc] | 
Printexc.exn_slot_idreturns an integer which uniquely identifies
    the constructor used to create the exception valueexn(in the current runtime).
 | 
| exn_slot_name [Printexc] | 
Printexc.exn_slot_name exnreturns the internal name of the constructor
    used to create the exception valueexn.
 | 
| exp [Float] |  | 
| exp [Complex] |  | 
| exp [Stdlib] |  | 
| exp2 [Float] | 
Base 2 exponential function. | 
| expm1 [Float] | 
expm1 xcomputesexp x -. 1.0, giving numerically-accurate results
    even ifxis close to0.0.
 | 
| expm1 [Stdlib] | 
expm1 xcomputesexp x -. 1.0, giving numerically-accurate results
    even ifxis close to0.0.
 | 
| extend [BytesLabels] | 
extend s ~left ~rightreturns a new byte sequence that contains
    the bytes ofs, withleftuninitialized bytes prepended andrightuninitialized bytes appended to it.
 | 
| extend [Bytes] | 
extend s left rightreturns a new byte sequence that contains
    the bytes ofs, withleftuninitialized bytes prepended andrightuninitialized bytes appended to it.
 | 
| extension [Filename] | 
extension nameis the shortest suffixextofname0where:
 | 
| extension_constructor [Obj] |  | 
| extension_id [Obj] |  | 
| extension_name [Obj] |  | 
| F | 
| failwith [Stdlib] | 
Raise exception Failurewith the given string. | 
| fast_sort [ListLabels] |  | 
| fast_sort [List] |  | 
| fast_sort [Float.ArrayLabels] |  | 
| fast_sort [Float.Array] |  | 
| fast_sort [ArrayLabels] |  | 
| fast_sort [Array] |  | 
| 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 natomically increments the value ofrbyn,
    and returns the current value (before the increment).
 | 
| fetch_and_add [CamlinternalAtomic] |  | 
| field [Obj] |  | 
| file [Digest] | 
Return the digest of the file whose name is given. | 
| file_exists [Sys] | 
Test if a file with the given name exists. | 
| fill [Weak] | 
Weak.fill ar ofs len elsets toelall pointers ofarfromofstoofs + len - 1.
 | 
| fill [String] | 
fill s pos len cmodifies byte sequencesin place,
    replacinglenbytes byc, starting atpos.
 | 
| fill [StringLabels] | 
fill s ~pos ~len cmodifies byte sequencesin place,
    replacinglenbytes byc, starting atpos.
 | 
| fill [Float.ArrayLabels] | 
fill a ~pos ~len xmodifies the floatarrayain place,
      storingxin elements numberpostopos + len - 1.
 | 
| fill [Float.Array] | 
fill a pos len xmodifies the floatarrayain place,
      storingxin elements numberpostopos + len - 1.
 | 
| fill [BytesLabels] | 
fill s ~pos ~len cmodifiessin place, replacinglencharacters withc, starting atpos.
 | 
| fill [Bytes] | 
fill s pos len cmodifiessin place, replacinglencharacters withc, starting atpos.
 | 
| 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 xmodifies the arrayain place,
   storingxin elements numberpostopos + len - 1.
 | 
| fill [Array] | 
fill a pos len xmodifies the arrayain place,
   storingxin elements numberpostopos + len - 1.
 | 
| filter [Set.S] | 
filter f sreturns the set of all elements insthat satisfy predicatef.
 | 
| filter [Seq] | 
filter p xsis the sequence of the elementsxofxsthat satisfyp x.
 | 
| filter [MoreLabels.Set.S] | 
filter ~f sreturns the set of all elements insthat satisfy predicatef.
 | 
| filter [MoreLabels.Map.S] | 
filter ~f mreturns the map with all the bindings inmthat satisfy predicatep.
 | 
| filter [Map.S] | 
filter f mreturns the map with all the bindings inmthat satisfy predicatep.
 | 
| filter [ListLabels] | 
filter ~f lreturns all the elements of the listlthat satisfy the predicatef.
 | 
| filter [List] | 
filter f lreturns all the elements of the listlthat satisfy the predicatef.
 | 
| filter_map [Set.S] | 
filter_map f sreturns the set of allvsuch thatf x = Some vfor some elementxofs.
 | 
| filter_map [Seq] | 
filter_map f xsis the sequence of the elementsysuch thatf x = Some y, wherexranges overxs.
 | 
| filter_map [MoreLabels.Set.S] | 
filter_map ~f sreturns the set of allvsuch thatf x = Some vfor some elementxofs.
 | 
| filter_map [MoreLabels.Map.S] | 
filter_map ~f mapplies the functionfto every binding ofm, and builds a map from the results.
 | 
| filter_map [Map.S] | 
filter_map f mapplies the functionfto every binding ofm, and builds a map from the results.
 | 
| filter_map [ListLabels] | 
filter_map ~f lappliesfto every element ofl, filters
    out theNoneelements and returns the list of the arguments of
    theSomeelements.
 | 
| filter_map [List] | 
filter_map f lappliesfto every element ofl, filters
    out theNoneelements and returns the list of the arguments of
    theSomeelements.
 | 
| filter_map_inplace [MoreLabels.Hashtbl.SeededS] | 
 | 
| filter_map_inplace [MoreLabels.Hashtbl.S] | 
 | 
| filter_map_inplace [MoreLabels.Hashtbl] | 
Hashtbl.filter_map_inplace ~f tblappliesfto all bindings in
      tabletbland update each binding depending on the result off.
 | 
| filter_map_inplace [Hashtbl.SeededS] | 
 | 
| filter_map_inplace [Hashtbl.S] | 
 | 
| filter_map_inplace [Hashtbl] | 
Hashtbl.filter_map_inplace f tblappliesfto all bindings in
    tabletbland update each binding depending on the result off.
 | 
| filter_map_inplace [Ephemeron.SeededS] |  | 
| filter_map_inplace [Ephemeron.S] |  | 
| filteri [ListLabels] | 
Same as ListLabels.filter, but the predicate is applied to the index of
   the element as first argument (counting from 0), and the element
   itself as second argument. | 
| filteri [List] | 
Same as List.filter, but the predicate is applied to the index of
   the element as first argument (counting from 0), and the element
   itself as second argument. | 
| final_tag [Obj] |  | 
| finalise [Gc] | 
finalise f vregistersfas a finalisation function forv.
 | 
| finalise_last [Gc] | 
same as Gc.finaliseexcept the value is not given as argument. | 
| finalise_release [Gc] | 
A finalisation function may call finalise_releaseto tell the
    GC that it can launch the next finalisation function without waiting
    for the current one to return. | 
| find [Weak.S] | 
find t xreturns an instance ofxfound int.
 | 
| find [Set.S] | 
find x sreturns the element ofsequal tox(according
        toOrd.compare), or raiseNot_foundif no such element
        exists.
 | 
| find [Seq] | 
find p xsreturnsSome x, wherexis the first element of the
    sequencexsthat satisfiesp x, if there is such an element.
 | 
| find [MoreLabels.Set.S] | 
find x sreturns the element ofsequal tox(according
          toOrd.compare), or raiseNot_foundif no such element
          exists.
 | 
| find [MoreLabels.Map.S] | 
find x mreturns the current value ofxinm,
         or raisesNot_foundif no binding forxexists.
 | 
| find [MoreLabels.Hashtbl.SeededS] |  | 
| find [MoreLabels.Hashtbl.S] |  | 
| find [MoreLabels.Hashtbl] | 
Hashtbl.find tbl xreturns the current binding ofxintbl,
     or raisesNot_foundif no such binding exists.
 | 
| find [Map.S] | 
find x mreturns the current value ofxinm,
       or raisesNot_foundif no binding forxexists.
 | 
| find [ListLabels] | 
find ~f lreturns the first element of the listlthat satisfies the predicatef.
 | 
| find [List] | 
find f lreturns the first element of the listlthat satisfies the predicatef.
 | 
| find [Hashtbl.SeededS] |  | 
| find [Hashtbl.S] |  | 
| find [Hashtbl] | 
Hashtbl.find tbl xreturns the current binding ofxintbl,
   or raisesNot_foundif no such binding exists.
 | 
| find [Ephemeron.Kn.Bucket] | 
Returns the data of the most-recently added ephemeron with the
        given keys, or Noneif there is no such ephemeron. | 
| find [Ephemeron.K2.Bucket] | 
Returns the data of the most-recently added ephemeron with the
        given keys, or Noneif there is no such ephemeron. | 
| find [Ephemeron.K1.Bucket] | 
Returns the data of the most-recently added ephemeron with the
        given key, or Noneif there is no such ephemeron. | 
| find [Ephemeron.SeededS] |  | 
| find [Ephemeron.S] |  | 
| find_all [Weak.S] | 
find_all t xreturns a list of all the instances ofxfound int.
 | 
| find_all [MoreLabels.Hashtbl.SeededS] |  | 
| find_all [MoreLabels.Hashtbl.S] |  | 
| find_all [MoreLabels.Hashtbl] | 
Hashtbl.find_all tbl xreturns the list of all data
     associated withxintbl.
 | 
| find_all [ListLabels] |  | 
| find_all [List] |  | 
| find_all [Hashtbl.SeededS] |  | 
| find_all [Hashtbl.S] |  | 
| find_all [Hashtbl] | 
Hashtbl.find_all tbl xreturns the list of all data
   associated withxintbl.
 | 
| find_all [Ephemeron.SeededS] |  | 
| find_all [Ephemeron.S] |  | 
| find_first [Set.S] | 
find_first f s, wherefis a monotonically increasing function,
       returns the lowest elementeofssuch thatf e,
       or raisesNot_foundif no such element exists.
 | 
| find_first [MoreLabels.Set.S] | 
find_first ~f s, wherefis a monotonically increasing function,
         returns the lowest elementeofssuch thatf e,
         or raisesNot_foundif no such element exists.
 | 
| find_first [MoreLabels.Map.S] | 
find_first ~f m, wherefis a monotonically increasing function,
         returns the binding ofmwith the lowest keyksuch thatf k,
         or raisesNot_foundif no such key exists.
 | 
| find_first [Map.S] | 
find_first f m, wherefis a monotonically increasing function,
       returns the binding ofmwith the lowest keyksuch thatf k,
       or raisesNot_foundif no such key exists.
 | 
| find_first_opt [Set.S] | 
find_first_opt f s, wherefis a monotonically increasing
       function, returns an option containing the lowest elementeofssuch thatf e, orNoneif no such element exists.
 | 
| find_first_opt [MoreLabels.Set.S] | 
find_first_opt ~f s, wherefis a monotonically increasing
         function, returns an option containing the lowest elementeofssuch thatf e, orNoneif no such element exists.
 | 
| find_first_opt [MoreLabels.Map.S] | 
find_first_opt ~f m, wherefis a monotonically increasing
         function, returns an option containing the binding ofmwith the
         lowest keyksuch thatf k, orNoneif no such key exists.
 | 
| find_first_opt [Map.S] | 
find_first_opt f m, wherefis a monotonically increasing
       function, returns an option containing the binding ofmwith the
       lowest keyksuch thatf k, orNoneif no such key exists.
 | 
| find_last [Set.S] | 
find_last f s, wherefis a monotonically decreasing function,
       returns the highest elementeofssuch thatf e,
       or raisesNot_foundif no such element exists.
 | 
| find_last [MoreLabels.Set.S] | 
find_last ~f s, wherefis a monotonically decreasing function,
         returns the highest elementeofssuch thatf e,
         or raisesNot_foundif no such element exists.
 | 
| find_last [MoreLabels.Map.S] | 
find_last ~f m, wherefis a monotonically decreasing function,
         returns the binding ofmwith the highest keyksuch thatf k,
         or raisesNot_foundif no such key exists.
 | 
| find_last [Map.S] | 
find_last f m, wherefis a monotonically decreasing function,
       returns the binding ofmwith the highest keyksuch thatf k,
       or raisesNot_foundif no such key exists.
 | 
| find_last_opt [Set.S] | 
find_last_opt f s, wherefis a monotonically decreasing
       function, returns an option containing the highest elementeofssuch thatf e, orNoneif no such element exists.
 | 
| find_last_opt [MoreLabels.Set.S] | 
find_last_opt ~f s, wherefis a monotonically decreasing
         function, returns an option containing the highest elementeofssuch thatf e, orNoneif no such element exists.
 | 
| find_last_opt [MoreLabels.Map.S] | 
find_last_opt ~f m, wherefis a monotonically decreasing
         function, returns an option containing the binding ofmwith
         the highest keyksuch thatf k, orNoneif no such key
         exists.
 | 
| find_last_opt [Map.S] | 
find_last_opt f m, wherefis a monotonically decreasing
       function, returns an option containing the binding ofmwith
       the highest keyksuch thatf k, orNoneif no such key
       exists.
 | 
| find_left [Either] | 
find_left (Left v)isSome v,find_left (Right _)isNone
 | 
| find_map [Seq] | 
find_map f xsreturnsSome y, wherexis the first element of the
    sequencexssuch thatf x = Some _, if there is such an element,
    and whereyis defined byf x = Some y.
 | 
| find_map [ListLabels] | 
find_map ~f lappliesfto the elements oflin order,
    and returns the first result of the formSome v, orNoneif none exist.
 | 
| find_map [List] | 
find_map f lappliesfto the elements oflin order,
    and returns the first result of the formSome v, orNoneif none exist.
 | 
| find_map [ArrayLabels] | 
find_map ~f aappliesfto the elements ofain order, and returns the
    first result of the formSome v, orNoneif none exist.
 | 
| find_map [Array] | 
find_map f aappliesfto the elements ofain order, and returns the
    first result of the formSome v, orNoneif none exist.
 | 
| find_opt [Weak.S] | 
find_opt t xreturns an instance ofxfound intorNoneif there is no such element.
 | 
| find_opt [Set.S] | 
find_opt x sreturns the element ofsequal tox(according
        toOrd.compare), orNoneif no such element
        exists.
 | 
| find_opt [MoreLabels.Set.S] | 
find_opt x sreturns the element ofsequal tox(according
          toOrd.compare), orNoneif no such element
          exists.
 | 
| find_opt [MoreLabels.Map.S] | 
find_opt x mreturnsSome vif the current value ofxinmisv, orNoneif no binding forxexists.
 | 
| find_opt [MoreLabels.Hashtbl.SeededS] | 
 | 
| find_opt [MoreLabels.Hashtbl.S] | 
 | 
| find_opt [MoreLabels.Hashtbl] | 
Hashtbl.find_opt tbl xreturns the current binding ofxintbl,
      orNoneif no such binding exists.
 | 
| find_opt [Map.S] | 
find_opt x mreturnsSome vif the current value ofxinmisv, orNoneif no binding forxexists.
 | 
| find_opt [ListLabels] | 
find ~f lreturns the first element of the listlthat satisfies the predicatef.
 | 
| find_opt [List] | 
find f lreturns the first element of the listlthat satisfies the predicatef.
 | 
| find_opt [Hashtbl.SeededS] | 
 | 
| find_opt [Hashtbl.S] | 
 | 
| find_opt [Hashtbl] | 
Hashtbl.find_opt tbl xreturns the current binding ofxintbl,
    orNoneif no such binding exists.
 | 
| find_opt [Ephemeron.SeededS] |  | 
| find_opt [Ephemeron.S] |  | 
| find_opt [ArrayLabels] | 
find_opt ~f areturns the first element of the arrayathat satisfies
    the predicatef, orNoneif there is no value that satisfiesfin the
    arraya.
 | 
| find_opt [Array] | 
find_opt f areturns the first element of the arrayathat satisfies
    the predicatef, orNoneif there is no value that satisfiesfin the
    arraya.
 | 
| find_right [Either] | 
find_right (Right v)isSome v,find_right (Left _)isNone
 | 
| first_chars [Str] | 
first_chars s nreturns the firstncharacters ofs.
 | 
| first_non_constant_constructor_tag [Obj] |  | 
| flat_map [Seq] | 
flat_map f xsis equivalent toconcat (map f xs).
 | 
| flatten [ListLabels] |  | 
| flatten [List] |  | 
| flip [Fun] | 
flip freverses the argument order of the binary functionf.
 | 
| float [Random.State] |  | 
| float [Random] | 
Random.float boundreturns a random floating-point number
   between 0 andbound(inclusive).
 | 
| float [Stdlib] |  | 
| 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] |  | 
| float_of_string_opt [Stdlib] | 
Convert the given string to a float. | 
| floor [Float] | 
Round below to an integer value. | 
| floor [Stdlib] | 
Round below to an integer value. | 
| flush [Out_channel] | 
Flush the buffer associated with the given output channel, performing all
    pending writes on that channel. | 
| flush [Stdlib] | 
Flush the buffer associated with the given output channel,
   performing all pending writes on that channel. | 
| flush_all [Out_channel] | 
Flush all open output channels; ignore errors. | 
| flush_all [Stdlib] | 
Flush all open output channels; ignore errors. | 
| flush_input [Lexing] | 
Discard the contents of the buffer and reset the current
    position to 0. | 
| flush_str_formatter [Format] | 
Returns the material printed with str_formatter, flushes
  the formatter and resets the corresponding buffer. | 
| flush_symbolic_output_buffer [Format] | 
flush_symbolic_output_buffer sobreturns the contents of buffersoband resets buffersob.
 | 
| fma [Float] | 
fma x y zreturnsx * 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 initcomputes(f d1 (... (f dN init)))whered1 ... dNare the elements oftin some unspecified order.
 | 
| fold [Stack] | 
fold f accu sis(f (... (f (f accu x1) x2) ...) xn)wherex1is the top of the stack,x2the second element,
    andxnthe bottom element.
 | 
| fold [Set.S] | 
fold f s initcomputes(f xN ... (f x2 (f x1 init))...),
       wherex1 ... xNare the elements ofs, in increasing order.
 | 
| fold [Result] | 
fold ~ok ~error risok vifrisOk vanderror eifrisError e.
 | 
| fold [Queue] | 
fold f accu qis equivalent toList.fold_left f accu l,
   wherelis the list ofq's elements.
 | 
| fold [Option] | 
fold ~none ~some oisnoneifoisNoneandsome vifoisSome v.
 | 
| fold [MoreLabels.Set.S] | 
fold ~f s initcomputes(f xN ... (f x2 (f x1 init))...),
         wherex1 ... xNare the elements ofs, in increasing order.
 | 
| fold [MoreLabels.Map.S] | 
fold ~f m ~initcomputes(f kN dN ... (f k1 d1 init)...),
         wherek1 ... kNare the keys of all bindings inm(in increasing order), andd1 ... dNare the associated data.
 | 
| fold [MoreLabels.Hashtbl.SeededS] |  | 
| fold [MoreLabels.Hashtbl.S] |  | 
| fold [MoreLabels.Hashtbl] | 
Hashtbl.fold ~f tbl ~initcomputes(f kN dN ... (f k1 d1 init)...),
     wherek1 ... kNare the keys of all bindings intbl,
     andd1 ... dNare the associated values.
 | 
| fold [Map.S] | 
fold f m initcomputes(f kN dN ... (f k1 d1 init)...),
       wherek1 ... kNare the keys of all bindings inm(in increasing order), andd1 ... dNare the associated data.
 | 
| fold [Hashtbl.SeededS] |  | 
| fold [Hashtbl.S] |  | 
| fold [Hashtbl] | 
Hashtbl.fold f tbl initcomputes(f kN dN ... (f k1 d1 init)...),
   wherek1 ... kNare the keys of all bindings intbl,
   andd1 ... dNare the associated values.
 | 
| fold [Ephemeron.SeededS] |  | 
| fold [Ephemeron.S] |  | 
| fold [Either] | 
fold ~left ~right (Left v)isleft v, andfold ~left ~right (Right v)isright v.
 | 
| fold_left [String] | 
fold_left f x scomputesf (... (f (f x s.[0]) s.[1]) ...) s.[n-1],
    wherenis the length of the strings.
 | 
| fold_left [StringLabels] | 
fold_left f x scomputesf (... (f (f x s.[0]) s.[1]) ...) s.[n-1],
    wherenis the length of the strings.
 | 
| fold_left [Seq] | 
fold_left f _ xsinvokesf _ xsuccessively
    for every elementxof the sequencexs,
    from left to right.
 | 
| fold_left [ListLabels] | 
fold_left ~f ~init [b1; ...; bn]isf (... (f (f init b1) b2) ...) bn.
 | 
| fold_left [List] | 
fold_left f init [b1; ...; bn]isf (... (f (f init b1) b2) ...) bn.
 | 
| fold_left [Float.ArrayLabels] | 
fold_left ~f x ~initcomputesf (... (f (f x init.(0)) init.(1)) ...) init.(n-1),
      wherenis the length of the floatarrayinit.
 | 
| fold_left [Float.Array] | 
fold_left f x initcomputesf (... (f (f x init.(0)) init.(1)) ...) init.(n-1),
      wherenis the length of the floatarrayinit.
 | 
| fold_left [BytesLabels] | 
fold_left f x scomputesf (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1)),
    wherenis the length ofs.
 | 
| fold_left [Bytes] | 
fold_left f x scomputesf (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1)),
    wherenis the length ofs.
 | 
| fold_left [ArrayLabels] | 
fold_left ~f ~init acomputesf (... (f (f init a.(0)) a.(1)) ...) a.(n-1),
   wherenis the length of the arraya.
 | 
| fold_left [Array] | 
fold_left f init acomputesf (... (f (f init a.(0)) a.(1)) ...) a.(n-1),
   wherenis the length of the arraya.
 | 
| fold_left2 [Seq] | 
fold_left2 f _ xs ysinvokesf _ x ysuccessively
    for every pair(x, y)of elements drawn synchronously
    from the sequencesxsandys.
 | 
| fold_left2 [ListLabels] | 
fold_left2 ~f ~init [a1; ...; an] [b1; ...; bn]isf (... (f (f init a1 b1) a2 b2) ...) an bn.
 | 
| fold_left2 [List] | 
fold_left2 f init [a1; ...; an] [b1; ...; bn]isf (... (f (f init a1 b1) a2 b2) ...) an bn.
 | 
| fold_left_map [ListLabels] | 
fold_left_mapis  a combination offold_leftandmapthat threads an
    accumulator through calls tof.
 | 
| fold_left_map [List] | 
fold_left_mapis  a combination offold_leftandmapthat threads an
    accumulator through calls tof.
 | 
| fold_left_map [ArrayLabels] |  | 
| fold_left_map [Array] |  | 
| fold_lefti [Seq] | 
fold_lefti f _ xsinvokesf _ i xsuccessively
    for every elementxlocated at indexiof the sequencexs.
 | 
| fold_right [String] | 
fold_right f s xcomputesf s.[0] (f s.[1] ( ... (f s.[n-1] x) ...)),
    wherenis the length of the strings.
 | 
| fold_right [StringLabels] | 
fold_right f s xcomputesf s.[0] (f s.[1] ( ... (f s.[n-1] x) ...)),
    wherenis the length of the strings.
 | 
| fold_right [ListLabels] | 
fold_right ~f [a1; ...; an] ~initisf a1 (f a2 (... (f an init) ...)).
 | 
| fold_right [List] | 
fold_right f [a1; ...; an] initisf a1 (f a2 (... (f an init) ...)).
 | 
| fold_right [Float.ArrayLabels] | 
fold_right f a initcomputesf a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)),
      wherenis the length of the floatarraya.
 | 
| fold_right [Float.Array] | 
fold_right f a initcomputesf a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)),
      wherenis the length of the floatarraya.
 | 
| fold_right [BytesLabels] | 
fold_right f s xcomputesf (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...)),
    wherenis the length ofs.
 | 
| fold_right [Bytes] | 
fold_right f s xcomputesf (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...)),
    wherenis the length ofs.
 | 
| fold_right [ArrayLabels] | 
fold_right ~f a ~initcomputesf a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)),
   wherenis the length of the arraya.
 | 
| fold_right [Array] | 
fold_right f a initcomputesf a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)),
   wherenis the length of the arraya.
 | 
| fold_right2 [ListLabels] | 
fold_right2 ~f [a1; ...; an] [b1; ...; bn] ~initisf a1 b1 (f a2 b2 (... (f an bn init) ...)).
 | 
| fold_right2 [List] | 
fold_right2 f [a1; ...; an] [b1; ...; bn] initisf a1 b1 (f a2 b2 (... (f an bn init) ...)).
 | 
| for_all [String] | 
for_all p schecks if all characters inssatisfy the predicatep.
 | 
| for_all [StringLabels] | 
for_all p schecks if all characters inssatisfy the predicatep.
 | 
| for_all [Set.S] | 
for_all f schecks if all elements of the set
       satisfy the predicatef.
 | 
| for_all [Seq] | 
for_all p xsdetermines whether all elementsxof the sequencexssatisfyp x.
 | 
| for_all [MoreLabels.Set.S] | 
for_all ~f schecks if all elements of the set
         satisfy the predicatef.
 | 
| for_all [MoreLabels.Map.S] | 
for_all ~f mchecks if all the bindings of the map
          satisfy the predicatef.
 | 
| for_all [Map.S] | 
for_all f mchecks if all the bindings of the map
        satisfy the predicatef.
 | 
| for_all [ListLabels] | 
for_all ~f [a1; ...; an]checks if all elements of the list
   satisfy the predicatef.
 | 
| for_all [List] | 
for_all f [a1; ...; an]checks if all elements of the list
   satisfy the predicatef.
 | 
| for_all [Float.ArrayLabels] | 
for_all ~f [|a1; ...; an|]checks if all elements of the floatarray
      satisfy the predicatef.
 | 
| for_all [Float.Array] | 
for_all f [|a1; ...; an|]checks if all elements of the floatarray
      satisfy the predicatef.
 | 
| for_all [Either] | 
for_all ~left ~right (Left v)isleft v, andfor_all ~left ~right (Right v)isright v.
 | 
| for_all [BytesLabels] | 
for_all p schecks if all characters inssatisfy the predicatep.
 | 
| for_all [Bytes] | 
for_all p schecks if all characters inssatisfy the predicatep.
 | 
| for_all [ArrayLabels] | 
for_all ~f [|a1; ...; an|]checks if all elements
   of the array satisfy the predicatef.
 | 
| for_all [Array] | 
for_all f [|a1; ...; an|]checks if all elements
   of the array satisfy the predicatef.
 | 
| for_all2 [Seq] | 
for_all2 p xs ysdetermines whether all pairs(x, y)of elements
    drawn synchronously from the sequencesxsandyssatisfyp x y.
 | 
| for_all2 [ListLabels] |  | 
| for_all2 [List] |  | 
| for_all2 [ArrayLabels] |  | 
| for_all2 [Array] |  | 
| force [CamlinternalLazy] |  | 
| force [Lazy] | 
force xforces the suspensionxand returns its result.
 | 
| force_lazy_block [CamlinternalLazy] |  | 
| force_newline [Format] | 
Force a new line in the current pretty-printing box. | 
| force_val [CamlinternalLazy] |  | 
| force_val [Lazy] | 
force_val xforces the suspensionxand returns its
    result.
 | 
| force_val_lazy_block [CamlinternalLazy] |  | 
| forever [Seq] | 
forever fis an infinite sequence where every element is produced
    (on demand) by the function callf().
 | 
| fork [UnixLabels] |  | 
| fork [Unix] |  | 
| format [Printexc.Slot] | 
format pos slotreturns the string representation ofslotasraw_backtrace_to_stringwould format it, assuming it is thepos-th element of the backtrace: the0-th element is
      pretty-printed differently than the others.
 | 
| format_from_string [Scanf] | 
format_from_string s fmtconverts a string argument to a format string,
    according to the given format stringfmt.
 | 
| format_of_string [Stdlib] | 
format_of_string sreturns a format string read from the string
    literals.
 | 
| format_of_string_fmtty [CamlinternalFormat] |  | 
| format_of_string_format [CamlinternalFormat] |  | 
| formatter_of_buffer [Format] | 
formatter_of_buffer breturns a new formatter writing to
  bufferb.
 | 
| formatter_of_out_channel [Format] | 
formatter_of_out_channel ocreturns a new formatter writing
  to the corresponding output channeloc.
 | 
| formatter_of_out_functions [Format] | 
formatter_of_out_functions out_funsreturns a new formatter that writes
  with the set of output functionsout_funs.
 | 
| formatter_of_symbolic_output_buffer [Format] | 
formatter_of_symbolic_output_buffer sobreturns a symbolic formatter
  that outputs tosymbolic_output_buffersob.
 | 
| fortran_layout [Bigarray] |  | 
| forward_tag [Obj] |  | 
| fprintf [Printf] | 
fprintf outchan format arg1 ... argNformats the argumentsarg1toargNaccording to the format stringformat, and
   outputs the resulting string on the channeloutchan.
 | 
| fprintf [Format] |  | 
| freeze_char_set [CamlinternalFormat] |  | 
| frexp [Float] | 
frexp freturns the pair of the significant
    and the exponent off.
 | 
| frexp [Stdlib] | 
frexp freturns the pair of the significant
   and the exponent off.
 | 
| from [Stream] | 
Stream.from freturns a stream built from the functionf.
 | 
| from_bytes [Marshal] | 
Marshal.from_bytes buff ofsunmarshals a structured value
   likeMarshal.from_channeldoes, except that the byte
   representation is not read from a channel, but taken from
   the byte sequencebuff, starting at positionofs.
 | 
| from_channel [Scanf.Scanning] |  | 
| from_channel [Marshal] | 
Marshal.from_channel chanreads from channelchanthe
   byte representation of a structured value, as produced by
   one of theMarshal.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] |  | 
| from_file_bin [Scanf.Scanning] |  | 
| from_fun [Lazy] | 
from_fun fis the same aslazy (f ())but slightly more efficient.
 | 
| from_function [Scanf.Scanning] | 
Scanning.from_function freturns aScanf.Scanning.in_channelformatted
    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] |  | 
| from_string [Marshal] | 
Same as from_bytesbut 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 vevaluatesvfirst (as any function would) and returns
    an already-forced suspension of its result.
 | 
| fscanf [Scanf] | 
 | 
| fst [Stdlib] | 
Return the first component of a pair. | 
| fstat [UnixLabels.LargeFile] |  | 
| fstat [UnixLabels] | 
Return the information for the file associated with the given
   descriptor. | 
| fstat [Unix.LargeFile] |  | 
| fstat [Unix] | 
Return the information for the file associated with the given
   descriptor. | 
| fsync [UnixLabels] | 
Flush file buffers to disk. | 
| fsync [Unix] | 
Flush file buffers to disk. | 
| ftruncate [UnixLabels.LargeFile] |  | 
| ftruncate [UnixLabels] | 
Truncates the file corresponding to the given descriptor
   to the given size. | 
| ftruncate [Unix.LargeFile] |  | 
| ftruncate [Unix] | 
Truncates the file corresponding to the given descriptor
   to the given size. | 
| full_init [Random] |  | 
| full_int [Random.State] |  | 
| full_int [Random] | 
Random.full_int boundreturns a random integer between 0 (inclusive)
     andbound(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 nreturns None if thenth cell ofaris
   empty,Some x(wherexis the value) if it is full.
 | 
| get [String] | 
get s iis the character at indexiins.
 | 
| get [StringLabels] | 
get s iis the character at indexiins.
 | 
| get [Option] | 
get oisvifoisSome vand raise otherwise.
 | 
| get [Gc] | 
Return the current values of the GC parameters in a controlrecord. | 
| get [Float.ArrayLabels] | 
get a nreturns the element numbernof floatarraya.
 | 
| get [Float.Array] | 
get a nreturns the element numbernof floatarraya.
 | 
| get [BytesLabels] | 
get s nreturns the byte at indexnin arguments.
 | 
| get [Bytes] | 
get s nreturns the byte at indexnin arguments.
 | 
| get [Bigarray.Array3] | 
Array3.get a x y z, also writtena.{x,y,z},
     returns the element ofaat coordinates (x,y,z).
 | 
| get [Bigarray.Array2] | 
Array2.get a x y, also writtena.{x,y},
     returns the element ofaat coordinates (x,y).
 | 
| get [Bigarray.Array1] | 
Array1.get a x, or alternativelya.{x},
     returns the element ofaat indexx.
 | 
| get [Bigarray.Array0] | 
Array0.get areturns the only element ina.
 | 
| get [Bigarray.Genarray] | 
Read an element of a generic Bigarray. | 
| get [Atomic] | 
Get the current value of the atomic reference. | 
| get [ArrayLabels] | 
get a nreturns the element numbernof arraya.
 | 
| get [Array] | 
get a nreturns the element numbernof arraya.
 | 
| get [CamlinternalAtomic] |  | 
| get_all_formatter_output_functions [Format] | 
 | 
| get_backtrace [Printexc] | 
Printexc.get_backtrace ()returns a string containing the
    same exception backtrace thatPrintexc.print_backtracewould
    print.
 | 
| get_bucket [Gc] | 
get_bucket nreturns the current size of then-th future bucket
    of the GC smoothing system.
 | 
| get_callstack [Printexc] | 
Printexc.get_callstack nreturns a description of the top of the
    call stack on the current program point (for the current thread),
    with at mostnentries.
 | 
| get_copy [Weak] | 
Weak.get_copy ar nreturns None if thenth cell ofaris
   empty,Some x(wherexis a (shallow) copy of the value) if
   it is full.
 | 
| get_credit [Gc] | 
get_credit ()returns the current size of the "work done in advance"
    counter of the GC smoothing system.
 | 
| get_data [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.get_data | 
| get_data [Ephemeron.Kn] |  | 
| get_data [Ephemeron.K2] |  | 
| get_data [Ephemeron.K1] | 
Ephemeron.K1.get_data ephreturnsNoneif the data ofephis
      empty,Some x(wherexis the data) if it is full.
 | 
| get_data_copy [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.get_data_copy | 
| get_data_copy [Ephemeron.Kn] |  | 
| get_data_copy [Ephemeron.K2] |  | 
| get_data_copy [Ephemeron.K1] | 
Ephemeron.K1.get_data_copy ephreturnsNoneif the data ofephis
      empty,Some x(wherexis a (shallow) copy of the data) if
      it is full.
 | 
| get_ellipsis_text [Format] | 
Return the text of the ellipsis. | 
| get_error [Result] | 
get_error riseifrisError eand raise otherwise.
 | 
| get_formatter_out_functions [Format] | 
Return the current output functions of the pretty-printer,
  including line splitting and indentation functions. | 
| get_formatter_output_functions [Format] | 
Return the current output functions of the standard pretty-printer. | 
| get_formatter_stag_functions [Format] | 
Return the current semantic tag operation functions of the standard
    pretty-printer. | 
| get_formatter_tag_functions [Format] | 
 | 
| get_geometry [Format] | 
Return the current geometry of the formatter | 
| get_int16_be [String] | 
get_int16_be b iisb's big-endian signed 16-bit integer
    starting at character indexi.
 | 
| get_int16_be [StringLabels] | 
get_int16_be b iisb's big-endian signed 16-bit integer
    starting at character indexi.
 | 
| get_int16_be [BytesLabels] | 
get_int16_be b iisb's big-endian signed 16-bit integer
    starting at byte indexi.
 | 
| get_int16_be [Bytes] | 
get_int16_be b iisb's big-endian signed 16-bit integer
    starting at byte indexi.
 | 
| get_int16_le [String] | 
get_int16_le b iisb's little-endian signed 16-bit integer
    starting at character indexi.
 | 
| get_int16_le [StringLabels] | 
get_int16_le b iisb's little-endian signed 16-bit integer
    starting at character indexi.
 | 
| get_int16_le [BytesLabels] | 
get_int16_le b iisb's little-endian signed 16-bit integer
    starting at byte indexi.
 | 
| get_int16_le [Bytes] | 
get_int16_le b iisb's little-endian signed 16-bit integer
    starting at byte indexi.
 | 
| get_int16_ne [String] | 
get_int16_ne b iisb's native-endian signed 16-bit integer
    starting at character indexi.
 | 
| get_int16_ne [StringLabels] | 
get_int16_ne b iisb's native-endian signed 16-bit integer
    starting at character indexi.
 | 
| get_int16_ne [BytesLabels] | 
get_int16_ne b iisb's native-endian signed 16-bit integer
    starting at byte indexi.
 | 
| get_int16_ne [Bytes] | 
get_int16_ne b iisb's native-endian signed 16-bit integer
    starting at byte indexi.
 | 
| get_int32_be [String] | 
get_int32_be b iisb's big-endian 32-bit integer
    starting at character indexi.
 | 
| get_int32_be [StringLabels] | 
get_int32_be b iisb's big-endian 32-bit integer
    starting at character indexi.
 | 
| get_int32_be [BytesLabels] | 
get_int32_be b iisb's big-endian 32-bit integer
    starting at byte indexi.
 | 
| get_int32_be [Bytes] | 
get_int32_be b iisb's big-endian 32-bit integer
    starting at byte indexi.
 | 
| get_int32_le [String] | 
get_int32_le b iisb's little-endian 32-bit integer
    starting at character indexi.
 | 
| get_int32_le [StringLabels] | 
get_int32_le b iisb's little-endian 32-bit integer
    starting at character indexi.
 | 
| get_int32_le [BytesLabels] | 
get_int32_le b iisb's little-endian 32-bit integer
    starting at byte indexi.
 | 
| get_int32_le [Bytes] | 
get_int32_le b iisb's little-endian 32-bit integer
    starting at byte indexi.
 | 
| get_int32_ne [String] | 
get_int32_ne b iisb's native-endian 32-bit integer
    starting at character indexi.
 | 
| get_int32_ne [StringLabels] | 
get_int32_ne b iisb's native-endian 32-bit integer
    starting at character indexi.
 | 
| get_int32_ne [BytesLabels] | 
get_int32_ne b iisb's native-endian 32-bit integer
    starting at byte indexi.
 | 
| get_int32_ne [Bytes] | 
get_int32_ne b iisb's native-endian 32-bit integer
    starting at byte indexi.
 | 
| get_int64_be [String] | 
get_int64_be b iisb's big-endian 64-bit integer
    starting at character indexi.
 | 
| get_int64_be [StringLabels] | 
get_int64_be b iisb's big-endian 64-bit integer
    starting at character indexi.
 | 
| get_int64_be [BytesLabels] | 
get_int64_be b iisb's big-endian 64-bit integer
    starting at byte indexi.
 | 
| get_int64_be [Bytes] | 
get_int64_be b iisb's big-endian 64-bit integer
    starting at byte indexi.
 | 
| get_int64_le [String] | 
get_int64_le b iisb's little-endian 64-bit integer
    starting at character indexi.
 | 
| get_int64_le [StringLabels] | 
get_int64_le b iisb's little-endian 64-bit integer
    starting at character indexi.
 | 
| get_int64_le [BytesLabels] | 
get_int64_le b iisb's little-endian 64-bit integer
    starting at byte indexi.
 | 
| get_int64_le [Bytes] | 
get_int64_le b iisb's little-endian 64-bit integer
    starting at byte indexi.
 | 
| get_int64_ne [String] | 
get_int64_ne b iisb's native-endian 64-bit integer
    starting at character indexi.
 | 
| get_int64_ne [StringLabels] | 
get_int64_ne b iisb's native-endian 64-bit integer
    starting at character indexi.
 | 
| get_int64_ne [BytesLabels] | 
get_int64_ne b iisb's native-endian 64-bit integer
    starting at byte indexi.
 | 
| get_int64_ne [Bytes] | 
get_int64_ne b iisb's native-endian 64-bit integer
    starting at byte indexi.
 | 
| get_int8 [String] | 
get_int8 b iisb's signed 8-bit integer starting at character
    indexi.
 | 
| get_int8 [StringLabels] | 
get_int8 b iisb's signed 8-bit integer starting at character
    indexi.
 | 
| get_int8 [BytesLabels] | 
get_int8 b iisb's signed 8-bit integer starting at byte indexi.
 | 
| get_int8 [Bytes] | 
get_int8 b iisb's signed 8-bit integer starting at byte indexi.
 | 
| get_key [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.get_key | 
| get_key [Ephemeron.Kn] |  | 
| get_key [Ephemeron.K1] | 
Ephemeron.K1.get_key ephreturnsNoneif the key ofephis
      empty,Some x(wherexis the key) if it is full.
 | 
| get_key1 [Ephemeron.K2] |  | 
| get_key1_copy [Ephemeron.K2] |  | 
| get_key2 [Ephemeron.K2] |  | 
| get_key2_copy [Ephemeron.K2] |  | 
| get_key_copy [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.get_key_copy | 
| get_key_copy [Ephemeron.Kn] |  | 
| get_key_copy [Ephemeron.K1] | 
Ephemeron.K1.get_key_copy ephreturnsNoneif the key ofephis
      empty,Some x(wherexis a (shallow) copy of the key) if
      it is full.
 | 
| get_margin [Format] | 
Returns the position of the right margin. | 
| get_mark_tags [Format] | 
Return the current status of tag-marking operations. | 
| get_max_boxes [Format] | 
Returns the maximum number of pretty-printing boxes allowed before
  ellipsis. | 
| get_max_indent [Format] | 
Return the maximum indentation limit (in characters). | 
| get_method [CamlinternalOO] |  | 
| get_method_label [CamlinternalOO] |  | 
| get_method_labels [CamlinternalOO] |  | 
| get_minor_free [Gc] | 
Return the current size of the free space inside the minor heap. | 
| get_ok [Result] | 
get_ok risvifrisOk vand 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 thatPrintexc.print_backtracewould print, but in
    a raw format.
 | 
| get_raw_backtrace_next_slot [Printexc] | 
get_raw_backtrace_next_slot slotreturns the next slot inlined, if any.
 | 
| get_raw_backtrace_slot [Printexc] | 
get_raw_backtrace_slot bckt posreturns the slot in positionposin the
    backtracebckt.
 | 
| get_state [Random] | 
Return the current state of the generator used by the basic functions. | 
| get_symbolic_output_buffer [Format] | 
get_symbolic_output_buffer sobreturns the contents of buffersob.
 | 
| get_temp_dir_name [Filename] | 
The name of the temporary directory:
    Under Unix, the value of the TMPDIRenvironment variable, or "/tmp"
    if the variable is not set. | 
| get_uint16_be [String] | 
get_uint16_be b iisb's big-endian unsigned 16-bit integer
    starting at character indexi.
 | 
| get_uint16_be [StringLabels] | 
get_uint16_be b iisb's big-endian unsigned 16-bit integer
    starting at character indexi.
 | 
| get_uint16_be [BytesLabels] | 
get_uint16_be b iisb's big-endian unsigned 16-bit integer
    starting at byte indexi.
 | 
| get_uint16_be [Bytes] | 
get_uint16_be b iisb's big-endian unsigned 16-bit integer
    starting at byte indexi.
 | 
| get_uint16_le [String] | 
get_uint16_le b iisb's little-endian unsigned 16-bit integer
    starting at character indexi.
 | 
| get_uint16_le [StringLabels] | 
get_uint16_le b iisb's little-endian unsigned 16-bit integer
    starting at character indexi.
 | 
| get_uint16_le [BytesLabels] | 
get_uint16_le b iisb's little-endian unsigned 16-bit integer
    starting at byte indexi.
 | 
| get_uint16_le [Bytes] | 
get_uint16_le b iisb's little-endian unsigned 16-bit integer
    starting at byte indexi.
 | 
| get_uint16_ne [String] | 
get_uint16_ne b iisb's native-endian unsigned 16-bit integer
    starting at character indexi.
 | 
| get_uint16_ne [StringLabels] | 
get_uint16_ne b iisb's native-endian unsigned 16-bit integer
    starting at character indexi.
 | 
| get_uint16_ne [BytesLabels] | 
get_uint16_ne b iisb's native-endian unsigned 16-bit integer
    starting at byte indexi.
 | 
| get_uint16_ne [Bytes] | 
get_uint16_ne b iisb's native-endian unsigned 16-bit integer
    starting at byte indexi.
 | 
| get_uint8 [String] | 
get_uint8 b iisb's unsigned 8-bit integer starting at character
    indexi.
 | 
| get_uint8 [StringLabels] | 
get_uint8 b iisb's unsigned 8-bit integer starting at character
    indexi.
 | 
| get_uint8 [BytesLabels] | 
get_uint8 b iisb's unsigned 8-bit integer starting at byte indexi.
 | 
| get_uint8 [Bytes] | 
get_uint8 b iisb's unsigned 8-bit integer starting at byte indexi.
 | 
| get_utf_16be_uchar [String] | 
get_utf_16be_uchar b idecodes an UTF-16BE character at indexiinb.
 | 
| get_utf_16be_uchar [StringLabels] | 
get_utf_16be_uchar b idecodes an UTF-16BE character at indexiinb.
 | 
| get_utf_16be_uchar [BytesLabels] | 
get_utf_16be_uchar b idecodes an UTF-16BE character at indexiinb.
 | 
| get_utf_16be_uchar [Bytes] | 
get_utf_16be_uchar b idecodes an UTF-16BE character at indexiinb.
 | 
| get_utf_16le_uchar [String] | 
get_utf_16le_uchar b idecodes an UTF-16LE character at indexiinb.
 | 
| get_utf_16le_uchar [StringLabels] | 
get_utf_16le_uchar b idecodes an UTF-16LE character at indexiinb.
 | 
| get_utf_16le_uchar [BytesLabels] | 
get_utf_16le_uchar b idecodes an UTF-16LE character at indexiinb.
 | 
| get_utf_16le_uchar [Bytes] | 
get_utf_16le_uchar b idecodes an UTF-16LE character at indexiinb.
 | 
| get_utf_8_uchar [String] | 
get_utf_8_uchar b idecodes an UTF-8 character at indexiinb.
 | 
| get_utf_8_uchar [StringLabels] | 
get_utf_8_uchar b idecodes an UTF-8 character at indexiinb.
 | 
| get_utf_8_uchar [BytesLabels] | 
get_utf_8_uchar b idecodes an UTF-8 character at indexiinb.
 | 
| get_utf_8_uchar [Bytes] | 
get_utf_8_uchar b idecodes an UTF-8 character at indexiinb.
 | 
| get_value [Semaphore.Counting] | 
get_value sreturns the current value of semaphores.
 | 
| get_variable [CamlinternalOO] |  | 
| get_variables [CamlinternalOO] |  | 
| getaddrinfo [UnixLabels] | 
getaddrinfo host service optsreturns a list ofUnixLabels.addr_inforecords describing socket parameters and addresses suitable for
    communicating with the given host and service.
 | 
| getaddrinfo [Unix] | 
getaddrinfo host service optsreturns a list ofUnix.addr_inforecords 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 Noneif 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 groupwith the given group id. | 
| getgrgid [Unix] | 
Find an entry in groupwith the given group id. | 
| getgrnam [UnixLabels] | 
Find an entry in groupwith the given name. | 
| getgrnam [Unix] | 
Find an entry in groupwith 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 hostswith the given address. | 
| gethostbyaddr [Unix] | 
Find an entry in hostswith the given address. | 
| gethostbyname [UnixLabels] | 
Find an entry in hostswith the given name. | 
| gethostbyname [Unix] | 
Find an entry in hostswith 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 optsreturns the host name and service name
    corresponding to the socket addressaddr.
 | 
| getnameinfo [Unix] | 
getnameinfo addr optsreturns the host name and service name
    corresponding to the socket addressaddr.
 | 
| 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 protocolswith the given name. | 
| getprotobyname [Unix] | 
Find an entry in protocolswith the given name. | 
| getprotobynumber [UnixLabels] | 
Find an entry in protocolswith the given protocol number. | 
| getprotobynumber [Unix] | 
Find an entry in protocolswith the given protocol number. | 
| getpwnam [UnixLabels] | 
Find an entry in passwdwith the given name. | 
| getpwnam [Unix] | 
Find an entry in passwdwith the given name. | 
| getpwuid [UnixLabels] | 
Find an entry in passwdwith the given user id. | 
| getpwuid [Unix] | 
Find an entry in passwdwith the given user id. | 
| getservbyname [UnixLabels] | 
Find an entry in serviceswith the given name. | 
| getservbyname [Unix] | 
Find an entry in serviceswith the given name. | 
| getservbyport [UnixLabels] | 
Find an entry in serviceswith the given service number. | 
| getservbyport [Unix] | 
Find an entry in serviceswith 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] |  | 
| getsockopt_float [Unix] | 
Same as Unix.getsockoptfor a socket option whose value is a
    floating-point number. | 
| getsockopt_int [UnixLabels] |  | 
| getsockopt_int [Unix] |  | 
| getsockopt_optint [UnixLabels] |  | 
| getsockopt_optint [Unix] |  | 
| gettimeofday [UnixLabels] |  | 
| 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 sreturns a string identical tos,
   except that all substrings ofsthat matchregexphave been
   replaced bytempl.
 | 
| global_substitute [Str] | 
global_substitute regexp subst sreturns a string identical
   tos, except that all substrings ofsthat matchregexphave been replaced by the result of functionsubst.
 | 
| 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 eqdefines an equality on elements,group eq xsis the sequence of the maximal runs
    of adjacent duplicate elements of the sequencexs. | 
| group_beginning [Str] | 
group_beginning nreturns the position of the first character
   of the substring that was matched by thenth group of
   the regular expression that was matched by the last call to a
   matching or searching function (seeStr.matched_stringfor details).
 | 
| group_end [Str] | 
group_end nreturns
   the position of the character following the last character of
   substring that was matched by thenth group of the regular
   expression that was matched by the last call to a matching or
   searching function (seeStr.matched_stringfor details).
 | 
| guard [Event] | 
guard fnreturns the event that, when synchronized, computesfn()and behaves as the resulting event.
 | 
| H | 
| handle_unix_error [UnixLabels] | 
handle_unix_error f xappliesftoxand returns the result.
 | 
| handle_unix_error [Unix] | 
handle_unix_error f xappliesftoxand returns the result.
 | 
| has_symlink [UnixLabels] | 
Returns trueif the user is able to create symbolic links. | 
| has_symlink [Unix] | 
Returns trueif the user is able to create symbolic links. | 
| hash [Uchar] | 
hash uassociates a non-negative integer tou.
 | 
| hash [MoreLabels.Hashtbl.SeededHashedType] | 
A seeded hashing function on keys. | 
| hash [MoreLabels.Hashtbl.HashedType] | 
A hashing function on keys. | 
| hash [MoreLabels.Hashtbl] | 
Hashtbl.hash xassociates a nonnegative integer to any value of
     any type.
 | 
| hash [Hashtbl.SeededHashedType] | 
A seeded hashing function on keys. | 
| hash [Hashtbl.HashedType] | 
A hashing function on keys. | 
| hash [Hashtbl] | 
Hashtbl.hash xassociates a nonnegative integer to any value of
   any type.
 | 
| hash [Float] | 
The hash function for floating-point numbers. | 
| hash_param [MoreLabels.Hashtbl] | 
Hashtbl.hash_param meaningful total xcomputes a hash value forx,
     with the same properties as forhash.
 | 
| hash_param [Hashtbl] | 
Hashtbl.hash_param meaningful total xcomputes a hash value forx,
   with the same properties as forhash.
 | 
| hd [ListLabels] | 
Return the first element of the given list. | 
| hd [List] | 
Return the first element of the given list. | 
| header_size [Marshal] | 
The bytes representing a marshaled value are composed of
   a fixed-size header and a variable-sized data part,
   whose size can be determined from the header. | 
| huge_fallback_count [Gc] | 
Return the number of times we tried to map huge pages and had to fall
    back to small pages. | 
| hypot [Float] | 
hypot x yreturnssqrt(x *. x + y *. y), that is, the length
    of the hypotenuse of a right-angled triangle with sides of lengthxandy, or, equivalently, the distance of the point(x,y)to origin.
 | 
| hypot [Stdlib] | 
hypot x yreturnssqrt(x *. x + y *. y), that is, the length
  of the hypotenuse of a right-angled triangle with sides of lengthxandy, or, equivalently, the distance of the point(x,y)to origin.
 | 
| I | 
| i [Complex] |  | 
| ibprintf [Printf] |  | 
| 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] | 
idis the identity function.
 | 
| ifprintf [Printf] |  | 
| ifprintf [Format] | 
Same as fprintfabove, but does not print anything. | 
| ignore [Stdlib] | 
Discard the value of its argument and return (). | 
| ikbprintf [Printf] | 
Same as kbprintfabove, but does not print anything. | 
| ikfprintf [Printf] | 
Same as kfprintfabove, but does not print anything. | 
| ikfprintf [Format] | 
Same as kfprintfabove, but does not print anything. | 
| in_channel_length [Stdlib.LargeFile] |  | 
| in_channel_length [Stdlib] | 
Return the size (number of characters) of the regular file
    on which the given channel is opened. | 
| in_channel_of_descr [UnixLabels] | 
Create an input channel reading from the given descriptor. | 
| in_channel_of_descr [Unix] | 
Create an input channel reading from the given descriptor. | 
| incr [Atomic] | 
incr ratomically increments the value ofrby1.
 | 
| incr [Stdlib] | 
Increment the integer contained in the given reference. | 
| incr [CamlinternalAtomic] |  | 
| index [String] |  | 
| index [StringLabels] |  | 
| index [BytesLabels] | 
index s creturns the index of the first occurrence of bytecins.
 | 
| index [Bytes] | 
index s creturns the index of the first occurrence of bytecins.
 | 
| index_from [String] | 
index_from s i cis the index of the first occurrence ofcinsafter positioni.
 | 
| index_from [StringLabels] | 
index_from s i cis the index of the first occurrence ofcinsafter positioni.
 | 
| index_from [BytesLabels] | 
index_from s i creturns the index of the first occurrence of
    bytecinsafter positioni.
 | 
| index_from [Bytes] | 
index_from s i creturns the index of the first occurrence of
    bytecinsafter positioni.
 | 
| index_from_opt [String] | 
index_from_opt s i cis the index of the first occurrence ofcinsafter positioni(if any).
 | 
| index_from_opt [StringLabels] | 
index_from_opt s i cis the index of the first occurrence ofcinsafter positioni(if any).
 | 
| index_from_opt [BytesLabels] | 
index_from_opt s i creturns the index of the first occurrence of
    bytecinsafter positioniorNoneifcdoes not occur insafter positioni.
 | 
| index_from_opt [Bytes] | 
index_from_opt s i creturns the index of the first occurrence of
    bytecinsafter positioniorNoneifcdoes not occur insafter positioni.
 | 
| index_opt [String] |  | 
| index_opt [StringLabels] |  | 
| index_opt [BytesLabels] | 
index_opt s creturns the index of the first occurrence of bytecinsorNoneifcdoes not occur ins.
 | 
| index_opt [Bytes] | 
index_opt s creturns the index of the first occurrence of bytecinsorNoneifcdoes not occur ins.
 | 
| inet6_addr_any [UnixLabels] | 
A special IPv6 address, for use only with bind, representing
   all the Internet addresses that the host machine possesses. | 
| inet6_addr_any [Unix] | 
A special IPv6 address, for use only with bind, representing
   all the Internet addresses that the host machine possesses. | 
| inet6_addr_loopback [UnixLabels] | 
A special IPv6 address representing the host machine (::1). | 
| inet6_addr_loopback [Unix] | 
A special IPv6 address representing the host machine (::1). | 
| inet_addr_any [UnixLabels] | 
A special IPv4 address, for use only with bind, representing
   all the Internet addresses that the host machine possesses. | 
| inet_addr_any [Unix] | 
A special IPv4 address, for use only with bind, representing
   all the Internet addresses that the host machine possesses. | 
| inet_addr_loopback [UnixLabels] | 
A special IPv4 address representing the host machine (127.0.0.1). | 
| inet_addr_loopback [Unix] | 
A special IPv4 address representing the host machine (127.0.0.1). | 
| inet_addr_of_string [UnixLabels] | 
Conversion from the printable representation of an Internet
    address to its internal representation. | 
| inet_addr_of_string [Unix] | 
Conversion from the printable representation of an Internet
    address to its internal representation. | 
| infinity [Float] |  | 
| infinity [Stdlib] |  | 
| infix_tag [Obj] |  | 
| info [Obj.Closure] |  | 
| inherits [CamlinternalOO] |  | 
| init [String] | 
init n fis a string of lengthnwith indexiholding the characterf i(called in increasing index order).
 | 
| init [StringLabels] | 
init n ~fis a string of lengthnwith indexiholding the characterf i(called in increasing index order).
 | 
| init [Seq] | 
init n fis the sequencef 0; f 1; ...; f (n-1).
 | 
| init [Random] | 
Initialize the generator, using the argument as a seed. | 
| init [ListLabels] | 
init ~len ~fisf 0; f 1; ...; f (len-1), evaluated left to right.
 | 
| init [List] | 
init len fisf 0; f 1; ...; f (len-1), evaluated left to right.
 | 
| init [Float.ArrayLabels] | 
init n ~freturns a fresh floatarray of lengthn,
      with element numberiinitialized to the result off i.
 | 
| init [Float.Array] | 
init n freturns a fresh floatarray of lengthn,
      with element numberiinitialized to the result off i.
 | 
| init [BytesLabels] | 
init n freturns a fresh byte sequence of lengthn,
    with characteriinitialized to the result off i(in increasing
    index order).
 | 
| init [Bytes] | 
init n freturns a fresh byte sequence of lengthn,
    with characteriinitialized to the result off i(in increasing
    index order).
 | 
| init [Bigarray.Array3] | 
Array3.init kind layout dim1 dim2 dim3 freturns a new Bigarraybof three dimensions, whose size isdim1in the first dimension,dim2in the second dimension, anddim3in the third.
 | 
| init [Bigarray.Array2] | 
Array2.init kind layout dim1 dim2 freturns a new Bigarraybof two dimensions, whose size isdim2in the first dimension
     anddim2in the second dimension.
 | 
| init [Bigarray.Array1] | 
Array1.init kind layout dim freturns a new Bigarraybof one dimension, whose size isdim.
 | 
| init [Bigarray.Array0] | 
Array0.init kind layout vbehaves likeArray0.create kind layoutexcept that the element is additionally initialized to the valuev.
 | 
| init [Bigarray.Genarray] | 
Genarray.init kind layout dimensions freturns a new Bigarraybwhose element kind is determined by the parameterkind(one offloat32,float64,int8_signed, etc) and whose layout is
      determined by the parameterlayout(one ofc_layoutorfortran_layout).
 | 
| init [ArrayLabels] | 
init n ~freturns a fresh array of lengthn,
   with element numberiinitialized to the result off i.
 | 
| init [Array] | 
init n freturns a fresh array of lengthn,
   with element numberiinitialized to the result off i.
 | 
| init_class [CamlinternalOO] |  | 
| init_mod [CamlinternalMod] |  | 
| initgroups [UnixLabels] | 
initgroups user groupinitializes the group access list by
    reading the group database /etc/group and using all groups of
    whichuseris a member.
 | 
| initgroups [Unix] | 
initgroups user groupinitializes the group access list by
    reading the group database /etc/group and using all groups of
    whichuseris a member.
 | 
| input [In_channel] | 
input ic buf pos lenreads up tolencharacters from the given channelic, storing them in byte sequencebuf, starting at character numberpos.
 | 
| input [Digest] | 
Read a digest from the given input channel. | 
| input [Stdlib] | 
input ic buf pos lenreads up tolencharacters from
   the given channelic, storing them in byte sequencebuf, starting at
   character numberpos.
 | 
| input_all [In_channel] | 
input_all icreads all remaining data fromic.
 | 
| input_binary_int [Stdlib] | 
Read an integer encoded in binary format (4 bytes, big-endian)
   from the given input channel. | 
| input_byte [In_channel] |  | 
| input_byte [Stdlib] | 
Same as input_char, but return the 8-bit integer representing
   the character. | 
| input_char [In_channel] | 
Read one character from the given input channel. | 
| input_char [Stdlib] | 
Read one character from the given input channel. | 
| input_line [In_channel] | 
input_line icreads characters fromicuntil a newline or the end of
    file is reached.
 | 
| input_line [Stdlib] | 
Read characters from the given input channel, until a
   newline character is encountered. | 
| input_value [Stdlib] | 
Read the representation of a structured value, as produced
   by output_value, and return the corresponding value. | 
| int [Random.State] |  | 
| int [Random] | 
Random.int boundreturns a random integer between 0 (inclusive)
     andbound(exclusive).
 | 
| int [Bigarray] |  | 
| int16_signed [Bigarray] |  | 
| int16_unsigned [Bigarray] |  | 
| int32 [Random.State] |  | 
| int32 [Random] | 
Random.int32 boundreturns a random integer between 0 (inclusive)
     andbound(exclusive).
 | 
| int32 [Bigarray] |  | 
| int64 [Random.State] |  | 
| int64 [Random] | 
Random.int64 boundreturns a random integer between 0 (inclusive)
     andbound(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 raiseFailure "int_of_string"instead of returningNone. | 
| int_of_string_opt [Stdlib] | 
Convert the given string to an integer. | 
| int_size [Sys] |  | 
| int_tag [Obj] |  | 
| inter [Set.S] |  | 
| inter [MoreLabels.Set.S] |  | 
| interactive [Sys] | 
This reference is initially set to falsein standalone
   programs and totrueif the code is being executed under
   the interactive toplevel systemocaml. | 
| interleave [Seq] | 
interleave xs ysis the sequence that begins with the first element ofxs, continues with the first element ofys, and so on.
 | 
| ints [Seq] | 
ints iis the infinite sequence of the integers beginning atiand
    counting up.
 | 
| inv [Complex] | 
Multiplicative inverse (1/z). | 
| invalid_arg [Stdlib] | 
Raise exception Invalid_argumentwith the given string. | 
| is_block [Obj] |  | 
| is_buffered [Out_channel] |  | 
| is_char [Uchar] | 
is_char uistrueif and only ifuis a latin1 OCaml character.
 | 
| is_directory [Sys] | 
Returns trueif the given name refers to a directory,falseif it refers to another kind of file. | 
| is_empty [Stack] | 
Return trueif the given stack is empty,falseotherwise. | 
| is_empty [Set.S] | 
Test whether a set is empty or not. | 
| is_empty [Seq] | 
is_empty xsdetermines whether the sequencexsis empty.
 | 
| is_empty [Queue] | 
Return trueif the given queue is empty,falseotherwise. | 
| is_empty [MoreLabels.Set.S] | 
Test whether a set is empty or not. | 
| is_empty [MoreLabels.Map.S] | 
Test whether a map is empty or not. | 
| is_empty [Map.S] | 
Test whether a map is empty or not. | 
| is_error [Result] | 
is_error ristrueif and only ifrisError _.
 | 
| is_finite [Float] | 
is_finite xistrueif and only ifxis finite i.e., not infinite and
   notFloat.nan.
 | 
| is_implicit [Filename] | 
Return trueif the file name is relative and does not start
   with an explicit reference to the current directory (./or../in Unix),falseif 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_addris an IPv6 address. | 
| is_inet6_addr [Unix] | 
Whether the given inet_addris an IPv6 address. | 
| is_infinite [Float] |  | 
| is_inline [Printexc.Slot] | 
is_inline slotistruewhenslotrefers to a call
      that got inlined by the compiler, andfalsewhen it comes from
      any other context.
 | 
| is_int [Obj] |  | 
| is_integer [Float] | 
is_integer xistrueif and only ifxis an integer.
 | 
| is_left [Either] | 
is_left (Left v)istrue,is_left (Right v)isfalse.
 | 
| is_nan [Float] | 
is_nan xistrueif and only ifxis not a number (seeFloat.nan).
 | 
| is_native [Dynlink] | 
trueif the program is native,falseif the program is bytecode.
 | 
| is_none [Option] | 
is_none oistrueif and only ifoisNone.
 | 
| is_ok [Result] | 
is_ok ristrueif and only ifrisOk _.
 | 
| is_raise [Printexc.Slot] | 
is_raise slotistruewhenslotrefers to a raising
      point in the code, andfalsewhen it comes from a simple
      function call.
 | 
| is_randomized [MoreLabels.Hashtbl] | 
Return trueif the tables are currently created in randomized mode
      by default,falseotherwise. | 
| is_randomized [Hashtbl] | 
Return trueif the tables are currently created in randomized mode
    by default,falseotherwise. | 
| is_relative [Filename] | 
Return trueif the file name is relative to the current
   directory,falseif it is absolute (i.e. | 
| is_right [Either] | 
is_right (Left v)isfalse,is_right (Right v)istrue.
 | 
| is_some [Option] | 
is_some oistrueif and only ifoisSome o.
 | 
| is_val [Lazy] | 
is_val xreturnstrueifxhas already been forced and
    did not raise an exception.
 | 
| is_valid [Uchar] | 
is_valid nistrueif and only ifnis a Unicode scalar value
    (i.e.
 | 
| is_valid_utf_16be [String] | 
is_valid_utf_16be bistrueif and only ifbcontains valid
    UTF-16BE data.
 | 
| is_valid_utf_16be [StringLabels] | 
is_valid_utf_16be bistrueif and only ifbcontains valid
    UTF-16BE data.
 | 
| is_valid_utf_16be [BytesLabels] | 
is_valid_utf_16be bistrueif and only ifbcontains valid
    UTF-16BE data.
 | 
| is_valid_utf_16be [Bytes] | 
is_valid_utf_16be bistrueif and only ifbcontains valid
    UTF-16BE data.
 | 
| is_valid_utf_16le [String] | 
is_valid_utf_16le bistrueif and only ifbcontains valid
    UTF-16LE data.
 | 
| is_valid_utf_16le [StringLabels] | 
is_valid_utf_16le bistrueif and only ifbcontains valid
    UTF-16LE data.
 | 
| is_valid_utf_16le [BytesLabels] | 
is_valid_utf_16le bistrueif and only ifbcontains valid
    UTF-16LE data.
 | 
| is_valid_utf_16le [Bytes] | 
is_valid_utf_16le bistrueif and only ifbcontains valid
    UTF-16LE data.
 | 
| is_valid_utf_8 [String] | 
is_valid_utf_8 bistrueif and only ifbcontains valid
    UTF-8 data.
 | 
| is_valid_utf_8 [StringLabels] | 
is_valid_utf_8 bistrueif and only ifbcontains valid
    UTF-8 data.
 | 
| is_valid_utf_8 [BytesLabels] | 
is_valid_utf_8 bistrueif and only ifbcontains valid
    UTF-8 data.
 | 
| is_valid_utf_8 [Bytes] | 
is_valid_utf_8 bistrueif and only ifbcontains valid
    UTF-8 data.
 | 
| isatty [UnixLabels] | 
Return trueif the given file descriptor refers to a terminal or
   console window,falseotherwise. | 
| isatty [Unix] | 
Return trueif the given file descriptor refers to a terminal or
   console window,falseotherwise. | 
| iter [Weak.S] | 
iter f tcallsfon each element oft, in some unspecified
        order.
 | 
| iter [String] | 
iter f sapplies functionfin turn to all the characters ofs.
 | 
| iter [Stream] | 
Stream.iter f sscans the whole stream s, applying functionfin turn to each stream element encountered.
 | 
| iter [StringLabels] | 
iter ~f sapplies functionfin turn to all the characters ofs.
 | 
| iter [Stack] | 
iter f sappliesfin turn to all elements ofs,
   from the element at the top of the stack to the element at the
   bottom of the stack.
 | 
| iter [Set.S] | 
iter f sappliesfin turn to all elements ofs.
 | 
| iter [Seq] | 
iter f xsinvokesf xsuccessively
    for every elementxof the sequencexs,
    from left to right.
 | 
| iter [Result] | 
iter f risf vifrisOk vand()otherwise.
 | 
| iter [Queue] | 
iter f qappliesfin turn to all elements ofq,
   from the least recently entered to the most recently entered.
 | 
| iter [Option] | 
iter f oisf vifoisSome vand()otherwise.
 | 
| iter [MoreLabels.Set.S] | 
iter ~f sappliesfin turn to all elements ofs.
 | 
| iter [MoreLabels.Map.S] | 
iter ~f mappliesfto all bindings in mapm.
 | 
| iter [MoreLabels.Hashtbl.SeededS] |  | 
| iter [MoreLabels.Hashtbl.S] |  | 
| iter [MoreLabels.Hashtbl] | 
Hashtbl.iter ~f tblappliesfto all bindings in tabletbl.
 | 
| iter [Map.S] | 
iter f mappliesfto all bindings in mapm.
 | 
| iter [ListLabels] | 
iter ~f [a1; ...; an]applies functionfin turn toa1; ...; an.
 | 
| iter [List] | 
iter f [a1; ...; an]applies functionfin turn toa1; ...; an.
 | 
| iter [Hashtbl.SeededS] |  | 
| iter [Hashtbl.S] |  | 
| iter [Hashtbl] | 
Hashtbl.iter f tblappliesfto all bindings in tabletbl.
 | 
| iter [Float.ArrayLabels] | 
iter ~f aapplies functionfin turn to all
      the elements ofa.
 | 
| iter [Float.Array] | 
iter f aapplies functionfin turn to all
      the elements ofa.
 | 
| iter [Ephemeron.SeededS] |  | 
| iter [Ephemeron.S] |  | 
| iter [Either] | 
iter ~left ~right (Left v)isleft v, anditer ~left ~right (Right v)isright v.
 | 
| iter [BytesLabels] | 
iter ~f sapplies functionfin turn to all the bytes ofs.
 | 
| iter [Bytes] | 
iter f sapplies functionfin turn to all the bytes ofs.
 | 
| iter [ArrayLabels] | 
iter ~f aapplies functionfin turn to all
   the elements ofa.
 | 
| iter [Array] | 
iter f aapplies functionfin turn to all
   the elements ofa.
 | 
| iter2 [Seq] | 
iter2 f xs ysinvokesf x ysuccessively for every pair(x, y)of
    elements drawn synchronously from the sequencesxsandys.
 | 
| iter2 [ListLabels] | 
iter2 ~f [a1; ...; an] [b1; ...; bn]calls in turnf a1 b1; ...; f an bn.
 | 
| iter2 [List] | 
iter2 f [a1; ...; an] [b1; ...; bn]calls in turnf a1 b1; ...; f an bn.
 | 
| iter2 [Float.ArrayLabels] | 
Array.iter2 ~f a bapplies functionfto all the elements ofaandb.
 | 
| iter2 [Float.Array] | 
Array.iter2 f a bapplies functionfto all the elements ofaandb.
 | 
| iter2 [ArrayLabels] | 
iter2 ~f a bapplies functionfto all the elements ofaandb.
 | 
| iter2 [Array] | 
iter2 f a bapplies functionfto all the elements ofaandb.
 | 
| iter_error [Result] | 
iter_error f risf eifrisError eand()otherwise.
 | 
| iterate [Seq] | 
iterate f xis the infinite sequence whose elements arex,f x,f (f x), and so on.
 | 
| iteri [String] | 
iteriis likeString.iter, but the function is also given the
    corresponding character index.
 | 
| iteri [StringLabels] | 
iteriis likeStringLabels.iter, but the function is also given the
    corresponding character index.
 | 
| iteri [Seq] | 
iteri f xsinvokesf i xsuccessively
    for every elementxlocated at indexiin the sequencexs.
 | 
| 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 thsuspends the execution of the calling thread
   until the threadthhas terminated.
 | 
| join [Result] | 
join rrisrifrrisOk randrrifrrisError _.
 | 
| join [Option] | 
join ooisSome vifooisSome (Some v)andNoneotherwise.
 | 
| junk [Stream] | 
Remove the first element of the stream, possibly unfreezing
   it before. | 
| K | 
| kasprintf [Format] | 
Same as asprintfabove, 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.dprintfabove, 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 fprintfabove, but instead of returning immediately,
  passes the formatter to its first argument at the end of printing. | 
| kfscanf [Scanf] | 
 | 
| kill [Thread] | 
This function was supposed to terminate prematurely the thread
    whose handle is given. | 
| kill [UnixLabels] | 
kill ~pid ~signalsends signal numbersignalto the process
   with idpid.
 | 
| kill [Unix] | 
kill pid signalsends signal numbersignalto the process
   with idpid.
 | 
| 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 kis the number of bytes used to store
   an element of typek.
 | 
| kprintf [Printf] | 
A deprecated synonym for ksprintf. | 
| kprintf [Format] | 
 | 
| kscanf [Scanf] | 
Same as Scanf.bscanf, but takes an additional function argumentefthat is called in case of error: if the scanning process or
    some conversion fails, the scanning function aborts and calls the
    error handling functionefwith the formatted input channel and the
    exception that aborted the scanning process as arguments. | 
| ksprintf [Printf] | 
Same as sprintfabove, but instead of returning the string,
   passes it to the first argument. | 
| ksprintf [Format] | 
Same as sprintfabove, but instead of returning the string,
  passes it to the first argument. | 
| ksscanf [Scanf] |  | 
| L | 
| last_chars [Str] | 
last_chars s nreturns the lastncharacters ofs.
 | 
| last_non_constant_constructor_tag [Obj] |  | 
| layout [Bigarray.Array3] | 
Return the layout of the given Bigarray. | 
| layout [Bigarray.Array2] | 
Return the layout of the given Bigarray. | 
| layout [Bigarray.Array1] | 
Return the layout of the given Bigarray. | 
| layout [Bigarray.Array0] | 
Return the layout of the given Bigarray. | 
| layout [Bigarray.Genarray] | 
Return the layout of the given Bigarray. | 
| lazy_from_fun [Lazy] | 
 | 
| lazy_from_val [Lazy] | 
 | 
| lazy_is_val [Lazy] | 
 | 
| lazy_tag [Obj] |  | 
| ldexp [Float] | 
ldexp x nreturnsx *. 2 ** n.
 | 
| ldexp [Stdlib] | 
ldexp x nreturnsx *. 2 ** n.
 | 
| left [Either] |  | 
| length [Weak] | 
Weak.length arreturns the length (number of elements) ofar.
 | 
| length [String] | 
length sis the length (number of bytes/characters) ofs.
 | 
| length [StringLabels] | 
length sis the length (number of bytes/characters) ofs.
 | 
| length [Stack] | 
Return the number of elements in a stack. | 
| length [Seq] | 
length xsis the length of the sequencexs.
 | 
| 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 tblreturns the number of bindings intbl.
 | 
| 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 tblreturns the number of bindings intbl.
 | 
| 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 lexbufreturns the string matched by
           the regular expression.
 | 
| lexeme_char [Lexing] | 
Lexing.lexeme_char lexbuf ireturns character numberiin
   the matched string.
 | 
| lexeme_end [Lexing] | 
Lexing.lexeme_end lexbufreturns 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 completepositioninstead
    of an offset. | 
| lexeme_start [Lexing] | 
Lexing.lexeme_start lexbufreturns the offset in the
   input stream of the first character of the matched string.
 | 
| lexeme_start_p [Lexing] | 
Like lexeme_start, but return a completepositioninstead
    of an offset. | 
| link [UnixLabels] | 
link ?follow ~src ~dstcreates a hard link nameddstto the file
   namedsrc.
 | 
| link [Unix] | 
link ?follow src dstcreates a hard link nameddstto the file
   namedsrc.
 | 
| 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 (.cmofile) or
    bytecode library file (.cmafile), 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 slotreturns the location information of the slot,
      if available, andNoneotherwise.
 | 
| lock [Mutex] |  | 
| lockf [UnixLabels] | 
lockf fd ~mode ~lenputs a lock on a region of the file opened
   asfd.
 | 
| lockf [Unix] | 
lockf fd mode lenputs a lock on a region of the file opened
   asfd.
 | 
| log [Float] |  | 
| log [Complex] | 
Natural logarithm (in base e). | 
| log [Stdlib] |  | 
| log10 [Float] |  | 
| log10 [Stdlib] |  | 
| log1p [Float] | 
log1p xcomputeslog(1.0 +. x)(natural logarithm),
    giving numerically-accurate results even ifxis close to0.0.
 | 
| log1p [Stdlib] | 
log1p xcomputeslog(1.0 +. x)(natural logarithm),
    giving numerically-accurate results even ifxis close to0.0.
 | 
| log2 [Float] |  | 
| logand [Nativeint] |  | 
| logand [Int64] |  | 
| logand [Int32] |  | 
| logand [Int] | 
logand x yis the bitwise logical and ofxandy.
 | 
| lognot [Nativeint] | 
Bitwise logical negation. | 
| lognot [Int64] | 
Bitwise logical negation. | 
| lognot [Int32] | 
Bitwise logical negation. | 
| lognot [Int] | 
lognot xis the bitwise logical negation ofx.
 | 
| logor [Nativeint] |  | 
| logor [Int64] |  | 
| logor [Int32] |  | 
| logor [Int] | 
logor x yis the bitwise logical or ofxandy.
 | 
| logxor [Nativeint] | 
Bitwise logical exclusive or. | 
| logxor [Int64] | 
Bitwise logical exclusive or. | 
| logxor [Int32] | 
Bitwise logical exclusive or. | 
| logxor [Int] | 
logxor x yis the bitwise logical exclusive or ofxandy.
 | 
| lookup_tables [CamlinternalOO] |  | 
| lowercase [String] | 
Return a copy of the argument, with all uppercase letters
    translated to lowercase, including accented letters of the ISO
    Latin-1 (8859-1) character set. | 
| lowercase [StringLabels] | 
Return a copy of the argument, with all uppercase letters
    translated to lowercase, including accented letters of the ISO
    Latin-1 (8859-1) character set. | 
| lowercase [Char] | 
Convert the given character to its equivalent lowercase character,
   using the ISO Latin-1 (8859-1) character set. | 
| lowercase [BytesLabels] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, including accented letters of the ISO
   Latin-1 (8859-1) character set. | 
| lowercase [Bytes] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, including accented letters of the ISO
   Latin-1 (8859-1) character set. | 
| lowercase_ascii [String] | 
lowercase_ascii sisswith all uppercase letters translated
    to lowercase, using the US-ASCII character set.
 | 
| lowercase_ascii [StringLabels] | 
lowercase_ascii sisswith all uppercase letters translated
    to lowercase, using the US-ASCII character set.
 | 
| lowercase_ascii [Char] | 
Convert the given character to its equivalent lowercase character,
   using the US-ASCII character set. | 
| lowercase_ascii [BytesLabels] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, using the US-ASCII character set. | 
| lowercase_ascii [Bytes] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, using the US-ASCII character set. | 
| lseek [UnixLabels.LargeFile] |  | 
| lseek [UnixLabels] | 
Set the current position for a file descriptor, and return the resulting
    offset (from the beginning of the file). | 
| lseek [Unix.LargeFile] |  | 
| 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 nDo a minor collection and a slice of major collection.
 | 
| make [Semaphore.Binary] | 
make breturns a new binary semaphore.
 | 
| make [Semaphore.Counting] | 
make nreturns a new counting semaphore, with initial valuen.
 | 
| make [String] | 
make n cis a string of lengthnwith each index holding the
    characterc.
 | 
| make [StringLabels] | 
make n cis a string of lengthnwith each index holding the
    characterc.
 | 
| make [Random.State] | 
Create a new state and initialize it with the given seed. | 
| make [Float.ArrayLabels] | 
make n xreturns a fresh floatarray of lengthn, initialized withx.
 | 
| make [Float.Array] | 
make n xreturns a fresh floatarray of lengthn, initialized withx.
 | 
| make [Ephemeron.Kn.Bucket] |  | 
| make [Ephemeron.Kn] |  | 
| make [Ephemeron.K2.Bucket] |  | 
| make [Ephemeron.K2] |  | 
| make [Ephemeron.K1.Bucket] |  | 
| make [Ephemeron.K1] | 
Ephemeron.K1.make k dcreates an ephemeron with keykand datad.
 | 
| make [BytesLabels] | 
make n creturns a new byte sequence of lengthn, filled with
    the bytec.
 | 
| make [Bytes] | 
make n creturns a new byte sequence of lengthn, filled with
    the bytec.
 | 
| make [Atomic] | 
Create an atomic reference. | 
| make [ArrayLabels] | 
make n xreturns a fresh array of lengthn,
   initialized withx.
 | 
| make [Array] | 
make n xreturns a fresh array of lengthn,
   initialized withx.
 | 
| make [CamlinternalAtomic] |  | 
| make_class [CamlinternalOO] |  | 
| make_class_store [CamlinternalOO] |  | 
| make_float [ArrayLabels] | 
 | 
| make_float [Array] | 
 | 
| make_formatter [Format] | 
make_formatter out flushreturns a new formatter that outputs with
  functionout, and flushes with functionflush.
 | 
| make_iprintf [CamlinternalFormat] |  | 
| make_lexer [Genlex] | 
Construct the lexer function. | 
| make_matrix [ArrayLabels] | 
make_matrix ~dimx ~dimy ereturns a two-dimensional array
   (an array of arrays) with first dimensiondimxand
   second dimensiondimy.
 | 
| make_matrix [Array] | 
make_matrix dimx dimy ereturns a two-dimensional array
   (an array of arrays) with first dimensiondimxand
   second dimensiondimy.
 | 
| make_printf [CamlinternalFormat] |  | 
| make_self_init [Random.State] | 
Create a new state and initialize it with a system-dependent
      low-entropy seed. | 
| make_symbolic_output_buffer [Format] | 
make_symbolic_output_buffer ()returns a fresh buffer for
  symbolic output.
 | 
| map [String] | 
map f sis the string resulting from applyingfto all the
    characters ofsin increasing order.
 | 
| map [StringLabels] | 
map f sis the string resulting from applyingfto all the
    characters ofsin increasing order.
 | 
| map [Set.S] | 
map f sis the set whose elements aref a0,f a1...
 | 
| map [Seq] | 
map f xsis the image of the sequencexsthrough the
    transformationf.
 | 
| map [Result] | 
map f risOk (f v)ifrisOk vandrifrisError _.
 | 
| map [Option] | 
map f oisNoneifoisNoneandSome (f v)isoisSome v.
 | 
| map [MoreLabels.Set.S] | 
map ~f sis the set whose elements aref a0,f a1...
 | 
| map [MoreLabels.Map.S] | 
map ~f mreturns a map with same domain asm, where the
         associated valueaof all bindings ofmhas been
         replaced by the result of the application offtoa.
 | 
| map [Map.S] | 
map f mreturns a map with same domain asm, where the
       associated valueaof all bindings ofmhas been
       replaced by the result of the application offtoa.
 | 
| map [ListLabels] | 
map ~f [a1; ...; an]applies functionftoa1, ..., an,
   and builds the list[f a1; ...; f an]with the results returned byf.
 | 
| map [List] | 
map f [a1; ...; an]applies functionftoa1, ..., an,
   and builds the list[f a1; ...; f an]with the results returned byf.
 | 
| map [Lazy] | 
map f xreturns a suspension that, when forced,
    forcesxand appliesfto its value.
 | 
| map [Float.ArrayLabels] | 
map ~f aapplies functionfto all the elements ofa,
      and builds a floatarray with the results returned byf.
 | 
| map [Float.Array] | 
map f aapplies functionfto all the elements ofa,
      and builds a floatarray with the results returned byf.
 | 
| map [Either] | 
map ~left ~right (Left v)isLeft (left v),map ~left ~right (Right v)isRight (right v).
 | 
| map [BytesLabels] | 
map ~f sapplies functionfin turn to all the bytes ofs(in
    increasing index order) and stores the resulting bytes in a new sequence
    that is returned as the result.
 | 
| map [Bytes] | 
map f sapplies functionfin turn to all the bytes ofs(in
    increasing index order) and stores the resulting bytes in a new sequence
    that is returned as the result.
 | 
| map [ArrayLabels] | 
map ~f aapplies functionfto all the elements ofa,
   and builds an array with the results returned byf:[| f a.(0); f a.(1); ...; f a.(length a - 1) |].
 | 
| map [Array] | 
map f aapplies functionfto all the elements ofa,
   and builds an array with the results returned byf:[| f a.(0); f a.(1); ...; f a.(length a - 1) |].
 | 
| map2 [Seq] | 
map2 f xs ysis the sequence of the elementsf x y,
    where the pairs(x, y)are drawn synchronously from the
    sequencesxsandys.
 | 
| 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 bapplies functionfto all the elements ofaandb, and builds a floatarray with the results returned byf:[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].
 | 
| map2 [Float.Array] | 
map2 f a bapplies functionfto all the elements ofaandb, and builds a floatarray with the results returned byf:[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].
 | 
| map2 [ArrayLabels] | 
map2 ~f a bapplies functionfto all the elements ofaandb, and builds an array with the results returned byf:[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].
 | 
| map2 [Array] | 
map2 f a bapplies functionfto all the elements ofaandb, and builds an array with the results returned byf:[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].
 | 
| map_error [Result] | 
map_error f risError (f e)ifrisError eandrifrisOk _.
 | 
| 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 aapplies functionfto all the elements ofa,
      and builds a floatarray with the results returned byf.
 | 
| map_from_array [Float.Array] | 
map_from_array f aapplies functionfto all the elements ofa,
      and builds a floatarray with the results returned byf.
 | 
| map_left [Either] | 
map_left f eisLeft (f v)ifeisLeft vandeifeisRight _.
 | 
| map_product [Seq] | 
The sequence map_product f xs ysis the image throughfof the Cartesian product of the sequencesxsandys. | 
| map_right [Either] | 
map_right f eisRight (f v)ifeisRight vandeifeisLeft _.
 | 
| map_to_array [Float.ArrayLabels] | 
map_to_array ~f aapplies functionfto all the elements ofa,
      and builds an array with the results returned byf:[| f a.(0); f a.(1); ...; f a.(length a - 1) |].
 | 
| map_to_array [Float.Array] | 
map_to_array f aapplies functionfto all the elements ofa,
      and builds an array with the results returned byf:[| f a.(0); f a.(1); ...; f a.(length a - 1) |].
 | 
| map_val [Lazy] | 
map_val f xappliesfdirectly ifxis already forced,
   otherwise it behaves asmap f x.
 | 
| mapi [String] | 
mapi f sis likeString.mapbut the index of the character is also
    passed tof.
 | 
| mapi [StringLabels] | 
mapi ~f sis likeStringLabels.mapbut the index of the character is also
    passed tof.
 | 
| mapi [Seq] | 
mapiis analogous tomap, but applies the functionfto
    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 scallsfwith each character ofsand 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 scallsfwith each character ofsand its
    index (in increasing index order) and stores the resulting bytes
    in a new sequence that is returned as the result.
 | 
| mapi [ArrayLabels] | 
Same as ArrayLabels.map, but the
   function is applied to the index of the element as first argument,
   and the element itself as second argument. | 
| mapi [Array] | 
Same as Array.map, but the
   function is applied to the index of the element as first argument,
   and the element itself as second argument. | 
| match_beginning [Str] | 
match_beginning()returns the position of the first character
   of the substring that was matched by the last call to a matching
   or searching function (seeStr.matched_stringfor 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 (seeStr.matched_stringfor
   details).
 | 
| matched_group [Str] | 
matched_group n sreturns the substring ofsthat was matched
   by thenth group\(...\)of the regular expression that was
   matched by the last call to a matching or searching function (seeStr.matched_stringfor details).
 | 
| matched_string [Str] | 
matched_string sreturns the substring ofsthat 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_firstprovided 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_splitNote: in the case ofglobal_substituteandsubstitute_first,
   a call tomatched_stringis only valid within thesubstargument,
   not afterglobal_substituteorsubstitute_firstreturns.
 | 
| max [Uchar] |  | 
| 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 yreturns the maximum ofxandy.
 | 
| max [Stdlib] | 
Return the greater of the two arguments. | 
| max_array_length [Sys] | 
Maximum length of a normal array (i.e. | 
| max_binding [MoreLabels.Map.S] |  | 
| 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] |  | 
| max_binding_opt [Map.S] |  | 
| max_elt [Set.S] | 
Same as Set.S.min_elt, but returns the largest element of the
       given set. | 
| max_elt [MoreLabels.Set.S] |  | 
| max_elt_opt [Set.S] |  | 
| max_elt_opt [MoreLabels.Set.S] |  | 
| max_ephe_length [Obj.Ephemeron] | 
Maximum length of an ephemeron, ie the maximum number of keys an
      ephemeron could contain | 
| max_float [Float] | 
The largest positive finite value of type float. | 
| max_float [Stdlib] | 
The largest positive finite value of type float. | 
| max_floatarray_length [Sys] | 
Maximum length of a floatarray. | 
| max_int [Nativeint] | 
The greatest representable native integer,
   either 231 - 1 on a 32-bit platform,
   or 263 - 1 on a 64-bit platform. | 
| max_int [Int64] | 
The greatest representable 64-bit integer, 263 - 1. | 
| max_int [Int32] | 
The greatest representable 32-bit integer, 231 - 1. | 
| max_int [Int] | 
max_intis the greatest representable integer,2{^[Sys.int_size - 1]} - 1.
 | 
| max_int [Stdlib] | 
The greatest representable integer. | 
| max_num [Float] | 
max_num x yreturns the maximum ofxandytreatingnanas
   missing values.
 | 
| max_string_length [Sys] | 
Maximum length of strings and byte sequences. | 
| mem [Weak.S] | 
mem t xreturnstrueif there is at least one instance
        ofxint, false otherwise.
 | 
| mem [Set.S] | 
mem x stests whetherxbelongs to the sets.
 | 
| mem [MoreLabels.Set.S] | 
mem x stests whetherxbelongs to the sets.
 | 
| mem [MoreLabels.Map.S] | 
mem x mreturnstrueifmcontains a binding forx,
         andfalseotherwise.
 | 
| mem [MoreLabels.Hashtbl.SeededS] |  | 
| mem [MoreLabels.Hashtbl.S] |  | 
| mem [MoreLabels.Hashtbl] | 
Hashtbl.mem tbl xchecks ifxis bound intbl.
 | 
| mem [Map.S] | 
mem x mreturnstrueifmcontains a binding forx,
       andfalseotherwise.
 | 
| mem [ListLabels] | 
mem a ~setis true if and only ifais equal
   to an element ofset.
 | 
| mem [List] | 
mem a setis true if and only ifais equal
   to an element ofset.
 | 
| mem [Hashtbl.SeededS] |  | 
| mem [Hashtbl.S] |  | 
| mem [Hashtbl] | 
Hashtbl.mem tbl xchecks ifxis bound intbl.
 | 
| mem [Float.ArrayLabels] | 
mem a ~setis true if and only if there is an element ofsetthat is
      structurally equal toa, i.e.
 | 
| mem [Float.Array] | 
mem a setis true if and only if there is an element ofsetthat is
      structurally equal toa, i.e.
 | 
| mem [Ephemeron.SeededS] |  | 
| mem [Ephemeron.S] |  | 
| mem [ArrayLabels] | 
mem a ~setis true if and only ifais structurally equal
    to an element ofl(i.e.
 | 
| mem [Array] | 
mem a setis true if and only ifais structurally equal
    to an element ofl(i.e.
 | 
| mem_assoc [ListLabels] | 
Same as ListLabels.assoc, but simply returntrueif a binding exists,
   andfalseif no bindings exist for the given key. | 
| mem_assoc [List] | 
Same as List.assoc, but simply returntrueif a binding exists,
   andfalseif 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] |  | 
| mem_ieee [Float.Array] | 
Same as Float.Array.mem, but uses IEEE equality instead of structural equality. | 
| memoize [Seq] | 
The sequence memoize xshas the same elements as the sequencexs. | 
| 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 xreturns an instance ofxfound intif any,
        or else addsxtotand returnx.
 | 
| merge [MoreLabels.Map.S] | 
merge ~f m1 m2computes a map whose keys are a subset of the keys ofm1and ofm2.
 | 
| merge [Map.S] | 
merge f m1 m2computes a map whose keys are a subset of the keys ofm1and ofm2.
 | 
| merge [ListLabels] | 
Merge two lists:
    Assuming that l1andl2are sorted according to the
    comparison functioncmp,merge ~cmp l1 l2will return a
    sorted list containing all the elements ofl1andl2. | 
| merge [List] | 
Merge two lists:
    Assuming that l1andl2are sorted according to the
    comparison functioncmp,merge cmp l1 l2will return a
    sorted list containing all the elements ofl1andl2. | 
| min [Uchar] |  | 
| 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 yreturns the minimum ofxandy.
 | 
| min [Stdlib] | 
Return the smaller of the two arguments. | 
| min_binding [MoreLabels.Map.S] | 
Return the binding with the smallest key in a given map
         (with respect to the Ord.compareordering), or raiseNot_foundif the map is empty. | 
| min_binding [Map.S] | 
Return the binding with the smallest key in a given map
       (with respect to the Ord.compareordering), or raiseNot_foundif 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.compareordering), orNoneif 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.compareordering), orNoneif the map is empty. | 
| min_elt [Set.S] | 
Return the smallest element of the given set
       (with respect to the Ord.compareordering), or raiseNot_foundif the set is empty. | 
| min_elt [MoreLabels.Set.S] | 
Return the smallest element of the given set
         (with respect to the Ord.compareordering), or raiseNot_foundif the set is empty. | 
| min_elt_opt [Set.S] | 
Return the smallest element of the given set
       (with respect to the Ord.compareordering), orNoneif the set is empty. | 
| min_elt_opt [MoreLabels.Set.S] | 
Return the smallest element of the given set
         (with respect to the Ord.compareordering), orNoneif the set is empty. | 
| min_float [Float] | 
The smallest positive, non-zero, non-denormalized value of type float. | 
| min_float [Stdlib] | 
The smallest positive, non-zero, non-denormalized value of type float. | 
| min_int [Nativeint] | 
The smallest representable native integer,
   either -231 on a 32-bit platform,
   or -263 on a 64-bit platform. | 
| min_int [Int64] | 
The smallest representable 64-bit integer, -263. | 
| min_int [Int32] | 
The smallest representable 32-bit integer, -231. | 
| min_int [Int] | 
min_intis the smallest representable integer,-2{^[Sys.int_size - 1]}.
 | 
| min_int [Stdlib] | 
The smallest representable integer. | 
| min_max [Float] | 
min_max x yis(min x y, max x y), just more efficient.
 | 
| min_max_num [Float] | 
min_max_num x yis(min_num x y, max_num x y), just more
   efficient.
 | 
| min_num [Float] | 
min_num x yreturns the minimum ofxandytreatingnanas
   missing values.
 | 
| minor [Gc] | 
Trigger a minor collection. | 
| minor_words [Gc] | 
Number of words allocated in the minor heap since the program was
    started. | 
| minus_one [Nativeint] |  | 
| minus_one [Int64] |  | 
| minus_one [Int32] |  | 
| minus_one [Int] | 
minus_oneis the integer-1.
 | 
| minus_one [Float] |  | 
| mkdir [UnixLabels] |  | 
| mkdir [Unix] | 
Create a directory with the given permissions (see Unix.umask). | 
| mkdir [Sys] | 
Create a directory with the given permissions. | 
| mkfifo [UnixLabels] |  | 
| mkfifo [Unix] | 
Create a named pipe with the given permissions (see Unix.umask). | 
| mktime [UnixLabels] | 
Convert a date and time, specified by the tmargument, into
   a time in seconds, as returned byUnixLabels.time. | 
| mktime [Unix] | 
Convert a date and time, specified by the tmargument, into
   a time in seconds, as returned byUnix.time. | 
| mod_float [Stdlib] | 
mod_float a breturns the remainder ofawith respect tob.
 | 
| modf [Float] | 
modf freturns the pair of the fractional and integral
    part off.
 | 
| modf [Stdlib] | 
modf freturns the pair of the fractional and integral
   part off.
 | 
| mul [Nativeint] |  | 
| mul [Int64] |  | 
| mul [Int32] |  | 
| mul [Int] | 
mul x yis the multiplicationx * y.
 | 
| mul [Float] | 
Floating-point multiplication. | 
| mul [Complex] |  | 
| N | 
| name [Printexc.Slot] | 
name slotreturns 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 icreturns the name of the character source
    for the givenScanf.Scanning.in_channelformatted input channel.
 | 
| nan [Float] | 
A special floating-point value denoting the result of an
    undefined operation such as 0.0 /. 0.0. | 
| nan [Stdlib] | 
A special floating-point value denoting the result of an
   undefined operation such as 0.0 /. 0.0. | 
| narrow [CamlinternalOO] |  | 
| nativebits [Random.State] | 
These functions are the same as the basic functions, except that they
      use (and update) the given PRNG state instead of the default one. | 
| nativebits [Random] |  | 
| nativeint [Random.State] |  | 
| nativeint [Random] | 
Random.nativeint boundreturns a random integer between 0 (inclusive)
     andbound(exclusive).
 | 
| nativeint [Bigarray] |  | 
| neg [Nativeint] |  | 
| neg [Int64] |  | 
| neg [Int32] |  | 
| neg [Int] |  | 
| neg [Float] |  | 
| neg [Complex] |  | 
| neg_infinity [Float] |  | 
| neg_infinity [Stdlib] |  | 
| negate [Fun] | 
negate pis the negation of the predicate functionp.
 | 
| new_block [Obj] |  | 
| new_channel [Event] |  | 
| new_line [Lexing] | 
Update the lex_curr_pfield of the lexbuf to reflect the start
    of a new line. | 
| new_method [CamlinternalOO] |  | 
| new_methods_variables [CamlinternalOO] |  | 
| new_variable [CamlinternalOO] |  | 
| next [Stream] | 
Return the first element of the stream and remove it from the
   stream. | 
| next_after [Float] | 
next_after x yreturns the next representable floating-point
   value followingxin the direction ofy.
 | 
| nice [UnixLabels] | 
Change the process priority. | 
| nice [Unix] | 
Change the process priority. | 
| no_scan_tag [Obj] |  | 
| none [Option] |  | 
| norm [Complex] | 
Norm: given x + i.y, returnssqrt(x^2 + y^2). | 
| norm2 [Complex] | 
Norm squared: given x + i.y, returnsx^2 + y^2. | 
| not [Bool] | 
not bis the boolean negation ofb.
 | 
| not [Stdlib] |  | 
| npeek [Stream] | 
npeek nreturns the list of thenfirst elements of
   the stream, or all its remaining elements if less thannelements are available.
 | 
| nth [ListLabels] | 
Return the n-th element of the given list. | 
| nth [List] | 
Return the n-th element of the given list. | 
| nth [Buffer] | 
Get the n-th character of the buffer. | 
| nth_dim [Bigarray.Genarray] | 
Genarray.nth_dim a nreturns then-th dimension of the
     Bigarraya.
 | 
| 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] | 
nullis"/dev/null"on POSIX and"NUL"on Windows.
 | 
| null_tracker [Gc.Memprof] | 
Default callbacks simply return Noneor() | 
| num_dims [Bigarray.Genarray] | 
Return the number of dimensions of the given Bigarray. | 
| O | 
| obj [Obj] |  | 
| object_tag [Obj] |  | 
| ocaml_release [Sys] |  | 
| ocaml_version [Sys] | 
ocaml_versionis the version of OCaml.
 | 
| of_array [Bigarray.Array3] | 
Build a three-dimensional Bigarray initialized from the
     given array of arrays of arrays. | 
| of_array [Bigarray.Array2] | 
Build a two-dimensional Bigarray initialized from the
     given array of arrays. | 
| of_array [Bigarray.Array1] | 
Build a one-dimensional Bigarray initialized from the
     given array. | 
| of_bytes [String] | 
Return a new string that contains the same bytes as the given byte
    sequence. | 
| of_bytes [Stream] | 
Return the stream of the characters of the bytes parameter. | 
| of_bytes [StringLabels] | 
Return a new string that contains the same bytes as the given byte
    sequence. | 
| of_channel [Stream] | 
Return the stream of the characters read from the input channel. | 
| of_char [Uchar] | 
of_char ciscas a Unicode character.
 | 
| of_dispenser [Seq] | 
of_dispenser itis the sequence of the elements produced by the
    dispenserit.
 | 
| 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 xtruncatesxto an integer.
 | 
| of_int [Uchar] | 
of_int iisias a Unicode character.
 | 
| of_int [Nativeint] | 
Convert the given integer (type int) to a native integer
   (typenativeint). | 
| of_int [Int64] | 
Convert the given integer (type int) to a 64-bit integer
    (typeint64). | 
| of_int [Int32] | 
Convert the given integer (type int) to a 32-bit integer
    (typeint32). | 
| 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 (typeint64). | 
| of_list [Stream] | 
Return the stream holding the elements of the list in the same
   order. | 
| of_list [Set.S] | 
of_list lcreates a set from a list of elements.
 | 
| of_list [MoreLabels.Set.S] | 
of_list lcreates a set from a list of elements.
 | 
| of_list [Float.ArrayLabels] | 
of_list lreturns a fresh floatarray containing the elements
      ofl.
 | 
| of_list [Float.Array] | 
of_list lreturns a fresh floatarray containing the elements
      ofl.
 | 
| of_list [ArrayLabels] | 
of_list lreturns a fresh array containing the elements
   ofl.
 | 
| of_list [Array] | 
of_list lreturns a fresh array containing the elements
   ofl.
 | 
| of_nativeint [Int64] | 
Convert the given native integer (type nativeint)
   to a 64-bit integer (typeint64). | 
| of_seq [String] | 
of_seq sis a string made of the sequence's characters.
 | 
| of_seq [StringLabels] | 
of_seq sis a string made of the sequence's characters.
 | 
| of_seq [Stack] | 
Create a stack from the sequence. | 
| of_seq [Set.S] | 
Build a set from the given bindings | 
| of_seq [Queue] | 
Create a queue from a sequence. | 
| of_seq [MoreLabels.Set.S] | 
Build a set from the given bindings | 
| of_seq [MoreLabels.Map.S] | 
Build a map from the given bindings | 
| of_seq [MoreLabels.Hashtbl.SeededS] | 
 | 
| of_seq [MoreLabels.Hashtbl.S] | 
 | 
| of_seq [MoreLabels.Hashtbl] | 
Build a table from the given bindings. | 
| of_seq [Map.S] | 
Build a map from the given bindings | 
| of_seq [ListLabels] | 
Create a list from a sequence. | 
| of_seq [List] | 
Create a list from a sequence. | 
| of_seq [Hashtbl.SeededS] | 
 | 
| of_seq [Hashtbl.S] | 
 | 
| of_seq [Hashtbl] | 
Build a table from the given bindings. | 
| of_seq [Float.ArrayLabels] | 
Create an array from the generator. | 
| of_seq [Float.Array] | 
Create an array from the generator. | 
| of_seq [Ephemeron.SeededS] |  | 
| of_seq [Ephemeron.S] |  | 
| of_seq [BytesLabels] | 
Create a string from the generator | 
| of_seq [Bytes] | 
Create a string from the generator | 
| of_seq [Buffer] | 
Create a buffer from the generator | 
| of_seq [ArrayLabels] | 
Create an array from the generator | 
| of_seq [Array] | 
Create an array from the generator | 
| of_string [Stream] | 
Return the stream of the characters of the string parameter. | 
| of_string [Nativeint] | 
Convert the given string to a native integer. | 
| of_string [Int64] | 
Convert the given string to a 64-bit integer. | 
| of_string [Int32] | 
Convert the given string to a 32-bit integer. | 
| of_string [Float] | 
Convert the given string to a float. | 
| of_string [BytesLabels] | 
Return a new byte sequence that contains the same bytes as the
    given string. | 
| of_string [Bytes] | 
Return a new byte sequence that contains the same bytes as the
    given string. | 
| of_string_opt [Nativeint] | 
Same as of_string, but returnNoneinstead of raising. | 
| of_string_opt [Int64] | 
Same as of_string, but returnNoneinstead of raising. | 
| of_string_opt [Int32] | 
Same as of_string, but returnNoneinstead of raising. | 
| of_string_opt [Float] | 
Same as of_string, but returnsNoneinstead of raising. | 
| of_val [Obj.Extension_constructor] |  | 
| of_value [Bigarray.Array0] | 
Build a zero-dimensional Bigarray initialized from the
     given value. | 
| ok [Result] |  | 
| once [Seq] | 
The sequence once xshas the same elements as the sequencexs. | 
| one [Nativeint] |  | 
| one [Int64] |  | 
| one [Int32] |  | 
| one [Int] |  | 
| one [Float] |  | 
| one [Complex] |  | 
| opaque_identity [Sys] | 
For the purposes of optimization, opaque_identitybehaves 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 dopens a new compacting pretty-printing box with
    offsetdin the formatterppf.
 | 
| open_box_of_string [CamlinternalFormat] |  | 
| open_connection [ThreadUnix] |  | 
| open_connection [UnixLabels] | 
Connect to a server at the given address. | 
| open_connection [Unix] | 
Connect to a server at the given address. | 
| open_gen [Out_channel] | 
open_gen mode perm filenameopens the named file for writing, as described
    above.
 | 
| open_gen [In_channel] | 
open_gen mode perm filenameopens 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 dopens a new 'horizontal-or-vertical'
  pretty-printing box with offsetd.
 | 
| open_hvbox [Format] | 
pp_open_hvbox ppf dopens a new 'horizontal/vertical' pretty-printing box
  with offsetd.
 | 
| open_in [Scanf.Scanning] | 
Scanning.open_in fnamereturns aScanf.Scanning.in_channelformatted input
    channel for bufferized reading in text mode from filefname.
 | 
| open_in [Stdlib] | 
Open the named file for reading, and return a new input channel
   on that file, positioned at the beginning of the file. | 
| open_in_bin [Scanf.Scanning] | 
Scanning.open_in_bin fnamereturns aScanf.Scanning.in_channelformatted
    input channel for bufferized reading in binary mode from filefname.
 | 
| open_in_bin [Stdlib] | 
Same as open_in, but the file is opened in binary mode,
   so that no translation takes place during reads. | 
| open_in_gen [Stdlib] | 
open_in_gen mode perm filenameopens 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 filenameopens the named file for writing,
   as described above.
 | 
| open_process [ThreadUnix] |  | 
| open_process [UnixLabels] | 
Same as UnixLabels.open_process_out, but redirects both the standard input
   and standard output of the command to pipes connected to the two
   returned channels. | 
| open_process [Unix] | 
Same as Unix.open_process_out, but redirects both the standard input
   and standard output of the command to pipes connected to the two
   returned channels. | 
| open_process_args [UnixLabels] | 
Same as UnixLabels.open_process_args_out, but redirects both the standard input and
    standard output of the new process to pipes connected to the two returned
    channels. | 
| open_process_args [Unix] | 
Same as Unix.open_process_args_out, but redirects both the standard input and
    standard output of the new process to pipes connected to the two returned
    channels. | 
| open_process_args_full [UnixLabels] |  | 
| open_process_args_full [Unix] | 
Similar to Unix.open_process_args, but the third argument specifies the
    environment passed to the new process. | 
| open_process_args_in [UnixLabels] | 
open_process_args_in prog argsruns the programprogwith argumentsargs.
 | 
| open_process_args_in [Unix] | 
open_process_args_in prog argsruns the programprogwith argumentsargs.
 | 
| open_process_args_out [UnixLabels] |  | 
| open_process_args_out [Unix] |  | 
| open_process_full [UnixLabels] |  | 
| open_process_full [Unix] | 
Similar to Unix.open_process, but the second argument specifies
   the environment passed to the command. | 
| open_process_in [ThreadUnix] |  | 
| open_process_in [UnixLabels] | 
High-level pipe and process management. | 
| open_process_in [Unix] | 
High-level pipe and process management. | 
| open_process_out [ThreadUnix] |  | 
| open_process_out [UnixLabels] |  | 
| open_process_out [Unix] |  | 
| open_stag [Format] | 
pp_open_stag ppf topens the semantic tag namedt.
 | 
| open_tag [Format] | 
 | 
| open_tbox [Format] | 
open_tbox ()opens a new tabulation box.
 | 
| open_temp_file [Filename] | 
Same as Filename.temp_file, but returns both the name of a fresh
   temporary file, and an output channel opened (atomically) on
   this file. | 
| open_text [Out_channel] | 
Same as Out_channel.open_bin, but the file is opened in text mode, so that newline
    translation takes place during writes. | 
| open_text [In_channel] | 
Same as In_channel.open_bin, but the file is opened in text mode, so that newline
    translation takes place during reads. | 
| open_vbox [Format] | 
pp_open_vbox ppf dopens a new 'vertical' pretty-printing box
  with offsetd.
 | 
| opendir [UnixLabels] | 
Open a descriptor on a directory | 
| opendir [Unix] | 
Open a descriptor on a directory | 
| openfile [UnixLabels] | 
Open the named file with the given flags. | 
| openfile [Unix] | 
Open the named file with the given flags. | 
| os_type [Sys] | 
Operating system currently executing the OCaml program. | 
| out_channel_length [Stdlib.LargeFile] |  | 
| out_channel_length [Stdlib] | 
Return the size (number of characters) of the regular file
   on which the given channel is opened. | 
| out_channel_of_descr [UnixLabels] | 
Create an output channel writing on the given descriptor. | 
| out_channel_of_descr [Unix] | 
Create an output channel writing on the given descriptor. | 
| out_of_heap_tag [Obj] |  | 
| output [Out_channel] | 
output oc buf pos lenwriteslencharacters from byte sequencebuf,
    starting at offsetpos, to the given output channeloc.
 | 
| output [Digest] | 
Write a digest on the given output channel. | 
| output [Stdlib] | 
output oc buf pos lenwriteslencharacters from byte sequencebuf,
   starting at offsetpos, to the given output channeloc.
 | 
| 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 bwrites the current contents of bufferbon the output channeloc.
 | 
| output_byte [Out_channel] | 
Write one 8-bit integer (as the single character with that code) on the
    given output channel. | 
| output_byte [Stdlib] | 
Write one 8-bit integer (as the single character with that code)
   on the given output channel. | 
| output_bytes [Out_channel] | 
Write the byte sequence on the given output channel. | 
| output_bytes [Stdlib] | 
Write the byte sequence on the given output channel. | 
| output_char [Out_channel] | 
Write the character on the given output channel. | 
| output_char [Stdlib] | 
Write the character on the given output channel. | 
| output_string [Out_channel] | 
Write the string on the given output channel. | 
| output_string [Stdlib] | 
Write the string on the given output channel. | 
| output_substring [Out_channel] |  | 
| output_substring [Stdlib] | 
Same as outputbut 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_msgparses the command line.
 | 
| parse_and_expand_argv_dynamic [Arg] | 
Same as Arg.parse_argv_dynamic, except that theargvargument is a
    reference and may be updated during the parsing ofExpandarguments. | 
| parse_argv [Arg] | 
Arg.parse_argv ~current args speclist anon_fun usage_msgparses
  the arrayargsas if it were the command line.
 | 
| parse_argv_dynamic [Arg] | 
Same as Arg.parse_argv, except that thespeclistargument is a
    reference and may be updated during the parsing. | 
| parse_dynamic [Arg] | 
Same as Arg.parse, except that thespeclistargument is a reference
    and may be updated during the parsing. | 
| parse_expand [Arg] | 
Same as Arg.parse, except that theExpandarguments are allowed and
    theArg.currentreference is not updated. | 
| partition [Set.S] | 
partition f sreturns a pair of sets(s1, s2), wheres1is the set of all the elements ofsthat satisfy the
       predicatef, ands2is the set of all the elements ofsthat do not satisfyf.
 | 
| partition [Seq] | 
partition p xsreturns a pair of the subsequence of the elements
    ofxsthat satisfypand the subsequence of the elements ofxsthat do not satisfyp.
 | 
| partition [MoreLabels.Set.S] | 
partition ~f sreturns a pair of sets(s1, s2), wheres1is the set of all the elements ofsthat satisfy the
         predicatef, ands2is the set of all the elements ofsthat do not satisfyf.
 | 
| partition [MoreLabels.Map.S] | 
partition ~f mreturns a pair of maps(m1, m2), wherem1contains all the bindings ofmthat satisfy the
          predicatef, andm2is the map with all the bindings ofmthat do not satisfyf.
 | 
| partition [Map.S] | 
partition f mreturns a pair of maps(m1, m2), wherem1contains all the bindings ofmthat satisfy the
        predicatef, andm2is the map with all the bindings ofmthat do not satisfyf.
 | 
| partition [ListLabels] | 
partition ~f lreturns a pair of lists(l1, l2), wherel1is the list of all the elements oflthat
   satisfy the predicatef, andl2is the list of all the
   elements oflthat do not satisfyf.
 | 
| partition [List] | 
partition f lreturns a pair of lists(l1, l2), wherel1is the list of all the elements oflthat
   satisfy the predicatef, andl2is the list of all the
   elements oflthat do not satisfyf.
 | 
| partition_map [Seq] | 
partition_map f xsreturns a pair of sequences(ys, zs), where:
 | 
| partition_map [ListLabels] | 
partition_map f lreturns a pair of lists(l1, l2)such that,
    for each elementxof the input listl: iff xisLeft y1, theny1is inl1, and, iff xisRight y2, theny2is inl2.
    The output elements are included inl1andl2in the same
    relative order as the corresponding input elements inl.
 | 
| partition_map [List] | 
partition_map f lreturns a pair of lists(l1, l2)such that,
    for each elementxof the input listl: iff xisLeft y1, theny1is inl1, and, iff xisRight y2, theny2is inl2.
    The output elements are included inl1andl2in the same
    relative order as the corresponding input elements inl.
 | 
| pause [UnixLabels] | 
Wait until a non-ignored, non-blocked signal is delivered. | 
| pause [Unix] | 
Wait until a non-ignored, non-blocked signal is delivered. | 
| peek [Stream] | 
Return Someof "the first element" of the stream, orNoneif
   the stream is empty. | 
| peek [Queue] | 
peek qreturns the first element in queueq, without removing
   it from the queue, or raisesQueue.Emptyif the queue is empty.
 | 
| peek_opt [Queue] | 
peek_opt qreturns the first element in queueq, without removing
   it from the queue, or returnsNoneif the queue is empty.
 | 
| pi [Float] |  | 
| pipe [ThreadUnix] |  | 
| pipe [UnixLabels] |  | 
| pipe [Unix] |  | 
| polar [Complex] | 
polar norm argreturns the complex having normnormand argumentarg.
 | 
| 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 returnSome rwhereris the result value of that communication. | 
| pop [Stack] | 
pop sremoves and returns the topmost element in stacks,
   or raisesStack.Emptyif the stack is empty.
 | 
| pop [Queue] | 
popis a synonym fortake.
 | 
| pop_opt [Stack] | 
pop_opt sremoves and returns the topmost element in stacks,
   or returnsNoneif 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] |  | 
| pow [Complex] |  | 
| pp_close_box [Format] |  | 
| pp_close_stag [Format] |  | 
| pp_close_tag [Format] | 
 | 
| pp_close_tbox [Format] |  | 
| pp_force_newline [Format] |  | 
| pp_get_all_formatter_output_functions [Format] | 
 | 
| pp_get_ellipsis_text [Format] |  | 
| pp_get_formatter_out_functions [Format] |  | 
| pp_get_formatter_output_functions [Format] |  | 
| pp_get_formatter_stag_functions [Format] |  | 
| pp_get_formatter_tag_functions [Format] | 
 | 
| pp_get_geometry [Format] |  | 
| pp_get_margin [Format] |  | 
| pp_get_mark_tags [Format] |  | 
| pp_get_max_boxes [Format] |  | 
| pp_get_max_indent [Format] |  | 
| pp_get_print_tags [Format] |  | 
| pp_open_box [Format] |  | 
| pp_open_hbox [Format] |  | 
| pp_open_hovbox [Format] |  | 
| pp_open_hvbox [Format] |  | 
| pp_open_stag [Format] |  | 
| pp_open_tag [Format] | 
 | 
| pp_open_tbox [Format] |  | 
| pp_open_vbox [Format] |  | 
| pp_over_max_boxes [Format] |  | 
| pp_print_as [Format] |  | 
| pp_print_bool [Format] |  | 
| pp_print_break [Format] |  | 
| pp_print_bytes [Format] |  | 
| pp_print_char [Format] |  | 
| pp_print_custom_break [Format] | 
pp_print_custom_break ppf ~fits:(s1, n, s2) ~breaks:(s3, m, s4)emits a
   custom break hint: the pretty-printer may split the line at this point.
 | 
| pp_print_cut [Format] |  | 
| pp_print_either [Format] | 
pp_print_either ~left ~right ppf eprintseonppfusingleftifeisEither.Left _andrightifeisEither.Right _.
 | 
| pp_print_float [Format] |  | 
| pp_print_flush [Format] |  | 
| pp_print_if_newline [Format] |  | 
| pp_print_int [Format] |  | 
| pp_print_list [Format] | 
pp_print_list ?pp_sep pp_v ppf lprints items of listl,
  usingpp_vto print each item, and callingpp_sepbetween items (pp_sepdefaults toFormat.pp_print_cut.
 | 
| pp_print_newline [Format] |  | 
| pp_print_option [Format] | 
pp_print_option ?none pp_v ppf oprintsoonppfusingpp_vifoisSome vandnoneif it isNone.
 | 
| pp_print_result [Format] | 
pp_print_result ~ok ~error ppf rprintsronppfusingokifrisOk _anderrorifrisError _.
 | 
| pp_print_seq [Format] | 
pp_print_seq ?pp_sep pp_v ppf sprints items of sequences,
  usingpp_vto print each item, and callingpp_sepbetween items (pp_sepdefaults toFormat.pp_print_cut.
 | 
| pp_print_space [Format] |  | 
| pp_print_string [Format] |  | 
| pp_print_tab [Format] |  | 
| pp_print_tbreak [Format] |  | 
| pp_print_text [Format] |  | 
| pp_safe_set_geometry [Format] |  | 
| pp_set_all_formatter_output_functions [Format] | 
 | 
| pp_set_ellipsis_text [Format] |  | 
| pp_set_formatter_out_channel [Format] | 
Redirecting the standard formatter output | 
| pp_set_formatter_out_functions [Format] |  | 
| pp_set_formatter_output_functions [Format] |  | 
| pp_set_formatter_stag_functions [Format] |  | 
| pp_set_formatter_tag_functions [Format] | 
This function will erase non-string tag formatting functions. | 
| pp_set_geometry [Format] |  | 
| pp_set_margin [Format] |  | 
| pp_set_mark_tags [Format] |  | 
| pp_set_max_boxes [Format] |  | 
| pp_set_max_indent [Format] |  | 
| pp_set_print_tags [Format] |  | 
| pp_set_tab [Format] |  | 
| pp_set_tags [Format] |  | 
| pp_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 thegeometryrecord with new fields.
 | 
| pred [Uchar] | 
pred uis the scalar value beforeuin the set of Unicode scalar
    values.
 | 
| pred [Nativeint] |  | 
| pred [Int64] |  | 
| pred [Int32] |  | 
| pred [Int] |  | 
| pred [Float] | 
pred xreturns the floating-point number right beforexi.e.,
   the greatest floating-point number smaller thanx.
 | 
| pred [Stdlib] |  | 
| 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 xappliesfntoxand returns the result.
 | 
| print_as [Format] | 
pp_print_as ppf len sprintssin the current pretty-printing box.
 | 
| print_backtrace [Printexc] | 
Printexc.print_backtrace ocprints an exception backtrace
    on the output channeloc.
 | 
| print_bool [Format] | 
Print a boolean in the current pretty-printing box. | 
| print_break [Format] | 
pp_print_break ppf nspaces offsetemits a 'full' break hint:
  the pretty-printer may split the line at this point,
  otherwise it printsnspacesspaces.
 | 
| print_bytes [Format] | 
pp_print_bytes ppf bprintsbin the current pretty-printing box.
 | 
| print_bytes [Stdlib] | 
Print a byte sequence on standard output. | 
| print_char [Format] | 
Print a character in the current pretty-printing box. | 
| print_char [Stdlib] | 
Print a character on standard output. | 
| print_cut [Format] | 
pp_print_cut ppf ()emits a 'cut' break hint:
  the pretty-printer may split the line at this point,
  otherwise it prints nothing.
 | 
| print_endline [Stdlib] | 
Print a string, followed by a newline character, on
   standard output and flush standard output. | 
| print_float [Format] | 
Print a floating point number in the current pretty-printing box. | 
| print_float [Stdlib] | 
Print a floating-point number, in decimal, on standard output. | 
| print_flush [Format] | 
End of pretty-printing: resets the pretty-printer to initial state. | 
| print_if_newline [Format] | 
Execute the next formatting command if the preceding line
  has just been split. | 
| print_int [Format] | 
Print an integer in the current pretty-printing box. | 
| print_int [Stdlib] | 
Print an integer, in decimal, on standard output. | 
| print_newline [Format] | 
End of pretty-printing: resets the pretty-printer to initial state. | 
| print_newline [Stdlib] | 
Print a newline character on standard output, and flush
   standard output. | 
| print_raw_backtrace [Printexc] | 
Print a raw backtrace in the same format
    Printexc.print_backtraceuses. | 
| print_space [Format] | 
pp_print_space ppf ()emits a 'space' break hint:
  the pretty-printer may split the line at this point,
  otherwise it prints one space.
 | 
| print_stat [Gc] | 
Print the current values of the memory management counters (in
   human-readable form) into the channel argument. | 
| print_string [Format] | 
pp_print_string ppf sprintssin the current pretty-printing box.
 | 
| print_string [Stdlib] | 
Print a string on standard output. | 
| print_tab [Format] | 
print_tab ()emits a 'next' tabulation break hint: if not already set on
  a tabulation marker, the insertion point moves to the first tabulation
  marker on the right, or the pretty-printer splits the line and insertion
  point moves to the leftmost tabulation marker.
 | 
| print_tbreak [Format] | 
print_tbreak nspaces offsetemits a 'full' tabulation break hint.
 | 
| printf [Printf] |  | 
| printf [Format] | 
Same as fprintfabove, but output onstd_formatter. | 
| process_full_pid [UnixLabels] |  | 
| process_full_pid [Unix] |  | 
| process_in_pid [UnixLabels] |  | 
| process_in_pid [Unix] |  | 
| process_out_pid [UnixLabels] |  | 
| process_out_pid [Unix] |  | 
| process_pid [UnixLabels] |  | 
| process_pid [Unix] |  | 
| product [Seq] | 
product xs ysis the Cartesian product of the sequencesxsandys.
 | 
| prohibit [Dynlink] | 
prohibit unitsprohibits dynamically-linked units from referencing
    the units named in listunitsby removing such units from the allowed
    units list.
 | 
| protect [Fun] | 
protect ~finally workinvokeswork ()and thenfinally ()beforework ()returns with its value or an exception.
 | 
| public_dynamically_loaded_units [Dynlink] | 
Return the list of compilation units that have been dynamically loaded via
    loadfile(and not vialoadfile_private). | 
| public_method_label [CamlinternalOO] |  | 
| push [Stack] | 
push x sadds the elementxat the top of stacks.
 | 
| push [Queue] | 
pushis a synonym foradd.
 | 
| putenv [UnixLabels] | 
putenv name valuesets the value associated to a
   variable in the process environment.
 | 
| putenv [Unix] | 
putenv name valuesets the value associated to a
   variable in the process environment.
 | 
| Q | 
| query [Ephemeron.Kn] |  | 
| query [Ephemeron.K2] |  | 
| query [Ephemeron.K1] | 
Ephemeron.K1.query eph keyreturnsSome x(wherexis the
      ephemeron's data) ifkeyis physically equal toeph's key, andNoneifephis empty orkeyis not equal toeph's key.
 | 
| quick_stat [Gc] | 
Same as statexcept thatlive_words,live_blocks,free_words,free_blocks,largest_free, andfragmentsare set to 0. | 
| quote [Str] | 
Str.quote sreturns a regexp string that matches exactlysand 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] |  | 
| R | 
| raise [Stdlib] | 
Raise the given exception value | 
| raise_notrace [Stdlib] | 
A faster version raisewhich 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.createreturns randomized
      hash tables, unless the~random:falseoptional parameter is given. | 
| randomize [Hashtbl] | 
After a call to Hashtbl.randomize(), hash tables are created in
    randomized mode by default:Hashtbl.createreturns randomized
    hash tables, unless the~random:falseoptional parameter is given. | 
| raw_backtrace_entries [Printexc] | 
 | 
| raw_backtrace_length [Printexc] | 
raw_backtrace_length bcktreturns the number of slots in the
    backtracebckt.
 | 
| raw_backtrace_to_string [Printexc] | 
Return a string from a raw backtrace, in the same format
    Printexc.get_backtraceuses. | 
| raw_field [Obj] |  | 
| rcontains_from [String] | 
rcontains_from s stop cistrueif and only ifcappears insbefore positionstop+1.
 | 
| rcontains_from [StringLabels] | 
rcontains_from s stop cistrueif and only ifcappears insbefore positionstop+1.
 | 
| rcontains_from [BytesLabels] | 
rcontains_from s stop ctests if bytecappears insbefore
    positionstop+1.
 | 
| rcontains_from [Bytes] | 
rcontains_from s stop ctests if bytecappears insbefore
    positionstop+1.
 | 
| reachable_words [Obj] | 
Computes the total size (in words, including the headers) of all
     heap blocks accessible from the argument. | 
| read [ThreadUnix] |  | 
| read [UnixLabels] | 
read fd ~buf ~pos ~lenreadslenbytes from descriptorfd,
    storing them in byte sequencebuf, starting at positionposinbuf.
 | 
| read [Unix] | 
read fd buf pos lenreadslenbytes from descriptorfd,
    storing them in byte sequencebuf, starting at positionposinbuf.
 | 
| read_arg [Arg] | 
Arg.read_arg filereads newline-terminated command line arguments from
    filefile.
 | 
| read_arg0 [Arg] | 
Identical to Arg.read_argbut assumes null character terminated command
    line arguments. | 
| read_float [Stdlib] | 
Same as read_float_opt, but raiseFailure "float_of_string"instead of returningNone. | 
| 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 raiseFailure "int_of_string"instead of returningNone. | 
| read_int_opt [Stdlib] | 
Flush standard output, then read one line from standard input
   and convert it to an integer. | 
| read_line [Stdlib] | 
Flush standard output, then read characters from standard input
   until a newline character is encountered. | 
| readdir [UnixLabels] | 
Return the next entry in a directory. | 
| readdir [Unix] | 
Return the next entry in a directory. | 
| readdir [Sys] | 
Return the names of all files present in the given directory. | 
| readlink [UnixLabels] | 
Read the contents of a symbolic link. | 
| readlink [Unix] | 
Read the contents of a symbolic link. | 
| really_input [In_channel] | 
really_input ic buf pos lenreadslencharacters from channelic,
    storing them in byte sequencebuf, starting at character numberpos.
 | 
| really_input [Stdlib] | 
really_input ic buf pos lenreadslencharacters from channelic,
   storing them in byte sequencebuf, starting at character numberpos.
 | 
| really_input_string [In_channel] | 
really_input_string ic lenreadslencharacters from channelicand
    returns them in a new string.
 | 
| really_input_string [Stdlib] | 
really_input_string ic lenreadslencharacters from channelicand returns them in a new string.
 | 
| realpath [UnixLabels] | 
realpath pis an absolute pathname forpobtained by resolving
    all extra/characters, relative path segments and symbolic links.
 | 
| realpath [Unix] | 
realpath pis an absolute pathname forpobtained 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 chreturns the event consisting in receiving a value
   from the channelch.
 | 
| record_backtrace [Printexc] | 
Printexc.record_backtrace bturns recording of exception backtraces
    on (ifb = true) or off (ifb = false).
 | 
| recv [ThreadUnix] |  | 
| recv [UnixLabels] | 
Receive data from a connected socket. | 
| recv [Unix] | 
Receive data from a connected socket. | 
| recvfrom [ThreadUnix] |  | 
| recvfrom [UnixLabels] | 
Receive data from an unconnected socket. | 
| recvfrom [Unix] | 
Receive data from an unconnected socket. | 
| ref [Stdlib] | 
Return a fresh reference containing the given value. | 
| regexp [Str] | 
Compile a regular expression. | 
| regexp_case_fold [Str] | 
Same as regexp, but the compiled expression will match text
    in a case-insensitive way: uppercase and lowercase letters will
    be considered equivalent. | 
| regexp_string [Str] | 
Str.regexp_string sreturns a regular expression
   that matches exactlysand nothing else.
 | 
| regexp_string_case_fold [Str] | 
Str.regexp_string_case_foldis similar toStr.regexp_string,
   but the regexp matches in a case-insensitive way.
 | 
| register [Callback] | 
Callback.register n vregisters the valuevunder
   the namen.
 | 
| register_exception [Callback] | 
Callback.register_exception n exnregisters the
   exception contained in the exception valueexnunder the namen.
 | 
| register_printer [Printexc] | 
Printexc.register_printer fnregistersfnas an exception
    printer.
 | 
| release [Semaphore.Binary] | 
release ssets the value of semaphoresto 1, putting it in the
    "available" state.
 | 
| release [Semaphore.Counting] | 
release sincrements the value of semaphores.
 | 
| rem [Nativeint] |  | 
| rem [Int64] |  | 
| rem [Int32] |  | 
| rem [Int] | 
rem x yis the remainderx mod y.
 | 
| rem [Float] | 
rem a breturns the remainder ofawith respect tob.
 | 
| remove [Weak.S] | 
remove t xremoves fromtone instance ofx.
 | 
| remove [Sys] | 
Remove the given file name from the file system. | 
| remove [Set.S] | 
remove x sreturns a set containing all elements ofs,
       exceptx.
 | 
| remove [MoreLabels.Set.S] | 
remove x sreturns a set containing all elements ofs,
         exceptx.
 | 
| remove [MoreLabels.Map.S] | 
remove x mreturns a map containing the same bindings asm, except forxwhich is unbound in the returned map.
 | 
| remove [MoreLabels.Hashtbl.SeededS] |  | 
| remove [MoreLabels.Hashtbl.S] |  | 
| remove [MoreLabels.Hashtbl] | 
Hashtbl.remove tbl xremoves the current binding ofxintbl,
     restoring the previous binding if it exists.
 | 
| remove [Map.S] | 
remove x mreturns a map containing the same bindings asm, except forxwhich is unbound in the returned map.
 | 
| remove [Hashtbl.SeededS] |  | 
| remove [Hashtbl.S] |  | 
| remove [Hashtbl] | 
Hashtbl.remove tbl xremoves the current binding ofxintbl,
   restoring the previous binding if it exists.
 | 
| remove [Ephemeron.Kn.Bucket] | 
remove b kremoves frombthe most-recently added
        ephemeron with keysk, or does nothing if there is no such
        ephemeron.
 | 
| remove [Ephemeron.K2.Bucket] | 
remove b k1 k2removes frombthe most-recently added
        ephemeron with keysk1andk2, or does nothing if there
        is no such ephemeron.
 | 
| remove [Ephemeron.K1.Bucket] | 
remove b kremoves frombthe most-recently added
        ephemeron with keyk, or does nothing if there is no such
        ephemeron.
 | 
| remove [Ephemeron.SeededS] |  | 
| remove [Ephemeron.S] |  | 
| remove_assoc [ListLabels] | 
remove_assoc a lreturns the list of
   pairslwithout the first pair with keya, if any.
 | 
| remove_assoc [List] | 
remove_assoc a lreturns the list of
   pairslwithout the first pair with keya, if any.
 | 
| remove_assq [ListLabels] |  | 
| remove_assq [List] | 
Same as List.remove_assoc, but uses physical equality instead
   of structural equality to compare keys. | 
| remove_extension [Filename] |  | 
| rename [UnixLabels] | 
rename ~src ~dstchanges the name of a file fromsrctodst,
    moving it between directories if needed.
 | 
| rename [Unix] | 
rename src dstchanges the name of a file fromsrctodst,
    moving it between directories if needed.
 | 
| rename [Sys] |  | 
| rep [Uchar] |  | 
| repeat [Seq] | 
repeat xis the infinite sequence
    where the elementxis repeated indefinitely.
 | 
| replace [MoreLabels.Hashtbl.SeededS] |  | 
| replace [MoreLabels.Hashtbl.S] |  | 
| replace [MoreLabels.Hashtbl] | 
Hashtbl.replace tbl ~key ~datareplaces the current binding ofkeyintblby a binding ofkeytodata.
 | 
| replace [Hashtbl.SeededS] |  | 
| replace [Hashtbl.S] |  | 
| replace [Hashtbl] | 
Hashtbl.replace tbl key datareplaces the current binding ofkeyintblby a binding ofkeytodata.
 | 
| 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 sreturns the replacement textreplin which\1,\2, etc.
 | 
| replace_seq [MoreLabels.Hashtbl.SeededS] | 
 | 
| replace_seq [MoreLabels.Hashtbl.S] | 
 | 
| replace_seq [MoreLabels.Hashtbl] |  | 
| replace_seq [Hashtbl.SeededS] | 
 | 
| replace_seq [Hashtbl.S] | 
 | 
| replace_seq [Hashtbl] |  | 
| 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 nthat was allocated byBuffer.createn. | 
| reshape [Bigarray] | 
reshape b [|d1;...;dN|]converts the Bigarraybto aN-dimensional array of dimensionsd1...
 | 
| reshape_0 [Bigarray] | 
Specialized version of Bigarray.reshapefor reshaping to
   zero-dimensional arrays. | 
| reshape_1 [Bigarray] | 
Specialized version of Bigarray.reshapefor reshaping to
   one-dimensional arrays. | 
| reshape_2 [Bigarray] | 
Specialized version of Bigarray.reshapefor reshaping to
   two-dimensional arrays. | 
| reshape_3 [Bigarray] | 
Specialized version of Bigarray.reshapefor reshaping to
   three-dimensional arrays. | 
| return [Seq] | 
return xis the sequence whose sole element isx.
 | 
| rev [ListLabels] |  | 
| rev [List] |  | 
| rev_append [ListLabels] | 
rev_append l1 l2reversesl1and concatenates it withl2.
 | 
| rev_append [List] | 
rev_append l1 l2reversesl1and concatenates it withl2.
 | 
| rev_char_set [CamlinternalFormat] |  | 
| rev_map [ListLabels] |  | 
| rev_map [List] | 
rev_map f lgives the same result asList.rev (List.map f l), but is tail-recursive and
   more efficient.
 | 
| rev_map2 [ListLabels] |  | 
| rev_map2 [List] | 
rev_map2 f l1 l2gives the same result asList.rev (List.map2 f l1 l2), but is tail-recursive and
   more efficient.
 | 
| rewinddir [UnixLabels] | 
Reposition the descriptor to the beginning of the directory | 
| rewinddir [Unix] | 
Reposition the descriptor to the beginning of the directory | 
| rhs_end [Parsing] |  | 
| rhs_end_pos [Parsing] | 
Same as rhs_end, but return apositioninstead of an offset. | 
| rhs_start [Parsing] | 
Same as Parsing.symbol_startandParsing.symbol_end, but
   return the offset of the string matching thenth item on the
   right-hand side of the rule, wherenis the integer parameter
   torhs_startandrhs_end. | 
| rhs_start_pos [Parsing] | 
Same as rhs_start, but return apositioninstead of an offset. | 
| right [Either] |  | 
| rindex [String] |  | 
| rindex [StringLabels] |  | 
| rindex [BytesLabels] | 
rindex s creturns the index of the last occurrence of bytecins.
 | 
| rindex [Bytes] | 
rindex s creturns the index of the last occurrence of bytecins.
 | 
| rindex_from [String] | 
rindex_from s i cis the index of the last occurrence ofcinsbefore positioni+1.
 | 
| rindex_from [StringLabels] | 
rindex_from s i cis the index of the last occurrence ofcinsbefore positioni+1.
 | 
| rindex_from [BytesLabels] | 
rindex_from s i creturns the index of the last occurrence of
    bytecinsbefore positioni+1.
 | 
| rindex_from [Bytes] | 
rindex_from s i creturns the index of the last occurrence of
    bytecinsbefore positioni+1.
 | 
| rindex_from_opt [String] | 
rindex_from_opt s i cis the index of the last occurrence ofcinsbefore positioni+1(if any).
 | 
| rindex_from_opt [StringLabels] | 
rindex_from_opt s i cis the index of the last occurrence ofcinsbefore positioni+1(if any).
 | 
| rindex_from_opt [BytesLabels] | 
rindex_from_opt s i creturns the index of the last occurrence
    of bytecinsbefore positioni+1orNoneifcdoes not
    occur insbefore positioni+1.
 | 
| rindex_from_opt [Bytes] | 
rindex_from_opt s i creturns the index of the last occurrence
    of bytecinsbefore positioni+1orNoneifcdoes not
    occur insbefore positioni+1.
 | 
| rindex_opt [String] |  | 
| rindex_opt [StringLabels] |  | 
| rindex_opt [BytesLabels] | 
rindex_opt s creturns the index of the last occurrence of bytecinsorNoneifcdoes not occur ins.
 | 
| rindex_opt [Bytes] | 
rindex_opt s creturns the index of the last occurrence of bytecinsorNoneifcdoes not occur ins.
 | 
| rmdir [UnixLabels] | 
Remove an empty directory. | 
| rmdir [Unix] | 
Remove an empty directory. | 
| rmdir [Sys] | 
Remove an empty directory. | 
| round [Float] | 
round xroundsxto the nearest integer with ties (fractional
   values of 0.5) rounded away from zero, regardless of the current
   rounding direction.
 | 
| run_initializers [CamlinternalOO] |  | 
| run_initializers_opt [CamlinternalOO] |  | 
| runtime_parameters [Sys] | 
Return the value of the runtime parameters, in the same format
    as the contents of the OCAMLRUNPARAMenvironment variable. | 
| runtime_variant [Sys] | 
Return the name of the runtime variant the program is running on. | 
| runtime_warnings_enabled [Sys] | 
Return whether runtime warnings are currently enabled. | 
| S | 
| safe_set_geometry [Format] | 
pp_set_geometry ppf ~max_indent ~marginsets both the margin
   and maximum indentation limit forppf.
 | 
| scan [Seq] | 
If xsis a sequence[x0; x1; x2; ...], thenscan f a0 xsis a sequence of accumulators[a0; a1; a2; ...]wherea1isf a0 x0,a2isf a1 x1, and so on. | 
| scanf [Scanf] |  | 
| search_backward [Str] | 
search_backward r s lastsearches the stringsfor a
  substring matching the regular expressionr.
 | 
| search_forward [Str] | 
search_forward r s startsearches the stringsfor a substring
   matching the regular expressionr.
 | 
| seeded_hash [MoreLabels.Hashtbl] |  | 
| seeded_hash [Hashtbl] | 
A variant of Hashtbl.hashthat is further parameterized by
   an integer seed. | 
| seeded_hash_param [MoreLabels.Hashtbl] |  | 
| seeded_hash_param [Hashtbl] |  | 
| seek [Out_channel] | 
seek chan possets the current writing position toposfor channelchan.
 | 
| seek [In_channel] | 
seek chan possets the current reading position toposfor channelchan.
 | 
| seek_in [Stdlib.LargeFile] |  | 
| seek_in [Stdlib] | 
seek_in chan possets the current reading position toposfor channelchan.
 | 
| seek_out [Stdlib.LargeFile] |  | 
| seek_out [Stdlib] | 
seek_out chan possets the current writing position toposfor channelchan.
 | 
| select [ThreadUnix] |  | 
| select [Event] | 
'Synchronize' on an alternative of events. | 
| select [Thread] |  | 
| select [UnixLabels] | 
Wait until some input/output operations become possible on
   some channels. | 
| select [Unix] | 
Wait until some input/output operations become possible on
   some channels. | 
| self [Thread] | 
Return the handle for the thread currently executing. | 
| self_init [Random] | 
Initialize the generator with a random seed chosen
   in a system-dependent way. | 
| send [ThreadUnix] |  | 
| send [Event] | 
send ch vreturns the event consisting in sending the valuevover the channelch.
 | 
| send [UnixLabels] | 
Send data over a connected socket. | 
| send [Unix] | 
Send data over a connected socket. | 
| send [CamlinternalOO] |  | 
| send_substring [ThreadUnix] |  | 
| send_substring [UnixLabels] | 
Same as send, but take the data from a string instead of a byte
    sequence. | 
| send_substring [Unix] | 
Same as send, but take the data from a string instead of a byte
    sequence. | 
| sendcache [CamlinternalOO] |  | 
| sendself [CamlinternalOO] |  | 
| sendto [ThreadUnix] |  | 
| sendto [UnixLabels] | 
Send data over an unconnected socket. | 
| sendto [Unix] | 
Send data over an unconnected socket. | 
| sendto_substring [ThreadUnix] |  | 
| sendto_substring [UnixLabels] | 
Same as sendto, but take the data from a string instead of a
    byte sequence. | 
| sendto_substring [Unix] | 
Same as sendto, but take the data from a string instead of a
    byte sequence. | 
| set [Weak] | 
Weak.set ar n (Some el)sets thenth cell ofarto be a
   (full) pointer toel;Weak.set ar n Nonesets thenth
   cell ofarto empty.
 | 
| set [String] | 
set s n cmodifies byte sequencesin place,
    replacing the byte at indexnwithc.
 | 
| set [StringLabels] | 
set s n cmodifies byte sequencesin place,
    replacing the byte at indexnwithc.
 | 
| set [Gc] | 
set rchanges the GC parameters according to thecontrolrecordr.
 | 
| set [Float.ArrayLabels] | 
set a n xmodifies floatarrayain place, replacing element
      numbernwithx.
 | 
| set [Float.Array] | 
set a n xmodifies floatarrayain place, replacing element
      numbernwithx.
 | 
| set [BytesLabels] | 
set s n cmodifiessin place, replacing the byte at indexnwithc.
 | 
| set [Bytes] | 
set s n cmodifiessin place, replacing the byte at indexnwithc.
 | 
| set [Bigarray.Array3] | 
Array3.set a x y v, or alternativelya.{x,y,z} <- v,
     stores the valuevat coordinates (x,y,z) ina.
 | 
| set [Bigarray.Array2] | 
Array2.set a x y v, or alternativelya.{x,y} <- v,
     stores the valuevat coordinates (x,y) ina.
 | 
| set [Bigarray.Array1] | 
Array1.set a x v, also writtena.{x} <- v,
     stores the valuevat indexxina.
 | 
| set [Bigarray.Array0] | 
Array0.set a x vstores the valuevina.
 | 
| 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 xmodifies arrayain place, replacing
   element numbernwithx.
 | 
| set [Array] | 
set a n xmodifies arrayain place, replacing
   element numbernwithx.
 | 
| set [CamlinternalAtomic] |  | 
| set_all_formatter_output_functions [Format] | 
 | 
| set_allowed_units [Dynlink] | 
Set the list of compilation units that may be referenced from units that
    are dynamically loaded in the future to be exactly the given value. | 
| set_binary_mode [Out_channel] | 
set_binary_mode oc truesets the channelocto binary mode: no
    translations take place during output.
 | 
| set_binary_mode [In_channel] | 
set_binary_mode ic truesets the channelicto binary mode: no
    translations take place during input.
 | 
| set_binary_mode_in [Stdlib] | 
set_binary_mode_in ic truesets the channelicto binary
   mode: no translations take place during input.
 | 
| set_binary_mode_out [Stdlib] | 
set_binary_mode_out oc truesets the channelocto binary
   mode: no translations take place during output.
 | 
| set_buffered [Out_channel] | 
set_buffered oc truesets the channelocto buffered mode.
 | 
| set_close_on_exec [UnixLabels] | 
Set the ``close-on-exec'' flag on the given descriptor. | 
| set_close_on_exec [Unix] | 
Set the ``close-on-exec'' flag on the given descriptor. | 
| set_data [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.set_data | 
| set_data [Ephemeron.Kn] |  | 
| set_data [Ephemeron.K2] |  | 
| set_data [Ephemeron.K1] | 
Ephemeron.K1.set_data eph elsets the data ofephto be a
      (full) data toel
 | 
| 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] |  | 
| set_filename [Lexing] | 
Set filename in the initial tracked position to fileinlexbuf. | 
| 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_funsSet all the pretty-printer output functions ofppfto those of
  argumentout_funs,
 | 
| set_formatter_output_functions [Format] | 
pp_set_formatter_output_functions ppf out flushredirects the
  standard pretty-printer output functions to the functionsoutandflush.
 | 
| set_formatter_stag_functions [Format] | 
pp_set_formatter_stag_functions ppf tag_funschanges the meaning of
  opening and closing semantic tag operations to use the functions intag_funswhen printing onppf.
 | 
| set_formatter_tag_functions [Format] | 
 | 
| set_geometry [Format] |  | 
| set_int16_be [BytesLabels] | 
set_int16_be b i vsetsb's big-endian signed 16-bit integer
    starting at byte indexitov.
 | 
| set_int16_be [Bytes] | 
set_int16_be b i vsetsb's big-endian signed 16-bit integer
    starting at byte indexitov.
 | 
| set_int16_le [BytesLabels] | 
set_int16_le b i vsetsb's little-endian signed 16-bit integer
    starting at byte indexitov.
 | 
| set_int16_le [Bytes] | 
set_int16_le b i vsetsb's little-endian signed 16-bit integer
    starting at byte indexitov.
 | 
| set_int16_ne [BytesLabels] | 
set_int16_ne b i vsetsb's native-endian signed 16-bit integer
    starting at byte indexitov.
 | 
| set_int16_ne [Bytes] | 
set_int16_ne b i vsetsb's native-endian signed 16-bit integer
    starting at byte indexitov.
 | 
| set_int32_be [BytesLabels] | 
set_int32_be b i vsetsb's big-endian 32-bit integer
    starting at byte indexitov.
 | 
| set_int32_be [Bytes] | 
set_int32_be b i vsetsb's big-endian 32-bit integer
    starting at byte indexitov.
 | 
| set_int32_le [BytesLabels] | 
set_int32_le b i vsetsb's little-endian 32-bit integer
    starting at byte indexitov.
 | 
| set_int32_le [Bytes] | 
set_int32_le b i vsetsb's little-endian 32-bit integer
    starting at byte indexitov.
 | 
| set_int32_ne [BytesLabels] | 
set_int32_ne b i vsetsb's native-endian 32-bit integer
    starting at byte indexitov.
 | 
| set_int32_ne [Bytes] | 
set_int32_ne b i vsetsb's native-endian 32-bit integer
    starting at byte indexitov.
 | 
| set_int64_be [BytesLabels] | 
set_int64_be b i vsetsb's big-endian 64-bit integer
    starting at byte indexitov.
 | 
| set_int64_be [Bytes] | 
set_int64_be b i vsetsb's big-endian 64-bit integer
    starting at byte indexitov.
 | 
| set_int64_le [BytesLabels] | 
set_int64_le b i vsetsb's little-endian 64-bit integer
    starting at byte indexitov.
 | 
| set_int64_le [Bytes] | 
set_int64_le b i vsetsb's little-endian 64-bit integer
    starting at byte indexitov.
 | 
| set_int64_ne [BytesLabels] | 
set_int64_ne b i vsetsb's native-endian 64-bit integer
    starting at byte indexitov.
 | 
| set_int64_ne [Bytes] | 
set_int64_ne b i vsetsb's native-endian 64-bit integer
    starting at byte indexitov.
 | 
| set_int8 [BytesLabels] | 
set_int8 b i vsetsb's signed 8-bit integer starting at byte indexitov.
 | 
| set_int8 [Bytes] | 
set_int8 b i vsetsb's signed 8-bit integer starting at byte indexitov.
 | 
| set_key [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.set_key | 
| set_key [Ephemeron.Kn] |  | 
| set_key [Ephemeron.K1] | 
Ephemeron.K1.set_key eph elsets the key ofephto be a
      (full) key toel
 | 
| set_key1 [Ephemeron.K2] |  | 
| set_key2 [Ephemeron.K2] |  | 
| set_margin [Format] | 
pp_set_margin ppf dsets the right margin tod(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 bturns on or off the tag-marking operations.
 | 
| set_max_boxes [Format] | 
pp_set_max_boxes ppf maxsets the maximum number of pretty-printing
    boxes simultaneously open.
 | 
| set_max_indent [Format] | 
pp_set_max_indent ppf dsets the maximum indentation limit of lines
  tod(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 lexbufto a custom value. | 
| set_print_tags [Format] | 
pp_set_print_tags ppf bturns on or off the tag-printing operations.
 | 
| set_raw_field [Obj] |  | 
| set_signal [Sys] |  | 
| set_state [Random] | 
Set the state of the generator used by the basic functions. | 
| set_tab [Format] | 
Sets a tabulation marker at current insertion point. | 
| set_tag [Obj] |  | 
| set_tags [Format] | 
pp_set_tags ppf bturns on or off the treatment of semantic tags
  (default is off).
 | 
| set_temp_dir_name [Filename] |  | 
| set_trace [Parsing] | 
Control debugging support for ocamlyacc-generated parsers. | 
| set_uint16_be [BytesLabels] | 
set_uint16_be b i vsetsb's big-endian unsigned 16-bit integer
    starting at byte indexitov.
 | 
| set_uint16_be [Bytes] | 
set_uint16_be b i vsetsb's big-endian unsigned 16-bit integer
    starting at byte indexitov.
 | 
| set_uint16_le [BytesLabels] | 
set_uint16_le b i vsetsb's little-endian unsigned 16-bit integer
    starting at byte indexitov.
 | 
| set_uint16_le [Bytes] | 
set_uint16_le b i vsetsb's little-endian unsigned 16-bit integer
    starting at byte indexitov.
 | 
| set_uint16_ne [BytesLabels] | 
set_uint16_ne b i vsetsb's native-endian unsigned 16-bit integer
    starting at byte indexitov.
 | 
| set_uint16_ne [Bytes] | 
set_uint16_ne b i vsetsb's native-endian unsigned 16-bit integer
    starting at byte indexitov.
 | 
| set_uint8 [BytesLabels] | 
set_uint8 b i vsetsb's unsigned 8-bit integer starting at byte indexitov.
 | 
| set_uint8 [Bytes] | 
set_uint8 b i vsetsb's unsigned 8-bit integer starting at byte indexitov.
 | 
| set_uncaught_exception_handler [Thread] | 
Thread.set_uncaught_exception_handler fnregistersfnas the handler
    for uncaught exceptions.
 | 
| set_uncaught_exception_handler [Printexc] | 
Printexc.set_uncaught_exception_handler fnregistersfnas the handler
    for uncaught exceptions.
 | 
| set_utf_16be_uchar [BytesLabels] | 
set_utf_16be_uchar b i uUTF-16BE encodesuat indexiinband returns the number of bytesnthat were written starting
    ati.
 | 
| set_utf_16be_uchar [Bytes] | 
set_utf_16be_uchar b i uUTF-16BE encodesuat indexiinband returns the number of bytesnthat were written starting
    ati.
 | 
| set_utf_16le_uchar [BytesLabels] | 
set_utf_16le_uchar b i uUTF-16LE encodesuat indexiinband returns the number of bytesnthat were written starting
    ati.
 | 
| set_utf_16le_uchar [Bytes] | 
set_utf_16le_uchar b i uUTF-16LE encodesuat indexiinband returns the number of bytesnthat were written starting
    ati.
 | 
| set_utf_8_uchar [BytesLabels] | 
set_utf_8_uchar b i uUTF-8 encodesuat indexiinband returns the number of bytesnthat were written starting
    ati.
 | 
| set_utf_8_uchar [Bytes] | 
set_utf_8_uchar b i uUTF-8 encodesuat indexiinband returns the number of bytesnthat were written starting
    ati.
 | 
| 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 groupssets the supplementary group IDs for the
    calling process.
 | 
| setgroups [Unix] | 
setgroups groupssets the supplementary group IDs for the
    calling process.
 | 
| setitimer [UnixLabels] | 
setitimer t ssets the interval timertand returns
   its previous status.
 | 
| setitimer [Unix] | 
setitimer t ssets the interval timertand 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] |  | 
| setsockopt_float [Unix] | 
Same as Unix.setsockoptfor a socket option whose value is a
    floating-point number. | 
| setsockopt_int [UnixLabels] |  | 
| setsockopt_int [Unix] |  | 
| setsockopt_optint [UnixLabels] |  | 
| setsockopt_optint [Unix] |  | 
| 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 yshiftsxto the left byybits.
 | 
| shift_left [Int64] | 
Int64.shift_left x yshiftsxto the left byybits.
 | 
| shift_left [Int32] | 
Int32.shift_left x yshiftsxto the left byybits.
 | 
| shift_left [Int] | 
shift_left x nshiftsxto the left bynbits.
 | 
| shift_right [Nativeint] | 
Nativeint.shift_right x yshiftsxto the right byybits.
 | 
| shift_right [Int64] | 
Int64.shift_right x yshiftsxto the right byybits.
 | 
| shift_right [Int32] | 
Int32.shift_right x yshiftsxto the right byybits.
 | 
| shift_right [Int] | 
shift_right x nshiftsxto the right bynbits.
 | 
| shift_right_logical [Nativeint] | 
Nativeint.shift_right_logical x yshiftsxto the right
   byybits.
 | 
| shift_right_logical [Int64] | 
Int64.shift_right_logical x yshiftsxto the right byybits.
 | 
| shift_right_logical [Int32] | 
Int32.shift_right_logical x yshiftsxto the right byybits.
 | 
| shift_right_logical [Int] | 
shift_right x nshiftsxto the right bynbits.
 | 
| 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] |  | 
| sigalrm [Sys] |  | 
| sigbus [Sys] |  | 
| sigchld [Sys] |  | 
| sigcont [Sys] |  | 
| sigfpe [Sys] |  | 
| 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 sigschanges the set of blocked signals for the
   calling thread.
 | 
| sign_bit [Float] | 
sign_bit xistrueif and only if the sign bit ofxis set.
 | 
| signal [Condition] | 
signal crestarts one of the processes waiting on the
   condition variablec.
 | 
| signal [Sys] | 
Set the behavior of the system on receipt of a given signal. | 
| sigpending [UnixLabels] | 
Return the set of blocked signals that are currently pending. | 
| sigpending [Unix] | 
Return the set of blocked signals that are currently pending. | 
| sigpipe [Sys] |  | 
| sigpoll [Sys] |  | 
| sigprocmask [UnixLabels] | 
sigprocmask ~mode sigschanges the set of blocked signals.
 | 
| sigprocmask [Unix] | 
sigprocmask mode sigschanges the set of blocked signals.
 | 
| sigprof [Sys] |  | 
| sigquit [Sys] |  | 
| sigsegv [Sys] |  | 
| sigstop [Sys] |  | 
| sigsuspend [UnixLabels] | 
sigsuspend sigsatomically sets the blocked signals tosigsand waits for a non-ignored, non-blocked signal to be delivered.
 | 
| sigsuspend [Unix] | 
sigsuspend sigsatomically sets the blocked signals tosigsand waits for a non-ignored, non-blocked signal to be delivered.
 | 
| sigsys [Sys] |  | 
| sigterm [Sys] |  | 
| sigtrap [Sys] |  | 
| sigtstp [Sys] |  | 
| 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] |  | 
| sigxcpu [Sys] |  | 
| sigxfsz [Sys] |  | 
| sin [Float] |  | 
| sin [Stdlib] |  | 
| single_write [UnixLabels] |  | 
| single_write [Unix] | 
Same as Unix.write, but attempts to write only once. | 
| single_write_substring [UnixLabels] |  | 
| 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 xreturns the one-element set containing onlyx.
 | 
| singleton [MoreLabels.Set.S] | 
singleton xreturns the one-element set containing onlyx.
 | 
| singleton [MoreLabels.Map.S] | 
singleton x yreturns the one-element map that contains a bindingyforx.
 | 
| singleton [Map.S] | 
singleton x yreturns the one-element map that contains a bindingyforx.
 | 
| sinh [Float] |  | 
| sinh [Stdlib] |  | 
| size [Obj] |  | 
| size [Nativeint] | 
The size in bits of a native integer. | 
| size_in_bytes [Bigarray.Array3] |  | 
| size_in_bytes [Bigarray.Array2] |  | 
| size_in_bytes [Bigarray.Array1] |  | 
| size_in_bytes [Bigarray.Array0] |  | 
| size_in_bytes [Bigarray.Genarray] |  | 
| sleep [ThreadUnix] |  | 
| sleep [UnixLabels] | 
Stop execution for the given number of seconds. | 
| sleep [Unix] | 
Stop execution for the given number of seconds. | 
| sleepf [UnixLabels] | 
Stop execution for the given number of seconds. | 
| sleepf [Unix] | 
Stop execution for the given number of seconds. | 
| slice [Bigarray.Array1] | 
Extract a scalar (zero-dimensional slice) of the given one-dimensional
     Bigarray. | 
| slice_left [Bigarray.Array2] | 
Extract a row (one-dimensional slice) of the given two-dimensional
     Bigarray. | 
| slice_left [Bigarray.Genarray] | 
Extract a sub-array of lower dimension from the given Bigarray
     by fixing one or several of the first (left-most) coordinates. | 
| slice_left_1 [Bigarray.Array3] | 
Extract a one-dimensional slice of the given three-dimensional
     Bigarray by fixing the first two coordinates. | 
| slice_left_2 [Bigarray.Array3] | 
Extract a  two-dimensional slice of the given three-dimensional
     Bigarray by fixing the first coordinate. | 
| slice_right [Bigarray.Array2] | 
Extract a column (one-dimensional slice) of the given
     two-dimensional Bigarray. | 
| slice_right [Bigarray.Genarray] | 
Extract a sub-array of lower dimension from the given Bigarray
     by fixing one or several of the last (right-most) coordinates. | 
| slice_right_1 [Bigarray.Array3] | 
Extract a one-dimensional slice of the given three-dimensional
     Bigarray by fixing the last two coordinates. | 
| slice_right_2 [Bigarray.Array3] | 
Extract a two-dimensional slice of the given
     three-dimensional Bigarray by fixing the last coordinate. | 
| snd [Stdlib] | 
Return the second component of a pair. | 
| socket [ThreadUnix] |  | 
| socket [UnixLabels] | 
Create a new socket in the given domain, and with the
   given kind. | 
| socket [Unix] | 
Create a new socket in the given domain, and with the
   given kind. | 
| socketpair [UnixLabels] | 
Create a pair of unnamed sockets, connected together. | 
| socketpair [Unix] | 
Create a pair of unnamed sockets, connected together. | 
| some [Option] |  | 
| 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] |  | 
| sort_uniq [List] | 
Same as List.sort, but also remove duplicates. | 
| sorted_merge [Seq] | 
If the sequences xsandysare sorted according to the total preordercmp, thensorted_merge cmp xs ysis the sorted sequence obtained by
    merging the sequencesxsandys. | 
| split [Str] | 
split r ssplitssinto substrings, taking as delimiters
   the substrings that matchr, and returns the list of substrings.
 | 
| split [Set.S] | 
split x sreturns a triple(l, present, r), wherelis the set of elements ofsthat are
          strictly less thanx;ris the set of elements ofsthat are
          strictly greater thanx;presentisfalseifscontains no element equal tox,
          ortrueifscontains an element equal tox.
 | 
| split [Seq] | 
splitis an alias forunzip.
 | 
| split [MoreLabels.Set.S] | 
split x sreturns a triple(l, present, r), wherelis the set of elements ofsthat are
            strictly less thanx;ris the set of elements ofsthat are
            strictly greater thanx;presentisfalseifscontains no element equal tox,
            ortrueifscontains an element equal tox.
 | 
| split [MoreLabels.Map.S] | 
split x mreturns a triple(l, data, r), wherelis the map with all the bindings ofmwhose key
          is strictly less thanx;ris the map with all the bindings ofmwhose key
          is strictly greater thanx;dataisNoneifmcontains no binding forx,
            orSome vifmbindsvtox.
 | 
| split [Map.S] | 
split x mreturns a triple(l, data, r), wherelis the map with all the bindings ofmwhose key
        is strictly less thanx;ris the map with all the bindings ofmwhose key
        is strictly greater thanx;dataisNoneifmcontains no binding forx,
          orSome vifmbindsvtox.
 | 
| 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.splitbut 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 sis the list of all (possibly empty)
    substrings ofsthat are delimited by the charactersep.
 | 
| split_on_char [StringLabels] | 
split_on_char ~sep sis the list of all (possibly empty)
    substrings ofsthat are delimited by the charactersep.
 | 
| split_on_char [BytesLabels] | 
split_on_char sep sreturns the list of all (possibly empty)
    subsequences ofsthat are delimited by thesepcharacter.
 | 
| split_on_char [Bytes] | 
split_on_char sep sreturns the list of all (possibly empty)
    subsequences ofsthat are delimited by thesepcharacter.
 | 
| 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 printfabove, but instead of printing on a formatter,
  returns a string containing the result of formatting the arguments. | 
| sqrt [Float] |  | 
| sqrt [Complex] |  | 
| sqrt [Stdlib] |  | 
| sscanf [Scanf] |  | 
| sscanf_format [Scanf] |  | 
| 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] |  | 
| stable_sort [Float.Array] |  | 
| stable_sort [ArrayLabels] |  | 
| stable_sort [Array] | 
Same as Array.sort, but the sorting algorithm is stable (i.e. | 
| start [Gc.Memprof] | 
Start the sampling with the given parameters. | 
| starts_with [String] | 
starts_with ~prefix sistrueif and only ifsstarts withprefix.
 | 
| starts_with [StringLabels] | 
starts_with ~prefix sistrueif and only ifsstarts withprefix.
 | 
| starts_with [BytesLabels] | 
starts_with ~prefix sistrueif and only ifsstarts withprefix.
 | 
| starts_with [Bytes] | 
starts_with ~prefix sistrueif and only ifsstarts withprefix.
 | 
| 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
   statrecord. | 
| stats [CamlinternalOO] |  | 
| stats [Weak.S] | 
Return statistics on the table. | 
| stats [MoreLabels.Hashtbl.SeededS] |  | 
| stats [MoreLabels.Hashtbl.S] | 
 | 
| stats [MoreLabels.Hashtbl] | 
Hashtbl.stats tblreturns statistics about the tabletbl:
     number of buckets, size of the biggest bucket, distribution of
     buckets by size.
 | 
| stats [Hashtbl.SeededS] |  | 
| stats [Hashtbl.S] | 
 | 
| stats [Hashtbl] | 
Hashtbl.stats tblreturns statistics about the tabletbl:
   number of buckets, size of the biggest bucket, distribution of
   buckets by size.
 | 
| stats [Ephemeron.SeededS] |  | 
| stats [Ephemeron.S] |  | 
| stats_alive [Ephemeron.SeededS] |  | 
| stats_alive [Ephemeron.S] |  | 
| std_formatter [Format] | 
The standard formatter to write to standard output. | 
| stdbuf [Format] | 
The string buffer in which str_formatterwrites. | 
| stderr [UnixLabels] | 
File descriptor for standard error. | 
| stderr [Unix] | 
File descriptor for standard error. | 
| stderr [Out_channel] | 
The standard error output for the process. | 
| stderr [Stdlib] | 
The standard error output for the process. | 
| stdib [Scanf.Scanning] |  | 
| stdin [UnixLabels] | 
File descriptor for standard input. | 
| stdin [Unix] | 
File descriptor for standard input. | 
| stdin [Scanf.Scanning] | 
The standard input notion for the Scanfmodule. | 
| stdin [In_channel] | 
The standard input for the process. | 
| stdin [Stdlib] | 
The standard input for the process. | 
| stdout [UnixLabels] | 
File descriptor for standard output. | 
| stdout [Unix] | 
File descriptor for standard output. | 
| stdout [Out_channel] | 
The standard output for the process. | 
| stdout [Stdlib] | 
The standard output for the process. | 
| stop [Gc.Memprof] |  | 
| str_formatter [Format] |  | 
| string [Digest] | 
Return the digest of the given string. | 
| string_after [Str] | 
string_after s nreturns the substring of all characters ofsthat follow positionn(including the character at
   positionn).
 | 
| string_before [Str] | 
string_before s nreturns the substring of all characters ofsthat precede positionn(excluding the character at
   positionn).
 | 
| string_match [Str] | 
string_match r s starttests whether a substring ofsthat
   starts at positionstartmatches the regular expressionr.
 | 
| string_of_bool [Stdlib] | 
Return the string representation of a boolean. | 
| string_of_float [Stdlib] | 
Return the string representation of a floating-point number. | 
| string_of_fmt [CamlinternalFormat] |  | 
| string_of_fmtty [CamlinternalFormat] |  | 
| string_of_format [Stdlib] | 
Converts a format string into a string. | 
| string_of_formatting_lit [CamlinternalFormat] |  | 
| string_of_inet_addr [UnixLabels] | 
Return the printable representation of the given Internet address. | 
| string_of_inet_addr [Unix] | 
Return the printable representation of the given Internet address. | 
| string_of_int [Stdlib] | 
Return the string representation of an integer, in decimal. | 
| string_partial_match [Str] | 
Similar to Str.string_match, but also returns true if
   the argument string is a prefix of a string that matches. | 
| string_tag [Obj] |  | 
| strput_acc [CamlinternalFormat] |  | 
| sub [String] | 
sub s pos lenis a string of lengthlen, containing the
    substring ofsthat starts at positionposand has lengthlen.
 | 
| sub [StringLabels] | 
sub s ~pos ~lenis a string of lengthlen, containing the
    substring ofsthat starts at positionposand has lengthlen.
 | 
| sub [Nativeint] |  | 
| sub [Int64] |  | 
| sub [Int32] |  | 
| sub [Int] | 
sub x yis the subtractionx - y.
 | 
| sub [Float.ArrayLabels] | 
sub a ~pos ~lenreturns a fresh floatarray of lengthlen,
      containing the elements numberpostopos + len - 1of floatarraya.
 | 
| sub [Float.Array] | 
sub a pos lenreturns a fresh floatarray of lengthlen,
      containing the elements numberpostopos + len - 1of floatarraya.
 | 
| sub [Float] | 
Floating-point subtraction. | 
| sub [Complex] |  | 
| sub [BytesLabels] | 
sub s ~pos ~lenreturns a new byte sequence of lengthlen,
    containing the subsequence ofsthat starts at positionposand has lengthlen.
 | 
| sub [Bytes] | 
sub s pos lenreturns a new byte sequence of lengthlen,
    containing the subsequence ofsthat starts at positionposand has lengthlen.
 | 
| sub [Buffer] | 
Buffer.sub b off lenreturns a copy oflenbytes from the
    current contents of the bufferb, starting at offsetoff.
 | 
| sub [Bigarray.Array1] | 
Extract a sub-array of the given one-dimensional Bigarray. | 
| sub [ArrayLabels] | 
sub a ~pos ~lenreturns a fresh array of lengthlen,
   containing the elements numberpostopos + len - 1of arraya.
 | 
| sub [Array] | 
sub a pos lenreturns a fresh array of lengthlen,
   containing the elements numberpostopos + len - 1of arraya.
 | 
| 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] |  | 
| sub_string [Bytes] | 
Same as Bytes.subbut return a string instead of a byte sequence. | 
| subbytes [Digest] | 
Digest.subbytes s ofs lenreturns the digest of the subsequence
    ofsstarting at indexofsand containinglenbytes.
 | 
| subset [Set.S] | 
subset s1 s2tests whether the sets1is a subset of
       the sets2.
 | 
| subset [MoreLabels.Set.S] | 
subset s1 s2tests whether the sets1is a subset of
         the sets2.
 | 
| 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 lenreturns the digest of the substring
   ofsstarting at indexofsand containinglencharacters.
 | 
| succ [Uchar] | 
succ uis the scalar value afteruin the set of Unicode scalar
    values.
 | 
| succ [Nativeint] |  | 
| succ [Int64] |  | 
| succ [Int32] |  | 
| succ [Int] |  | 
| succ [Float] | 
succ xreturns the floating point number right afterxi.e.,
   the smallest floating-point number greater thanx.
 | 
| succ [Stdlib] |  | 
| symbol_end [Parsing] |  | 
| symbol_end_pos [Parsing] | 
Same as symbol_end, but return apositioninstead of an offset. | 
| symbol_start [Parsing] | 
symbol_startandParsing.symbol_endare to be called in the
   action part of a grammar rule only.
 | 
| symbol_start_pos [Parsing] | 
Same as symbol_start, but return apositioninstead of an offset. | 
| symlink [UnixLabels] | 
symlink ?to_dir ~src ~dstcreates the filedstas a symbolic link
   to the filesrc.
 | 
| symlink [Unix] | 
symlink ?to_dir src dstcreates the filedstas a symbolic link
   to the filesrc.
 | 
| symm [CamlinternalFormat] |  | 
| sync [Event] | 
'Synchronize' on an event: offer all the communication
   possibilities specified in the event to the outside world,
   and block until one of the communications succeed. | 
| system [ThreadUnix] |  | 
| system [UnixLabels] | 
Execute the given command, wait until it terminates, and return
   its termination status. | 
| system [Unix] | 
Execute the given command, wait until it terminates, and return
   its termination status. | 
| T | 
| tag [Obj] |  | 
| take [Seq] | 
take n xsis the sequence of the firstnelements ofxs.
 | 
| take [Queue] | 
take qremoves and returns the first element in queueq,
   or raisesQueue.Emptyif the queue is empty.
 | 
| take_opt [Queue] | 
take_opt qremoves and returns the first element in queueq,
   or returnsNoneif the queue is empty.
 | 
| take_while [Seq] | 
take_while p xsis the longest prefix of the sequencexswhere every elementxsatisfiesp x.
 | 
| tan [Float] |  | 
| tan [Stdlib] |  | 
| tanh [Float] |  | 
| tanh [Stdlib] |  | 
| 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:
   TCOOFFsuspends output,TCOONrestarts output,TCIOFFtransmits a STOP character to suspend input,
   andTCIONtransmits 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:
   TCOOFFsuspends output,TCOONrestarts output,TCIOFFtransmits a STOP character to suspend input,
   andTCIONtransmits 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: TCIFLUSHflushes data received but not read,TCOFLUSHflushes data written but not transmitted, andTCIOFLUSHflushes 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: TCIFLUSHflushes data received but not read,TCOFLUSHflushes data written but not transmitted, andTCIOFLUSHflushes both. | 
| tcgetattr [UnixLabels] | 
Return the status of the terminal referred to by the given
   file descriptor. | 
| tcgetattr [Unix] | 
Return the status of the terminal referred to by the given
   file descriptor. | 
| tcsendbreak [UnixLabels] | 
Send a break condition on the given file descriptor. | 
| tcsendbreak [Unix] | 
Send a break condition on the given file descriptor. | 
| tcsetattr [UnixLabels] | 
Set the status of the terminal referred to by the given
   file descriptor. | 
| tcsetattr [Unix] | 
Set the status of the terminal referred to by the given
   file descriptor. | 
| temp_dir_name [Filename] | 
The name of the initial temporary directory:
    Under Unix, the value of the TMPDIRenvironment variable, or "/tmp"
    if the variable is not set. | 
| temp_file [Filename] | 
temp_file prefix suffixreturns the name of a
   fresh temporary file in the temporary directory.
 | 
| time [UnixLabels] | 
Return the current time since 00:00:00 GMT, Jan. | 
| time [Unix] | 
Return the current time since 00:00:00 GMT, Jan. | 
| time [Sys] | 
Return the processor time, in seconds, used by the program
   since the beginning of execution. | 
| timed_read [ThreadUnix] |  | 
| timed_write [ThreadUnix] | 
Behave as ThreadUnix.readandThreadUnix.write, except thatUnix_error(ETIMEDOUT,_,_)is raised if no data is
   available for reading or ready for writing afterdseconds. | 
| timed_write_substring [ThreadUnix] |  | 
| times [UnixLabels] | 
Return the execution times of the process. | 
| times [Unix] | 
Return the execution times of the process. | 
| tl [ListLabels] | 
Return the given list without its first element. | 
| tl [List] | 
Return the given list without its first element. | 
| to_buffer [Marshal] | 
Marshal.to_buffer buff ofs len v flagsmarshals the valuev,
   storing its byte representation in the sequencebuff,
   starting at indexofs, and writing at mostlenbytes.
 | 
| 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 flagsreturns a byte sequence containing
   the representation ofv.
 | 
| to_bytes [Buffer] | 
Return a copy of the current contents of the buffer. | 
| to_channel [Marshal] | 
Marshal.to_channel chan v flagswrites the representation
   ofvon channelchan.
 | 
| to_char [Uchar] | 
to_char uisuas an OCaml latin1 character.
 | 
| to_dispenser [Seq] | 
to_dispenser xsis a fresh dispenser on the sequencexs.
 | 
| 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 xisxas a floating point number.
 | 
| to_float [Bool] | 
to_float bis0.ifbisfalseand1.ifbistrue.
 | 
| to_hex [Digest] | 
Return the printable hexadecimal representation of the given digest. | 
| to_int [Uchar] | 
to_int uisuas an integer.
 | 
| to_int [Nativeint] | 
Convert the given native integer (type nativeint) to an
   integer (typeint). | 
| to_int [Int64] | 
Convert the given 64-bit integer (type int64) to an
   integer (typeint). | 
| to_int [Int32] | 
Convert the given 32-bit integer (type int32) to an
   integer (typeint). | 
| to_int [Float] | 
Truncate the given floating-point number to an integer. | 
| to_int [Bool] | 
to_int bis0ifbisfalseand1ifbistrue.
 | 
| 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 (typeint32). | 
| to_list [Result] | 
to_list ris[v]ifrisOk vand[]otherwise.
 | 
| to_list [Option] | 
to_list ois[]ifoisNoneand[v]ifoisSome v.
 | 
| to_list [Float.ArrayLabels] | 
to_list areturns the list of all the elements ofa.
 | 
| to_list [Float.Array] | 
to_list areturns the list of all the elements ofa.
 | 
| to_list [ArrayLabels] | 
to_list areturns the list of all the elements ofa.
 | 
| to_list [Array] | 
to_list areturns the list of all the elements ofa.
 | 
| to_nativeint [Int64] | 
Convert the given 64-bit integer (type int64) to a
   native integer. | 
| to_option [Result] | 
to_option risras an option, mappingOk vtoSome vandError _toNone.
 | 
| to_result [Option] | 
to_result ~none oisOk vifoisSome vandError noneotherwise.
 | 
| 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 sis a sequence made of the string's characters in
    increasing order.
 | 
| to_seq [StringLabels] | 
to_seq sis 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 risras a sequence.
 | 
| to_seq [Queue] | 
Iterate on the queue, in front-to-back order. | 
| to_seq [Option] | 
to_seq oisoas 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] |  | 
| to_seq [List] |  | 
| to_seq [Hashtbl.SeededS] | 
 | 
| to_seq [Hashtbl.S] | 
 | 
| to_seq [Hashtbl] | 
Iterate on the whole table. | 
| to_seq [Float.ArrayLabels] | 
Iterate on the floatarray, in increasing order. | 
| to_seq [Float.Array] | 
Iterate on the floatarray, in increasing order. | 
| to_seq [Ephemeron.SeededS] |  | 
| to_seq [Ephemeron.S] |  | 
| to_seq [BytesLabels] | 
Iterate on the string, in increasing index order. | 
| to_seq [Bytes] | 
Iterate on the string, in increasing index order. | 
| to_seq [Buffer] | 
Iterate on the buffer, in increasing order. | 
| to_seq [ArrayLabels] | 
Iterate on the array, in increasing order. | 
| to_seq [Array] | 
Iterate on the array, in increasing order. | 
| to_seq_from [Set.S] | 
to_seq_from x siterates on a subset of the elements ofsin ascending order, fromxor above.
 | 
| to_seq_from [MoreLabels.Set.S] | 
to_seq_from x siterates on a subset of the elements ofsin ascending order, fromxor above.
 | 
| to_seq_from [MoreLabels.Map.S] | 
to_seq_from k miterates on a subset of the bindings ofm,
          in ascending order of keys, from keykor above.
 | 
| to_seq_from [Map.S] | 
to_seq_from k miterates on a subset of the bindings ofm,
        in ascending order of keys, from keykor above.
 | 
| to_seq_keys [MoreLabels.Hashtbl.SeededS] | 
 | 
| to_seq_keys [MoreLabels.Hashtbl.S] | 
 | 
| to_seq_keys [MoreLabels.Hashtbl] | 
Same as Seq.map fst (to_seq m) | 
| to_seq_keys [Hashtbl.SeededS] | 
 | 
| to_seq_keys [Hashtbl.S] | 
 | 
| to_seq_keys [Hashtbl] | 
Same as Seq.map fst (to_seq m) | 
| to_seq_keys [Ephemeron.SeededS] |  | 
| to_seq_keys [Ephemeron.S] |  | 
| to_seq_values [MoreLabels.Hashtbl.SeededS] | 
 | 
| to_seq_values [MoreLabels.Hashtbl.S] | 
 | 
| to_seq_values [MoreLabels.Hashtbl] | 
Same as Seq.map snd (to_seq m) | 
| to_seq_values [Hashtbl.SeededS] | 
 | 
| to_seq_values [Hashtbl.S] | 
 | 
| to_seq_values [Hashtbl] | 
Same as Seq.map snd (to_seq m) | 
| to_seq_values [Ephemeron.SeededS] |  | 
| to_seq_values [Ephemeron.S] |  | 
| to_seqi [String] | 
to_seqi sis likeString.to_seqbut also tuples the corresponding index.
 | 
| to_seqi [StringLabels] |  | 
| to_seqi [Float.ArrayLabels] | 
Iterate on the floatarray, in increasing order, yielding indices along
      elements. | 
| to_seqi [Float.Array] | 
Iterate on the floatarray, in increasing order, yielding indices along
      elements. | 
| to_seqi [BytesLabels] | 
Iterate on the string, in increasing order, yielding indices along chars | 
| to_seqi [Bytes] | 
Iterate on the string, in increasing order, yielding indices along chars | 
| to_seqi [Buffer] | 
Iterate on the buffer, in increasing order, yielding indices along chars. | 
| to_seqi [ArrayLabels] | 
Iterate on the array, in increasing order, yielding indices along elements. | 
| to_seqi [Array] | 
Iterate on the array, in increasing order, yielding indices along elements. | 
| to_string [Unit] |  | 
| to_string [Printexc] | 
Printexc.to_string ereturns a string representation of
   the exceptione.
 | 
| to_string [Nativeint] | 
Return the string representation of its argument, in decimal. | 
| to_string [Marshal] | 
Same as to_bytesbut 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 xis the written representation ofxin decimal.
 | 
| to_string [Float] | 
Return the string representation of a floating-point number. | 
| to_string [BytesLabels] | 
Return a new string that contains the same bytes as the given byte
    sequence. | 
| to_string [Bytes] | 
Return a new string that contains the same bytes as the given byte
    sequence. | 
| to_string [Bool] | 
to_string bis"true"ifbistrueand"false"ifbisfalse.
 | 
| to_string_default [Printexc] | 
Printexc.to_string_default ereturns a string representation of the
    exceptione, ignoring all registered exception printers.
 | 
| top [Stack] | 
top sreturns the topmost element in stacks,
   or raisesStack.Emptyif the stack is empty.
 | 
| top [Queue] | 
topis a synonym forpeek.
 | 
| top_opt [Stack] | 
top_opt sreturns the topmost element in stacks,
   orNoneif the stack is empty.
 | 
| total_size [Marshal] |  | 
| trans [CamlinternalFormat] |  | 
| transfer [Queue] | 
transfer q1 q2adds all ofq1's elements at the end of
   the queueq2, then clearsq1.
 | 
| transpose [Seq] | 
If xssis a matrix (a sequence of rows), thentranspose xssis
    the sequence of the columns of the matrixxss. | 
| trim [String] | 
trim sisswithout leading and trailing whitespace.
 | 
| trim [StringLabels] | 
trim sisswithout 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 xroundsxto the nearest integer whose absolute value is
   less than or equal tox.
 | 
| truncate [UnixLabels.LargeFile] |  | 
| truncate [UnixLabels] | 
Truncates the named file to the given size. | 
| truncate [Unix.LargeFile] |  | 
| truncate [Unix] | 
Truncates the named file to the given size. | 
| truncate [Obj] |  | 
| truncate [Buffer] | 
truncate b lentruncates the length ofbtolenNote: the internal byte sequence is not shortened.
 | 
| truncate [Stdlib] |  | 
| try_acquire [Semaphore.Binary] | 
try_acquire simmediately returnsfalseif the semaphoreshas value 0.
 | 
| try_acquire [Semaphore.Counting] | 
try_acquire simmediately returnsfalseif the value of semaphoresis zero.
 | 
| try_lock [Mutex] | 
Same as Mutex.lock, but does not suspend the calling thread if
   the mutex is already locked: just returnfalseimmediately
   in that case. | 
| type_format [CamlinternalFormat] |  | 
| U | 
| umask [UnixLabels] | 
Set the process's file mode creation mask, and return the previous
    mask. | 
| umask [Unix] | 
Set the process's file mode creation mask, and return the previous
    mask. | 
| unaligned_tag [Obj] |  | 
| uncapitalize [String] | 
Return a copy of the argument, with the first character set to lowercase,
    using the ISO Latin-1 (8859-1) character set. | 
| uncapitalize [StringLabels] | 
Return a copy of the argument, with the first character set to lowercase,
    using the ISO Latin-1 (8859-1) character set. | 
| uncapitalize [BytesLabels] | 
Return a copy of the argument, with the first character set to lowercase,
   using the ISO Latin-1 (8859-1) character set. | 
| uncapitalize [Bytes] | 
Return a copy of the argument, with the first character set to lowercase,
   using the ISO Latin-1 (8859-1) character set. | 
| uncapitalize_ascii [String] | 
uncapitalize_ascii sisswith the first character set to lowercase,
    using the US-ASCII character set.
 | 
| uncapitalize_ascii [StringLabels] | 
uncapitalize_ascii sisswith 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 xsis empty, thenuncons xsisNone. | 
| unescaped [Scanf] | 
unescaped sreturn a copy ofswith escape sequences (according to
    the lexical conventions of OCaml) replaced by their corresponding special
    characters.
 | 
| unfold [Seq] | 
unfoldconstructs a sequence
    out of a step function and an initial state.
 | 
| union [Set.S] |  | 
| union [MoreLabels.Set.S] |  | 
| union [MoreLabels.Map.S] | 
union ~f m1 m2computes a map whose keys are a subset of the keys
          ofm1and ofm2.
 | 
| union [Map.S] | 
union f m1 m2computes a map whose keys are a subset of the keys
        ofm1and ofm2.
 | 
| unix [Sys] | 
True if Sys.os_type = "Unix". | 
| unlink [UnixLabels] |  | 
| unlink [Unix] |  | 
| unlock [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] |  | 
| unsafe_get [Bigarray.Array2] |  | 
| unsafe_get [Bigarray.Array1] |  | 
| 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] |  | 
| unsafe_set [Bigarray.Array2] |  | 
| unsafe_set [Bigarray.Array1] |  | 
| unsafe_to_string [BytesLabels] | 
Unsafely convert a byte sequence into a string. | 
| unsafe_to_string [Bytes] | 
Unsafely convert a byte sequence into a string. | 
| unset_data [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.unset_data | 
| unset_data [Ephemeron.Kn] |  | 
| unset_data [Ephemeron.K2] |  | 
| unset_data [Ephemeron.K1] | 
Ephemeron.K1.unset_data eph elsets the key ofephto be an
      empty key.
 | 
| unset_key [Obj.Ephemeron] | 
Same as Stdlib.Ephemeron.K1.unset_key | 
| unset_key [Ephemeron.Kn] |  | 
| unset_key [Ephemeron.K1] | 
Ephemeron.K1.unset_key eph elsets the key ofephto be an
      empty key.
 | 
| unset_key1 [Ephemeron.K2] |  | 
| unset_key2 [Ephemeron.K2] |  | 
| 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] |  | 
| 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] | 
unziptransforms a sequence of pairs into a pair of sequences.
 | 
| update [MoreLabels.Map.S] | 
update ~key ~f mreturns a map containing the same bindings asm, except for the binding ofkey.
 | 
| update [Map.S] | 
update key f mreturns a map containing the same bindings asm, except for the binding ofkey.
 | 
| update_geometry [Format] |  | 
| update_mod [CamlinternalMod] |  | 
| uppercase [String] | 
Return a copy of the argument, with all lowercase letters
    translated to uppercase, including accented letters of the ISO
    Latin-1 (8859-1) character set. | 
| uppercase [StringLabels] | 
Return a copy of the argument, with all lowercase letters
    translated to uppercase, including accented letters of the ISO
    Latin-1 (8859-1) character set. | 
| uppercase [Char] | 
Convert the given character to its equivalent uppercase character,
   using the ISO Latin-1 (8859-1) character set. | 
| uppercase [BytesLabels] | 
Return a copy of the argument, with all lowercase letters
   translated to uppercase, including accented letters of the ISO
   Latin-1 (8859-1) character set. | 
| uppercase [Bytes] | 
Return a copy of the argument, with all lowercase letters
   translated to uppercase, including accented letters of the ISO
   Latin-1 (8859-1) character set. | 
| uppercase_ascii [String] | 
uppercase_ascii sisswith all lowercase letters
    translated to uppercase, using the US-ASCII character set.
 | 
| uppercase_ascii [StringLabels] | 
uppercase_ascii sisswith 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_msgprints 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 ereturnsNoneif there are no registered
    printers andSome swith else as the resulting string otherwise.
 | 
| utf_16_byte_length [Uchar] | 
utf_16_byte_length uis the number of bytes needed to encodeuin UTF-16.
 | 
| utf_8_byte_length [Uchar] | 
utf_8_byte_length uis the number of bytes needed to encodeuin UTF-8.
 | 
| utf_decode [Uchar] | 
utf_decode n uis a valid UTF decode foruthat consumednelements from the source for decoding.
 | 
| utf_decode_invalid [Uchar] | 
utf_decode_invalid nis an invalid UTF decode that consumednelements from the source to error.
 | 
| utf_decode_is_valid [Uchar] | 
utf_decode_is_valid distrueif and only ifdholds a valid
    decode.
 | 
| utf_decode_length [Uchar] | 
utf_decode_length dis the number of elements from the source
    that were consumed by the decoded.
 | 
| utf_decode_uchar [Uchar] | 
utf_decode_uchar dis the Unicode character decoded bydifutf_decode_is_valid distrueandUchar.repotherwise.
 | 
| 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 ~defaultisvifrisOk vanddefaultotherwise.
 | 
| value [Option] | 
value o ~defaultisvifoisSome vanddefaultotherwise.
 | 
| W | 
| wait [ThreadUnix] |  | 
| wait [Condition] | 
wait c matomically unlocks the mutexmand suspends the
   calling process on the condition variablec.
 | 
| wait [UnixLabels] | 
Wait until one of the children processes die, and return its pid
   and termination status. | 
| wait [Unix] | 
Wait until one of the children processes die, and return its pid
   and termination status. | 
| wait_pid [Thread] |  | 
| wait_read [Thread] | 
This function does nothing in the current implementation of the threading
    library and can be removed from all user programs. | 
| wait_signal [Thread] | 
wait_signal sigssuspends the execution of the calling thread
   until the process receives one of the signals specified in the
   listsigs.
 | 
| 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. | 
| wait_write [Thread] | 
This function does nothing in the current implementation of the threading
    library and can be removed from all user programs. | 
| waitpid [ThreadUnix] |  | 
| waitpid [UnixLabels] | 
Same as UnixLabels.wait, but waits for the child process whose pid is given. | 
| waitpid [Unix] | 
Same as Unix.wait, but waits for the child process whose pid is given. | 
| widen [CamlinternalOO] |  | 
| win32 [Sys] | 
True if Sys.os_type = "Win32". | 
| with_open_bin [Out_channel] | 
with_open_bin fn fopens a channelocon filefnand returnsf.oc
 | 
| with_open_bin [In_channel] | 
with_open_bin fn fopens a channelicon filefnand returnsf.ic
 | 
| with_open_gen [Out_channel] |  | 
| with_open_gen [In_channel] |  | 
| with_open_text [Out_channel] |  | 
| with_open_text [In_channel] |  | 
| 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 istrue). | 
| 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 fnreturns the event that performs the same communications
   asev, then applies the post-processing functionfnon the return value.
 | 
| wrap_abort [Event] | 
wrap_abort ev fnreturns the event that performs
   the same communications asev, but if it is not selected
   the functionfnis called after the synchronization.
 | 
| write [ThreadUnix] |  | 
| write [UnixLabels] | 
write fd ~buf ~pos ~lenwriteslenbytes to descriptorfd,
    taking them from byte sequencebuf, starting at positionposinbuff.
 | 
| write [Unix] | 
write fd buf pos lenwriteslenbytes to descriptorfd,
    taking them from byte sequencebuf, starting at positionposinbuff.
 | 
| write_arg [Arg] | 
Arg.write_arg file argswrites the argumentsargsnewline-terminated
    into the filefile.
 | 
| write_arg0 [Arg] | 
Identical to Arg.write_argbut uses the null character for terminator
    instead of newline. | 
| write_substring [ThreadUnix] |  | 
| write_substring [UnixLabels] | 
Same as UnixLabels.write, but take the data from a string instead of a byte
    sequence. | 
| write_substring [Unix] | 
Same as Unix.write, but take the data from a string instead of a byte
    sequence. | 
| Y | 
| yield [Thread] | 
Re-schedule the calling thread without suspending it. | 
| Z | 
| zero [Nativeint] |  | 
| zero [Int64] |  | 
| zero [Int32] |  | 
| zero [Int] |  | 
| zero [Float] |  | 
| zero [Complex] |  | 
| zip [Seq] | 
zip xs ysis the sequence of pairs(x, y)drawn synchronously from the sequencesxsandys.
 |