| ( * ) [Pervasives] | 
Integer multiplication.
 | 
| ( ** ) [Pervasives] | 
Exponentiation.
 | 
| ( **/ ) [Num] | 
Same as  Num.power_num. | 
| ( *. ) [Pervasives] | 
Floating-point multiplication
 | 
| ( */ ) [Num] | 
Same as  Num.mult_num. | 
| (!) [Pervasives] | !rreturns the current contents of referencer. | 
| (!=) [Pervasives] | 
Negation of  (==). | 
| (&&) [Pervasives] | 
The boolean 'and'.
 | 
| (&) [Pervasives] | |
| (+) [Pervasives] | 
Integer addition.
 | 
| (+.) [Pervasives] | 
Floating-point addition
 | 
| (+/) [Num] | 
Same as  Num.add_num. | 
| (-) [Pervasives] | 
Integer subtraction.
 | 
| (-.) [Pervasives] | 
Floating-point subtraction
 | 
| (-/) [Num] | 
Same as  Num.sub_num. | 
| (/) [Pervasives] | 
Integer division.
 | 
| (/.) [Pervasives] | 
Floating-point division.
 | 
| (//) [Num] | 
Same as  Num.div_num. | 
| (:=) [Pervasives] | r := astores the value ofain referencer. | 
| (<) [Pervasives] | 
See  (>=). | 
| (</) [Num] | |
| (<=) [Pervasives] | 
See  (>=). | 
| (<=/) [Num] | |
| (<>) [Pervasives] | 
Negation of  (=). | 
| (<>/) [Num] | |
| (=) [Pervasives] | e1 = e2tests for structural equality ofe1ande2. | 
| (=/) [Num] | |
| (==) [Pervasives] | e1 == e2tests for physical equality ofe1ande2. | 
| (>) [Pervasives] | 
See  (>=). | 
| (>/) [Num] | |
| (>=) [Pervasives] | 
Structural ordering functions.
 | 
| (>=/) [Num] | |
| (@) [Pervasives] | 
List concatenation.
 | 
| (@@) [Pervasives] | 
Application operator:  g @@ f @@ xis exactly equivalent tog (f (x)). | 
| (^) [Pervasives] | 
String concatenation.
 | 
| (^^) [Pervasives] | f1 ^^ f2catenates format stringsf1andf2. | 
| (asr) [Pervasives] | n asr mshiftsnto the right bymbits. | 
| (land) [Pervasives] | 
Bitwise logical and.
 | 
| (lor) [Pervasives] | 
Bitwise logical or.
 | 
| (lsl) [Pervasives] | n lsl mshiftsnto the left bymbits. | 
| (lsr) [Pervasives] | n lsr mshiftsnto the right bymbits. | 
| (lxor) [Pervasives] | 
Bitwise logical exclusive or.
 | 
| (mod) [Pervasives] | 
Integer remainder.
 | 
| (or) [Pervasives] | |
| (|>) [Pervasives] | 
Reverse-application operator:  x |> f |> gis exactly equivalent
 tog (f (x)). | 
| (||) [Pervasives] | 
The boolean 'or'.
 | 
| (~+) [Pervasives] | 
Unary addition.
 | 
| (~+.) [Pervasives] | 
Unary addition.
 | 
| (~-) [Pervasives] | 
Unary negation.
 | 
| (~-.) [Pervasives] | 
Unary negation.
 | 
| __FILE__ [Pervasives] | __FILE__returns the name of the file currently being
    parsed by the compiler. | 
| __LINE_OF__ [Pervasives] | __LINE__ exprreturns a pair(line, expr), wherelineis the
    line number at which the expressionexprappears in the file
    currently being parsed by the compiler. | 
| __LINE__ [Pervasives] | __LINE__returns the line number at which this expression
    appears in the file currently being parsed by the compiler. | 
| __LOC_OF__ [Pervasives] | __LOC_OF__ 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__ [Pervasives] | __LOC__returns the location at which this expression appears in
    the file currently being parsed by the compiler, with the standard
    error format of OCaml: "File %S, line %d, characters %d-%d". | 
| __MODULE__ [Pervasives] | __MODULE__returns the module name of the file being
    parsed by the compiler. | 
| __POS_OF__ [Pervasives] | __POS_OF__ 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__ [Pervasives] | __POS__returns a tuple(file,lnum,cnum,enum), corresponding
    to the location at which this expression appears in the file
    currently being parsed by the compiler. | 
| A | |
| abs [Targetint] | 
Return the absolute value of its argument.
 | 
| abs [Pervasives] | 
Return the absolute value of the argument.
 | 
| abs [Nativeint] | 
Return the absolute value of its argument.
 | 
| abs [Int64] | 
Return the absolute value of its argument.
 | 
| abs [Int32] | 
Return the absolute value of its argument.
 | 
| abs_big_int [Big_int] | 
Absolute value.
 | 
| abs_float [Pervasives] | abs_float freturns the absolute value off. | 
| abs_num [Num] | 
Absolute value.
 | 
| absname [Location] | |
| absolute_path [Location] | |
| abstract_tag [Obj] | |
| accept [UnixLabels] | 
Accept connections on the given socket.
 | 
| accept [Unix] | 
Accept connections on the given socket.
 | 
| accept [ThreadUnix] | |
| access [UnixLabels] | 
Check that the process has the given permissions over the named
   file.
 | 
| access [Unix] | 
Check that the process has the given permissions over the named file.
 | 
| accumulate_time [Timings] | 
Like time for passes that can run multiple times
 | 
| acos [Pervasives] | 
Arc cosine.
 | 
| adapt_filename [Dynlink] | 
In bytecode, the identity function.
 | 
| add [Weak.S] | add t xaddsxtot. | 
| add [Tbl] | |
| add [Targetint] | 
Addition.
 | 
| add [Queue] | add x qadds the elementxat the end of the queueq. | 
| add [Nativeint] | 
Addition.
 | 
| add [MoreLabels.Set.S] | |
| add [MoreLabels.Map.S] | |
| add [MoreLabels.Hashtbl.SeededS] | |
| add [MoreLabels.Hashtbl.S] | |
| add [MoreLabels.Hashtbl] | |
| add [Int64] | 
Addition.
 | 
| add [Int32] | 
Addition.
 | 
| add [Hashtbl.SeededS] | |
| add [Hashtbl.S] | |
| add [Hashtbl] | Hashtbl.add tbl x yadds a binding ofxtoyin tabletbl. | 
| add [Map.S] | add x y mreturns a map containing the same bindings asm, plus a binding ofxtoy. | 
| add [Set.S] | add x sreturns a set containing all elements ofs,
       plusx. | 
| add [Complex] | 
Addition
 | 
| add_arguments [Clflags] | |
| add_available_units [Dynlink] | 
Same as  Dynlink.add_interfaces, but instead of searching.cmifiles
    to find the unit interfaces, uses the interface digests given
    for each unit. | 
| add_base_override [Arg_helper.Make] | |
| add_big_int [Big_int] | 
Addition.
 | 
| add_buffer [Buffer] | add_buffer b1 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_docs_attrs [Docstrings] | 
Convert item documentation to attributes and add them to an
    attribute list
 | 
| add_hook [Misc.HookSig] | |
| add_implementation [Depend] | |
| add_implementation_binding [Depend] | |
| add_in_char_set [CamlinternalFormat] | |
| add_info_attrs [Docstrings] | 
Convert field info to attributes and add them to an
    attribute list
 | 
| add_initializer [CamlinternalOO] | |
| add_int_big_int [Big_int] | 
Addition of a small integer to a big integer.
 | 
| add_interfaces [Dynlink] | add_interfaces units pathgrants dynamically-linked object
    files access to the compilation  units named in listunits. | 
| add_num [Num] | 
Addition
 | 
| add_offset [Obj] | |
| add_ppx_context_sig [Ast_mapper] | 
Same as  add_ppx_context_str, but for signatures. | 
| add_ppx_context_str [Ast_mapper] | 
Extract information from the current environment and encode it
    into an attribute which is prepended to the list of structure
    items in order to pass the information to an external
    processor.
 | 
| add_signature [Depend] | |
| add_signature_binding [Depend] | |
| 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_text_attrs [Docstrings] | 
Convert text to attributes and add them to an attribute list
 | 
| add_use_file [Depend] | |
| add_user_override [Arg_helper.Make] | |
| afl_inst_ratio [Clflags] | |
| afl_instrument [Config] | |
| afl_instrument [Clflags] | |
| alarm [UnixLabels] | 
Schedule a  SIGALRMsignal after the given number of seconds. | 
| alarm [Unix] | 
Schedule a  SIGALRMsignal after the given number of seconds. | 
| alias [Ast_helper.Mty] | |
| alias [Ast_helper.Pat] | |
| alias [Ast_helper.Typ] | |
| align [Misc] | |
| align [Arg] | 
Align the documentation strings by inserting spaces at the first
    space, according to the length of the keyword.
 | 
| all_ccopts [Clflags] | |
| all_passes [Clflags] | |
| all_ppx [Clflags] | |
| allocated_bytes [Gc] | 
Return the total number of bytes allocated since the program was
   started.
 | 
| allow_only [Dynlink] | allow_only unitsrestricts the compilation units that
    dynamically-linked units can reference: it forbids all references
    to units other than those named in the listunits. | 
| 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. | 
| and_big_int [Big_int] | 
Bitwise logical 'and'.
 | 
| annotations [Clflags] | |
| ansi_of_style_l [Misc.Color] | |
| any [Ast_helper.Pat] | |
| any [Ast_helper.Typ] | |
| append [ListLabels] | 
Catenate two lists.
 | 
| append [List] | 
Concatenate two lists.
 | 
| append [ArrayLabels] | Array.append v1 v2returns a fresh array containing the
   concatenation of the arraysv1andv2. | 
| append [Array] | Array.append v1 v2returns a fresh array containing the
   concatenation of the arraysv1andv2. | 
| applicative_functors [Clflags] | |
| apply [Ast_mapper] | 
Apply a mapper (parametrized by the unit name) to a dumped
    parsetree found in the  sourcefile and put the result in thetargetfile. | 
| apply [Ast_helper.Cl] | |
| apply [Ast_helper.Mod] | |
| apply [Ast_helper.Exp] | |
| apply_hooks [Misc.HookSig] | |
| approx_num_exp [Num] | 
Approximate a number by a decimal.
 | 
| approx_num_fix [Num] | 
See  Num.approx_num_exp. | 
| ar [Config] | |
| architecture [Config] | |
| arg [Complex] | 
Argument.
 | 
| arg_spec [Clflags] | |
| argv [Sys] | 
The command line arguments given to the process.
 | 
| arith_status [Arith_status] | 
Print the current status of the arithmetic flags.
 | 
| array [Sort] | 
Sort an array in increasing order according to an
   ordering predicate.
 | 
| array [Ast_helper.Exp] | |
| array [Ast_helper.Pat] | |
| array0_of_genarray [Bigarray] | 
Return the zero-dimensional big array corresponding to the given
   generic big array.
 | 
| array1_of_genarray [Bigarray] | 
Return the one-dimensional big array corresponding to the given
   generic big array.
 | 
| array2_of_genarray [Bigarray] | 
Return the two-dimensional big array corresponding to the given
   generic big array.
 | 
| array3_of_genarray [Bigarray] | 
Return the three-dimensional big array corresponding to the given
   generic big array.
 | 
| arrow [Ast_helper.Cty] | |
| arrow [Ast_helper.Typ] | |
| asin [Pervasives] | 
Arc sine.
 | 
| asm [Config] | |
| asm_cfi_supported [Config] | |
| asprintf [Format] | 
Same as  printfabove, but instead of printing on a formatter,
  returns a string containing the result of formatting the arguments. | 
| assert_ [Ast_helper.Exp] | |
| assoc [ListLabels] | assoc a 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  List.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  List.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. | 
| ast_impl_magic_number [Config] | |
| ast_intf_magic_number [Config] | |
| at_exit [Pervasives] | 
Register the given function to be called at program
   termination time.
 | 
| atan [Pervasives] | 
Arc tangent.
 | 
| atan2 [Pervasives] | atan2 y xreturns the arc tangent ofy /. x. | 
| attr [Ast_helper.Cf] | |
| attr [Ast_helper.Cl] | |
| attr [Ast_helper.Ctf] | |
| attr [Ast_helper.Cty] | |
| attr [Ast_helper.Mod] | |
| attr [Ast_helper.Mty] | |
| attr [Ast_helper.Exp] | |
| attr [Ast_helper.Pat] | |
| attr [Ast_helper.Typ] | |
| attribute [Ast_helper.Cf] | |
| attribute [Ast_helper.Ctf] | |
| attribute [Ast_helper.Str] | |
| attribute [Ast_helper.Sig] | |
| attribute_of_warning [Ast_mapper] | 
Encode a warning message into an 'ocaml.ppwarning' attribute which can be
    inserted in a generated Parsetree.
 | 
| auto_synchronize [Graphics] | 
By default, drawing takes place both on the window displayed
   on screen, and in a memory area (the 'backing store').
 | 
| B | |
| backend_type [Sys] | 
Backend type  currently executing the OCaml program.
 | 
| background [Graphics] | 
See  Graphics.foreground. | 
| backtrace_slots [Printexc] | 
Returns the slots of a raw backtrace, or  Noneif none of them
    contain useful information. | 
| backtrace_status [Printexc] | Printexc.backtrace_status()returnstrueif exception
    backtraces are currently recorded,falseif not. | 
| backup [Warnings] | |
| backup [Terminfo] | |
| basename [Filename] | 
Split a file name into directory name / base file name.
 | 
| beginning_of_input [Scanf.Scanning] | Scanning.beginning_of_input 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.
 | 
| big_int_of_int [Big_int] | 
Convert a small integer to a big integer.
 | 
| big_int_of_int32 [Big_int] | 
Convert a 32-bit integer to a big integer.
 | 
| big_int_of_int64 [Big_int] | 
Convert a 64-bit integer to a big integer.
 | 
| big_int_of_nativeint [Big_int] | 
Convert a native integer to a big integer.
 | 
| big_int_of_num [Num] | |
| big_int_of_num_opt [Num] | |
| big_int_of_string [Big_int] | 
Convert a string to a big integer, in decimal.
 | 
| big_int_of_string_opt [Big_int] | 
Convert a string to a big integer, in decimal.
 | 
| binary_annotations [Clflags] | |
| bind [UnixLabels] | 
Bind a socket to an address.
 | 
| bind [Unix] | 
Bind a socket to an address.
 | 
| bindings [MoreLabels.Map.S] | |
| bindings [Map.S] | 
Return the list of all bindings of the given map.
 | 
| bits [Random.State] | |
| bits [Random] | 
Return 30 random bits in a nonnegative integer.
 | 
| bits_of_float [Int64] | 
Return the internal representation of the given float according
   to the IEEE 754 floating-point 'double format' bit layout.
 | 
| bits_of_float [Int32] | 
Return the internal representation of the given float according
   to the IEEE 754 floating-point 'single format' bit layout.
 | 
| black [Graphics] | |
| blit [Weak] | Weak.blit ar1 off1 ar2 off2 lencopieslenweak pointers
   fromar1(starting atoff1) toar2(starting atoff2). | 
| blit [String] | 
Same as  Bytes.blit_string. | 
| blit [StringLabels] | String.blit src srcoff dst dstoff lencopieslenbytes
   from the stringsrc, starting at indexsrcoff,
   to byte sequencedst, starting at character numberdstoff. | 
| blit [Misc.LongString] | |
| blit [BytesLabels] | blit src srcoff dst dstoff lencopieslenbytes from sequencesrc, starting at indexsrcoff, to sequencedst, starting at
    indexdstoff. | 
| blit [Bytes] | blit src srcoff dst dstoff lencopieslenbytes from sequencesrc, starting at indexsrcoff, to sequencedst, starting at
    indexdstoff. | 
| 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 big array to the second big array.
 | 
| blit [Bigarray.Array2] | 
Copy the first big array to the second big array.
 | 
| blit [Bigarray.Array1] | 
Copy the first big array to the second big array.
 | 
| blit [Bigarray.Array0] | 
Copy the first big array to the second big array.
 | 
| blit [Bigarray.Genarray] | 
Copy all elements of a big array in another big array.
 | 
| blit [ArrayLabels] | Array.blit v1 o1 v2 o2 lencopieslenelements
   from arrayv1, starting at element numbero1, to arrayv2,
   starting at element numbero2. | 
| blit [Array] | Array.blit v1 o1 v2 o2 lencopieslenelements
   from arrayv1, starting at element numbero1, to arrayv2,
   starting at element numbero2. | 
| blit_data [Obj.Ephemeron] | 
Same as  Ephemeron.K1.blit_data | 
| blit_data [Ephemeron.Kn] | 
Same as  Ephemeron.K1.blit_data | 
| blit_data [Ephemeron.K2] | 
Same as  Ephemeron.K1.blit_data | 
| blit_data [Ephemeron.K1] | Ephemeron.K1.blit_data eph1 eph2sets the data ofeph2with
      the data ofeph1. | 
| blit_image [Graphics] | blit_image img x ycopies screen pixels into the imageimg,
   modifyingimgin-place. | 
| blit_key [Obj.Ephemeron] | 
Same as  Ephemeron.K1.blit_key | 
| blit_key [Ephemeron.Kn] | 
Same as  Ephemeron.K1.blit_key | 
| blit_key [Ephemeron.K1] | Ephemeron.K1.blit_key eph1 eph2sets the key ofeph2with
      the key ofeph1. | 
| blit_key1 [Ephemeron.K2] | 
Same as  Ephemeron.K1.blit_key | 
| blit_key12 [Ephemeron.K2] | 
Same as  Ephemeron.K1.blit_key | 
| blit_key2 [Ephemeron.K2] | 
Same as  Ephemeron.K1.blit_key | 
| blit_string [BytesLabels] | blit src srcoff dst dstoff lencopieslenbytes from stringsrc, starting at indexsrcoff, to byte sequencedst,
    starting at indexdstoff. | 
| blit_string [Bytes] | blit src srcoff dst dstoff lencopieslenbytes from stringsrc, starting at indexsrcoff, to byte sequencedst,
    starting at indexdstoff. | 
| blue [Graphics] | |
| bool [Random.State] | 
These functions are the same as the basic functions, except that they
      use (and update) the given PRNG state instead of the default one.
 | 
| bool [Random] | Random.bool ()returnstrueorfalsewith probability 0.5 each. | 
| bool_of_string [Pervasives] | 
Convert the given string to a boolean.
 | 
| bool_of_string_opt [Pervasives] | 
Convert the given string to a boolean.
 | 
| bounded_full_split [Str] | 
Same as  Str.bounded_split_delim, but returns
   the delimiters as well as the substrings contained between
   delimiters. | 
| bounded_split [Str] | |
| 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] | |
| button_down [Graphics] | 
Return  trueif the mouse button is pressed,falseotherwise. | 
| bytecode_compatible_32 [Clflags] | |
| bytecomp_c_compiler [Config] | |
| bytecomp_c_libraries [Config] | |
| bytes [Digest] | 
Return the digest of the given byte sequence.
 | 
| C | |
| c_compiler [Clflags] | |
| c_layout [Bigarray] | |
| call_linker [Ccomp] | |
| capitalize [String] | 
Return a copy of the argument, with the first character set to uppercase,
   using the ISO Latin-1 (8859-1) character set..
 | 
| capitalize [StringLabels] | 
Return a copy of the argument, with the first character set to uppercase,
   using the ISO Latin-1 (8859-1) character set..
 | 
| capitalize [BytesLabels] | 
Return a copy of the argument, with the first character set to uppercase,
   using the ISO Latin-1 (8859-1) character set..
 | 
| capitalize [Bytes] | 
Return a copy of the argument, with the first character set to uppercase,
   using the ISO Latin-1 (8859-1) character set..
 | 
| capitalize_ascii [String] | 
Return a copy of the argument, with the first character set to uppercase,
   using the US-ASCII character set.
 | 
| capitalize_ascii [StringLabels] | 
Return a copy of the argument, with the first character set to uppercase,
   using the US-ASCII character set.
 | 
| capitalize_ascii [BytesLabels] | 
Return a copy of the argument, with the first character set to uppercase,
   using the US-ASCII character set.
 | 
| capitalize_ascii [Bytes] | 
Return a copy of the argument, with the first character set to uppercase,
   using the US-ASCII character set.
 | 
| cardinal [MoreLabels.Set.S] | |
| cardinal [MoreLabels.Map.S] | |
| cardinal [Map.S] | 
Return the number of bindings of a map.
 | 
| cardinal [Set.S] | 
Return the number of elements of a set.
 | 
| case [Ast_helper.Exp] | |
| cat [BytesLabels] | cat s1 s2concatenatess1ands2and returns the result
     as new byte sequence. | 
| cat [Bytes] | cat s1 s2concatenatess1ands2and returns the result
     as 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. | 
| cc_profile [Config] | |
| ccobjs [Clflags] | |
| ccomp_type [Config] | |
| ceil [Pervasives] | 
Round above to an integer value.
 | 
| ceiling_num [Num] | ceiling_num nreturns the smallest integer bigger or equal ton. | 
| 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,
   big arrays of kind  float32_eltandfloat64_eltare
   accessed using the OCaml typefloat. | 
| char [Ast_helper.Const] | |
| char_of_iconv [CamlinternalFormat] | |
| char_of_int [Pervasives] | 
Return the character with the given ASCII code.
 | 
| chdir [UnixLabels] | 
Change the process working directory.
 | 
| chdir [Unix] | 
Change the process working directory.
 | 
| chdir [Sys] | 
Change the current working directory of the process.
 | 
| check [Weak] | Weak.check ar nreturnstrueif thenth cell ofaris
   full,falseif it is empty. | 
| check [Consistbl] | |
| check_data [Obj.Ephemeron] | 
Same as  Ephemeron.K1.check_data | 
| check_data [Ephemeron.Kn] | 
Same as  Ephemeron.K1.check_data | 
| check_data [Ephemeron.K2] | 
Same as  Ephemeron.K1.check_data | 
| check_data [Ephemeron.K1] | Ephemeron.K1.check_data ephreturnstrueif the data of theephis full,falseif it is empty. | 
| check_deprecated [Builtin_attributes] | |
| check_deprecated_mutable [Builtin_attributes] | |
| check_fatal [Warnings] | |
| check_key [Obj.Ephemeron] | 
Same as  Ephemeron.K1.check_key | 
| check_key [Ephemeron.Kn] | 
Same as  Ephemeron.K1.check_key | 
| check_key [Ephemeron.K1] | Ephemeron.K1.check_key ephreturnstrueif the key of theephis full,falseif it is empty. | 
| check_key1 [Ephemeron.K2] | 
Same as  Ephemeron.K1.check_key | 
| check_key2 [Ephemeron.K2] | 
Same as  Ephemeron.K1.check_key | 
| check_noadd [Consistbl] | |
| check_suffix [Filename] | check_suffix name 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 [MoreLabels.Set.S] | |
| choose [MoreLabels.Map.S] | |
| choose [Event] | choose evlreturns the event that is the alternative of
   all the events in the listevl. | 
| choose [Map.S] | 
Return one binding of the given map, or raise  Not_foundif
       the map is empty. | 
| choose [Set.S] | 
Return one element of the given set, or raise  Not_foundif
       the set is empty. | 
| choose_opt [MoreLabels.Set.S] | |
| choose_opt [MoreLabels.Map.S] | |
| choose_opt [Map.S] | 
Return one binding of the given map, or  Noneif
       the map is empty. | 
| choose_opt [Set.S] | 
Return one element of the given set, or  Noneif
        the set is empty. | 
| chop_extension [Filename] | 
Same as  Filename.remove_extension, but raiseInvalid_argumentif the given name has an empty extension. | 
| chop_extensions [Misc] | |
| chop_suffix [Filename] | chop_suffix name suffremoves the suffixsufffrom
   the filenamename. | 
| chown [UnixLabels] | 
Change the owner uid and owner gid of the named file.
 | 
| chown [Unix] | 
Change the owner uid and owner gid of the named file.
 | 
| chr [Char] | 
Return the character with the given ASCII code.
 | 
| chroot [UnixLabels] | 
Change the process root directory.
 | 
| chroot [Unix] | 
Change the process root directory.
 | 
| clambda_checks [Clflags] | |
| class_ [Ast_helper.Str] | |
| class_ [Ast_helper.Sig] | |
| class_ [Ast_helper.Typ] | |
| class_type [Ast_helper.Str] | |
| class_type [Ast_helper.Sig] | |
| classic [Clflags] | |
| classic_arguments [Clflags] | |
| classic_inlining [Clflags] | |
| classify_float [Pervasives] | 
Return the class of the given floating-point number:
   normal, subnormal, zero, infinite, or not a number.
 | 
| clean [Ephemeron.SeededS] | 
remove all dead bindings.
 | 
| clean [Ephemeron.S] | 
remove all dead bindings.
 | 
| clear [Weak.S] | 
Remove all elements from the table.
 | 
| clear [Stack] | 
Discard all elements from a stack.
 | 
| clear [Queue] | 
Discard all elements from a queue.
 | 
| clear [MoreLabels.Hashtbl.SeededS] | |
| clear [MoreLabels.Hashtbl.S] | |
| clear [MoreLabels.Hashtbl] | |
| clear [Hashtbl.SeededS] | |
| clear [Hashtbl.S] | |
| clear [Hashtbl] | 
Empty a hash table.
 | 
| clear [Consistbl] | |
| clear [Buffer] | 
Empty the buffer.
 | 
| clear_available_units [Dynlink] | 
Empty the list of compilation units accessible to dynamically-linked
    programs.
 | 
| clear_close_on_exec [UnixLabels] | 
Clear the ``close-on-exec'' flag on the given descriptor.
 | 
| clear_close_on_exec [Unix] | 
Clear the ``close-on-exec'' flag on the given descriptor.
 | 
| clear_graph [Graphics] | 
Erase the graphics window.
 | 
| clear_nonblock [UnixLabels] | 
Clear the ``non-blocking'' flag on the given descriptor.
 | 
| clear_nonblock [Unix] | 
Clear the ``non-blocking'' flag on the given descriptor.
 | 
| clear_parser [Parsing] | 
Empty the parser stack.
 | 
| close [UnixLabels] | 
Close a file descriptor.
 | 
| close [Unix] | 
Close a file descriptor.
 | 
| close_box [Format] | 
Closes the most recently opened pretty-printing box.
 | 
| close_graph [Graphics] | 
Delete the graphics window or switch the screen back to text mode.
 | 
| close_in [Scanf.Scanning] | 
Closes the  in_channelassociated with the givenScanf.Scanning.in_channelformatted input channel. | 
| close_in [Pervasives] | 
Close the given channel.
 | 
| close_in_noerr [Pervasives] | 
Same as  close_in, but ignore all errors. | 
| close_out [Pervasives] | 
Close the given channel, flushing all buffered write operations.
 | 
| close_out_noerr [Pervasives] | 
Same as  close_out, but ignore all errors. | 
| close_process [UnixLabels] | 
Close channels opened by  UnixLabels.open_process,
   wait for the associated command to terminate,
   and return its termination status. | 
| close_process [Unix] | 
Close channels opened by  Unix.open_process,
   wait for the associated command to terminate,
   and return its termination status. | 
| close_process_full [UnixLabels] | 
Close channels opened by  UnixLabels.open_process_full,
   wait for the associated command to terminate,
   and return its termination status. | 
| close_process_full [Unix] | 
Close channels opened by  Unix.open_process_full,
   wait for the associated command to terminate,
   and return its termination status. | 
| close_process_in [UnixLabels] | 
Close channels opened by  UnixLabels.open_process_in,
   wait for the associated command to terminate,
   and return its termination status. | 
| close_process_in [Unix] | 
Close channels opened by  Unix.open_process_in,
   wait for the associated command to terminate,
   and return its termination status. | 
| close_process_out [UnixLabels] | 
Close channels opened by  UnixLabels.open_process_out,
   wait for the associated command to terminate,
   and return its termination status. | 
| close_process_out [Unix] | 
Close channels opened by  Unix.open_process_out,
   wait for the associated command to terminate,
   and return its termination status. | 
| close_subwindow [GraphicsX11] | 
Close the sub-window having the given identifier.
 | 
| close_tag [Format] | close_tag ()closes the most recently opened tagt. | 
| close_tbox [Format] | |
| closedir [UnixLabels] | 
Close a directory descriptor.
 | 
| closedir [Unix] | 
Close a directory descriptor.
 | 
| closure_tag [Obj] | |
| cma_magic_number [Config] | |
| cmi_magic_number [Config] | |
| cmo_magic_number [Config] | |
| cmt_magic_number [Config] | |
| cmx_magic_number [Config] | |
| cmxa_magic_number [Config] | |
| cmxs_magic_number [Config] | |
| code [Char] | 
Return the ASCII code of the argument.
 | 
| coerce [Ast_helper.Exp] | |
| color [Clflags] | |
| combine [ListLabels] | 
Transform a pair of lists into a list of pairs:
    combine [a1; ...; an] [b1; ...; bn]is[(a1,b1); ...; (an,bn)]. | 
| combine [List] | 
Transform a pair of lists into a list of pairs:
    combine [a1; ...; an] [b1; ...; bn]is[(a1,b1); ...; (an,bn)]. | 
| command [Sys] | 
Execute the given shell command and return its exit code.
 | 
| command [Ccomp] | |
| comments [Lexer] | |
| compact [Gc] | 
Perform a full major collection and compact the heap.
 | 
| compare [Uchar] | compare u u'isPervasives.compare u u'. | 
| compare [Targetint] | 
The comparison function for target integers, with the same specification as
     compare. | 
| compare [String] | 
The comparison function for strings, with the same specification as
     compare. | 
| compare [StringLabels] | 
The comparison function for strings, with the same specification as
     compare. | 
| compare [Pervasives] | compare x yreturns0ifxis equal toy,
   a negative integer ifxis less thany, and a positive integer
   ifxis greater thany. | 
| compare [Nativeint] | 
The comparison function for native integers, with the same specification as
     compare. | 
| compare [Set.OrderedType] | 
A total ordering function over the set elements.
 | 
| compare [MoreLabels.Set.S] | |
| compare [MoreLabels.Map.S] | |
| compare [Misc.Stdlib.List] | 
The lexicographic order supported by the provided order.
 | 
| compare [Map.OrderedType] | 
A total ordering function over the keys.
 | 
| compare [Int64] | 
The comparison function for 64-bit integers, with the same specification as
     compare. | 
| compare [Int32] | 
The comparison function for 32-bit integers, with the same specification as
     compare. | 
| compare [Digest] | 
The comparison function for 16-character digest, with the same
    specification as  compareand the implementation
    shared withString.compare. | 
| compare [Map.S] | 
Total ordering between maps.
 | 
| compare [Set.S] | 
Total ordering between sets.
 | 
| compare [Char] | 
The comparison function for characters, with the same specification as
     compare. | 
| compare [BytesLabels] | 
The comparison function for byte sequences, with the same
    specification as  compare. | 
| compare [Bytes] | 
The comparison function for byte sequences, with the same
    specification as  compare. | 
| compare_big_int [Big_int] | compare_big_int a breturns0ifaandbare equal,1ifais greater thanb, and-1ifais smaller
            thanb. | 
| 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.
 | 
| compare_num [Num] | 
Return  -1,0or1if the first argument is less than,
   equal to, or greater than the second argument. | 
| compile_file [Ccomp] | |
| compile_only [Clflags] | |
| complex32 [Bigarray] | 
See  Bigarray.char. | 
| complex64 [Bigarray] | 
See  Bigarray.char. | 
| component_graph [Strongly_connected_components.S] | |
| concat [String] | String.concat sep slconcatenates the list of stringssl,
    inserting the separator stringsepbetween each. | 
| concat [StringLabels] | String.concat sep slconcatenates the list of stringssl,
   inserting the separator stringsepbetween each. | 
| concat [ListLabels] | 
Concatenate a list of lists.
 | 
| concat [List] | 
Concatenate a list of lists.
 | 
| 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] | 
Same as  Array.append, but concatenates a list of arrays. | 
| concat [Array] | 
Same as  Array.append, but concatenates a list of arrays. | 
| concat_fmt [CamlinternalFormatBasics] | |
| concat_fmtty [CamlinternalFormatBasics] | |
| concrete [Ast_helper.Cf] | |
| conj [Complex] | 
Conjugate: given the complex  x + i.y, returnsx - i.y. | 
| connect [UnixLabels] | 
Connect a socket to an address.
 | 
| connect [Unix] | 
Connect a socket to an address.
 | 
| connect [ThreadUnix] | |
| connected_components_sorted_from_roots_to_leaf [Strongly_connected_components.S] | |
| cons [ListLabels] | cons x xsisx :: xs | 
| cons [List] | cons x xsisx :: xs | 
| constant [Ast_helper.Exp] | |
| constant [Ast_helper.Pat] | |
| constr [Ast_helper.Cl] | |
| constr [Ast_helper.Cty] | |
| constr [Ast_helper.Typ] | |
| constraint_ [Ast_helper.Cf] | |
| constraint_ [Ast_helper.Cl] | |
| constraint_ [Ast_helper.Ctf] | |
| constraint_ [Ast_helper.Mod] | |
| constraint_ [Ast_helper.Exp] | |
| constraint_ [Ast_helper.Pat] | |
| construct [Ast_helper.Exp] | |
| construct [Ast_helper.Pat] | |
| constructor [Ast_helper.Te] | |
| constructor [Ast_helper.Type] | |
| contains [String] | String.contains s ctests if charactercappears in the strings. | 
| contains [StringLabels] | String.contains s ctests if charactercappears in the strings. | 
| contains [BytesLabels] | contains s ctests if bytecappears ins. | 
| contains [Bytes] | contains s ctests if bytecappears ins. | 
| contains_from [String] | String.contains_from s start ctests if charactercappears insafter positionstart. | 
| contains_from [StringLabels] | String.contains_from s start ctests if charactercappears 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 [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] | |
| copy [Hashtbl.SeededS] | |
| copy [Hashtbl.S] | |
| copy [Hashtbl] | 
Return a copy of the given hashtable.
 | 
| copy [CamlinternalOO] | |
| copy [BytesLabels] | 
Return a new byte sequence that contains the same bytes as the
    argument.
 | 
| copy [Bytes] | 
Return a new byte sequence that contains the same bytes as the
    argument.
 | 
| copy [ArrayLabels] | Array.copy areturns a copy ofa, that is, a fresh array
   containing the same elements asa. | 
| copy [Array] | Array.copy areturns a copy ofa, that is, a fresh array
   containing the same elements asa. | 
| copy_file [Misc] | |
| copy_file_chunk [Misc] | |
| copysign [Pervasives] | copysign x yreturns a float whose absolute value is that ofxand whose sign is that ofy. | 
| core_type [Pprintast] | |
| core_type [Parse] | |
| cos [Pervasives] | 
Cosine.
 | 
| cosh [Pervasives] | 
Hyperbolic cosine.
 | 
| count [Weak.S] | 
Count the number of elements in the table.
 | 
| count [Stream] | 
Return the current count of the stream elements, i.e.
 | 
| counters [Gc] | 
Return  (minor_words, promoted_words, major_words). | 
| create [Weak.S] | create ncreates a new empty weak hash set, of initial
        sizen. | 
| create [Weak] | Weak.create nreturns a new weak array of lengthn. | 
| 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 [String] | String.create nreturns a fresh byte sequence of lengthn. | 
| create [StringLabels] | String.create nreturns a fresh byte sequence of lengthn. | 
| create [Stack] | 
Return a new stack, initially empty.
 | 
| create [Spacetime.Series] | create ~pathcreates a series file atpath. | 
| create [Queue] | 
Return a new queue, initially empty.
 | 
| create [Obj.Ephemeron] | create nreturns an ephemeron withnkeys. | 
| create [Mutex] | 
Return a new mutex.
 | 
| create [MoreLabels.Hashtbl.SeededS] | |
| create [MoreLabels.Hashtbl.S] | |
| create [MoreLabels.Hashtbl] | |
| create [Misc.LongString] | |
| create [Hashtbl.SeededS] | |
| create [Hashtbl.S] | |
| create [Hashtbl] | Hashtbl.create ncreates a new, empty hash table, with
   initial sizen. | 
| create [Ephemeron.Kn] | 
Same as  Ephemeron.K1.create | 
| create [Ephemeron.K2] | 
Same as  Ephemeron.K1.create | 
| create [Ephemeron.K1] | Ephemeron.K1.create ()creates an ephemeron with one key. | 
| create [Consistbl] | |
| create [Condition] | 
Return a new condition variable.
 | 
| create [BytesLabels] | create 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 dimension, 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 dimension, 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 big array
     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_archive [Ccomp] | |
| create_char_set [CamlinternalFormat] | |
| create_float [ArrayLabels] | Array.create_float nreturns a fresh float array of lengthn,
    with uninitialized data. | 
| create_float [Array] | Array.create_float nreturns a fresh float array of lengthn,
    with uninitialized data. | 
| create_hashtable [Misc] | |
| create_image [Graphics] | create_image w hreturns a new imagewpixels wide andhpixels tall, to be used in conjunction withblit_image. | 
| create_matrix [ArrayLabels] | |
| create_matrix [Array] | |
| create_object [CamlinternalOO] | |
| create_object_and_run_initializers [CamlinternalOO] | |
| create_object_opt [CamlinternalOO] | |
| create_process [UnixLabels] | create_process prog args new_stdin new_stdout new_stderrforks a new process that executes the program
   in fileprog, with argumentsargs. | 
| create_process [Unix] | create_process prog args new_stdin new_stdout new_stderrforks a new process that executes the program
   in fileprog, with argumentsargs. | 
| create_process_env [UnixLabels] | create_process_env prog args env new_stdin new_stdout new_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 new_stdin new_stdout new_stderrworks asUnix.create_process, except that the extra argumentenvspecifies the environment passed to the program. | 
| create_table [CamlinternalOO] | |
| curr [Location] | 
Get the location of the current token from the  lexbuf. | 
| current [Arg] | 
Position (in  Sys.argv) of the argument being processed. | 
| current_dir_name [Filename] | 
The conventional name for the current directory (e.g.
 | 
| current_point [Graphics] | 
Return the position of the current point.
 | 
| current_x [Graphics] | 
Return the abscissa of the current point.
 | 
| current_y [Graphics] | 
Return the ordinate of the current point.
 | 
| curveto [Graphics] | curveto b c ddraws a cubic Bezier curve starting from
   the current point to pointd, with control pointsbandc, and moves the current point tod. | 
| custom_runtime [Clflags] | |
| custom_tag [Obj] | |
| cut_at [Misc] | String.cut_at s creturns a pair containing the sub-string before
   the first occurrence ofcins, and the sub-string after the
   first occurrence ofcins. | 
| cyan [Graphics] | |
| cygwin [Sys] | 
True if  Sys.os_type = "Cygwin". | 
| D | |
| data [Identifiable.S.Map] | |
| data_size [Marshal] | 
See  Marshal.header_size. | 
| debug [Clflags] | |
| decl [Ast_helper.Te] | |
| decr [Pervasives] | 
Decrement the integer contained in the given reference.
 | 
| decr_num [Num] | decr risr:=!r-1, whereris a reference to a number. | 
| default [Arg_helper.Make] | |
| default_available_units [Dynlink] | 
Reset the set of units that can be referenced from dynamically-linked
    code to its default value, that is, all units composing the currently
    running program.
 | 
| default_error_reporter [Location] | 
Original error reporter for use in hooks.
 | 
| default_executable_name [Config] | |
| default_inline_alloc_cost [Clflags] | |
| default_inline_branch_cost [Clflags] | |
| default_inline_branch_factor [Clflags] | |
| default_inline_call_cost [Clflags] | |
| default_inline_indirect_cost [Clflags] | |
| default_inline_lifting_benefit [Clflags] | |
| default_inline_max_depth [Clflags] | |
| default_inline_max_unroll [Clflags] | |
| default_inline_prim_cost [Clflags] | |
| default_inline_threshold [Clflags] | |
| default_inline_toplevel_threshold [Clflags] | |
| default_iterator [Ast_iterator] | 
A default iterator, which implements a "do not do anything" mapping.
 | 
| default_loc [Ast_helper] | 
Default value for all optional location arguments.
 | 
| default_mapper [Ast_mapper] | 
A default mapper, which implements a "deep identity" mapping.
 | 
| default_simplify_rounds [Clflags] | |
| default_styles [Misc.Color] | |
| default_unbox_closures_factor [Clflags] | |
| default_warning_printer [Location] | 
Original warning printer for use in hooks.
 | 
| defaults_w [Warnings] | |
| defaults_warn_error [Warnings] | |
| delay [Thread] | delay dsuspends the execution of the calling thread fordseconds. | 
| delete_alarm [Gc] | delete_alarm awill stop the calls to the function associated
   toa. | 
| delete_eol_spaces [Misc] | delete_eol_spaces sreturns a fresh copy ofswith any end of
   line spaces removed. | 
| deprecated_of_attrs [Builtin_attributes] | |
| deprecated_of_sig [Builtin_attributes] | |
| deprecated_of_str [Builtin_attributes] | |
| descr_of_in_channel [UnixLabels] | 
Return the descriptor corresponding to an input channel.
 | 
| descr_of_in_channel [Unix] | 
Return the descriptor corresponding to an input channel.
 | 
| descr_of_out_channel [UnixLabels] | 
Return the descriptor corresponding to an output channel.
 | 
| descr_of_out_channel [Unix] | 
Return the descriptor corresponding to an output channel.
 | 
| did_you_mean [Misc] | did_you_mean ppf get_choiceshints that the user may have meant
    one of the option returned by callingget_choices. | 
| diff [MoreLabels.Set.S] | |
| diff [Set.S] | 
Set difference.
 | 
| dim [Bigarray.Array1] | 
Return the size (dimension) of the given one-dimensional
     big array.
 | 
| dim1 [Bigarray.Array3] | 
Return the first dimension of the given three-dimensional big array.
 | 
| dim1 [Bigarray.Array2] | 
Return the first dimension of the given two-dimensional big array.
 | 
| dim2 [Bigarray.Array3] | 
Return the second dimension of the given three-dimensional big array.
 | 
| dim2 [Bigarray.Array2] | 
Return the second dimension of the given two-dimensional big array.
 | 
| dim3 [Bigarray.Array3] | 
Return the third dimension of the given three-dimensional big array.
 | 
| dims [Bigarray.Genarray] | Genarray.dims areturns all dimensions of the big arraya,
     as an array of integers of lengthGenarray.num_dims a. | 
| dir_sep [Filename] | 
The directory separator (e.g.
 | 
| dirname [Filename] | 
See  Filename.basename. | 
| disjoint_union [Identifiable.S.Map] | disjoint_union m1 m2contains all bindings fromm1andm2. | 
| display_mode [Graphics] | 
Set display mode on or off.
 | 
| div [Targetint] | 
Integer division.
 | 
| div [Nativeint] | 
Integer division.
 | 
| div [Int64] | 
Integer division.
 | 
| div [Int32] | 
Integer division.
 | 
| div [Complex] | 
Division
 | 
| div_big_int [Big_int] | 
Euclidean quotient of two big integers.
 | 
| div_num [Num] | 
Division
 | 
| dlcode [Clflags] | |
| dllibs [Clflags] | |
| dllpaths [Clflags] | |
| docs_attr [Docstrings] | |
| docstring [Docstrings] | 
Create a docstring
 | 
| docstring_body [Docstrings] | 
Get the text of a docstring
 | 
| docstring_loc [Docstrings] | 
Get the location of a docstring
 | 
| domain_of_sockaddr [UnixLabels] | 
Return the socket domain adequate for the given socket address.
 | 
| domain_of_sockaddr [Unix] | 
Return the socket domain adequate for the given socket address.
 | 
| dont_write_files [Clflags] | |
| double_array_tag [Obj] | |
| double_field [Obj] | |
| double_tag [Obj] | |
| draw_arc [Graphics] | draw_arc x y rx ry a1 a2draws an elliptical arc with centerx,y, horizontal radiusrx, vertical radiusry, from anglea1to anglea2(in degrees). | 
| draw_char [Graphics] | 
See  Graphics.draw_string. | 
| draw_circle [Graphics] | draw_circle x y rdraws a circle with centerx,yand
   radiusr. | 
| draw_ellipse [Graphics] | draw_ellipse x y rx rydraws an ellipse with centerx,y, horizontal radiusrxand vertical radiusry. | 
| draw_image [Graphics] | 
Draw the given image with lower left corner at the given point.
 | 
| draw_poly [Graphics] | draw_poly polygondraws the given polygon. | 
| draw_poly_line [Graphics] | draw_poly_line pointsdraws the line that joins the
   points given by the array argument. | 
| draw_rect [Graphics] | draw_rect x y w hdraws the rectangle with lower left corner
   atx,y, widthwand heighth. | 
| draw_segments [Graphics] | draw_segments segmentsdraws the segments given in the array
   argument. | 
| draw_string [Graphics] | 
Draw a character or a character string with lower left corner
   at current position.
 | 
| drop_ppx_context_sig [Ast_mapper] | 
Same as  drop_ppx_context_str, but for signatures. | 
| drop_ppx_context_str [Ast_mapper] | 
Drop the ocaml.ppx.context attribute from a structure.
 | 
| dummy_class [CamlinternalOO] | |
| dummy_pos [Lexing] | 
A value of type  position, guaranteed to be different from any
   valid position. | 
| dummy_table [CamlinternalOO] | |
| dump_clambda [Clflags] | |
| dump_cmm [Clflags] | |
| dump_combine [Clflags] | |
| dump_cse [Clflags] | |
| dump_flambda [Clflags] | |
| dump_flambda_let [Clflags] | |
| dump_flambda_verbose [Clflags] | |
| dump_image [Graphics] | 
Convert an image to a color matrix.
 | 
| dump_instr [Clflags] | |
| dump_interf [Clflags] | |
| dump_lambda [Clflags] | |
| dump_linear [Clflags] | |
| dump_live [Clflags] | |
| dump_parsetree [Clflags] | |
| dump_prefer [Clflags] | |
| dump_rawclambda [Clflags] | |
| dump_rawflambda [Clflags] | |
| dump_rawlambda [Clflags] | |
| dump_regalloc [Clflags] | |
| dump_reload [Clflags] | |
| dump_scheduling [Clflags] | |
| dump_selection [Clflags] | |
| dump_source [Clflags] | |
| dump_spill [Clflags] | |
| dump_split [Clflags] | |
| dump_typedtree [Clflags] | |
| dumped_pass [Clflags] | |
| dup [UnixLabels] | 
Return a new file descriptor referencing the same file as
   the given descriptor.
 | 
| dup [Unix] | 
Return a new file descriptor referencing the same file as
   the given descriptor.
 | 
| dup [Obj] | |
| dup2 [UnixLabels] | dup2 fd1 fd2duplicatesfd1tofd2, closingfd2if already
   opened. | 
| dup2 [Unix] | dup2 fd1 fd2duplicatesfd1tofd2, closingfd2if already
   opened. | 
| E | |
| echo_eof [Location] | |
| edit_distance [Misc] | edit_distance a b cutoffcomputes the edit distance between
    stringsaandb. | 
| elements [MoreLabels.Set.S] | |
| elements [Set.S] | 
Return the list of all elements of the given set.
 | 
| emit_external_warnings [Builtin_attributes] | |
| empty [Tbl] | |
| empty [Stream] | 
Return  ()if the stream is empty, else raiseStream.Failure. | 
| empty [MoreLabels.Set.S] | |
| empty [MoreLabels.Map.S] | |
| empty [Map.S] | 
The empty map.
 | 
| empty [Set.S] | 
The empty set.
 | 
| empty [BytesLabels] | 
A byte sequence of size 0.
 | 
| empty [Bytes] | 
A byte sequence of size 0.
 | 
| empty_docs [Docstrings] | |
| empty_info [Docstrings] | |
| empty_text [Docstrings] | |
| empty_text_lazy [Docstrings] | |
| enable_runtime_warnings [Sys] | 
Control whether the OCaml runtime system can emit warnings
    on stderr.
 | 
| enabled [Spacetime] | enabledistrueif the compiler is configured with spacetime andfalseotherwise | 
| end_of_input [Scanf.Scanning] | Scanning.end_of_input ictests the end-of-input condition of the givenScanf.Scanning.in_channelformatted input channel. | 
| environment [UnixLabels] | 
Return the process environment, as an array of strings
    with the format ``variable=value''.
 | 
| environment [Unix] | 
Return the process environment, as an array of strings
    with the format ``variable=value''.
 | 
| eprintf [Printf] | 
Same as  Printf.fprintf, but output onstderr. | 
| eprintf [Format] | 
Same as  fprintfabove, but output onerr_formatter. | 
| epsilon_float [Pervasives] | 
The difference between  1.0and the smallest exactly representable
    floating-point number greater than1.0. | 
| eq_big_int [Big_int] | |
| eq_num [Num] | |
| equal [Uchar] | equal u u'isu = u'. | 
| equal [Targetint] | 
The equal function for target ints.
 | 
| equal [String] | 
The equal function for strings.
 | 
| equal [StringLabels] | 
The equal function for strings.
 | 
| equal [Nativeint] | 
The equal function for native ints.
 | 
| equal [MoreLabels.Set.S] | |
| equal [MoreLabels.Map.S] | |
| equal [Misc.Stdlib.Option] | |
| equal [Misc.Stdlib.List] | 
Returns  trueiff the given lists have the same length and content
        with respect to the given equality function. | 
| equal [Int64] | 
The equal function for int64s.
 | 
| equal [Int32] | 
The equal function for int32s.
 | 
| equal [Hashtbl.SeededHashedType] | 
The equality predicate used to compare keys.
 | 
| equal [Hashtbl.HashedType] | 
The equality predicate used to compare keys.
 | 
| equal [Digest] | 
The equal function for 16-character digest.
 | 
| equal [Map.S] | equal cmp m1 m2tests whether the mapsm1andm2are
       equal, that is, contain equal keys and associate them with
       equal data. | 
| equal [Set.S] | equal s1 s2tests whether the setss1ands2are
       equal, that is, contain equal elements. | 
| equal [Char] | 
The equal function for chars.
 | 
| equal [BytesLabels] | 
The equality function for byte sequences.
 | 
| equal [Bytes] | 
The equality function for byte sequences.
 | 
| erase_rel [CamlinternalFormatBasics] | |
| err_formatter [Format] | 
A formatter to use with formatting functions below for
  output to standard error.
 | 
| error [Location] | |
| error_message [UnixLabels] | 
Return a string describing the given error code.
 | 
| error_message [Unix] | 
Return a string describing the given error code.
 | 
| error_message [Dynlink] | 
Convert an error description to a printable message.
 | 
| error_of_exn [Location] | |
| error_of_extension [Builtin_attributes] | |
| error_of_printer [Location] | |
| error_of_printer_file [Location] | |
| error_reporter [Location] | 
Hook for intercepting error reports.
 | 
| error_size [Clflags] | |
| errorf [Location] | |
| escaped [String] | 
Return a copy of the argument, with special characters
    represented by escape sequences, following the lexical
    conventions of OCaml.
 | 
| escaped [StringLabels] | 
Return a copy of the argument, with special characters
   represented by escape sequences, following the lexical
   conventions of OCaml.
 | 
| escaped [Char] | 
Return a string representing the given character,
    with special characters escaped following the lexical conventions
    of OCaml.
 | 
| escaped [BytesLabels] | 
Return a copy of the argument, with special characters represented
    by escape sequences, following the lexical conventions of OCaml.
 | 
| escaped [Bytes] | 
Return a copy of the argument, with special characters represented
    by escape sequences, following the lexical conventions of OCaml.
 | 
| establish_server [UnixLabels] | 
Establish a server on the given address.
 | 
| establish_server [Unix] | 
Establish a server on the given address.
 | 
| eval [Ast_helper.Str] | |
| exception_ [Ast_helper.Str] | |
| exception_ [Ast_helper.Sig] | |
| exception_ [Ast_helper.Pat] | |
| exec_magic_number [Config] | |
| executable_name [Sys] | 
The name of the file containing the executable currently running.
 | 
| execv [UnixLabels] | execv prog 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. | 
| execv [ThreadUnix] | |
| execve [UnixLabels] | 
Same as  UnixLabels.execv, except that the third argument provides the
   environment to the program executed. | 
| execve [Unix] | 
Same as  Unix.execv, except that the third argument provides the
   environment to the program executed. | 
| execve [ThreadUnix] | |
| execvp [UnixLabels] | 
Same as  UnixLabels.execv, except that
   the program is searched in the path. | 
| execvp [Unix] | 
Same as  Unix.execv, except that
   the program is searched in the path. | 
| execvp [ThreadUnix] | |
| execvpe [UnixLabels] | 
Same as  UnixLabels.execve, except that
   the program is searched in the path. | 
| execvpe [Unix] | 
Same as  Unix.execve, except that
   the program is searched in the path. | 
| exists [MoreLabels.Set.S] | |
| exists [MoreLabels.Map.S] | |
| exists [ListLabels] | exists p [a1; ...; an]checks if at least one element of
   the list satisfies the predicatep. | 
| exists [List] | exists p [a1; ...; an]checks if at least one element of
   the list satisfies the predicatep. | 
| exists [Map.S] | exists p mchecks if at least one binding of the map
        satisfies the predicatep. | 
| exists [Set.S] | exists p schecks if at least one element of
       the set satisfies the predicatep. | 
| exists [ArrayLabels] | Array.exists p [|a1; ...; an|]checks if at least one element of
    the array satisfies the predicatep. | 
| exists [Array] | Array.exists p [|a1; ...; an|]checks if at least one element of
    the array satisfies the predicatep. | 
| exists2 [ListLabels] | 
Same as  List.exists, but for a two-argument predicate. | 
| exists2 [List] | 
Same as  List.exists, but for a two-argument predicate. | 
| exit [Thread] | 
Terminate prematurely the currently executing thread.
 | 
| exit [Pervasives] | 
Terminate the process, returning the given status code
   to the operating system: usually 0 to indicate no errors,
   and a small positive integer to indicate failure.
 | 
| exn_slot_id [Printexc] | Printexc.exn_slot_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 [Pervasives] | 
Exponential.
 | 
| exp [Complex] | 
Exponentiation.
 | 
| expand_directory [Misc] | |
| expand_libname [Ccomp] | |
| explicit_arity [Builtin_attributes] | |
| expm1 [Pervasives] | expm1 xcomputesexp x -. 1.0, giving numerically-accurate results
    even ifxis close to0.0. | 
| expression [Printast] | |
| expression [Pprintast] | |
| expression [Parse] | |
| ext_asm [Config] | |
| ext_dll [Config] | |
| ext_lib [Config] | |
| ext_obj [Config] | |
| 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 [Ast_helper.Cf] | |
| extension [Ast_helper.Cl] | |
| extension [Ast_helper.Ctf] | |
| extension [Ast_helper.Cty] | |
| extension [Ast_helper.Str] | |
| extension [Ast_helper.Sig] | |
| extension [Ast_helper.Mod] | |
| extension [Ast_helper.Mty] | |
| extension [Ast_helper.Exp] | |
| extension [Ast_helper.Pat] | |
| extension [Ast_helper.Typ] | |
| extension_constructor [Obj] | |
| extension_id [Obj] | |
| extension_name [Obj] | |
| extension_of_error [Ast_mapper] | 
Encode an error into an 'ocaml.error' extension node which can be
    inserted in a generated Parsetree.
 | 
| extract [Consistbl] | |
| extract_big_int [Big_int] | extract_big_int bi ofs nreturns a nonnegative number
            corresponding to bitsofstoofs + n - 1of the
            binary representation ofbi. | 
| F | |
| failwith [Pervasives] | 
Raise exception  Failurewith the given string. | 
| fast [Clflags] | |
| fast_sort [ListLabels] | 
Same as  List.sortorList.stable_sort, whichever is
    faster on typical input. | 
| fast_sort [List] | 
Same as  List.sortorList.stable_sort, whichever is faster
    on typical input. | 
| fast_sort [ArrayLabels] | 
Same as  Array.sortorArray.stable_sort, whichever is
    faster on typical input. | 
| fast_sort [Array] | 
Same as  Array.sortorArray.stable_sort, whichever is faster
    on typical input. | 
| fatal_error [Misc] | |
| fatal_errorf [Misc] | |
| fchmod [UnixLabels] | 
Change the permissions of an opened file.
 | 
| fchmod [Unix] | 
Change the permissions of an opened file.
 | 
| fchown [UnixLabels] | 
Change the owner uid and owner gid of an opened file.
 | 
| fchown [Unix] | 
Change the owner uid and owner gid of an opened file.
 | 
| field [Obj] | |
| field [Ast_helper.Type] | |
| field [Ast_helper.Exp] | |
| file [Digest] | 
Return the digest of the file whose name is given.
 | 
| file_exists [Sys] | 
Test if a file with the given name exists.
 | 
| fill [Weak] | Weak.fill ar ofs len elsets toelall pointers ofarfromofstoofs + len - 1. | 
| fill [String] | String.fill s start len cmodifies byte sequencesin place,
   replacinglenbytes withc, starting atstart. | 
| fill [StringLabels] | String.fill s start len cmodifies byte sequencesin place,
   replacinglenbytes byc, starting atstart. | 
| fill [BytesLabels] | fill s start len cmodifiessin place, replacinglencharacters withc, starting atstart. | 
| fill [Bytes] | fill s start len cmodifiessin place, replacinglencharacters withc, starting atstart. | 
| fill [Bigarray.Array3] | 
Fill the given big array with the given value.
 | 
| fill [Bigarray.Array2] | 
Fill the given big array with the given value.
 | 
| fill [Bigarray.Array1] | 
Fill the given big array with the given value.
 | 
| fill [Bigarray.Array0] | 
Fill the given big array with the given value.
 | 
| fill [Bigarray.Genarray] | 
Set all elements of a big array to a given value.
 | 
| fill [ArrayLabels] | Array.fill a ofs len xmodifies the arrayain place,
   storingxin elements numberofstoofs + len - 1. | 
| fill [Array] | Array.fill a ofs len xmodifies the arrayain place,
   storingxin elements numberofstoofs + len - 1. | 
| fill_arc [Graphics] | 
Fill an elliptical pie slice with the current color.
 | 
| fill_circle [Graphics] | 
Fill a circle with the current color.
 | 
| fill_ellipse [Graphics] | 
Fill an ellipse with the current color.
 | 
| fill_poly [Graphics] | 
Fill the given polygon with the current color.
 | 
| fill_rect [Graphics] | fill_rect x y w hfills the rectangle with lower left corner
   atx,y, widthwand heighth, with the current color. | 
| filter [MoreLabels.Set.S] | |
| filter [MoreLabels.Map.S] | |
| filter [ListLabels] | filter p lreturns all the elements of the listlthat satisfy the predicatep. | 
| filter [List] | filter p lreturns all the elements of the listlthat satisfy the predicatep. | 
| filter [Map.S] | filter p mreturns the map with all the bindings inmthat satisfy predicatep. | 
| filter [Set.S] | filter p sreturns the set of all elements insthat satisfy predicatep. | 
| filter [Consistbl] | |
| filter_map [Misc.Stdlib.List] | filter_map f lappliesfto every element ofl, filters
        out theNoneelements and returns the list of the arguments of
        theSomeelements. | 
| filter_map [Identifiable.S.Map] | |
| filter_map_inplace [MoreLabels.Hashtbl.SeededS] | |
| filter_map_inplace [MoreLabels.Hashtbl.S] | |
| filter_map_inplace [MoreLabels.Hashtbl] | |
| filter_map_inplace [Hashtbl.SeededS] | |
| filter_map_inplace [Hashtbl.S] | |
| filter_map_inplace [Hashtbl] | Hashtbl.filter_map_inplace f tblappliesfto all bindings in
    tabletbland update each binding depending on the result off. | 
| 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 [Tbl] | |
| find [MoreLabels.Set.S] | |
| find [MoreLabels.Map.S] | |
| find [MoreLabels.Hashtbl.SeededS] | |
| find [MoreLabels.Hashtbl.S] | |
| find [MoreLabels.Hashtbl] | |
| find [ListLabels] | find p lreturns the first element of the listlthat satisfies the predicatep. | 
| find [List] | find p lreturns the first element of the listlthat satisfies the predicatep. | 
| find [Hashtbl.SeededS] | |
| find [Hashtbl.S] | |
| find [Hashtbl] | Hashtbl.find tbl xreturns the current binding ofxintbl,
   or raisesNot_foundif no such binding exists. | 
| find [Map.S] | find x mreturns the current binding ofxinm,
       or raisesNot_foundif no such binding exists. | 
| find [Set.S] | find x sreturns the element ofsequal tox(according
        toOrd.compare), or raiseNot_foundif no such element
        exists. | 
| 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] | |
| find_all [ListLabels] | find_allis another name forList.filter. | 
| find_all [List] | find_allis another name forList.filter. | 
| find_all [Hashtbl.SeededS] | |
| find_all [Hashtbl.S] | |
| find_all [Hashtbl] | Hashtbl.find_all tbl xreturns the list of all data
   associated withxintbl. | 
| find_first [MoreLabels.Set.S] | |
| find_first [MoreLabels.Map.S] | |
| 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 [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_opt [MoreLabels.Set.S] | |
| find_first_opt [MoreLabels.Map.S] | |
| 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_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_in_path [Misc] | |
| find_in_path_rel [Misc] | |
| find_in_path_uncap [Misc] | |
| find_last [MoreLabels.Set.S] | |
| find_last [MoreLabels.Map.S] | |
| find_last [Map.S] | find_last 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 [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_opt [MoreLabels.Set.S] | |
| find_last_opt [MoreLabels.Map.S] | |
| 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_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_opt [Weak.S] | find_opt t xreturns an instance ofxfound intorNoneif there is no such element. | 
| find_opt [MoreLabels.Set.S] | |
| find_opt [MoreLabels.Map.S] | |
| find_opt [MoreLabels.Hashtbl.SeededS] | |
| find_opt [MoreLabels.Hashtbl.S] | |
| find_opt [MoreLabels.Hashtbl] | |
| find_opt [ListLabels] | find p lreturns the first element of the listlthat satisfies the predicatep. | 
| find_opt [List] | find_opt p lreturns the first element of the listlthat
    satisfies the predicatep, orNoneif there is no value that
    satisfiespin the listl. | 
| 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 [Map.S] | find_opt x mreturnsSome vif the current binding ofxinmisv, orNoneif no such binding exists. | 
| find_opt [Set.S] | find_opt x sreturns the element ofsequal tox(according
        toOrd.compare), orNoneif no such element
        exists. | 
| first_chars [Str] | first_chars s nreturns the firstncharacters ofs. | 
| first_non_constant_constructor_tag [Obj] | |
| flambda [Config] | |
| flambda_invariant_checks [Clflags] | |
| flatten [Longident] | |
| flatten [ListLabels] | 
Same as  concat. | 
| flatten [List] | 
An alias for  concat. | 
| flexdll_dirs [Config] | |
| float [Random.State] | |
| float [Random] | Random.float boundreturns a random floating-point number
   between 0 andbound(inclusive). | 
| float [Pervasives] | 
Same as  float_of_int. | 
| float [Ast_helper.Const] | |
| float32 [Bigarray] | 
See  Bigarray.char. | 
| float64 [Bigarray] | 
See  Bigarray.char. | 
| float_const_prop [Clflags] | |
| float_of_big_int [Big_int] | 
Returns a floating-point number approximating the
           given big integer.
 | 
| float_of_bits [Int64] | 
Return the floating-point number whose internal representation,
   according to the IEEE 754 floating-point 'double format' bit layout,
   is the given  int64. | 
| float_of_bits [Int32] | 
Return the floating-point number whose internal representation,
   according to the IEEE 754 floating-point 'single format' bit layout,
   is the given  int32. | 
| float_of_int [Pervasives] | 
Convert an integer to floating-point.
 | 
| float_of_num [Num] | |
| float_of_string [Pervasives] | 
Convert the given string to a float.
 | 
| float_of_string_opt [Pervasives] | 
Same as  float_of_string, but returnsNoneinstead of raising. | 
| floor [Pervasives] | 
Round below to an integer value.
 | 
| floor_num [Num] | floor_num nreturns the largest integer smaller or equal ton. | 
| flush [Pervasives] | 
Flush the buffer associated with the given output channel,
   performing all pending writes on that channel.
 | 
| flush_all [Pervasives] | 
Flush all open output channels; ignore errors.
 | 
| flush_input [Lexing] | 
Discard the contents of the buffer and reset the current
    position to 0.
 | 
| flush_str_formatter [Format] | 
Returns the material printed with  str_formatter, flushes
  the formatter and resets the corresponding buffer. | 
| fmt_ebb_of_string [CamlinternalFormat] | |
| fold [Weak.S] | fold f t initcomputes(f d1 (... (f dN init)))whered1 ... dNare the elements oftin some unspecified order. | 
| fold [Tbl] | |
| 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 [Queue] | fold f accu qis equivalent toList.fold_left f accu l,
   wherelis the list ofq's elements. | 
| fold [MoreLabels.Set.S] | |
| fold [MoreLabels.Map.S] | |
| fold [MoreLabels.Hashtbl.SeededS] | |
| fold [MoreLabels.Hashtbl.S] | |
| fold [MoreLabels.Hashtbl] | |
| fold [Misc.Stdlib.Option] | |
| fold [Hashtbl.SeededS] | |
| fold [Hashtbl.S] | |
| fold [Hashtbl] | 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 acomputes(f kN dN ... (f k1 d1 a)...),
       wherek1 ... kNare the keys of all bindings inm(in increasing order), andd1 ... dNare the associated data. | 
| fold [Set.S] | fold f s acomputes(f xN ... (f x2 (f x1 a))...),
       wherex1 ... xNare the elements ofs, in increasing order. | 
| fold_left [ListLabels] | List.fold_left f a [b1; ...; bn]isf (... (f (f a b1) b2) ...) bn. | 
| fold_left [List] | List.fold_left f a [b1; ...; bn]isf (... (f (f a b1) b2) ...) bn. | 
| fold_left [ArrayLabels] | Array.fold_left f x acomputesf (... (f (f x a.(0)) a.(1)) ...) a.(n-1),
   wherenis the length of the arraya. | 
| fold_left [Array] | Array.fold_left f x acomputesf (... (f (f x a.(0)) a.(1)) ...) a.(n-1),
   wherenis the length of the arraya. | 
| fold_left2 [ListLabels] | List.fold_left2 f a [b1; ...; bn] [c1; ...; cn]isf (... (f (f a b1 c1) b2 c2) ...) bn cn. | 
| fold_left2 [List] | List.fold_left2 f a [b1; ...; bn] [c1; ...; cn]isf (... (f (f a b1 c1) b2 c2) ...) bn cn. | 
| fold_right [ListLabels] | List.fold_right f [a1; ...; an] bisf a1 (f a2 (... (f an b) ...)). | 
| fold_right [List] | List.fold_right f [a1; ...; an] bisf a1 (f a2 (... (f an b) ...)). | 
| fold_right [ArrayLabels] | Array.fold_right f a xcomputesf a.(0) (f a.(1) ( ... (f a.(n-1) x) ...)),
   wherenis the length of the arraya. | 
| fold_right [Array] | Array.fold_right f a xcomputesf a.(0) (f a.(1) ( ... (f a.(n-1) x) ...)),
   wherenis the length of the arraya. | 
| fold_right2 [ListLabels] | List.fold_right2 f [a1; ...; an] [b1; ...; bn] cisf a1 b1 (f a2 b2 (... (f an bn c) ...)). | 
| fold_right2 [List] | List.fold_right2 f [a1; ...; an] [b1; ...; bn] cisf a1 b1 (f a2 b2 (... (f an bn c) ...)). | 
| for4 [Misc] | |
| for_ [Ast_helper.Exp] | |
| for_all [MoreLabels.Set.S] | |
| for_all [MoreLabels.Map.S] | |
| for_all [ListLabels] | for_all p [a1; ...; an]checks if all elements of the list
   satisfy the predicatep. | 
| for_all [List] | for_all p [a1; ...; an]checks if all elements of the list
   satisfy the predicatep. | 
| for_all [Map.S] | for_all p mchecks if all the bindings of the map
        satisfy the predicatep. | 
| for_all [Set.S] | for_all p schecks if all elements of the set
       satisfy the predicatep. | 
| for_all [ArrayLabels] | Array.for_all p [|a1; ...; an|]checks if all elements of the array
   satisfy the predicatep. | 
| for_all [Array] | Array.for_all p [|a1; ...; an|]checks if all elements of the array
   satisfy the predicatep. | 
| for_all2 [Misc] | |
| for_all2 [ListLabels] | 
Same as  List.for_all, but for a two-argument predicate. | 
| for_all2 [List] | 
Same as  List.for_all, but for a two-argument predicate. | 
| for_package [Clflags] | |
| force [Lazy] | force xforces the suspensionxand returns its result. | 
| force [CamlinternalLazy] | |
| force_lazy_block [CamlinternalLazy] | |
| force_newline [Format] | 
Forces a new line in the current box.
 | 
| force_poly [Ast_helper.Typ] | |
| force_slash [Clflags] | |
| force_val [Lazy] | force_val xforces the suspensionxand returns its
    result. | 
| force_val [CamlinternalLazy] | |
| force_val_lazy_block [CamlinternalLazy] | |
| foreground [Graphics] | 
Default background and foreground colors (usually, either black
   foreground on a white background or white foreground on a
   black background).
 | 
| fork [UnixLabels] | 
Fork a new process.
 | 
| fork [Unix] | 
Fork a new process.
 | 
| format [Printexc.Slot] | format pos 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 [Pervasives] | format_of_string sreturns a format string read from the string
    literals. | 
| format_of_string_fmtty [CamlinternalFormat] | |
| format_of_string_format [CamlinternalFormat] | |
| formatter_for_warnings [Location] | |
| 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 that
  writes to the corresponding channeloc. | 
| 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] | |
| free_structure_names [Depend] | |
| freeze_char_set [CamlinternalFormat] | |
| frexp [Pervasives] | 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] | Scanning.from_channel icreturns aScanf.Scanning.in_channelformatted
    input channel which reads from the regularin_channelinput
    channelicargument. | 
| 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] | 
An alias for  Scanf.Scanning.open_inabove. | 
| from_file_bin [Scanf.Scanning] | 
An alias for  Scanf.Scanning.open_in_binabove. | 
| 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] | Scanning.from_string sreturns aScanf.Scanning.in_channelformatted
    input channel which reads from the given string. | 
| 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 vreturns an already-forced suspension ofv. | 
| fscanf [Scanf] | |
| fst [Pervasives] | 
Return the first component of a pair.
 | 
| fst3 [Misc] | |
| fst4 [Misc] | |
| fstat [UnixLabels.LargeFile] | |
| fstat [UnixLabels] | 
Return the information for the file associated with the given
   descriptor.
 | 
| fstat [Unix.LargeFile] | |
| fstat [Unix] | 
Return the information for the file associated with the given
   descriptor.
 | 
| ftruncate [UnixLabels.LargeFile] | |
| ftruncate [UnixLabels] | 
Truncates the file corresponding to the given descriptor
   to the given size.
 | 
| ftruncate [Unix.LargeFile] | 
See  Unix.ftruncate. | 
| ftruncate [Unix] | 
Truncates the file corresponding to the given descriptor
   to the given size.
 | 
| full_init [Random] | 
Same as  Random.initbut takes more data as seed. | 
| full_major [Gc] | 
Do a minor collection, finish the current major collection cycle,
   and perform a complete new cycle.
 | 
| full_split [Str] | 
Same as  Str.split_delim, but returns
   the delimiters as well as the substrings contained between
   delimiters. | 
| fun_ [Ast_helper.Cl] | |
| fun_ [Ast_helper.Exp] | |
| function_ [Ast_helper.Exp] | |
| functor_ [Ast_helper.Mod] | |
| functor_ [Ast_helper.Mty] | |
| G | |
| gcd_big_int [Big_int] | 
Greatest common divisor of two big integers.
 | 
| ge_big_int [Big_int] | |
| ge_num [Num] | |
| genarray_of_array0 [Bigarray] | 
Return the generic big array corresponding to the given zero-dimensional
   big array.
 | 
| genarray_of_array1 [Bigarray] | 
Return the generic big array corresponding to the given one-dimensional
   big array.
 | 
| genarray_of_array2 [Bigarray] | 
Return the generic big array corresponding to the given two-dimensional
   big array.
 | 
| genarray_of_array3 [Bigarray] | 
Return the generic big array corresponding to the given three-dimensional
   big array.
 | 
| get [Weak] | Weak.get ar nreturns None if thenth cell ofaris
   empty,Some x(wherexis the value) if it is full. | 
| get [Timings] | 
returns the runtime in seconds of a completed pass
 | 
| get [String] | String.get s nreturns the character at indexnin strings. | 
| get [StringLabels] | String.get s nreturns the character at indexnin strings. | 
| get [Misc.LongString] | |
| get [Gc] | 
Return the current values of the GC parameters in a  controlrecord. | 
| get [Clflags.Float_arg_helper] | |
| get [Clflags.Int_arg_helper] | |
| 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 big array.
 | 
| get [ArrayLabels] | Array.get a nreturns the element numbernof arraya. | 
| get [Array] | Array.get a nreturns the element numbernof arraya. | 
| get [Arg_helper.Make] | |
| get_all_formatter_output_functions [Format] | |
| get_approx_printing [Arith_status] | |
| 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_cookie [Ast_mapper] | |
| 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  Ephemeron.K1.get_data | 
| get_data [Ephemeron.Kn] | 
Same as  Ephemeron.K1.get_data | 
| get_data [Ephemeron.K2] | 
Same as  Ephemeron.K1.get_data | 
| get_data [Ephemeron.K1] | Ephemeron.K1.get_data ephreturnsNoneif the data ofephis
      empty,Some x(wherexis the data) if it is full. | 
| get_data_copy [Obj.Ephemeron] | 
Same as  Ephemeron.K1.get_data_copy | 
| get_data_copy [Ephemeron.Kn] | 
Same as  Ephemeron.K1.get_data_copy | 
| get_data_copy [Ephemeron.K2] | 
Same as  Ephemeron.K1.get_data_copy | 
| get_data_copy [Ephemeron.K1] | Ephemeron.K1.get_data_copy 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_when_null_denominator [Arith_status] | |
| get_floating_precision [Arith_status] | |
| get_formatter_out_functions [Format] | 
Return the current output functions of the pretty-printer,
  including line splitting and indentation functions.
 | 
| get_formatter_output_functions [Format] | 
Return the current output functions of the pretty-printer.
 | 
| get_formatter_tag_functions [Format] | 
Return the current tag functions of the pretty-printer.
 | 
| get_image [Graphics] | 
Capture the contents of a rectangle on the screen as an image.
 | 
| get_key [Obj.Ephemeron] | 
Same as  Ephemeron.K1.get_key | 
| get_key [Ephemeron.Kn] | 
Same as  Ephemeron.K1.get_key | 
| get_key [Ephemeron.K1] | Ephemeron.K1.get_key ephreturnsNoneif the key ofephis
      empty,Some x(wherexis the key) if it is full. | 
| get_key1 [Ephemeron.K2] | 
Same as  Ephemeron.K1.get_key | 
| get_key1_copy [Ephemeron.K2] | 
Same as  Ephemeron.K1.get_key_copy | 
| get_key2 [Ephemeron.K2] | 
Same as  Ephemeron.K1.get_key | 
| get_key2_copy [Ephemeron.K2] | 
Same as  Ephemeron.K1.get_key_copy | 
| get_key_copy [Obj.Ephemeron] | 
Same as  Ephemeron.K1.get_key_copy | 
| get_key_copy [Ephemeron.Kn] | 
Same as  Ephemeron.K1.get_key_copy | 
| get_key_copy [Ephemeron.K1] | Ephemeron.K1.get_key_copy 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 tags marking.
 | 
| get_max_boxes [Format] | 
Returns the maximum number of boxes allowed before ellipsis.
 | 
| get_max_indent [Format] | 
Return the maximum indentation limit (in characters).
 | 
| get_method [CamlinternalOO] | |
| get_method_label [CamlinternalOO] | |
| get_method_labels [CamlinternalOO] | |
| get_minor_free [Gc] | 
Return the current size of the free space inside the minor heap.
 | 
| get_no_payload_attribute [Attr_helper] | 
The  string listargument of the following functions is a list of
    alternative names for the attribute we are looking for. | 
| get_normalize_ratio [Arith_status] | |
| get_normalize_ratio_when_printing [Arith_status] | |
| get_pos_info [Location] | |
| get_print_tags [Format] | 
Return the current status of tags printing.
 | 
| get_public_method [CamlinternalOO] | |
| get_raw_backtrace [Printexc] | Printexc.get_raw_backtrace ()returns the same exception
    backtrace 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_ref [Misc] | |
| get_state [Random] | 
Return the current state of the generator used by the basic functions.
 | 
| get_styles [Misc.Color] | |
| get_temp_dir_name [Filename] | 
The name of the temporary directory:
    Under Unix, the value of the  TMPDIRenvironment variable, or "/tmp"
    if the variable is not set. | 
| get_variable [CamlinternalOO] | |
| get_variables [CamlinternalOO] | |
| getaddrinfo [UnixLabels] | getaddrinfo host service optsreturns a list ofUnix.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.
 | 
| 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, or raiseNot_found. | 
| getgrgid [Unix] | 
Find an entry in  groupwith the given group id. | 
| getgrnam [UnixLabels] | 
Find an entry in  groupwith the given name, or raiseNot_found. | 
| 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, or raiseNot_found. | 
| gethostbyaddr [Unix] | 
Find an entry in  hostswith the given address. | 
| gethostbyname [UnixLabels] | 
Find an entry in  hostswith the given name, or raiseNot_found. | 
| 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, or raiseNot_found. | 
| getprotobyname [Unix] | 
Find an entry in  protocolswith the given name. | 
| getprotobynumber [UnixLabels] | 
Find an entry in  protocolswith the given protocol number,
   or raiseNot_found. | 
| getprotobynumber [Unix] | 
Find an entry in  protocolswith the given protocol number. | 
| getpwnam [UnixLabels] | 
Find an entry in  passwdwith the given name, or raiseNot_found. | 
| getpwnam [Unix] | 
Find an entry in  passwdwith the given name. | 
| getpwuid [UnixLabels] | 
Find an entry in  passwdwith the given user id, or raiseNot_found. | 
| getpwuid [Unix] | 
Find an entry in  passwdwith the given user id. | 
| getservbyname [UnixLabels] | 
Find an entry in  serviceswith the given name, or raiseNot_found. | 
| getservbyname [Unix] | 
Find an entry in  serviceswith the given name. | 
| getservbyport [UnixLabels] | 
Find an entry in  serviceswith the given service number,
   or raiseNot_found. | 
| 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] | 
Same as  Unix.getsockoptfor a socket option whose value is a
    floating-point number. | 
| getsockopt_float [Unix] | 
Same as  Unix.getsockoptfor a socket option whose value is a
   floating-point number. | 
| getsockopt_int [UnixLabels] | 
Same as  Unix.getsockoptfor an integer-valued socket option. | 
| getsockopt_int [Unix] | 
Same as  Unix.getsockoptfor an integer-valued socket option. | 
| getsockopt_optint [UnixLabels] | 
Same as  Unix.getsockoptfor a socket option whose value is
    anint option. | 
| getsockopt_optint [Unix] | 
Same as  Unix.getsockoptfor a socket option whose value is anint option. | 
| gettimeofday [UnixLabels] | 
Same as  UnixLabels.time, but with resolution better than 1 second. | 
| gettimeofday [Unix] | 
Same as  Unix.time, but with resolution better than 1 second. | 
| getuid [UnixLabels] | 
Return the user id of the user executing the process.
 | 
| getuid [Unix] | 
Return the user id of the user executing the process.
 | 
| global_replace [Str] | global_replace regexp templ 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. | 
| gprofile [Clflags] | |
| green [Graphics] | |
| 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). | 
| gt_big_int [Big_int] | 
Usual boolean comparisons between two big integers.
 | 
| gt_num [Num] | |
| guard [Event] | guard fnreturns the event that, when synchronized, computesfn()and behaves as the resulting event. | 
| H | |
| handle_docstrings [Lexer] | |
| 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_boxed [Builtin_attributes] | |
| has_no_payload_attribute [Attr_helper] | |
| 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. | 
| has_unboxed [Builtin_attributes] | |
| hash [Uchar] | hash uassociates a non-negative integer tou. | 
| hash [MoreLabels.Hashtbl] | |
| 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_param [MoreLabels.Hashtbl] | |
| 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.
 | 
| help_warnings [Warnings] | |
| highlight_locations [Location] | |
| host [Config] | |
| huge_fallback_count [Gc] | 
Return the number of times we tried to map huge pages and had to fall
    back to small pages.
 | 
| hypot [Pervasives] | hypot x 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] | 
The complex number  i. | 
| id [Thread] | 
Return the identifier of the given thread.
 | 
| id [Oo] | 
Return an integer identifying this object, unique for
    the current execution of the program.
 | 
| ident [Ast_helper.Mod] | |
| ident [Ast_helper.Mty] | |
| ident [Ast_helper.Exp] | |
| ifprintf [Printf] | 
Same as  Printf.fprintf, but does not print anything. | 
| ifprintf [Format] | 
Same as  fprintfabove, but does not print anything. | 
| ifthenelse [Ast_helper.Exp] | |
| ignore [Pervasives] | 
Discard the value of its argument and return  (). | 
| ikfprintf [Printf] | 
Same as  kfprintfabove, but does not print anything. | 
| ikfprintf [Format] | 
Same as  kfprintfabove, but does not print anything. | 
| ill_formed_ast [Syntaxerr] | |
| immediate [Builtin_attributes] | |
| implementation [Printast] | |
| implementation [Parser] | |
| implementation [Parse] | |
| in_channel_length [Pervasives.LargeFile] | |
| in_channel_length [Pervasives] | 
Return the size (number of characters) of the regular file
    on which the given channel is opened.
 | 
| in_channel_of_descr [UnixLabels] | 
Create an input channel reading from the given descriptor.
 | 
| in_channel_of_descr [Unix] | 
Create an input channel reading from the given descriptor.
 | 
| in_comment [Lexer] | |
| in_file [Location] | 
Return an empty ghost range located in a given file.
 | 
| in_string [Lexer] | |
| include_ [Ast_helper.Str] | |
| include_ [Ast_helper.Sig] | |
| include_dirs [Clflags] | |
| incr [Pervasives] | 
Increment the integer contained in the given reference.
 | 
| incr_num [Num] | incr risr:=!r+1, whereris a reference to a number. | 
| index [String] | String.index s creturns the index of the first
   occurrence of charactercin strings. | 
| index [StringLabels] | String.index s creturns the index of the first
   occurrence of charactercin strings. | 
| 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] | String.index_from s i creturns the index of the
   first occurrence of charactercin stringsafter positioni. | 
| index_from [StringLabels] | String.index_from s i creturns the index of the
   first occurrence of charactercin stringsafter 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] | String.index_from_opt s i creturns the index of the
    first occurrence of charactercin stringsafter positioniorNoneifcdoes not occur insafter positioni. | 
| index_from_opt [StringLabels] | String.index_from_opt s i creturns the index of the
    first occurrence of charactercin stringsafter positioniorNoneifcdoes not occur insafter positioni. | 
| index_from_opt [BytesLabels] | index_from _opts i creturns the index of the first occurrence of
    bytecinsafter positioniorNoneifcdoes not occur insafter positioni. | 
| index_from_opt [Bytes] | index_from _opts i creturns the index of the first occurrence of
    bytecinsafter positioniorNoneifcdoes not occur insafter positioni. | 
| index_opt [String] | String.index_opt s creturns the index of the first
    occurrence of charactercin strings, orNoneifcdoes not occur ins. | 
| index_opt [StringLabels] | String.index_opt s creturns the index of the first
    occurrence of charactercin strings, orNoneifcdoes not occur ins. | 
| 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 [Pervasives] | 
Positive infinity.
 | 
| infix_tag [Obj] | |
| info_attr [Docstrings] | |
| inherit_ [Ast_helper.Cf] | |
| inherit_ [Ast_helper.Ctf] | |
| inherits [CamlinternalOO] | |
| init [String] | String.init n freturns a string of lengthn, with characteriinitialized to the result off i(called in increasing
    index order). | 
| init [StringLabels] | init n freturns a string of lengthn,
    with characteriinitialized to the result off i. | 
| init [Random] | 
Initialize the generator, using the argument as a seed.
 | 
| init [Location] | 
Set the file name and line number of the  lexbufto be the start
    of the named file. | 
| init [Lexer] | |
| init [Dynlink] | |
| init [Docstrings] | 
(Re)Initialise all docstring state
 | 
| init [BytesLabels] | init n freturns a fresh byte sequence of lengthn,
    with characteriinitialized to the result off i. | 
| init [Bytes] | Bytes.init n freturns a fresh byte sequence of lengthn, with
    characteriinitialized to the result off i(in increasing
    index order). | 
| init [ArrayLabels] | Array.init n freturns a fresh array of lengthn,
   with element numberiinitialized to the result off i. | 
| init [Array] | Array.init n freturns a fresh array of lengthn,
   with element numberiinitialized to the result off i. | 
| init_class [CamlinternalOO] | |
| init_file [Clflags] | |
| 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. | 
| initializer_ [Ast_helper.Cf] | |
| inline_alloc_cost [Clflags] | |
| inline_branch_cost [Clflags] | |
| inline_branch_factor [Clflags] | |
| inline_call_cost [Clflags] | |
| inline_indirect_cost [Clflags] | |
| inline_lifting_benefit [Clflags] | |
| inline_max_depth [Clflags] | |
| inline_max_unroll [Clflags] | |
| inline_prim_cost [Clflags] | |
| inline_threshold [Clflags] | |
| inline_toplevel_threshold [Clflags] | |
| inlining_report [Clflags] | |
| input [Pervasives] | input ic buf pos 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_binary_int [Pervasives] | 
Read an integer encoded in binary format (4 bytes, big-endian)
   from the given input channel.
 | 
| input_byte [Pervasives] | 
Same as  input_char, but return the 8-bit integer representing
   the character. | 
| input_bytes [Misc.LongString] | |
| input_char [Pervasives] | 
Read one character from the given input channel.
 | 
| input_lexbuf [Location] | |
| input_line [Pervasives] | 
Read characters from the given input channel, until a
   newline character is encountered.
 | 
| input_name [Location] | |
| input_value [Pervasives] | 
Read the representation of a structured value, as produced
   by  output_value, and return the corresponding value. | 
| int [Random.State] | |
| int [Random] | Random.int boundreturns a random integer between 0 (inclusive)
     andbound(exclusive). | 
| int [Misc.Int_literal_converter] | |
| int [Bigarray] | 
See  Bigarray.char. | 
| int [Ast_helper.Const] | |
| int16_signed [Bigarray] | 
See  Bigarray.char. | 
| int16_unsigned [Bigarray] | 
See  Bigarray.char. | 
| int32 [Random.State] | |
| int32 [Random] | Random.int32 boundreturns a random integer between 0 (inclusive)
     andbound(exclusive). | 
| int32 [Misc.Int_literal_converter] | |
| int32 [Bigarray] | 
See  Bigarray.char. | 
| int32 [Ast_helper.Const] | |
| int32_of_big_int [Big_int] | 
Convert a big integer to a 32-bit integer.
 | 
| int32_of_big_int_opt [Big_int] | 
Convert a big integer to a 32-bit integer.
 | 
| int64 [Random.State] | |
| int64 [Random] | Random.int64 boundreturns a random integer between 0 (inclusive)
     andbound(exclusive). | 
| int64 [Misc.Int_literal_converter] | |
| int64 [Bigarray] | 
See  Bigarray.char. | 
| int64 [Ast_helper.Const] | |
| int64_of_big_int [Big_int] | 
Convert a big integer to a 64-bit integer.
 | 
| int64_of_big_int_opt [Big_int] | 
Convert a big integer to a 64-bit integer.
 | 
| int8_signed [Bigarray] | 
See  Bigarray.char. | 
| int8_unsigned [Bigarray] | 
See  Bigarray.char. | 
| int_of_big_int [Big_int] | 
Convert a big integer to a small integer (type  int). | 
| int_of_big_int_opt [Big_int] | 
Convert a big integer to a small integer (type  int). | 
| int_of_char [Pervasives] | 
Return the ASCII code of the argument.
 | 
| int_of_float [Pervasives] | 
Truncate the given floating-point number to an integer.
 | 
| int_of_num [Num] | |
| int_of_num_opt [Num] | |
| int_of_string [Pervasives] | 
Convert the given string to an integer.
 | 
| int_of_string_opt [Pervasives] | 
Same as  int_of_string, but retursNoneinstead of raising. | 
| int_size [Sys] | 
Size of an int.
 | 
| int_tag [Obj] | |
| integer [Ast_helper.Const] | |
| integer_num [Num] | integer_num nreturns the integer closest ton. | 
| inter [MoreLabels.Set.S] | |
| inter [Set.S] | 
Set intersection.
 | 
| interactive [Sys] | 
This reference is initially set to  falsein standalone
   programs and totrueif the code is being executed under
   the interactive toplevel systemocaml. | 
| interface [Printast] | |
| interface [Parser] | |
| interface [Parse] | |
| interface_suffix [Config] | |
| interval [Ast_helper.Pat] | |
| inv [Complex] | 
Multiplicative inverse ( 1/z). | 
| invalid_arg [Pervasives] | 
Raise exception  Invalid_argumentwith the given string. | 
| is_active [Warnings] | |
| is_block [Obj] | |
| is_char [Uchar] | is_char uistrueiffuis 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 [Queue] | 
Return  trueif the given queue is empty,falseotherwise. | 
| is_empty [MoreLabels.Set.S] | |
| is_empty [MoreLabels.Map.S] | |
| is_empty [Map.S] | 
Test whether a map is empty or not.
 | 
| is_empty [Set.S] | 
Test whether a set is empty or not.
 | 
| is_error [Warnings] | |
| is_implicit [Filename] | 
Return  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_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_int_big_int [Big_int] | 
Test whether the given big integer is small enough to
           be representable as a small integer (type  int)
           without loss of precision. | 
| is_integer_num [Num] | 
Test if a number is an integer
 | 
| is_native [Dynlink] | trueif the program is native,falseif the program is bytecode. | 
| 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] | |
| is_randomized [Hashtbl] | 
return if the tables are currently created in randomized mode by default
 | 
| is_relative [Filename] | 
Return  trueif the file name is relative to the current
   directory,falseif it is absolute (i.e. | 
| is_val [Lazy] | is_val xreturnstrueifxhas already been forced and
    did not raise an exception. | 
| is_valid [Uchar] | is_valid nistrueiffnis an Unicode scalar value
    (i.e. | 
| 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 [Tbl] | |
| iter [String] | 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] | String.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 [Queue] | iter f qappliesfin turn to all elements ofq,
   from the least recently entered to the most recently entered. | 
| iter [MoreLabels.Set.S] | |
| iter [MoreLabels.Map.S] | |
| iter [MoreLabels.Hashtbl.SeededS] | |
| iter [MoreLabels.Hashtbl.S] | |
| iter [MoreLabels.Hashtbl] | |
| iter [Misc.Stdlib.Option] | |
| iter [ListLabels] | List.iter f [a1; ...; an]applies functionfin turn toa1; ...; an. | 
| iter [List] | 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 [Map.S] | iter f mappliesfto all bindings in mapm. | 
| iter [Set.S] | iter f sappliesfin turn to all elements ofs. | 
| 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] | Array.iter f aapplies functionfin turn to all
   the elements ofa. | 
| iter [Array] | Array.iter f aapplies functionfin turn to all
   the elements ofa. | 
| iter2 [ListLabels] | List.iter2 f [a1; ...; an] [b1; ...; bn]calls in turnf a1 b1; ...; f an bn. | 
| iter2 [List] | List.iter2 f [a1; ...; an] [b1; ...; bn]calls in turnf a1 b1; ...; f an bn. | 
| iter2 [ArrayLabels] | Array.iter2 f a bapplies functionfto all the elements ofaandb. | 
| iter2 [Array] | Array.iter2 f a bapplies functionfto all the elements ofaandb. | 
| iteri [String] | 
Same as  String.iter, but the
   function is applied to the index of the element as first argument
   (counting from 0), and the character itself as second argument. | 
| iteri [StringLabels] | 
Same as  String.iter, but the
   function is applied to the index of the element as first argument
   (counting from 0), and the character itself as second argument. | 
| iteri [ListLabels] | 
Same as  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 [List] | 
Same as  List.iter, but the function is applied to the index of
   the element as first argument (counting from 0), and the element
   itself as second argument. | 
| iteri [BytesLabels] | 
Same as  Bytes.iter, but the function is applied to the index of
    the byte as first argument and the byte itself as second
    argument. | 
| iteri [Bytes] | 
Same as  Bytes.iter, but the function is applied to the index of
    the byte as first argument and the byte itself as second
    argument. | 
| iteri [ArrayLabels] | 
Same as  Array.iter, but the
   function is applied to the index of the element as first argument,
   and the element itself as second argument. | 
| iteri [Array] | 
Same as  Array.iter, but the
   function is applied with the index of the element as first argument,
   and the element itself as second argument. | 
| J | |
| join [Thread] | join thsuspends the execution of the calling thread
   until the threadthhas terminated. | 
| 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. | 
| keep_asm_file [Clflags] | |
| keep_docs [Clflags] | |
| keep_locs [Clflags] | |
| keep_startup_file [Clflags] | |
| key_pressed [Graphics] | 
Return  trueif a keypress is available; that is, ifread_keywould not block. | 
| keys [Identifiable.S.Map] | |
| kfprintf [Printf] | 
Same as  fprintf, but instead of returning immediately,
   passes the out channel to its first argument at the end of printing. | 
| kfprintf [Format] | 
Same as  fprintfabove, but instead of returning immediately,
  passes the formatter to its first argument at the end of printing. | 
| kfscanf [Scanf] | |
| kill [UnixLabels] | kill pid sigsends signal numbersigto the process
   with idpid. | 
| kill [Unix] | kill pid sigsends signal numbersigto the process
   with idpid. | 
| kill [Thread] | 
Terminate prematurely the thread whose handle is given.
 | 
| kind [Bigarray.Array3] | 
Return the kind of the given big array.
 | 
| kind [Bigarray.Array2] | 
Return the kind of the given big array.
 | 
| kind [Bigarray.Array1] | 
Return the kind of the given big array.
 | 
| kind [Bigarray.Array0] | 
Return the kind of the given big array.
 | 
| kind [Bigarray.Genarray] | 
Return the kind of the given big array.
 | 
| kind_size_in_bytes [Bigarray] | 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] | 
Same as  Scanf.kscanfbut reads from the given string. | 
| L | |
| last [Longident] | |
| 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 big array.
 | 
| layout [Bigarray.Array2] | 
Return the layout of the given big array.
 | 
| layout [Bigarray.Array1] | 
Return the layout of the given big array.
 | 
| layout [Bigarray.Array0] | 
Return the layout of the given big array.
 | 
| layout [Bigarray.Genarray] | 
Return the layout of the given big array.
 | 
| lazy_ [Ast_helper.Exp] | |
| lazy_ [Ast_helper.Pat] | |
| lazy_from_fun [Lazy] | |
| lazy_from_val [Lazy] | |
| lazy_is_val [Lazy] | |
| lazy_tag [Obj] | |
| lazy_tag [Config] | |
| ldexp [Pervasives] | ldexp x nreturnsx *. 2 ** n. | 
| le_big_int [Big_int] | |
| le_num [Num] | |
| length [Weak] | Weak.length arreturns the length (number of elements) ofar. | 
| length [String] | 
Return the length (number of characters) of the given string.
 | 
| length [StringLabels] | 
Return the length (number of characters) of the given string.
 | 
| length [Stack] | 
Return the number of elements in a stack.
 | 
| length [Queue] | 
Return the number of elements in a queue.
 | 
| length [Obj.Ephemeron] | 
return the number of keys
 | 
| length [MoreLabels.Hashtbl.SeededS] | |
| length [MoreLabels.Hashtbl.S] | |
| length [MoreLabels.Hashtbl] | |
| length [Misc.LongString] | |
| length [ListLabels] | 
Return the length (number of elements) of the given list.
 | 
| length [List] | 
Return the length (number of elements) of the given list.
 | 
| length [Hashtbl.SeededS] | |
| length [Hashtbl.S] | |
| length [Hashtbl] | Hashtbl.length tblreturns the number of bindings intbl. | 
| length [BytesLabels] | 
Return the length (number of bytes) of the argument.
 | 
| length [Bytes] | 
Return the length (number of bytes) of the argument.
 | 
| length [Buffer] | 
Return the number of characters currently contained in the buffer.
 | 
| length [ArrayLabels] | 
Return the length (number of elements) of the given array.
 | 
| length [Array] | 
Return the length (number of elements) of the given array.
 | 
| let_ [Ast_helper.Cl] | |
| let_ [Ast_helper.Exp] | |
| letexception [Ast_helper.Exp] | |
| letmodule [Ast_helper.Exp] | |
| lexeme [Lexing] | 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. | 
| libunwind_available [Config] | |
| libunwind_link_flags [Config] | |
| lineto [Graphics] | 
Draw a line with endpoints the current point and the given point,
   and move the current point to the given point.
 | 
| link [UnixLabels] | link source destcreates a hard link nameddestto the file
   namedsource. | 
| link [Unix] | link source destcreates a hard link nameddestto the file
   namedsource. | 
| link_everything [Clflags] | |
| list [Sort] | 
Sort a list in increasing order according to an ordering predicate.
 | 
| list_remove [Misc] | |
| listen [UnixLabels] | 
Set up a socket for receiving connection requests.
 | 
| listen [Unix] | 
Set up a socket for receiving connection requests.
 | 
| lnot [Pervasives] | 
Bitwise logical negation.
 | 
| load_path [Config] | |
| loadfile [Dynlink] | 
In bytecode: load the given bytecode object file ( .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. | 
| location_of_error [Syntaxerr] | |
| lock [Mutex] | 
Lock the given mutex.
 | 
| lockf [UnixLabels] | lockf fd cmd sizeputs a lock on a region of the file opened
   asfd. | 
| lockf [Unix] | lockf fd cmd sizeputs a lock on a region of the file opened
   asfd. | 
| log [Pervasives] | 
Natural logarithm.
 | 
| log [Complex] | 
Natural logarithm (in base  e). | 
| log10 [Pervasives] | 
Base 10 logarithm.
 | 
| log1p [Pervasives] | log1p xcomputeslog(1.0 +. x)(natural logarithm),
    giving numerically-accurate results even ifxis close to0.0. | 
| log2 [Misc] | |
| logand [Targetint] | 
Bitwise logical and.
 | 
| logand [Nativeint] | 
Bitwise logical and.
 | 
| logand [Int64] | 
Bitwise logical and.
 | 
| logand [Int32] | 
Bitwise logical and.
 | 
| lognot [Targetint] | 
Bitwise logical negation
 | 
| lognot [Nativeint] | 
Bitwise logical negation
 | 
| lognot [Int64] | 
Bitwise logical negation
 | 
| lognot [Int32] | 
Bitwise logical negation
 | 
| logor [Targetint] | 
Bitwise logical or.
 | 
| logor [Nativeint] | 
Bitwise logical or.
 | 
| logor [Int64] | 
Bitwise logical or.
 | 
| logor [Int32] | 
Bitwise logical or.
 | 
| logxor [Targetint] | 
Bitwise logical exclusive or.
 | 
| logxor [Nativeint] | 
Bitwise logical exclusive or.
 | 
| logxor [Int64] | 
Bitwise logical exclusive or.
 | 
| logxor [Int32] | 
Bitwise logical exclusive or.
 | 
| lookup_tables [CamlinternalOO] | |
| loop_at_exit [Graphics] | 
Loop before exiting the program, the list given as argument is the
    list of handlers and the events on which these handlers are called.
 | 
| lowercase [String] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, including accented letters of the ISO
   Latin-1 (8859-1) character set.
 | 
| lowercase [StringLabels] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, including accented letters of the ISO
   Latin-1 (8859-1) character set.
 | 
| lowercase [Char] | 
Convert the given character to its equivalent lowercase character,
   using the ISO Latin-1 (8859-1) character set.
 | 
| lowercase [BytesLabels] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, including accented letters of the ISO
   Latin-1 (8859-1) character set.
 | 
| lowercase [Bytes] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, including accented letters of the ISO
   Latin-1 (8859-1) character set.
 | 
| lowercase_ascii [String] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, using the US-ASCII character set.
 | 
| lowercase_ascii [StringLabels] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, using the US-ASCII character set.
 | 
| lowercase_ascii [Char] | 
Convert the given character to its equivalent lowercase character,
   using the US-ASCII character set.
 | 
| lowercase_ascii [BytesLabels] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, using the US-ASCII character set.
 | 
| lowercase_ascii [Bytes] | 
Return a copy of the argument, with all uppercase letters
   translated to lowercase, using the US-ASCII character set.
 | 
| lseek [UnixLabels.LargeFile] | |
| lseek [UnixLabels] | 
Set the current position for a file descriptor, and return the resulting
    offset (from the beginning of the file).
 | 
| lseek [Unix.LargeFile] | 
See  Unix.lseek. | 
| lseek [Unix] | 
Set the current position for a file descriptor, and return the resulting
    offset (from the beginning of the file).
 | 
| lstat [UnixLabels.LargeFile] | |
| lstat [UnixLabels] | 
Same as  UnixLabels.stat, but in case the file is a symbolic link,
   return the information for the link itself. | 
| lstat [Unix.LargeFile] | |
| lstat [Unix] | 
Same as  Unix.stat, but in case the file is a symbolic link,
   return the information for the link itself. | 
| lt_big_int [Big_int] | |
| lt_num [Num] | |
| M | |
| magenta [Graphics] | |
| magic [Obj] | |
| major [Gc] | 
Do a minor collection and finish the current major collection cycle.
 | 
| major_slice [Gc] | major_slice nDo a minor collection and a slice of major collection. | 
| make [String] | String.make n creturns a fresh string of lengthn,
   filled with the characterc. | 
| make [StringLabels] | String.make n creturns a fresh string of lengthn,
   filled with the characterc. | 
| make [Random.State] | 
Create a new state and initialize it with the given seed.
 | 
| 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 [ArrayLabels] | Array.make n xreturns a fresh array of lengthn,
   initialized withx. | 
| make [Array] | Array.make n xreturns a fresh array of lengthn,
   initialized withx. | 
| make_archive [Clflags] | |
| make_class [CamlinternalOO] | |
| make_class_store [CamlinternalOO] | |
| make_float [ArrayLabels] | |
| make_float [Array] | |
| make_formatter [Format] | make_formatter out flushreturns a new formatter that writes according
  to the output functionout, and the flushing functionflush. | 
| make_image [Graphics] | 
Convert the given color matrix to an image.
 | 
| make_iprintf [CamlinternalFormat] | |
| make_leaf [Depend] | |
| make_lexer [Genlex] | 
Construct the lexer function.
 | 
| make_matrix [ArrayLabels] | Array.make_matrix dimx dimy ereturns a two-dimensional array
   (an array of arrays) with first dimensiondimxand
   second dimensiondimy. | 
| make_matrix [Array] | Array.make_matrix dimx dimy ereturns a two-dimensional array
   (an array of arrays) with first dimensiondimxand
   second dimensiondimy. | 
| make_node [Depend] | |
| make_package [Clflags] | |
| make_printf [CamlinternalFormat] | |
| make_runtime [Clflags] | |
| make_self_init [Random.State] | 
Create a new state and initialize it with a system-dependent
      low-entropy seed.
 | 
| map [Tbl] | |
| map [String] | String.map f sapplies functionfin turn to all the
    characters ofs(in increasing index order) and stores the
    results in a new string that is returned. | 
| map [StringLabels] | String.map f sapplies functionfin turn to all
   the characters ofsand stores the results in a new string that
   is returned. | 
| map [MoreLabels.Set.S] | |
| map [MoreLabels.Map.S] | |
| map [Misc.Stdlib.Option] | |
| map [ListLabels] | List.map f [a1; ...; an]applies functionftoa1, ..., an,
   and builds the list[f a1; ...; f an]with the results returned byf. | 
| map [List] | List.map f [a1; ...; an]applies functionftoa1, ..., an,
   and builds the list[f a1; ...; f an]with the results returned byf. | 
| map [Identifiable.S.Tbl] | |
| map [Identifiable.S.Set] | |
| 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 [Set.S] | map f sis the set whose elements aref a0,f a1... | 
| map [BytesLabels] | map f sapplies functionfin turn to all the bytes ofsand
    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] | 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.(Array.length a - 1) |]. | 
| map [Array] | 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.(Array.length a - 1) |]. | 
| map2 [ListLabels] | List.map2 f [a1; ...; an] [b1; ...; bn]is[f a1 b1; ...; f an bn]. | 
| map2 [List] | List.map2 f [a1; ...; an] [b1; ...; bn]is[f a1 b1; ...; f an bn]. | 
| map2 [ArrayLabels] | 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.(Array.length a - 1) b.(Array.length b - 1)|]. | 
| map2 [Array] | 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.(Array.length a - 1) b.(Array.length b - 1)|]. | 
| map2_prefix [Misc.Stdlib.List] | let r1, r2 = map2_prefix f l1 l2Ifl1is of length n andl2 = h2 @ t2with h2 of length n,
        r1 isList.map2 f l1 h1and r2 is t2. | 
| map_end [Misc] | |
| map_file [Bigarray.Array3] | 
Memory mapping of a file as a three-dimensional big array.
 | 
| map_file [Bigarray.Array2] | 
Memory mapping of a file as a two-dimensional big array.
 | 
| map_file [Bigarray.Array1] | 
Memory mapping of a file as a one-dimensional big array.
 | 
| map_file [Bigarray.Genarray] | 
Memory mapping of a file as a big array.
 | 
| map_keys [Identifiable.S.Map] | |
| map_left_right [Misc] | |
| map_opt [Ast_mapper] | |
| mapi [String] | String.mapi f scallsfwith each character ofsand its
    index (in increasing index order) and stores the results in a new
    string that is returned. | 
| mapi [StringLabels] | String.mapi f scallsfwith each character ofsand its
    index (in increasing index order) and stores the results in a new
    string that is returned. | 
| mapi [MoreLabels.Map.S] | |
| mapi [ListLabels] | 
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 [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 [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 [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  Array.map, but the
   function is applied to the index of the element as first argument,
   and the element itself as second argument. | 
| mapi [Array] | 
Same as  Array.map, but the
   function is applied to the index of the element as first argument,
   and the element itself as second argument. | 
| mark_rhs_docs [Docstrings] | 
Mark as associated the item documentation for the symbols between
    two positions (for ambiguity warnings)
 | 
| mark_symbol_docs [Docstrings] | 
Mark the item documentation for the current symbol (for ambiguity
    warnings).
 | 
| marshal [Obj] | |
| match_ [Ast_helper.Exp] | |
| match_beginning [Str] | match_beginning()returns the position of the first character
   of the substring that was matched by the last call to a matching
   or searching function (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 inbetween:Str.global_replace,Str.replace_first,Str.split,Str.bounded_split,Str.split_delim,Str.bounded_split_delim,Str.full_split,Str.bounded_full_splitNote: in the case ofglobal_substituteandsubstitute_first,
   a call tomatched_stringis only valid within thesubstargument,
   not afterglobal_substituteorsubstitute_firstreturns. | 
| max [Uchar] | maxis U+10FFFF. | 
| max [Pervasives] | 
Return the greater of the two arguments.
 | 
| max_array_length [Sys] | 
Maximum length of a normal array.
 | 
| max_big_int [Big_int] | 
Return the greater of its two arguments.
 | 
| max_binding [MoreLabels.Map.S] | |
| max_binding [Map.S] | 
Same as  Map.S.min_binding, but returns the largest binding
        of the given map. | 
| max_binding_opt [MoreLabels.Map.S] | |
| max_binding_opt [Map.S] | 
Same as  Map.S.min_binding_opt, but returns the largest binding
        of the given map. | 
| max_elt [MoreLabels.Set.S] | |
| max_elt [Set.S] | 
Same as  Set.S.min_elt, but returns the largest element of the
       given set. | 
| max_elt_opt [MoreLabels.Set.S] | |
| max_elt_opt [Set.S] | 
Same as  Set.S.min_elt_opt, but returns the largest element of the
        given set. | 
| max_float [Pervasives] | 
The largest positive finite value of type  float. | 
| max_int [Targetint] | 
The greatest representable target integer,
    either 231 - 1 on a 32-bit platform,
    or 263 - 1 on a 64-bit platform.
 | 
| max_int [Pervasives] | 
The greatest representable integer.
 | 
| max_int [Nativeint] | 
The greatest representable native integer,
   either 231 - 1 on a 32-bit platform,
   or 263 - 1 on a 64-bit platform.
 | 
| max_int [Int64] | 
The greatest representable 64-bit integer, 263 - 1.
 | 
| max_int [Int32] | 
The greatest representable 32-bit integer, 231 - 1.
 | 
| max_num [Num] | 
Return the greater of the two arguments.
 | 
| max_string_length [Sys] | 
Maximum length of strings and byte sequences.
 | 
| max_tag [Config] | |
| max_young_wosize [Config] | |
| may [Misc] | |
| may_map [Misc] | |
| mem [Weak.S] | mem t xreturnstrueif there is at least one instance
        ofxint, false otherwise. | 
| mem [Tbl] | |
| mem [MoreLabels.Set.S] | |
| mem [MoreLabels.Map.S] | |
| mem [MoreLabels.Hashtbl.SeededS] | |
| mem [MoreLabels.Hashtbl.S] | |
| mem [MoreLabels.Hashtbl] | |
| mem [ListLabels] | mem a lis true if and only ifais equal
   to an element ofl. | 
| mem [List] | mem a lis true if and only ifais equal
   to an element ofl. | 
| mem [Hashtbl.SeededS] | |
| mem [Hashtbl.S] | |
| mem [Hashtbl] | Hashtbl.mem tbl xchecks ifxis bound intbl. | 
| mem [Map.S] | mem x mreturnstrueifmcontains a binding forx,
       andfalseotherwise. | 
| mem [Set.S] | mem x stests whetherxbelongs to the sets. | 
| mem [ArrayLabels] | mem x ais true if and only ifxis equal
   to an element ofa. | 
| mem [Array] | mem a lis true if and only ifais equal
   to an element ofl. | 
| mem_assoc [ListLabels] | 
Same as  List.assoc, but simply return true if a binding exists,
   and false if no bindings exist for the given key. | 
| mem_assoc [List] | 
Same as  List.assoc, but simply return true if a binding exists,
   and false if no bindings exist for the given key. | 
| mem_assq [ListLabels] | 
Same as  List.mem_assoc, but uses physical equality instead of
   structural equality to compare keys. | 
| mem_assq [List] | 
Same as  List.mem_assoc, but uses physical equality instead of
   structural equality to compare keys. | 
| memoize [Identifiable.S.Tbl] | |
| memq [ListLabels] | 
Same as  List.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  Array.mem, but uses physical equality instead of structural
   equality to compare list elements. | 
| memq [Array] | 
Same as  Array.mem, but uses physical equality instead of structural
   equality to compare array elements. | 
| merge [Weak.S] | merge t xreturns an instance ofxfound intif any,
        or else addsxtotand returnx. | 
| merge [Sort] | 
Merge two lists according to the given predicate.
 | 
| merge [MoreLabels.Map.S] | |
| merge [ListLabels] | 
Merge two lists:
    Assuming that  l1andl2are sorted according to the
    comparison functioncmp,merge cmp l1 l2will return a
    sorted list containting 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 containting all the elements ofl1andl2. | 
| merge [Map.S] | merge f m1 m2computes a map whose keys is a subset of keys ofm1and ofm2. | 
| method_ [Ast_helper.Cf] | |
| method_ [Ast_helper.Ctf] | |
| min [Uchar] | minis U+0000. | 
| min [Pervasives] | 
Return the smaller of the two arguments.
 | 
| min_big_int [Big_int] | 
Return the smaller of its two arguments.
 | 
| min_binding [MoreLabels.Map.S] | |
| min_binding [Map.S] | 
Return the smallest binding of the given map
       (with respect to the  Ord.compareordering), or raiseNot_foundif the map is empty. | 
| min_binding_opt [MoreLabels.Map.S] | |
| min_binding_opt [Map.S] | 
Return the smallest binding of the given map
       (with respect to the  Ord.compareordering), orNoneif the map is empty. | 
| min_elt [MoreLabels.Set.S] | |
| min_elt [Set.S] | 
Return the smallest element of the given set
       (with respect to the  Ord.compareordering), or raiseNot_foundif the set is empty. | 
| min_elt_opt [MoreLabels.Set.S] | |
| 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_float [Pervasives] | 
The smallest positive, non-zero, non-denormalized value of type  float. | 
| min_int [Targetint] | 
The smallest representable target integer,
   either -231 on a 32-bit platform,
   or -263 on a 64-bit platform.
 | 
| min_int [Pervasives] | 
The smallest representable integer.
 | 
| min_int [Nativeint] | 
The smallest representable native integer,
   either -231 on a 32-bit platform,
   or -263 on a 64-bit platform.
 | 
| min_int [Int64] | 
The smallest representable 64-bit integer, -263.
 | 
| min_int [Int32] | 
The smallest representable 32-bit integer, -231.
 | 
| min_num [Num] | 
Return the smaller of the two arguments.
 | 
| minor [Gc] | 
Trigger a minor collection.
 | 
| minor_words [Gc] | 
Number of words allocated in the minor heap since the program was
    started.
 | 
| minus_big_int [Big_int] | 
Unary negation.
 | 
| minus_num [Num] | 
Unary negation.
 | 
| minus_one [Targetint] | 
The target integer -1.
 | 
| minus_one [Nativeint] | 
The native integer -1.
 | 
| minus_one [Int64] | 
The 64-bit integer -1.
 | 
| minus_one [Int32] | 
The 32-bit integer -1.
 | 
| mk [Ast_helper.Cstr] | |
| mk [Ast_helper.Csig] | |
| mk [Ast_helper.Ci] | |
| mk [Ast_helper.Cf] | |
| mk [Ast_helper.Cl] | |
| mk [Ast_helper.Ctf] | |
| mk [Ast_helper.Cty] | |
| mk [Ast_helper.Vb] | |
| mk [Ast_helper.Incl] | |
| mk [Ast_helper.Opn] | |
| mk [Ast_helper.Mb] | |
| mk [Ast_helper.Mtd] | |
| mk [Ast_helper.Md] | |
| mk [Ast_helper.Str] | |
| mk [Ast_helper.Sig] | |
| mk [Ast_helper.Mod] | |
| mk [Ast_helper.Mty] | |
| mk [Ast_helper.Te] | |
| mk [Ast_helper.Type] | |
| mk [Ast_helper.Val] | |
| mk [Ast_helper.Exp] | |
| mk [Ast_helper.Pat] | |
| mk [Ast_helper.Typ] | |
| mkdir [UnixLabels] | 
Create a directory with the given permissions.
 | 
| mkdir [Unix] | 
Create a directory with the given permissions (see  Unix.umask). | 
| mkdll [Config] | |
| mkexe [Config] | |
| mkfifo [UnixLabels] | 
Create a named pipe with the given permissions.
 | 
| mkfifo [Unix] | 
Create a named pipe with the given permissions (see  Unix.umask). | 
| mkloc [Location] | |
| mkmaindll [Config] | |
| mknoloc [Location] | |
| mktime [UnixLabels] | 
Convert a date and time, specified by the  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_big_int [Big_int] | 
Euclidean modulus of two big integers.
 | 
| mod_float [Pervasives] | mod_float a breturns the remainder ofawith respect tob. | 
| mod_num [Num] | 
Euclidean division: remainder.
 | 
| model [Config] | |
| modf [Pervasives] | modf freturns the pair of the fractional and integral
   part off. | 
| modtype [Ast_helper.Str] | |
| modtype [Ast_helper.Sig] | |
| module_ [Ast_helper.Str] | |
| module_ [Ast_helper.Sig] | |
| mouse_pos [Graphics] | 
Return the position of the mouse cursor, relative to the
   graphics window.
 | 
| moveto [Graphics] | 
Position the current point.
 | 
| mul [Targetint] | 
Multiplication.
 | 
| mul [Nativeint] | 
Multiplication.
 | 
| mul [Int64] | 
Multiplication.
 | 
| mul [Int32] | 
Multiplication.
 | 
| mul [Complex] | 
Multiplication
 | 
| mult_big_int [Big_int] | 
Multiplication of two big integers.
 | 
| mult_int_big_int [Big_int] | 
Multiplication of a big integer by a small integer
 | 
| mult_num [Num] | 
Multiplication
 | 
| N | |
| name_of_input [Scanf.Scanning] | Scanning.name_of_input icreturns the name of the character source
    for the givenScanf.Scanning.in_channelformatted input channel. | 
| nan [Pervasives] | 
A special floating-point value denoting the result of an
   undefined operation such as  0.0 /. 0.0. | 
| narrow [CamlinternalOO] | |
| nat_of_num [Num] | |
| nat_of_num_opt [Num] | |
| native_c_compiler [Config] | |
| native_c_libraries [Config] | |
| native_code [Clflags] | |
| native_pack_linker [Config] | |
| nativeint [Random.State] | |
| nativeint [Random] | Random.nativeint boundreturns a random integer between 0 (inclusive)
     andbound(exclusive). | 
| nativeint [Misc.Int_literal_converter] | |
| nativeint [Bigarray] | 
See  Bigarray.char. | 
| nativeint [Ast_helper.Const] | |
| nativeint_of_big_int [Big_int] | 
Convert a big integer to a native integer.
 | 
| nativeint_of_big_int_opt [Big_int] | 
Convert a big integer to a native integer.
 | 
| neg [Targetint] | 
Unary negation.
 | 
| neg [Nativeint] | 
Unary negation.
 | 
| neg [Int64] | 
Unary negation.
 | 
| neg [Int32] | 
Unary negation.
 | 
| neg [Complex] | 
Unary negation.
 | 
| neg_infinity [Pervasives] | 
Negative infinity.
 | 
| new_ [Ast_helper.Exp] | |
| new_block [Obj] | |
| new_channel [Event] | 
Return a new channel.
 | 
| new_line [Lexing] | 
Update the  lex_curr_pfield of the lexbuf to reflect the start
    of a new line. | 
| new_method [CamlinternalOO] | |
| new_methods_variables [CamlinternalOO] | |
| new_variable [CamlinternalOO] | |
| newtype [Ast_helper.Exp] | |
| next [Stream] | 
Return the first element of the stream and remove it from the
   stream.
 | 
| nice [UnixLabels] | 
Change the process priority.
 | 
| nice [Unix] | 
Change the process priority.
 | 
| no_auto_link [Clflags] | |
| no_check_prims [Clflags] | |
| no_overflow_add [Misc] | |
| no_overflow_lsl [Misc] | |
| no_overflow_mul [Misc] | |
| no_overflow_sub [Misc] | |
| no_scan_tag [Obj] | |
| no_std_include [Clflags] | |
| noassert [Clflags] | |
| noinit [Clflags] | |
| none [Location] | 
An arbitrary value of type  t; describes an empty ghost range. | 
| nopervasives [Clflags] | |
| noprompt [Clflags] | |
| nopromptcont [Clflags] | |
| norm [Complex] | 
Norm: given  x + i.y, returnssqrt(x^2 + y^2). | 
| norm2 [Complex] | 
Norm squared: given  x + i.y, returnsx^2 + y^2. | 
| normalise_eol [Misc] | normalise_eol sreturns a fresh copy ofswith any '\r' characters
   removed. | 
| not [Pervasives] | 
The boolean negation.
 | 
| noversion [Clflags] | |
| 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
     big arraya. | 
| nth_opt [ListLabels] | 
Return the  n-th element of the given list. | 
| nth_opt [List] | 
Return the  n-th element of the given list. | 
| num_bits_big_int [Big_int] | 
Return the number of significant bits in the absolute
            value of the given big integer.
 | 
| num_digits_big_int [Big_int] | 
Return the number of machine words used to store the
            given big integer.
 | 
| num_dims [Bigarray.Genarray] | 
Return the number of dimensions of the given big array.
 | 
| num_of_big_int [Num] | |
| num_of_int [Num] | |
| num_of_nat [Num] | |
| num_of_ratio [Num] | |
| num_of_string [Num] | 
Convert a string to a number.
 | 
| num_of_string_opt [Num] | 
Convert a string to a number.
 | 
| O | |
| o1_arguments [Clflags] | |
| o2_arguments [Clflags] | |
| o3_arguments [Clflags] | |
| obj [Obj] | |
| object_ [Ast_helper.Exp] | |
| object_ [Ast_helper.Typ] | |
| object_tag [Obj] | |
| objfiles [Clflags] | |
| ocaml_version [Sys] | ocaml_versionis the version of OCaml. | 
| of_array [Bigarray.Array3] | 
Build a three-dimensional big array initialized from the
     given array of arrays of arrays.
 | 
| of_array [Bigarray.Array2] | 
Build a two-dimensional big array initialized from the
     given array of arrays.
 | 
| of_array [Bigarray.Array1] | 
Build a one-dimensional big array initialized from the
     given array.
 | 
| of_bytes [Stream] | 
Return the stream of the characters of the bytes parameter.
 | 
| of_channel [Stream] | 
Return the stream of the characters read from the input channel.
 | 
| of_char [Uchar] | of_char ciscas an Unicode character. | 
| of_float [Targetint] | 
Convert the given floating-point number to a target integer,
   discarding the fractional part (truncate towards 0).
 | 
| of_float [Nativeint] | 
Convert the given floating-point number to a native integer,
   discarding the fractional part (truncate towards 0).
 | 
| of_float [Int64] | 
Convert the given floating-point number to a 64-bit integer,
   discarding the fractional part (truncate towards 0).
 | 
| of_float [Int32] | 
Convert the given floating-point number to a 32-bit integer,
   discarding the fractional part (truncate towards 0).
 | 
| of_int [Uchar] | of_int iisias an Unicode character. | 
| of_int [Targetint] | 
Convert the given integer (type  int) to a target integer
    (typet), module the target word size. | 
| 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_int32 [Targetint] | 
Convert the given 32-bit integer (type  int32)
    to a target integer. | 
| 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_int64 [Targetint] | 
Convert the given 64-bit integer (type  int64)
    to a target integer. | 
| of_int_exn [Targetint] | 
Convert the given integer (type  int) to a target integer
    (typet). | 
| of_list [Stream] | 
Return the stream holding the elements of the list in the same
   order.
 | 
| of_list [MoreLabels.Set.S] | |
| of_list [Identifiable.S.Tbl] | |
| of_list [Identifiable.S.Map] | |
| of_list [Identifiable.S.Set] | |
| of_list [Set.S] | of_list lcreates a set from a list of elements. | 
| of_list [ArrayLabels] | Array.of_list lreturns a fresh array containing the elements
   ofl. | 
| of_list [Array] | Array.of_list lreturns a fresh array containing the elements
   ofl. | 
| of_map [Identifiable.S.Tbl] | |
| of_nativeint [Int64] | 
Convert the given native integer (type  nativeint)
   to a 64-bit integer (typeint64). | 
| of_set [Identifiable.S.Map] | |
| of_string [Targetint] | 
Convert the given string to a target integer.
 | 
| of_string [Stream] | 
Return the stream of the characters of the string parameter.
 | 
| of_string [Nativeint] | 
Convert the given string to a native integer.
 | 
| of_string [Int64] | 
Convert the given string to a 64-bit integer.
 | 
| of_string [Int32] | 
Convert the given string to a 32-bit integer.
 | 
| of_string [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_value [Bigarray.Array0] | 
Build a zero-dimensional big array initialized from the
     given value.
 | 
| one [Targetint] | 
The target integer 1.
 | 
| one [Nativeint] | 
The native integer 1.
 | 
| one [Int64] | 
The 64-bit integer 1.
 | 
| one [Int32] | 
The 32-bit integer 1.
 | 
| one [Complex] | 
The complex number  1. | 
| opaque [Clflags] | |
| opaque_identity [Sys] | 
For the purposes of optimization,  opaque_identitybehaves like an
    unknown (and thus possibly side-effecting) function. | 
| open_ [Ast_helper.Str] | |
| open_ [Ast_helper.Sig] | |
| open_ [Ast_helper.Exp] | |
| open_ [Ast_helper.Pat] | |
| open_box [Format] | open_box dopens a new pretty-printing box
   with offsetd. | 
| open_box_of_string [CamlinternalFormat] | |
| open_connection [UnixLabels] | 
Connect to a server at the given address.
 | 
| open_connection [Unix] | 
Connect to a server at the given address.
 | 
| open_connection [ThreadUnix] | |
| open_graph [Graphics] | 
Show the graphics window or switch the screen to graphic mode.
 | 
| open_hbox [Format] | open_hbox ()opens a new 'horizontal' pretty-printing box. | 
| open_hovbox [Format] | open_hovbox dopens a new 'horizontal-or-vertical' pretty-printing box
  with offsetd. | 
| open_hvbox [Format] | open_hvbox 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 [Pervasives] | 
Open the named file for reading, and return a new input channel
   on that file, positioned at the beginning of the file.
 | 
| open_in_bin [Scanf.Scanning] | Scanning.open_in_bin fnamereturns aScanf.Scanning.in_channelformatted
    input channel for bufferized reading in binary mode from filefname. | 
| open_in_bin [Pervasives] | 
Same as  open_in, but the file is opened in binary mode,
   so that no translation takes place during reads. | 
| open_in_gen [Pervasives] | open_in_gen mode perm filenameopens the named file for reading,
   as described above. | 
| open_module [Depend] | |
| open_modules [Clflags] | |
| open_out [Pervasives] | 
Open the named file for writing, and return a new output channel
   on that file, positioned at the beginning of the file.
 | 
| open_out_bin [Pervasives] | 
Same as  open_out, but the file is opened in binary mode,
   so that no translation takes place during writes. | 
| open_out_gen [Pervasives] | open_out_gen mode perm filenameopens the named file for writing,
   as described above. | 
| open_process [UnixLabels] | 
Same as  UnixLabels.open_process_out, but redirects both the standard
   input and standard output of the command to pipes connected to the two
   returned channels. | 
| open_process [Unix] | 
Same as  Unix.open_process_out, but redirects both the standard input
   and standard output of the command to pipes connected to the two
   returned channels. | 
| open_process [ThreadUnix] | |
| open_process_full [UnixLabels] | 
Similar to  UnixLabels.open_process, but the second argument specifies
   the environment passed to the command. | 
| open_process_full [Unix] | 
Similar to  Unix.open_process, but the second argument specifies
   the environment passed to the command. | 
| open_process_in [UnixLabels] | 
High-level pipe and process management.
 | 
| open_process_in [Unix] | 
High-level pipe and process management.
 | 
| open_process_in [ThreadUnix] | |
| open_process_out [UnixLabels] | 
Same as  UnixLabels.open_process_in, but redirect the standard input of
   the command to a pipe. | 
| open_process_out [Unix] | 
Same as  Unix.open_process_in, but redirect the standard input of
   the command to a pipe. | 
| open_process_out [ThreadUnix] | |
| open_subwindow [GraphicsX11] | 
Create a sub-window of the current OCaml graphics window
   and return its identifier.
 | 
| open_tag [Format] | open_tag topens the tag namedt; theprint_open_tagfunction of the formatter is called withtas argument;
  the tag markermark_open_tag twill be flushed into the output
  device of the formatter. | 
| open_tbox [Format] | |
| open_temp_file [Filename] | 
Same as  Filename.temp_file, but returns both the name of a fresh
   temporary file, and an output channel opened (atomically) on
   this file. | 
| open_vbox [Format] | open_vbox 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.
 | 
| optimize_for_speed [Clflags] | |
| or_ [Ast_helper.Pat] | |
| or_big_int [Big_int] | 
Bitwise logical 'or'.
 | 
| os_type [Sys] | 
Operating system currently executing the OCaml program.
 | 
| out_channel_length [Pervasives.LargeFile] | |
| out_channel_length [Pervasives] | 
Return the size (number of characters) of the regular file
   on which the given channel is opened.
 | 
| out_channel_of_descr [UnixLabels] | 
Create an output channel writing on the given descriptor.
 | 
| out_channel_of_descr [Unix] | 
Create an output channel writing on the given descriptor.
 | 
| out_of_heap_tag [Obj] | |
| output [Pervasives] | output oc buf pos lenwriteslencharacters from byte sequencebuf,
   starting at offsetpos, to the given output channeloc. | 
| output [Misc.LongString] | |
| output [Identifiable.S.Set] | |
| output [Identifiable.Thing] | |
| output [Digest] | 
Write a digest on the given output channel.
 | 
| output_acc [CamlinternalFormat] | |
| output_binary_int [Pervasives] | 
Write one integer in binary format (4 bytes, big-endian)
   on the given output channel.
 | 
| output_buffer [Buffer] | output_buffer oc bwrites the current contents of bufferbon the output channeloc. | 
| output_byte [Pervasives] | 
Write one 8-bit integer (as the single character with that code)
   on the given output channel.
 | 
| output_bytes [Pervasives] | 
Write the byte sequence on the given output channel.
 | 
| output_c_object [Clflags] | |
| output_char [Pervasives] | 
Write the character on the given output channel.
 | 
| output_complete_object [Clflags] | |
| output_name [Clflags] | |
| output_string [Pervasives] | 
Write the string on the given output channel.
 | 
| output_substring [Pervasives] | 
Same as  outputbut take a string as argument instead of
   a byte sequence. | 
| output_value [Pervasives] | 
Write the representation of a structured value of any type
   to a channel.
 | 
| over_max_boxes [Format] | 
Tests if the maximum number of boxes allowed have already been opened.
 | 
| override [Ast_helper.Exp] | |
| P | |
| pack [Ast_helper.Exp] | |
| package [Ast_helper.Typ] | |
| param_format_of_ignored_format [CamlinternalFormat] | |
| params [CamlinternalOO] | |
| parent_dir_name [Filename] | 
The conventional name for the parent of the current directory
   (e.g.
 | 
| parse [Longident] | |
| parse [Clflags.Float_arg_helper] | |
| parse [Clflags.Int_arg_helper] | |
| parse [Arg_helper.Make] | |
| parse [Arg] | Arg.parse speclist anon_fun usage_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_arguments [Clflags] | |
| 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_color_setting [Clflags] | |
| parse_core_type [Parser] | |
| 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. | 
| parse_expression [Parser] | |
| parse_no_error [Clflags.Float_arg_helper] | |
| parse_no_error [Clflags.Int_arg_helper] | |
| parse_no_error [Arg_helper.Make] | |
| parse_options [Warnings] | |
| parse_pattern [Parser] | |
| partition [MoreLabels.Set.S] | |
| partition [MoreLabels.Map.S] | |
| partition [ListLabels] | partition p lreturns a pair of lists(l1, l2), wherel1is the list of all the elements oflthat
   satisfy the predicatep, andl2is the list of all the
   elements oflthat do not satisfyp. | 
| partition [List] | partition p lreturns a pair of lists(l1, l2), wherel1is the list of all the elements oflthat
   satisfy the predicatep, andl2is the list of all the
   elements oflthat do not satisfyp. | 
| partition [Map.S] | partition p mreturns a pair of maps(m1, m2), wherem1contains all the bindings ofsthat satisfy the
        predicatep, andm2is the map with all the bindings ofsthat do not satisfyp. | 
| partition [Set.S] | partition p sreturns a pair of sets(s1, s2), wheres1is the set of all the elements ofsthat satisfy the
       predicatep, ands2is the set of all the elements ofsthat do not satisfyp. | 
| pattern [Pprintast] | |
| pattern [Parse] | |
| pause [UnixLabels] | 
Wait until a non-ignored, non-blocked signal is delivered.
 | 
| pause [Unix] | 
Wait until a non-ignored, non-blocked signal is delivered.
 | 
| payload [Printast] | |
| peek [Stream] | 
Return  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. | 
| pic_code [Clflags] | |
| pipe [UnixLabels] | 
Create a pipe.
 | 
| pipe [Unix] | 
Create a pipe.
 | 
| pipe [ThreadUnix] | |
| plot [Graphics] | 
Plot the given point with the current drawing color.
 | 
| plots [Graphics] | 
Plot the given points with the current drawing color.
 | 
| point_color [Graphics] | 
Return the color of the given point in the backing store
   (see "Double buffering" below).
 | 
| polar [Complex] | polar norm 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. | 
| poly [Ast_helper.Exp] | |
| poly [Ast_helper.Typ] | |
| pop [Stack] | pop sremoves and returns the topmost element in stacks,
   or raisesStack.Emptyif the stack is empty. | 
| pop [Queue] | popis a synonym fortake. | 
| pos_in [Pervasives.LargeFile] | |
| pos_in [Pervasives] | 
Return the current reading position for the given channel.
 | 
| pos_out [Pervasives.LargeFile] | |
| pos_out [Pervasives] | 
Return the current writing position for the given channel.
 | 
| pow [Complex] | 
Power function.
 | 
| power_big_int_positive_big_int [Big_int] | 
Exponentiation functions.
 | 
| power_big_int_positive_int [Big_int] | |
| power_int_positive_big_int [Big_int] | |
| power_int_positive_int [Big_int] | |
| power_num [Num] | 
Exponentiation
 | 
| pp_close_box [Format] | |
| pp_close_tag [Format] | |
| pp_close_tbox [Format] | |
| pp_flush_formatter [Format] | pp_flush_formatter fmtflushesfmt's internal queue, ensuring that all
    the printing and flushing actions have been performed. | 
| pp_force_newline [Format] | |
| pp_get_all_formatter_output_functions [Format] | |
| pp_get_ellipsis_text [Format] | |
| pp_get_formatter_out_functions [Format] | 
These functions are the basic ones: usual functions
   operating on the standard formatter are defined via partial
   evaluation of these primitives.
 | 
| pp_get_formatter_output_functions [Format] | |
| pp_get_formatter_tag_functions [Format] | |
| pp_get_margin [Format] | |
| pp_get_mark_tags [Format] | |
| pp_get_max_boxes [Format] | |
| pp_get_max_indent [Format] | |
| pp_get_print_tags [Format] | |
| pp_open_box [Format] | |
| pp_open_hbox [Format] | |
| pp_open_hovbox [Format] | |
| pp_open_hvbox [Format] | |
| pp_open_tag [Format] | |
| pp_open_tbox [Format] | |
| pp_open_vbox [Format] | |
| pp_over_max_boxes [Format] | |
| pp_print_as [Format] | |
| pp_print_bool [Format] | |
| pp_print_break [Format] | |
| pp_print_char [Format] | |
| pp_print_cut [Format] | |
| pp_print_float [Format] | |
| pp_print_flush [Format] | |
| pp_print_if_newline [Format] | |
| pp_print_int [Format] | |
| pp_print_list [Format] | pp_print_list ?pp_sep pp_v ppf 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_space [Format] | |
| pp_print_string [Format] | |
| pp_print_tab [Format] | |
| pp_print_tbreak [Format] | |
| pp_print_text [Format] | pp_print_text ppf sprintsswith spaces and newlines
  respectively printed withFormat.pp_print_spaceandFormat.pp_force_newline. | 
| pp_set_all_formatter_output_functions [Format] | |
| pp_set_ellipsis_text [Format] | |
| pp_set_formatter_out_channel [Format] | |
| pp_set_formatter_out_functions [Format] | |
| pp_set_formatter_output_functions [Format] | |
| pp_set_formatter_tag_functions [Format] | |
| pp_set_margin [Format] | |
| pp_set_mark_tags [Format] | |
| pp_set_max_boxes [Format] | |
| pp_set_max_indent [Format] | |
| pp_set_print_tags [Format] | |
| pp_set_tab [Format] | |
| pp_set_tags [Format] | |
| pred [Uchar] | pred uis the scalar value beforeuin the set of Unicode scalar
    values. | 
| pred [Targetint] | 
Predecessor.
 | 
| pred [Pervasives] | pred xisx - 1. | 
| pred [Nativeint] | 
Predecessor.
 | 
| pred [Int64] | 
Predecessor.
 | 
| pred [Int32] | 
Predecessor.
 | 
| pred_big_int [Big_int] | 
Predecessor (subtract 1).
 | 
| pred_num [Num] | pred nisn-1 | 
| preprocessor [Clflags] | |
| prerr_bytes [Pervasives] | 
Print a byte sequence on standard error.
 | 
| prerr_char [Pervasives] | 
Print a character on standard error.
 | 
| prerr_endline [Pervasives] | 
Print a string, followed by a newline character on standard
   error and flush standard error.
 | 
| prerr_float [Pervasives] | 
Print a floating-point number, in decimal, on standard error.
 | 
| prerr_int [Pervasives] | 
Print an integer, in decimal, on standard error.
 | 
| prerr_newline [Pervasives] | 
Print a newline character on standard error, and flush
   standard error.
 | 
| prerr_string [Pervasives] | 
Print a string on standard error.
 | 
| prerr_warning [Location] | |
| primitive [Ast_helper.Str] | |
| principal [Clflags] | |
| print [Warnings] | |
| print [Timings] | 
Prints all recorded timings to the formatter.
 | 
| print [Tbl] | |
| print [Printexc] | Printexc.print fn xappliesfntoxand returns the result. | 
| print [Location] | |
| print [Identifiable.S.Map] | |
| print [Identifiable.S.Set] | |
| print [Identifiable.Thing] | |
| print_arguments [Clflags] | |
| print_as [Format] | print_as len strprintsstrin the
   current box. | 
| print_backtrace [Printexc] | Printexc.print_backtrace ocprints an exception backtrace
    on the output channeloc. | 
| print_bool [Format] | 
Prints a boolean in the current box.
 | 
| print_break [Format] | print_break nspaces offsetthe 'full' break hint:
  the pretty-printer may split the line at this
  point, otherwise it printsnspacesspaces. | 
| print_bytes [Pervasives] | 
Print a byte sequence on standard output.
 | 
| print_char [Pervasives] | 
Print a character on standard output.
 | 
| print_char [Format] | 
Prints a character in the current box.
 | 
| print_compact [Location] | |
| print_config [Config] | |
| print_cut [Format] | print_cut ()the 'cut' break hint:
  the pretty-printer may split the line at this
  point, otherwise it prints nothing. | 
| print_endline [Pervasives] | 
Print a string, followed by a newline character, on
   standard output and flush standard output.
 | 
| print_error [Location] | |
| print_error_cur_file [Location] | |
| print_error_prefix [Location] | |
| print_filename [Location] | |
| print_float [Pervasives] | 
Print a floating-point number, in decimal, on standard output.
 | 
| print_float [Format] | 
Prints a floating point number in the current box.
 | 
| print_flush [Format] | 
Flushes the pretty printer: all opened boxes are closed,
  and all pending text is displayed.
 | 
| print_if_newline [Format] | 
Executes the next formatting command if the preceding line
  has just been split.
 | 
| print_int [Pervasives] | 
Print an integer, in decimal, on standard output.
 | 
| print_int [Format] | 
Prints an integer in the current box.
 | 
| print_loc [Location] | |
| print_newline [Pervasives] | 
Print a newline character on standard output, and flush
   standard output.
 | 
| print_newline [Format] | 
Equivalent to  print_flushfollowed by a new line. | 
| print_raw_backtrace [Printexc] | 
Print a raw backtrace in the same format
     Printexc.print_backtraceuses. | 
| print_space [Format] | print_space ()the 'space' break hint:
  the pretty-printer may split the line at this
  point, otherwise it prints one space. | 
| print_stat [Gc] | 
Print the current values of the memory management counters (in
   human-readable form) into the channel argument.
 | 
| print_string [Pervasives] | 
Print a string on standard output.
 | 
| print_string [Format] | print_string strprintsstrin the current box. | 
| print_tab [Format] | |
| print_tbreak [Format] | |
| print_timings [Clflags] | |
| print_types [Clflags] | |
| print_warning [Location] | |
| print_warnings [Lexer] | |
| printf [Printf] | 
Same as  Printf.fprintf, but output onstdout. | 
| printf [Format] | 
Same as  fprintfabove, but output onstd_formatter. | 
| profiling [Config] | |
| profinfo [Config] | |
| profinfo_width [Config] | |
| prohibit [Dynlink] | prohibit unitsprohibits dynamically-linked units from referencing
    the units named in listunits. | 
| protect_refs [Misc] | protect_refs l ftemporarily setsrtovfor eachR (r, v)inlwhile executingf. | 
| public_method_label [CamlinternalOO] | |
| push [Stack] | push x sadds the elementxat the top of stacks. | 
| push [Queue] | pushis a synonym foradd. | 
| putenv [UnixLabels] | Unix.putenv name valuesets the value associated to a
   variable in the process environment. | 
| putenv [Unix] | Unix.putenv name valuesets the value associated to a
   variable in the process environment. | 
| Q | |
| quick_stat [Gc] | 
Same as  statexcept thatlive_words,live_blocks,free_words,free_blocks,largest_free, andfragmentsare set to 0. | 
| quo_num [Num] | 
Euclidean division: quotient.
 | 
| quomod_big_int [Big_int] | 
Euclidean division of two big integers.
 | 
| 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_files [Ccomp] | |
| quote_optfile [Ccomp] | |
| R | |
| raise [Pervasives] | 
Raise the given exception value
 | 
| raise_direct_hook_exn [Misc] | 
A hook can use  raise_unwrapped_hook_exnto raise an exception that will
      not be wrapped into aMisc.HookExnWrapper. | 
| raise_errorf [Location] | |
| raise_notrace [Pervasives] | 
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] | |
| 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. | 
| ranlib [Config] | |
| ratio_of_num [Num] | |
| 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. | 
| rcontains_from [String] | String.rcontains_from s stop ctests if charactercappears insbefore positionstop+1. | 
| rcontains_from [StringLabels] | String.rcontains_from s stop ctests if charactercappears 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 [UnixLabels] | read fd buff ofs lenreadslenbytes from descriptorfd,
    storing them in byte sequencebuff, starting at positionofsinbuff. | 
| read [Unix] | read fd buff ofs lenreadslenbytes from descriptorfd,
    storing them in byte sequencebuff, starting at positionofsinbuff. | 
| read [ThreadUnix] | |
| 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 [Pervasives] | 
Flush standard output, then read one line from standard input
   and convert it to a floating-point number.
 | 
| read_float_opt [Pervasives] | 
Flush standard output, then read one line from standard input
    and convert it to a floating-point number.
 | 
| read_int [Pervasives] | 
Flush standard output, then read one line from standard input
   and convert it to an integer.
 | 
| read_int_opt [Pervasives] | 
Same as  read_int_opt, but retursNoneinstead of raising. | 
| read_key [Graphics] | 
Wait for a key to be pressed, and return the corresponding
   character.
 | 
| read_line [Pervasives] | 
Flush standard output, then read characters from standard input
   until a newline character is encountered.
 | 
| readdir [UnixLabels] | 
Return the next entry in a directory.
 | 
| readdir [Unix] | 
Return the next entry in a directory.
 | 
| readdir [Sys] | 
Return the names of all files present in the given directory.
 | 
| readlink [UnixLabels] | 
Read the contents of a link.
 | 
| readlink [Unix] | 
Read the contents of a symbolic link.
 | 
| real_paths [Clflags] | |
| really_input [Pervasives] | really_input ic buf pos lenreadslencharacters from channelic,
   storing them in byte sequencebuf, starting at character numberpos. | 
| really_input_string [Pervasives] | really_input_string ic lenreadslencharacters from channelicand returns them in a new string. | 
| rebind [Ast_helper.Te] | |
| rec_module [Ast_helper.Str] | |
| rec_module [Ast_helper.Sig] | |
| recast [CamlinternalFormat] | |
| receive [Event] | receive chreturns the event consisting in receiving a value
   from the channelch. | 
| record [Ast_helper.Exp] | |
| record [Ast_helper.Pat] | |
| record_backtrace [Printexc] | Printexc.record_backtrace bturns recording of exception backtraces
    on (ifb = true) or off (ifb = false). | 
| recursive_types [Clflags] | |
| recv [UnixLabels] | 
Receive data from a connected socket.
 | 
| recv [Unix] | 
Receive data from a connected socket.
 | 
| recv [ThreadUnix] | |
| recvfrom [UnixLabels] | 
Receive data from an unconnected socket.
 | 
| recvfrom [Unix] | 
Receive data from an unconnected socket.
 | 
| recvfrom [ThreadUnix] | |
| red [Graphics] | |
| ref [Pervasives] | 
Return a fresh reference containing the given value.
 | 
| regexp [Str] | 
Compile a regular expression.
 | 
| regexp_case_fold [Str] | 
Same as  regexp, but the compiled expression will match text
    in a case-insensitive way: uppercase and lowercase letters will
    be considered equivalent. | 
| regexp_string [Str] | Str.regexp_string 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 [Docstrings] | 
Register a docstring
 | 
| register [Callback] | Callback.register n vregisters the valuevunder
   the namen. | 
| register [Ast_mapper] | 
Apply the  register_function. | 
| register_error_of_exn [Location] | |
| register_exception [Callback] | Callback.register_exception n exnregisters the
   exception contained in the exception valueexnunder the namen. | 
| register_function [Ast_mapper] | |
| register_printer [Printexc] | Printexc.register_printer fnregistersfnas an exception
    printer. | 
| rem [Targetint] | 
Integer remainder.
 | 
| rem [Nativeint] | 
Integer remainder.
 | 
| rem [Int64] | 
Integer remainder.
 | 
| rem [Int32] | 
Integer remainder.
 | 
| remember_mode [Graphics] | 
Set remember mode on or off.
 | 
| remove [Weak.S] | remove t xremoves fromtone instance ofx. | 
| remove [Tbl] | |
| remove [Sys] | 
Remove the given file name from the file system.
 | 
| remove [MoreLabels.Set.S] | |
| remove [MoreLabels.Map.S] | |
| remove [MoreLabels.Hashtbl.SeededS] | |
| remove [MoreLabels.Hashtbl.S] | |
| remove [MoreLabels.Hashtbl] | |
| remove [Hashtbl.SeededS] | |
| remove [Hashtbl.S] | |
| remove [Hashtbl] | 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 [Set.S] | remove x sreturns a set containing all elements ofs,
       exceptx. | 
| 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] | 
Same as  List.remove_assoc, but uses physical equality instead
   of structural equality to compare keys. | 
| remove_assq [List] | 
Same as  List.remove_assoc, but uses physical equality instead
   of structural equality to compare keys. | 
| remove_extension [Filename] | 
Return the given file name without its extension, as defined
    in  Filename.extension. | 
| remove_file [Misc] | |
| remove_unused_arguments [Clflags] | |
| rename [UnixLabels] | rename old newchanges the name of a file fromoldtonew. | 
| rename [Unix] | rename old newchanges the name of a file fromoldtonew. | 
| rename [Sys] | 
Rename a file.
 | 
| rename [Identifiable.S.Map] | |
| replace [MoreLabels.Hashtbl.SeededS] | |
| replace [MoreLabels.Hashtbl.S] | |
| replace [MoreLabels.Hashtbl] | |
| replace [Hashtbl.SeededS] | |
| replace [Hashtbl.S] | |
| replace [Hashtbl] | Hashtbl.replace tbl x yreplaces the current binding ofxintblby a binding ofxtoy. | 
| 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_substring [Misc] | |
| replicate_list [Misc] | |
| report_error [Syntaxerr] | |
| report_error [Location] | |
| report_error [Lexer] | |
| report_error [Attr_helper] | |
| report_exception [Location] | |
| repr [Targetint] | 
The concrete representation of a native integer.
 | 
| repr [Obj] | |
| reset [Timings] | 
erase all recorded times
 | 
| reset [MoreLabels.Hashtbl.SeededS] | |
| reset [MoreLabels.Hashtbl.S] | |
| reset [MoreLabels.Hashtbl] | |
| reset [Location] | |
| reset [Hashtbl.SeededS] | |
| reset [Hashtbl.S] | |
| reset [Hashtbl] | 
Empty a hash table and shrink the size of the bucket table
    to its initial size.
 | 
| reset [Buffer] | 
Empty the buffer and deallocate the internal byte sequence holding the
   buffer contents, replacing it with the initial internal byte sequence
   of length  nthat was allocated byBuffer.createn. | 
| reset_base_overrides [Arg_helper.Make] | |
| reset_fatal [Warnings] | |
| reshape [Bigarray] | reshape b [|d1;...;dN|]converts the big arraybto 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. | 
| resize_window [Graphics] | 
Resize and erase the graphics window.
 | 
| restore [Warnings] | |
| resume [Terminfo] | |
| rev [ListLabels] | 
List reversal.
 | 
| rev [List] | 
List reversal.
 | 
| rev_append [ListLabels] | List.rev_append l1 l2reversesl1and concatenates it tol2. | 
| rev_append [List] | List.rev_append l1 l2reversesl1and concatenates it tol2. | 
| rev_char_set [CamlinternalFormat] | |
| rev_map [ListLabels] | |
| rev_map [List] | |
| rev_map2 [ListLabels] | |
| rev_map2 [List] | |
| rev_split_words [Misc] | |
| rewinddir [UnixLabels] | 
Reposition the descriptor to the beginning of the directory
 | 
| rewinddir [Unix] | 
Reposition the descriptor to the beginning of the directory
 | 
| rgb [Graphics] | rgb r g breturns the integer encoding the color with red
   componentr, green componentg, and blue componentb. | 
| rhs_docs [Docstrings] | 
Fetch the item documentation for the symbols between two
    positions.
 | 
| rhs_docs_lazy [Docstrings] | |
| rhs_end [Parsing] | 
See  Parsing.rhs_start. | 
| rhs_end_pos [Parsing] | 
Same as  rhs_end, but return apositioninstead of an offset. | 
| rhs_info [Docstrings] | 
Fetch the field info following the symbol at a given position.
 | 
| rhs_loc [Location] | rhs_loc nreturns the location of the symbol at positionn, starting
  at 1, in the current parser rule. | 
| rhs_post_extra_text [Docstrings] | 
Fetch additional text following the symbol at the given position
 | 
| rhs_pre_extra_text [Docstrings] | 
Fetch additional text preceding the symbol at the given position
 | 
| rhs_start [Parsing] | 
Same as  Parsing.symbol_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. | 
| rhs_text [Docstrings] | 
Fetch the text preceding the symbol at the given position.
 | 
| rhs_text_lazy [Docstrings] | |
| rindex [String] | String.rindex s creturns the index of the last
   occurrence of charactercin strings. | 
| rindex [StringLabels] | String.rindex s creturns the index of the last
   occurrence of charactercin strings. | 
| 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] | String.rindex_from s i creturns the index of the
   last occurrence of charactercin stringsbefore positioni+1. | 
| rindex_from [StringLabels] | String.rindex_from s i creturns the index of the
   last occurrence of charactercin stringsbefore 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] | String.rindex_from_opt s i creturns the index of the
   last occurrence of charactercin stringsbefore positioni+1orNoneifcdoes not occur insbefore positioni+1. | 
| rindex_from_opt [StringLabels] | String.rindex_from_opt s i creturns the index of the
   last occurrence of charactercin stringsbefore positioni+1orNoneifcdoes not occur insbefore positioni+1. | 
| 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] | String.rindex_opt s creturns the index of the last occurrence
    of charactercin strings, orNoneifcdoes not occur ins. | 
| rindex_opt [StringLabels] | String.rindex_opt s creturns the index of the last occurrence
    of charactercin strings, orNoneifcdoes not occur ins. | 
| 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. | 
| rlineto [Graphics] | 
Draw a line with endpoints the current point and the
   current point translated of the given vector,
   and move the current point to this point.
 | 
| rmdir [UnixLabels] | 
Remove an empty directory.
 | 
| rmdir [Unix] | 
Remove an empty directory.
 | 
| rmoveto [Graphics] | rmoveto dx dytranslates the current point by the given vector. | 
| round_num [Num] | round_num nreturns the integer closest ton. | 
| rounds [Clflags] | |
| run_command [Ccomp] | |
| run_initializers [CamlinternalOO] | |
| run_initializers_opt [CamlinternalOO] | |
| run_main [Ast_mapper] | 
Entry point to call to implement a standalone -ppx rewriter from a
    mapper, parametrized by the command line arguments.
 | 
| runtime_parameters [Sys] | 
Return the value of the runtime parameters, in the same format
    as the contents of the  OCAMLRUNPARAMenvironment variable. | 
| runtime_variant [Sys] | 
Return the name of the runtime variant the program is running on.
 | 
| runtime_variant [Clflags] | |
| runtime_warnings_enabled [Sys] | 
Return whether runtime warnings are currently enabled.
 | 
| S | |
| safe_string [Config] | |
| save_and_close [Spacetime.Series] | save_and_close serieswrites information intoseriesrequired for
      interpeting the snapshots thatseriescontains and then closes theseriesfile. | 
| save_event [Spacetime.Series] | save_eventwrites an event, which is an arbitrary string, into the
      given series file. | 
| save_event_for_automatic_snapshots [Spacetime] | 
Like  Spacetime.Series.save_event, but writes to the automatic snapshot file. | 
| scanf [Scanf] | 
Same as  Scanf.bscanf, but reads from the predefined formatted input
    channelScanf.Scanning.stdinthat is connected tostdin. | 
| 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. | 
| search_substring [Misc] | |
| 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] | 
A variant of  Hashtbl.hash_paramthat is further parameterized by
   an integer seed. | 
| seek_in [Pervasives.LargeFile] | |
| seek_in [Pervasives] | seek_in chan possets the current reading position toposfor channelchan. | 
| seek_out [Pervasives.LargeFile] | |
| seek_out [Pervasives] | seek_out chan possets the current writing position toposfor channelchan. | 
| select [UnixLabels] | 
Wait until some input/output operations become possible on
   some channels.
 | 
| select [Unix] | 
Wait until some input/output operations become possible on
   some channels.
 | 
| select [ThreadUnix] | |
| select [Thread] | 
Suspend the execution of the calling thread until input/output
   becomes possible on the given Unix file descriptors.
 | 
| select [Event] | 
'Synchronize' on an alternative of events.
 | 
| self [Thread] | 
Return the thread currently executing.
 | 
| self_init [Random] | 
Initialize the generator with a random seed chosen
   in a system-dependent way.
 | 
| send [UnixLabels] | 
Send data over a connected socket.
 | 
| send [Unix] | 
Send data over a connected socket.
 | 
| send [ThreadUnix] | |
| send [Event] | send ch vreturns the event consisting in sending the valuevover the channelch. | 
| send [CamlinternalOO] | |
| send [Ast_helper.Exp] | |
| send_substring [UnixLabels] | 
Same as  send, but take the data from a string instead of a byte
    sequence. | 
| send_substring [Unix] | 
Same as  send, but take the data from a string instead of a byte
    sequence. | 
| send_substring [ThreadUnix] | |
| sendcache [CamlinternalOO] | |
| sendself [CamlinternalOO] | |
| sendto [UnixLabels] | 
Send data over an unconnected socket.
 | 
| sendto [Unix] | 
Send data over an unconnected socket.
 | 
| sendto [ThreadUnix] | |
| sendto_substring [UnixLabels] | 
Same as  sendto, but take the data from a string instead of a
    byte sequence. | 
| sendto_substring [Unix] | 
Same as  sendto, but take the data from a string instead of a
    byte sequence. | 
| sendto_substring [ThreadUnix] | |
| sequence [Ast_helper.Exp] | |
| set [Weak] | Weak.set ar n (Some el)sets thenth cell ofarto be a
   (full) pointer toel;Weak.set ar n Nonesets thenth
   cell ofarto empty. | 
| set [String] | String.set s n cmodifies byte sequencesin place,
   replacing the byte at indexnwithc. | 
| set [StringLabels] | String.set s n cmodifies byte sequencesin place,
   replacing the byte at indexnwithc. | 
| set [Misc.LongString] | |
| set [Gc] | set rchanges the GC parameters according to thecontrolrecordr. | 
| set [Consistbl] | |
| 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 big array.
 | 
| set [ArrayLabels] | Array.set a n xmodifies arrayain place, replacing
   element numbernwithx. | 
| set [Array] | Array.set a n xmodifies arrayain place, replacing
   element numbernwithx. | 
| set_all_formatter_output_functions [Format] | |
| set_approx_printing [Arith_status] | 
Get or set the flag  approx_printing. | 
| set_base_default [Arg_helper.Make] | |
| set_binary_mode_in [Pervasives] | set_binary_mode_in ic truesets the channelicto binary
   mode: no translations take place during input. | 
| set_binary_mode_out [Pervasives] | set_binary_mode_out oc truesets the channelocto binary
   mode: no translations take place during output. | 
| set_close_on_exec [UnixLabels] | 
Set the ``close-on-exec'' flag on the given descriptor.
 | 
| set_close_on_exec [Unix] | 
Set the ``close-on-exec'' flag on the given descriptor.
 | 
| set_color [Graphics] | 
Set the current drawing color.
 | 
| set_color_tag_handling [Misc.Color] | |
| set_cookie [Ast_mapper] | |
| set_data [Obj.Ephemeron] | 
Same as  Ephemeron.K1.set_data | 
| set_data [Ephemeron.Kn] | 
Same as  Ephemeron.K1.set_data | 
| set_data [Ephemeron.K2] | 
Same as  Ephemeron.K1.set_data | 
| set_data [Ephemeron.K1] | Ephemeron.K1.set_data eph elsets the data ofephto be a
      (full) data toel | 
| set_double_field [Obj] | |
| set_dumped_pass [Clflags] | |
| set_ellipsis_text [Format] | 
Set the text of the ellipsis printed when too many boxes
  are opened (a single dot,  ., by default). | 
| set_error_when_null_denominator [Arith_status] | 
Get or set the flag  null_denominator. | 
| set_field [Obj] | 
When using flambda:
 | 
| set_floating_docstrings [Docstrings] | 
Docstrings not immediately adjacent to a token
 | 
| set_floating_precision [Arith_status] | 
Get or set the parameter  floating_precision. | 
| set_font [Graphics] | 
Set the font used for drawing text.
 | 
| set_formatter_out_channel [Format] | 
Redirect the pretty-printer output to the given channel.
 | 
| set_formatter_out_functions [Format] | set_formatter_out_functions fRedirect the pretty-printer output to the functionsf.out_stringandf.out_flushas described inset_formatter_output_functions. | 
| set_formatter_output_functions [Format] | set_formatter_output_functions out flushredirects the
  pretty-printer output functions to the functionsoutandflush. | 
| set_formatter_tag_functions [Format] | set_formatter_tag_functions tag_funschanges the meaning of
  opening and closing tags to use the functions intag_funs. | 
| set_key [Obj.Ephemeron] | 
Same as  Ephemeron.K1.set_key | 
| set_key [Ephemeron.Kn] | 
Same as  Ephemeron.K1.set_key | 
| set_key [Ephemeron.K1] | Ephemeron.K1.set_key eph elsets the key ofephto be a
      (full) key toel | 
| set_key1 [Ephemeron.K2] | 
Same as  Ephemeron.K1.set_key | 
| set_key2 [Ephemeron.K2] | 
Same as  Ephemeron.K1.set_key | 
| set_line_width [Graphics] | 
Set the width of points and lines drawn with the functions above.
 | 
| set_margin [Format] | set_margin 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] | set_mark_tags bturns on or off the output of tag markers. | 
| set_max_boxes [Format] | set_max_boxes maxsets the maximum number of boxes simultaneously
  opened. | 
| set_max_indent [Format] | set_max_indent dsets the maximum indentation limit of lines tod(in
  characters):
  once this limit is reached, new boxes are rejected to the left,
  if they do not fit on the current line. | 
| set_method [CamlinternalOO] | |
| set_methods [CamlinternalOO] | |
| set_nonblock [UnixLabels] | 
Set the ``non-blocking'' flag on the given descriptor.
 | 
| set_nonblock [Unix] | 
Set the ``non-blocking'' flag on the given descriptor.
 | 
| set_normalize_ratio [Arith_status] | 
Get or set the flag  normalize_ratio. | 
| set_normalize_ratio_when_printing [Arith_status] | 
Get or set the flag  normalize_ratio_when_printing. | 
| set_post_docstrings [Docstrings] | 
Docstrings immediately following a token
 | 
| set_post_extra_docstrings [Docstrings] | 
Docstrings immediately preceding the token which follows this one
 | 
| set_pre_docstrings [Docstrings] | 
Docstrings immediately preceding a token
 | 
| set_pre_extra_docstrings [Docstrings] | 
Docstrings immediately following the token which precedes this one
 | 
| set_preprocessor [Lexer] | |
| set_print_tags [Format] | set_print_tags bturns on or off the printing of tags. | 
| set_signal [Sys] | 
Same as  Sys.signalbut return value is ignored. | 
| set_state [Random] | 
Set the state of the generator used by the basic functions.
 | 
| set_styles [Misc.Color] | |
| set_tab [Format] | |
| set_tag [Obj] | |
| set_tags [Format] | set_tags bturns on or off the treatment of tags (default is off). | 
| set_temp_dir_name [Filename] | 
Change the temporary directory returned by  Filename.get_temp_dir_nameand used byFilename.temp_fileandFilename.open_temp_file. | 
| set_text_size [Graphics] | 
Set the character size used for drawing text.
 | 
| set_trace [Parsing] | 
Control debugging support for  ocamlyacc-generated parsers. | 
| set_uncaught_exception_handler [Printexc] | Printexc.set_uncaught_exception_handler fnregistersfnas the handler
    for uncaught exceptions. | 
| set_user_default [Arg_helper.Make] | |
| set_window_title [Graphics] | 
Set the title of the graphics window.
 | 
| setfield [Ast_helper.Exp] | |
| setgid [UnixLabels] | 
Set the real group id and effective group id for the process.
 | 
| setgid [Unix] | 
Set the real group id and effective group id for the process.
 | 
| setgroups [UnixLabels] | setgroups groupssets the supplementary group IDs for the
      calling process. | 
| setgroups [Unix] | setgroups groupssets the supplementary group IDs for the
    calling process. | 
| setinstvar [Ast_helper.Exp] | |
| 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] | 
Same as  Unix.setsockoptfor a socket option whose value is a
    floating-point number. | 
| setsockopt_float [Unix] | 
Same as  Unix.setsockoptfor a socket option whose value is a
   floating-point number. | 
| setsockopt_int [UnixLabels] | 
Same as  Unix.setsockoptfor an integer-valued socket option. | 
| setsockopt_int [Unix] | 
Same as  Unix.setsockoptfor an integer-valued socket option. | 
| setsockopt_optint [UnixLabels] | 
Same as  Unix.setsockoptfor a socket option whose value is
    anint option. | 
| setsockopt_optint [Unix] | 
Same as  Unix.setsockoptfor a socket option whose value is anint option. | 
| setuid [UnixLabels] | 
Set the real user id and effective user id for the process.
 | 
| setuid [Unix] | 
Set the real user id and effective user id for the process.
 | 
| setup [Terminfo] | |
| setup [Misc.Color] | |
| shared [Clflags] | |
| shift_left [Targetint] | Targetint.shift_left x yshiftsxto the left byybits. | 
| 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_big_int [Big_int] | shift_left_big_int b nreturnsbshifted left bynbits. | 
| shift_right [Targetint] | Targetint.shift_right x yshiftsxto the right byybits. | 
| 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_big_int [Big_int] | shift_right_big_int b nreturnsbshifted right bynbits. | 
| shift_right_logical [Targetint] | Targetint.shift_right_logical x yshiftsxto the right
    byybits. | 
| 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_towards_zero_big_int [Big_int] | shift_right_towards_zero_big_int b nreturnsbshifted
            right bynbits. | 
| show_filename [Location] | 
In -absname mode, return the absolute path for this filename.
 | 
| shutdown [UnixLabels] | 
Shutdown a socket connection.
 | 
| shutdown [Unix] | 
Shutdown a socket connection.
 | 
| shutdown_connection [UnixLabels] | 
``Shut down'' a connection established with  UnixLabels.open_connection;
   that is, transmit an end-of-file condition to the server reading
   on the other side of the connection. | 
| shutdown_connection [Unix] | 
``Shut down'' a connection established with  Unix.open_connection;
   that is, transmit an end-of-file condition to the server reading
   on the other side of the connection. | 
| sigabrt [Sys] | 
Abnormal termination
 | 
| sigalrm [Sys] | 
Timeout
 | 
| sigbus [Sys] | 
Bus error
 | 
| sigchld [Sys] | 
Child process terminated
 | 
| sigcont [Sys] | 
Continue
 | 
| sigfpe [Sys] | 
Arithmetic exception
 | 
| sighup [Sys] | 
Hangup on controlling terminal
 | 
| sigill [Sys] | 
Invalid hardware instruction
 | 
| sigint [Sys] | 
Interactive interrupt (ctrl-C)
 | 
| sigkill [Sys] | 
Termination (cannot be ignored)
 | 
| sigmask [Thread] | sigmask cmd sigschanges the set of blocked signals for the
   calling thread. | 
| sign_big_int [Big_int] | 
Return  0if the given big integer is zero,1if it is positive, and-1if it is negative. | 
| sign_num [Num] | 
Return  -1,0or1according to the sign of the argument. | 
| signal [Sys] | 
Set the behavior of the system on receipt of a given signal.
 | 
| signal [Condition] | signal crestarts one of the processes waiting on the
   condition variablec. | 
| signature [Pprintast] | |
| signature [Ast_invariants] | |
| signature [Ast_helper.Cty] | |
| signature [Ast_helper.Mty] | |
| sigpending [UnixLabels] | 
Return the set of blocked signals that are currently pending.
 | 
| sigpending [Unix] | 
Return the set of blocked signals that are currently pending.
 | 
| sigpipe [Sys] | 
Broken pipe
 | 
| sigpoll [Sys] | 
Pollable event
 | 
| sigprocmask [UnixLabels] | sigprocmask cmd sigschanges the set of blocked signals. | 
| sigprocmask [Unix] | sigprocmask cmd sigschanges the set of blocked signals. | 
| sigprof [Sys] | 
Profiling interrupt
 | 
| sigquit [Sys] | 
Interactive termination
 | 
| sigsegv [Sys] | 
Invalid memory reference
 | 
| sigstop [Sys] | 
Stop
 | 
| 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] | 
Bad argument to routine
 | 
| sigterm [Sys] | 
Termination
 | 
| sigtrap [Sys] | 
Trace/breakpoint trap
 | 
| sigtstp [Sys] | 
Interactive stop
 | 
| sigttin [Sys] | 
Terminal read from background process
 | 
| sigttou [Sys] | 
Terminal write from background process
 | 
| sigurg [Sys] | 
Urgent condition on socket
 | 
| sigusr1 [Sys] | 
Application-defined signal 1
 | 
| sigusr2 [Sys] | 
Application-defined signal 2
 | 
| sigvtalrm [Sys] | 
Timeout in virtual time
 | 
| sigxcpu [Sys] | 
Timeout in cpu time
 | 
| sigxfsz [Sys] | 
File size limit exceeded
 | 
| simplify_rounds [Clflags] | |
| sin [Pervasives] | 
Sine.
 | 
| single_write [UnixLabels] | 
Same as  write, but attempts to write only once. | 
| single_write [Unix] | 
Same as  write, but attempts to write only once. | 
| single_write_substring [UnixLabels] | 
Same as  single_write, but take the data from a string instead of
    a byte sequence. | 
| single_write_substring [Unix] | 
Same as  single_write, but take the data from a string instead of
    a byte sequence. | 
| singleton [MoreLabels.Set.S] | |
| singleton [MoreLabels.Map.S] | |
| singleton [Map.S] | singleton x yreturns the one-element map that contains a bindingyforx. | 
| singleton [Set.S] | singleton xreturns the one-element set containing onlyx. | 
| sinh [Pervasives] | 
Hyperbolic sine.
 | 
| size [Targetint] | 
The size in bits of a target native integer.
 | 
| size [Obj] | |
| size [Nativeint] | 
The size in bits of a native integer.
 | 
| size_in_bytes [Bigarray.Array3] | |
| size_in_bytes [Bigarray.Array2] | |
| size_in_bytes [Bigarray.Array1] | |
| size_in_bytes [Bigarray.Array0] | |
| size_in_bytes [Bigarray.Genarray] | |
| size_x [Graphics] | 
See  Graphics.size_y. | 
| size_y [Graphics] | 
Return the size of the graphics window.
 | 
| skip_hash_bang [Lexer] | |
| sleep [UnixLabels] | 
Stop execution for the given number of seconds.
 | 
| sleep [Unix] | 
Stop execution for the given number of seconds.
 | 
| sleep [ThreadUnix] | |
| sleepf [Unix] | 
Stop execution for the given number of seconds.
 | 
| slice [Bigarray.Array1] | 
Extract a scalar (zero-dimensional slice) of the given one-dimensional
     big array.
 | 
| slice_left [Bigarray.Array2] | 
Extract a row (one-dimensional slice) of the given two-dimensional
     big array.
 | 
| slice_left [Bigarray.Genarray] | 
Extract a sub-array of lower dimension from the given big array
     by fixing one or several of the first (left-most) coordinates.
 | 
| slice_left_1 [Bigarray.Array3] | 
Extract a one-dimensional slice of the given three-dimensional
     big array by fixing the first two coordinates.
 | 
| slice_left_2 [Bigarray.Array3] | 
Extract a  two-dimensional slice of the given three-dimensional
     big array by fixing the first coordinate.
 | 
| slice_right [Bigarray.Array2] | 
Extract a column (one-dimensional slice) of the given
     two-dimensional big array.
 | 
| slice_right [Bigarray.Genarray] | 
Extract a sub-array of lower dimension from the given big array
     by fixing one or several of the last (right-most) coordinates.
 | 
| slice_right_1 [Bigarray.Array3] | 
Extract a one-dimensional slice of the given three-dimensional
     big array by fixing the last two coordinates.
 | 
| slice_right_2 [Bigarray.Array3] | 
Extract a two-dimensional slice of the given
     three-dimensional big array by fixing the last coordinate.
 | 
| snd [Pervasives] | 
Return the second component of a pair.
 | 
| snd3 [Misc] | |
| snd4 [Misc] | |
| socket [UnixLabels] | 
Create a new socket in the given domain, and with the
   given kind.
 | 
| socket [Unix] | 
Create a new socket in the given domain, and with the
   given kind.
 | 
| socket [ThreadUnix] | |
| socketpair [UnixLabels] | 
Create a pair of unnamed sockets, connected together.
 | 
| socketpair [Unix] | 
Create a pair of unnamed sockets, connected together.
 | 
| some_if_all_elements_are_some [Misc.Stdlib.List] | 
If all elements of the given list are  Some _thenSome xsis returned with thexsbeing the contents of thoseSomes, with
        order preserved. | 
| sort [ListLabels] | 
Sort a list in increasing order according to a comparison
   function.
 | 
| sort [List] | 
Sort a list in increasing order according to a comparison
   function.
 | 
| sort [ArrayLabels] | 
Sort an array in increasing order according to a comparison
   function.
 | 
| sort [Array] | 
Sort an array in increasing order according to a comparison
   function.
 | 
| sort_uniq [ListLabels] | 
Same as  List.sort, but also remove duplicates. | 
| sort_uniq [List] | 
Same as  List.sort, but also remove duplicates. | 
| sound [Graphics] | sound freq durplays a sound at frequencyfreq(in hertz)
   for a durationdur(in milliseconds). | 
| source [Consistbl] | |
| spacetime [Config] | |
| spellcheck [Misc] | spellcheck env nametakes a list of namesenvthat exist in
    the current environment and an erroneousname, and returns a
    list of suggestions taken fromenv, that are close enough tonamethat it may be a typo for one of them. | 
| split [Str] | split r ssplitssinto substrings, taking as delimiters
   the substrings that matchr, and returns the list of substrings. | 
| split [MoreLabels.Set.S] | |
| split [MoreLabels.Map.S] | |
| 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 [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 [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_at [Misc.Stdlib.List] | split_at n lreturns the pairbefore, afterwherebeforeis
        thenfirst elements oflandafterthe remaining ones. | 
| 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_last [Misc] | |
| split_on_char [String] | String.split_on_char sep sreturns the list of all (possibly empty)
    substrings ofsthat are delimited by thesepcharacter. | 
| split_on_char [StringLabels] | String.split_on_char sep sreturns the list of all (possibly empty)
    substrings 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 [Pervasives] | 
Square root.
 | 
| sqrt [Complex] | 
Square root.
 | 
| sqrt_big_int [Big_int] | sqrt_big_int areturns the integer square root ofa,
           that is, the largest big integerrsuch thatr * r <= a. | 
| square_big_int [Big_int] | 
Return the square of the given big integer
 | 
| square_num [Num] | 
Squaring
 | 
| sscanf [Scanf] | 
Same as  Scanf.bscanf, but reads from the given string. | 
| sscanf_format [Scanf] | 
Same as  Scanf.bscanf_format, but reads from the given string. | 
| stable_sort [ListLabels] | 
Same as  List.sort, but the sorting algorithm is guaranteed to
   be stable (i.e. | 
| stable_sort [List] | 
Same as  List.sort, but the sorting algorithm is guaranteed to
   be stable (i.e. | 
| stable_sort [ArrayLabels] | 
Same as  Array.sort, but the sorting algorithm is stable (i.e. | 
| stable_sort [Array] | 
Same as  Array.sort, but the sorting algorithm is stable (i.e. | 
| stack_safety_margin [Config] | |
| stack_threshold [Config] | |
| standard_library [Config] | |
| standard_runtime [Config] | |
| standout [Terminfo] | |
| stat [UnixLabels.LargeFile] | |
| stat [UnixLabels] | 
Return the information for the named file.
 | 
| stat [Unix.LargeFile] | |
| stat [Unix] | 
Return the information for the named file.
 | 
| stat [Gc] | 
Return the current values of the memory management counters in a
    statrecord. | 
| stats [Weak.S] | 
Return statistics on the table.
 | 
| stats [MoreLabels.Hashtbl.SeededS] | |
| stats [MoreLabels.Hashtbl.S] | |
| stats [MoreLabels.Hashtbl] | |
| stats [Hashtbl.SeededS] | |
| stats [Hashtbl.S] | |
| stats [Hashtbl] | Hashtbl.stats tblreturns statistics about the tabletbl:
   number of buckets, size of the biggest bucket, distribution of
   buckets by size. | 
| stats [CamlinternalOO] | |
| stats_alive [Ephemeron.SeededS] | 
same as  Hashtbl.SeededS.statsbut only count the alive bindings | 
| stats_alive [Ephemeron.S] | 
same as  Hashtbl.SeededS.statsbut only count the alive bindings | 
| std_formatter [Format] | 
The standard formatter used by the formatting functions
  above.
 | 
| std_include_dir [Clflags] | |
| std_include_flag [Clflags] | |
| stdbuf [Format] | 
The string buffer in which  str_formatterwrites. | 
| stderr [UnixLabels] | 
File descriptor for standard error.
 | 
| stderr [Unix] | 
File descriptor for standard error.
 | 
| stderr [Pervasives] | 
The standard error output for the process.
 | 
| stdib [Scanf.Scanning] | 
A deprecated alias for  Scanf.Scanning.stdin, the scanning buffer reading fromstdin. | 
| 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 [Pervasives] | 
The standard input for the process.
 | 
| stdout [UnixLabels] | 
File descriptor for standard output.
 | 
| stdout [Unix] | 
File descriptor for standard output.
 | 
| stdout [Pervasives] | 
The standard output for the process.
 | 
| str_formatter [Format] | 
A formatter to use with formatting functions below for
  output to the  stdbufstring buffer. | 
| strict_formats [Clflags] | |
| strict_sequence [Clflags] | |
| string [Digest] | 
Return the digest of the given string.
 | 
| string [Ast_helper.Const] | |
| string_after [Str] | string_after s 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_big_int [Big_int] | 
Return the string representation of the given big integer,
            in decimal (base 10).
 | 
| string_of_bool [Pervasives] | 
Return the string representation of a boolean.
 | 
| string_of_expression [Pprintast] | |
| string_of_file [Misc] | |
| string_of_float [Pervasives] | 
Return the string representation of a floating-point number.
 | 
| string_of_fmt [CamlinternalFormat] | |
| string_of_fmtty [CamlinternalFormat] | |
| string_of_format [Pervasives] | 
Converts a format string into a string.
 | 
| string_of_formatting_gen [CamlinternalFormat] | |
| string_of_formatting_lit [CamlinternalFormat] | |
| string_of_inet_addr [UnixLabels] | 
Return the printable representation of the given Internet address.
 | 
| string_of_inet_addr [Unix] | 
Return the printable representation of the given Internet address.
 | 
| string_of_int [Pervasives] | 
Return the string representation of an integer, in decimal.
 | 
| string_of_num [Num] | 
Convert a number to a string, using fractional notation.
 | 
| string_of_structure [Pprintast] | |
| string_partial_match [Str] | 
Similar to  Str.string_match, but also returns true if
   the argument string is a prefix of a string that matches. | 
| string_tag [Obj] | |
| strput_acc [CamlinternalFormat] | |
| structure [Printast] | |
| structure [Pprintast] | |
| structure [Ast_invariants] | |
| structure [Ast_helper.Cl] | |
| structure [Ast_helper.Mod] | |
| sub [Targetint] | 
Subtraction.
 | 
| sub [String] | String.sub s start lenreturns a fresh string of lengthlen,
   containing the substring ofsthat starts at positionstartand
   has lengthlen. | 
| sub [StringLabels] | String.sub s start lenreturns a fresh string of lengthlen,
   containing the substring ofsthat starts at positionstartand
   has lengthlen. | 
| sub [Nativeint] | 
Subtraction.
 | 
| sub [Int64] | 
Subtraction.
 | 
| sub [Int32] | 
Subtraction.
 | 
| sub [Complex] | 
Subtraction
 | 
| sub [BytesLabels] | sub s start lenreturns a new byte sequence of lengthlen,
    containing the subsequence ofsthat starts at positionstartand has lengthlen. | 
| sub [Bytes] | sub s start lenreturns a new byte sequence of lengthlen,
    containing the subsequence ofsthat starts at positionstartand 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 big array.
 | 
| sub [ArrayLabels] | Array.sub a start lenreturns a fresh array of lengthlen,
   containing the elements numberstarttostart + len - 1of arraya. | 
| sub [Array] | Array.sub a start lenreturns a fresh array of lengthlen,
   containing the elements numberstarttostart + len - 1of arraya. | 
| sub_big_int [Big_int] | 
Subtraction.
 | 
| sub_left [Bigarray.Array3] | 
Extract a three-dimensional sub-array of the given
     three-dimensional big array by restricting the first dimension.
 | 
| sub_left [Bigarray.Array2] | 
Extract a two-dimensional sub-array of the given two-dimensional
     big array by restricting the first dimension.
 | 
| sub_left [Bigarray.Genarray] | 
Extract a sub-array of the given big array by restricting the
     first (left-most) dimension.
 | 
| sub_num [Num] | 
Subtraction
 | 
| sub_right [Bigarray.Array3] | 
Extract a three-dimensional sub-array of the given
     three-dimensional big array by restricting the second dimension.
 | 
| sub_right [Bigarray.Array2] | 
Extract a two-dimensional sub-array of the given two-dimensional
     big array by restricting the second dimension.
 | 
| sub_right [Bigarray.Genarray] | 
Extract a sub-array of the given big array by restricting the
     last (right-most) dimension.
 | 
| sub_string [BytesLabels] | 
Same as  subbut return a string instead of a byte sequence. | 
| sub_string [Bytes] | 
Same as  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 [MoreLabels.Set.S] | |
| subset [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 [Targetint] | 
Successor.
 | 
| succ [Pervasives] | succ xisx + 1. | 
| succ [Nativeint] | 
Successor.
 | 
| succ [Int64] | 
Successor.
 | 
| succ [Int32] | 
Successor.
 | 
| succ_big_int [Big_int] | 
Successor (add 1).
 | 
| succ_num [Num] | succ nisn+1 | 
| symbol_docs [Docstrings] | 
Fetch the item documentation for the current symbol.
 | 
| symbol_docs_lazy [Docstrings] | |
| symbol_end [Parsing] | 
See  Parsing.symbol_start. | 
| symbol_end_pos [Parsing] | 
Same as  symbol_end, but return apositioninstead of an offset. | 
| symbol_gloc [Location] | |
| symbol_info [Docstrings] | 
Fetch the field info for the current symbol.
 | 
| symbol_post_extra_text [Docstrings] | 
Fetch additional text following the current symbol
 | 
| symbol_pre_extra_text [Docstrings] | 
Fetch additional text preceding the current symbol
 | 
| symbol_rloc [Location] | |
| symbol_start [Parsing] | symbol_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. | 
| symbol_text [Docstrings] | 
Fetch the text preceding the current symbol.
 | 
| symbol_text_lazy [Docstrings] | |
| symlink [UnixLabels] | symlink source destcreates the filedestas a symbolic link
   to the filesource. | 
| symlink [Unix] | symlink ?to_dir source destcreates the filedestas a symbolic link
   to the filesource. | 
| symm [CamlinternalFormat] | |
| sync [Event] | 
'Synchronize' on an event: offer all the communication
   possibilities specified in the event to the outside world,
   and block until one of the communications succeed.
 | 
| synchronize [Graphics] | 
Synchronize the backing store and the on-screen window, by
   copying the contents of the backing store onto the graphics
   window.
 | 
| system [UnixLabels] | 
Execute the given command, wait until it terminates, and return
   its termination status.
 | 
| system [Unix] | 
Execute the given command, wait until it terminates, and return
   its termination status.
 | 
| system [ThreadUnix] | |
| system [Config] | |
| systhread_supported [Config] | |
| T | |
| tag [Obj] | |
| take [Spacetime.Snapshot] | take seriestakes a snapshot of the profiling annotations on the values
      in the minor and major heaps, together with GC stats, and write the
      result to theseriesfile. | 
| take [Queue] | take qremoves and returns the first element in queueq,
   or raisesQueue.Emptyif the queue is empty. | 
| tan [Pervasives] | 
Tangent.
 | 
| tanh [Pervasives] | 
Hyperbolic tangent.
 | 
| target [Config] | |
| tcdrain [UnixLabels] | 
Waits until all output written on the given file descriptor
   has been transmitted.
 | 
| tcdrain [Unix] | 
Waits until all output written on the given file descriptor
   has been transmitted.
 | 
| tcflow [UnixLabels] | 
Suspend or restart reception or transmission of data on
   the given file descriptor, depending on the second argument:
    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. | 
| text [Ast_helper.Cf] | |
| text [Ast_helper.Ctf] | |
| text [Ast_helper.Str] | |
| text [Ast_helper.Sig] | |
| text_attr [Docstrings] | |
| text_size [Graphics] | 
Return the dimensions of the given text, if it were drawn with
   the current font and size.
 | 
| thd3 [Misc] | |
| thd4 [Misc] | |
| time [UnixLabels] | 
Return the current time since 00:00:00 GMT, Jan.
 | 
| time [Unix] | 
Return the current time since 00:00:00 GMT, Jan.
 | 
| time [Timings] | time pass f argrecords the runtime off arg | 
| time [Sys] | 
Return the processor time, in seconds, used by the program
   since the beginning of execution.
 | 
| time_call [Timings] | time_call pass fcallsfand records its runtime. | 
| 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 [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_float [Targetint] | 
Convert the given target integer to a floating-point number.
 | 
| to_float [Nativeint] | 
Convert the given native integer to a floating-point number.
 | 
| to_float [Int64] | 
Convert the given 64-bit integer to a floating-point number.
 | 
| to_float [Int32] | 
Convert the given 32-bit integer to a floating-point number.
 | 
| to_hex [Digest] | 
Return the printable hexadecimal representation of the given digest.
 | 
| to_int [Uchar] | to_int uisuas an integer. | 
| to_int [Targetint] | 
Convert the given target integer (type  t) to an
    integer (typeint). | 
| 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_int32 [Targetint] | 
Convert the given target integer to a
    32-bit integer (type  int32). | 
| 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_int64 [Targetint] | 
Convert the given target integer to a
    64-bit integer (type  int64). | 
| to_list [Identifiable.S.Tbl] | |
| to_list [ArrayLabels] | Array.to_list areturns the list of all the elements ofa. | 
| to_list [Array] | Array.to_list areturns the list of all the elements ofa. | 
| to_map [Identifiable.S.Tbl] | |
| to_nativeint [Int64] | 
Convert the given 64-bit integer (type  int64) to a
   native integer. | 
| to_string [Targetint] | 
Return the string representation of its argument, in decimal.
 | 
| 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 [Identifiable.S.Set] | |
| to_string [BytesLabels] | 
Return a new string that contains the same bytes as the given byte
    sequence.
 | 
| to_string [Bytes] | 
Return a new string that contains the same bytes as the given byte
    sequence.
 | 
| token [Lexer] | |
| token_with_comments [Lexer] | |
| tool_name [Ast_mapper] | 
Can be used within a ppx preprocessor to know which tool is
    calling it  "ocamlc","ocamlopt","ocamldoc","ocamldep","ocaml", ... | 
| top [Stack] | |
| top [Queue] | topis a synonym forpeek. | 
| top_phrase [Printast] | |
| top_phrase [Pprintast] | |
| toplevel_phrase [Pprintast] | |
| toplevel_phrase [Parser] | |
| toplevel_phrase [Parse] | |
| total_size [Marshal] | 
See  Marshal.header_size. | 
| trans [CamlinternalFormat] | |
| transfer [Queue] | transfer q1 q2adds all ofq1's elements at the end of
   the queueq2, then clearsq1. | 
| transp [Graphics] | 
In matrices of colors, this color represent a 'transparent'
   point: when drawing the corresponding image, all pixels on the
   screen corresponding to a transparent pixel in the image will
   not be modified, while other points will be set to the color
   of the corresponding point in the image.
 | 
| transparent_modules [Clflags] | |
| transpose_keys_and_data [Identifiable.S.Map] | |
| transpose_keys_and_data_set [Identifiable.S.Map] | |
| trim [String] | 
Return a copy of the argument, without leading and trailing
   whitespace.
 | 
| trim [StringLabels] | 
Return a copy of the argument, without leading and trailing
   whitespace.
 | 
| trim [BytesLabels] | 
Return a copy of the argument, without leading and trailing
    whitespace.
 | 
| trim [Bytes] | 
Return a copy of the argument, without leading and trailing
    whitespace.
 | 
| truncate [UnixLabels.LargeFile] | |
| truncate [UnixLabels] | 
Truncates the named file to the given size.
 | 
| truncate [Unix.LargeFile] | 
See  Unix.truncate. | 
| truncate [Unix] | 
Truncates the named file to the given size.
 | 
| truncate [Pervasives] | 
Same as  int_of_float. | 
| truncate [Obj] | |
| truncate [Buffer] | truncate b lentruncates the length ofbtolenNote: the internal byte sequence is not shortened. | 
| try_ [Ast_helper.Exp] | |
| try_finally [Misc] | |
| try_lock [Mutex] | 
Same as  Mutex.lock, but does not suspend the calling thread if
   the mutex is already locked: just returnfalseimmediately
   in that case. | 
| tuple [Ast_helper.Exp] | |
| tuple [Ast_helper.Pat] | |
| tuple [Ast_helper.Typ] | |
| type_ [Ast_helper.Str] | |
| type_ [Ast_helper.Sig] | |
| type_ [Ast_helper.Pat] | |
| type_extension [Ast_helper.Str] | |
| type_extension [Ast_helper.Sig] | |
| type_format [CamlinternalFormat] | |
| typeof_ [Ast_helper.Mty] | |
| U | |
| umask [UnixLabels] | 
Set the process's file mode creation mask, and return the previous
    mask.
 | 
| umask [Unix] | 
Set the process's file mode creation mask, and return the previous
    mask.
 | 
| unaligned_tag [Obj] | |
| unbox_closures [Clflags] | |
| unbox_closures_factor [Clflags] | |
| unbox_free_vars_of_closures [Clflags] | |
| unbox_specialised_args [Clflags] | |
| unboxed_types [Clflags] | |
| uncapitalize [String] | 
Return a copy of the argument, with the first character set to lowercase,
   using the ISO Latin-1 (8859-1) character set..
 | 
| uncapitalize [StringLabels] | 
Return a copy of the argument, with the first character set to lowercase,
   using the ISO Latin-1 (8859-1) character set..
 | 
| uncapitalize [BytesLabels] | 
Return a copy of the argument, with the first character set to lowercase,
   using the ISO Latin-1 (8859-1) character set..
 | 
| uncapitalize [Bytes] | 
Return a copy of the argument, with the first character set to lowercase,
   using the ISO Latin-1 (8859-1) character set..
 | 
| uncapitalize_ascii [String] | 
Return a copy of the argument, with the first character set to lowercase,
   using the US-ASCII character set.
 | 
| uncapitalize_ascii [StringLabels] | 
Return a copy of the argument, with the first character set to lowercase,
   using the US-ASCII character set.
 | 
| uncapitalize_ascii [BytesLabels] | 
Return a copy of the argument, with the first character set to lowercase,
   using the US-ASCII character set.
 | 
| uncapitalize_ascii [Bytes] | 
Return a copy of the argument, with the first character set to lowercase,
   using the US-ASCII character set.
 | 
| unescaped [Scanf] | unescaped sreturn a copy ofswith escape sequences (according to
    the lexical conventions of OCaml) replaced by their corresponding special
    characters. | 
| union [MoreLabels.Set.S] | |
| union [MoreLabels.Map.S] | |
| union [Map.S] | union f m1 m2computes a map whose keys is the union of keys
        ofm1and ofm2. | 
| union [Set.S] | 
Set union.
 | 
| union_left [Identifiable.S.Map] | union_left m1 m2 = union_right m2 m1 | 
| union_merge [Identifiable.S.Map] | |
| union_right [Identifiable.S.Map] | union_right m1 m2contains all bindings fromm1andm2. | 
| unit_big_int [Big_int] | 
The big integer  1. | 
| unix [Sys] | 
True if  Sys.os_type = "Unix". | 
| unlink [UnixLabels] | 
Removes the named file
 | 
| unlink [Unix] | 
Removes the named file.
 | 
| unlock [Mutex] | 
Unlock the given mutex.
 | 
| unmarshal [Obj] | |
| unpack [Ast_helper.Mod] | |
| unpack [Ast_helper.Pat] | |
| unreachable [Ast_helper.Exp] | |
| unsafe_blit_to_bytes [Misc.LongString] | |
| unsafe_get [Bigarray.Array3] | 
Like  Bigarray.Array3.get, but bounds checking is not always
      performed. | 
| unsafe_get [Bigarray.Array2] | 
Like  Bigarray.Array2.get, but bounds checking is not always
      performed. | 
| unsafe_get [Bigarray.Array1] | 
Like  Bigarray.Array1.get, but bounds checking is not always performed. | 
| unsafe_of_string [Bytes] | 
Unsafely convert a shared string to a byte sequence that should
    not be mutated.
 | 
| unsafe_set [Bigarray.Array3] | 
Like  Bigarray.Array3.set, but bounds checking is not always
      performed. | 
| unsafe_set [Bigarray.Array2] | 
Like  Bigarray.Array2.set, but bounds checking is not always
      performed. | 
| unsafe_set [Bigarray.Array1] | 
Like  Bigarray.Array1.set, but bounds checking is not always performed. | 
| unsafe_string [Clflags] | |
| unsafe_to_string [Bytes] | 
Unsafely convert a byte sequence into a string.
 | 
| unset_data [Obj.Ephemeron] | 
Same as  Ephemeron.K1.unset_data | 
| unset_data [Ephemeron.Kn] | 
Same as  Ephemeron.K1.unset_data | 
| unset_data [Ephemeron.K2] | 
Same as  Ephemeron.K1.unset_data | 
| unset_data [Ephemeron.K1] | Ephemeron.K1.unset_data eph elsets the key ofephto be an
      empty key. | 
| unset_key [Obj.Ephemeron] | 
Same as  Ephemeron.K1.unset_key | 
| unset_key [Ephemeron.Kn] | 
Same as  Ephemeron.K1.unset_key | 
| unset_key [Ephemeron.K1] | Ephemeron.K1.unset_key eph elsets the key ofephto be an
      empty key. | 
| unset_key1 [Ephemeron.K2] | 
Same as  Ephemeron.K1.unset_key | 
| unset_key2 [Ephemeron.K2] | 
Same as  Ephemeron.K1.unset_key | 
| update_mod [CamlinternalMod] | |
| uppercase [String] | 
Return a copy of the argument, with all lowercase letters
   translated to uppercase, including accented letters of the ISO
   Latin-1 (8859-1) character set.
 | 
| uppercase [StringLabels] | 
Return a copy of the argument, with all lowercase letters
   translated to uppercase, including accented letters of the ISO
   Latin-1 (8859-1) character set.
 | 
| uppercase [Char] | 
Convert the given character to its equivalent uppercase character,
   using the ISO Latin-1 (8859-1) character set.
 | 
| uppercase [BytesLabels] | 
Return a copy of the argument, with all lowercase letters
   translated to uppercase, including accented letters of the ISO
   Latin-1 (8859-1) character set.
 | 
| uppercase [Bytes] | 
Return a copy of the argument, with all lowercase letters
   translated to uppercase, including accented letters of the ISO
   Latin-1 (8859-1) character set.
 | 
| uppercase_ascii [String] | 
Return a copy of the argument, with all lowercase letters
   translated to uppercase, using the US-ASCII character set.
 | 
| uppercase_ascii [StringLabels] | 
Return a copy of the argument, with all lowercase letters
   translated to uppercase, using the US-ASCII character set.
 | 
| uppercase_ascii [Char] | 
Convert the given character to its equivalent uppercase character,
   using the US-ASCII character set.
 | 
| uppercase_ascii [BytesLabels] | 
Return a copy of the argument, with all lowercase letters
   translated to uppercase, using the US-ASCII character set.
 | 
| uppercase_ascii [Bytes] | 
Return a copy of the argument, with all lowercase letters
   translated to uppercase, using the US-ASCII character set.
 | 
| usage [Arg] | 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_file [Parser] | |
| use_file [Parse] | |
| use_inlining_arguments_set [Clflags] | 
Set all the inlining arguments for a round.
 | 
| use_prims [Clflags] | |
| use_runtime [Clflags] | |
| use_threads [Clflags] | |
| use_vmthreads [Clflags] | |
| utimes [UnixLabels] | 
Set the last access time (second arg) and last modification time
   (third arg) for a file.
 | 
| utimes [Unix] | 
Set the last access time (second arg) and last modification time
   (third arg) for a file.
 | 
| V | |
| val_ [Ast_helper.Cf] | |
| val_ [Ast_helper.Ctf] | |
| value [Ast_helper.Str] | |
| value [Ast_helper.Sig] | |
| value_default [Misc.Stdlib.Option] | |
| var [Ast_helper.Pat] | |
| var [Ast_helper.Typ] | |
| variant [Ast_helper.Exp] | |
| variant [Ast_helper.Pat] | |
| variant [Ast_helper.Typ] | |
| varify_constructors [Ast_helper.Typ] | varify_constructors newtypes teis type expressionte, of which
        any of nullary type constructortcis replaced by type variable of
        the same name, iftc's name appears innewtypes. | 
| verbose [Clflags] | |
| version [Config] | |
| virtual_ [Ast_helper.Cf] | |
| W | |
| wait [UnixLabels] | 
Wait until one of the children processes die, and return its pid
   and termination status.
 | 
| wait [Unix] | 
Wait until one of the children processes die, and return its pid
   and termination status.
 | 
| wait [ThreadUnix] | |
| wait [Condition] | wait c matomically unlocks the mutexmand suspends the
   calling process on the condition variablec. | 
| wait_next_event [Graphics] | 
Wait until one of the events specified in the given event list
   occurs, and return the status of the mouse and keyboard at
   that time.
 | 
| wait_pid [Thread] | wait_pid psuspends the execution of the calling thread
   until the process specified by the process identifierpterminates. | 
| wait_read [Thread] | 
See  Thread.wait_write. | 
| 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 is available for reading ( wait_read) or
   one character can be written without blocking (wait_write)
   on the given Unix file descriptor. | 
| wait_write [Thread] | 
This function does nothing in this implementation.
 | 
| waitpid [UnixLabels] | 
Same as  UnixLabels.wait, but waits for the child process whose pid
   is given. | 
| waitpid [Unix] | 
Same as  Unix.wait, but waits for the child process whose pid is given. | 
| waitpid [ThreadUnix] | |
| warn_bad_docstrings [Docstrings] | 
Emit warnings for unattached and ambiguous docstrings
 | 
| warn_on_literal_pattern [Builtin_attributes] | |
| warning_attribute [Builtin_attributes] | |
| warning_enter_scope [Builtin_attributes] | |
| warning_leave_scope [Builtin_attributes] | |
| warning_printer [Location] | 
Hook for intercepting warnings.
 | 
| weaken_map [Depend] | |
| while_ [Ast_helper.Exp] | |
| white [Graphics] | |
| widen [CamlinternalOO] | |
| win32 [Sys] | 
True if  Sys.os_type = "Win32". | 
| window_id [GraphicsX11] | 
Return the unique identifier of the OCaml graphics window.
 | 
| with_ [Ast_helper.Mty] | |
| with_default_loc [Ast_helper] | 
Set the  default_locwithin the scope of the execution
        of the provided function. | 
| with_frame_pointers [Config] | |
| with_warning_attribute [Builtin_attributes] | |
| word_size [Sys] | 
Size of one word on the machine currently executing the OCaml
   program, in bits: 32 or 64.
 | 
| wrap [Event] | wrap ev 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 [UnixLabels] | write fd buff ofs lenwriteslenbytes to descriptorfd,
    taking them from byte sequencebuff, starting at positionofsinbuff. | 
| write [Unix] | write fd buff ofs lenwriteslenbytes to descriptorfd,
    taking them from byte sequencebuff, starting at positionofsinbuff. | 
| write [ThreadUnix] | |
| 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 [UnixLabels] | 
Same as  write, but take the data from a string instead of a byte
    sequence. | 
| write_substring [Unix] | 
Same as  write, but take the data from a string instead of a byte
    sequence. | 
| write_substring [ThreadUnix] | |
| X | |
| xor_big_int [Big_int] | 
Bitwise logical 'exclusive or'.
 | 
| Y | |
| yellow [Graphics] | |
| yield [Thread] | 
Re-schedule the calling thread without suspending it.
 | 
| Z | |
| zero [Targetint] | 
The target integer 0.
 | 
| zero [Nativeint] | 
The native integer 0.
 | 
| zero [Int64] | 
The 64-bit integer 0.
 | 
| zero [Int32] | 
The 32-bit integer 0.
 | 
| zero [Complex] | 
The complex number  0. | 
| zero_big_int [Big_int] | 
The big integer  0. | 
| zero_to_n [Numbers.Int] | zero_to_n nis the set of numbers {0, ..., n} (inclusive). |