| ( * ) [Pervasives] | |
| ( ** ) [Pervasives] | |
| ( *. ) [Pervasives] | |
| (!) [Pervasives] | |
| (!=) [Pervasives] | |
| (&&) [Pervasives] | |
| (&&) [Bool] | 
 | 
| (&) [Pervasives] | |
| (+) [Pervasives] | |
| (+.) [Pervasives] | |
| (-) [Pervasives] | |
| (-.) [Pervasives] | |
| (/) [Pervasives] | |
| (/.) [Pervasives] | |
| (:=) [Pervasives] | |
| (<) [Pervasives] | |
| (<=) [Pervasives] | |
| (<>) [Pervasives] | |
| (=) [Pervasives] | |
| (==) [Pervasives] | |
| (>) [Pervasives] | |
| (>=) [Pervasives] | |
| (@) [Pervasives] | |
| (@@) [Pervasives] | |
| (^) [Pervasives] | |
| (^^) [Pervasives] | |
| (asr) [Pervasives] | |
| (land) [Pervasives] | |
| (lor) [Pervasives] | |
| (lsl) [Pervasives] | |
| (lsr) [Pervasives] | |
| (lxor) [Pervasives] | |
| (mod) [Pervasives] | |
| (or) [Pervasives] | |
| (|>) [Pervasives] | |
| (||) [Pervasives] | |
| (||) [Bool] | 
 | 
| (~+) [Pervasives] | |
| (~+.) [Pervasives] | |
| (~-) [Pervasives] | |
| (~-.) [Pervasives] | |
| __FILE__ [Pervasives] | |
| __LINE_OF__ [Pervasives] | |
| __LINE__ [Pervasives] | |
| __LOC_OF__ [Pervasives] | |
| __LOC__ [Pervasives] | |
| __MODULE__ [Pervasives] | |
| __POS_OF__ [Pervasives] | |
| __POS__ [Pervasives] | |
| A | |
| abs [Pervasives] | |
| abs [Nativeint] | Return the absolute value of its argument. | 
| abs [Int64] | Return the absolute value of its argument. | 
| abs [Int32] | Return the absolute value of its argument. | 
| abs [Int] | 
 | 
| abs [Float] | 
 | 
| abs_float [Pervasives] | |
| 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. | 
| acos [Pervasives] | |
| acos [Float] | Arc cosine. | 
| adapt_filename [Dynlink] | In bytecode, the identity function. | 
| add [Weak.S] | 
 | 
| add [Set.S] | 
 | 
| add [Queue] | 
 | 
| add [Nativeint] | Addition. | 
| add [MoreLabels.Set.S] | |
| add [MoreLabels.Map.S] | |
| add [MoreLabels.Hashtbl.SeededS] | |
| add [MoreLabels.Hashtbl.S] | |
| add [MoreLabels.Hashtbl] | |
| add [Map.S] | 
 | 
| add [Int64] | Addition. | 
| add [Int32] | Addition. | 
| add [Int] | 
 | 
| add [Hashtbl.SeededS] | |
| add [Hashtbl.S] | |
| add [Hashtbl] | 
 | 
| add [Float] | Floating-point addition. | 
| add [Complex] | Addition | 
| add_buffer [Buffer] | 
 | 
| add_bytes [Buffer] | 
 | 
| add_channel [Buffer] | 
 | 
| add_char [Buffer] | 
 | 
| add_in_char_set [CamlinternalFormat] | |
| add_initializer [CamlinternalOO] | |
| add_int16_be [Buffer] | 
 | 
| add_int16_le [Buffer] | 
 | 
| add_int16_ne [Buffer] | 
 | 
| add_int32_be [Buffer] | 
 | 
| add_int32_le [Buffer] | 
 | 
| add_int32_ne [Buffer] | 
 | 
| add_int64_be [Buffer] | 
 | 
| add_int64_le [Buffer] | 
 | 
| add_int64_ne [Buffer] | 
 | 
| add_int8 [Buffer] | 
 | 
| add_offset [Obj] | |
| add_seq [Stack] | Add the elements from the iterator on the top of the stack. | 
| add_seq [Set.S] | Add the given elements to the set, in order. | 
| add_seq [Queue] | Add the elements from the generator to the end of the queue | 
| add_seq [MoreLabels.Set.S] | |
| add_seq [MoreLabels.Map.S] | |
| add_seq [MoreLabels.Hashtbl.SeededS] | |
| add_seq [MoreLabels.Hashtbl.S] | |
| add_seq [MoreLabels.Hashtbl] | |
| add_seq [Map.S] | Add the given bindings to the map, in order. | 
| add_seq [Hashtbl.SeededS] | |
| add_seq [Hashtbl.S] | |
| add_seq [Hashtbl] | Add the given bindings to the table, using  | 
| add_seq [Buffer] | Add chars to the buffer | 
| add_string [Buffer] | 
 | 
| add_subbytes [Buffer] | 
 | 
| add_substitute [Buffer] | 
 | 
| add_substring [Buffer] | 
 | 
| add_symbolic_output_item [Format] | 
 | 
| add_uint16_be [Buffer] | 
 | 
| add_uint16_le [Buffer] | 
 | 
| add_uint16_ne [Buffer] | 
 | 
| add_uint8 [Buffer] | 
 | 
| add_utf_16be_uchar [Buffer] | 
 | 
| add_utf_16le_uchar [Buffer] | 
 | 
| add_utf_8_uchar [Buffer] | 
 | 
| alarm [UnixLabels] | Schedule a  | 
| alarm [Unix] | Schedule a  | 
| align [Arg] | Align the documentation strings by inserting spaces at the first alignment separator (tab or, if tab is not found, space), according to the length of the keyword. | 
| all_units [Dynlink] | Return the list of compilation units that form the main program together
    with those that have been dynamically loaded via  | 
| allocated_bytes [Gc] | Return the total number of bytes allocated since the program was started. | 
| allow_only [Dynlink] | 
 | 
| allow_unsafe_modules [Dynlink] | Govern whether unsafe object files are allowed to be dynamically linked. | 
| always [Event] | 
 | 
| append [ListLabels] | Catenate two lists. | 
| append [List] | Concatenate two lists. | 
| append [Float.ArrayLabels] | |
| append [Float.Array] | 
 | 
| append [ArrayLabels] | 
 | 
| append [Array] | 
 | 
| arg [Complex] | Argument. | 
| argv [Sys] | The command line arguments given to the process. | 
| array0_of_genarray [Bigarray] | Return the zero-dimensional Bigarray corresponding to the given generic Bigarray. | 
| array1_of_genarray [Bigarray] | Return the one-dimensional Bigarray corresponding to the given generic Bigarray. | 
| array2_of_genarray [Bigarray] | Return the two-dimensional Bigarray corresponding to the given generic Bigarray. | 
| array3_of_genarray [Bigarray] | Return the three-dimensional Bigarray corresponding to the given generic Bigarray. | 
| asin [Pervasives] | |
| asin [Float] | Arc sine. | 
| asprintf [Format] | Same as  | 
| assoc [ListLabels] | 
 | 
| assoc [List] | 
 | 
| assoc_opt [ListLabels] | 
 | 
| assoc_opt [List] | 
 | 
| assq [ListLabels] | Same as  | 
| assq [List] | Same as  | 
| assq_opt [ListLabels] | Same as  | 
| assq_opt [List] | Same as  | 
| at_exit [Pervasives] | |
| atan [Pervasives] | |
| atan [Float] | Arc tangent. | 
| atan2 [Pervasives] | |
| atan2 [Float] | 
 | 
| B | |
| backend_type [Sys] | Backend type currently executing the OCaml program. | 
| backtrace_slots [Printexc] | Returns the slots of a raw backtrace, or  | 
| backtrace_status [Printexc] | 
 | 
| basename [Filename] | Split a file name into directory name / base file name. | 
| beginning_of_input [Scanf.Scanning] | 
 | 
| big_endian [Sys] | Whether the machine currently executing the Caml program is big-endian. | 
| bind [UnixLabels] | Bind a socket to an address. | 
| bind [Unix] | Bind a socket to an address. | 
| bind [Result] | 
 | 
| bind [Option] | 
 | 
| 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. | 
| blit [Weak] | 
 | 
| blit [String] | Same as  | 
| blit [StringLabels] | 
 | 
| blit [Float.ArrayLabels] | |
| blit [Float.Array] | 
 | 
| blit [BytesLabels] | 
 | 
| blit [Bytes] | 
 | 
| blit [Buffer] | 
 | 
| blit [Bigarray.Array3] | Copy the first Bigarray to the second Bigarray. | 
| blit [Bigarray.Array2] | Copy the first Bigarray to the second Bigarray. | 
| blit [Bigarray.Array1] | Copy the first Bigarray to the second Bigarray. | 
| blit [Bigarray.Array0] | Copy the first Bigarray to the second Bigarray. | 
| blit [Bigarray.Genarray] | Copy all elements of a Bigarray in another Bigarray. | 
| blit [ArrayLabels] | 
 | 
| blit [Array] | 
 | 
| blit_data [Obj.Ephemeron] | Same as  | 
| blit_data [Ephemeron.Kn] | Same as  | 
| blit_data [Ephemeron.K2] | Same as  | 
| blit_data [Ephemeron.K1] | 
 | 
| blit_key [Obj.Ephemeron] | Same as  | 
| blit_key [Ephemeron.Kn] | Same as  | 
| blit_key [Ephemeron.K1] | 
 | 
| blit_key1 [Ephemeron.K2] | Same as  | 
| blit_key12 [Ephemeron.K2] | Same as  | 
| blit_key2 [Ephemeron.K2] | Same as  | 
| blit_string [BytesLabels] | 
 | 
| blit_string [Bytes] | 
 | 
| bom [Uchar] | 
 | 
| 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] | 
 | 
| bool_of_string [Pervasives] | |
| bool_of_string_opt [Pervasives] | |
| bounded_full_split [Str] | Same as  | 
| bounded_split [Str] | Same as  | 
| bounded_split_delim [Str] | Same as  | 
| bprintf [Printf] | Same as  | 
| bprintf [Format] | |
| broadcast [Condition] | 
 | 
| bscanf [Scanf] | |
| bscanf_format [Scanf] | 
 | 
| bufput_acc [CamlinternalFormat] | |
| bytes [Digest] | Return the digest of the given byte sequence. | 
| C | |
| c_layout [Bigarray] | |
| capitalize [String] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.. | 
| capitalize [StringLabels] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.. | 
| capitalize [BytesLabels] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.. | 
| capitalize [Bytes] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.. | 
| capitalize_ascii [String] | 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 [Set.S] | Return the number of elements of a set. | 
| cardinal [MoreLabels.Set.S] | |
| cardinal [MoreLabels.Map.S] | |
| cardinal [Map.S] | Return the number of bindings of a map. | 
| cat [BytesLabels] | 
 | 
| cat [Bytes] | 
 | 
| catch [Printexc] | 
 | 
| catch_break [Sys] | 
 | 
| ceil [Pervasives] | |
| ceil [Float] | Round above to an integer value. | 
| change_layout [Bigarray.Array3] | 
 | 
| change_layout [Bigarray.Array2] | 
 | 
| change_layout [Bigarray.Array1] | 
 | 
| change_layout [Bigarray.Array0] | 
 | 
| change_layout [Bigarray.Genarray] | 
 | 
| channel [Digest] | If  | 
| char [Bigarray] | As shown by the types of the values above,
   Bigarrays of kind  | 
| char_of_iconv [CamlinternalFormat] | |
| char_of_int [Pervasives] | |
| 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] | 
 | 
| check_data [Obj.Ephemeron] | Same as  | 
| check_data [Ephemeron.Kn] | Same as  | 
| check_data [Ephemeron.K2] | Same as  | 
| check_data [Ephemeron.K1] | 
 | 
| check_geometry [Format] | Check if the formatter geometry is valid:  | 
| check_key [Obj.Ephemeron] | Same as  | 
| check_key [Ephemeron.Kn] | Same as  | 
| check_key [Ephemeron.K1] | 
 | 
| check_key1 [Ephemeron.K2] | Same as  | 
| check_key2 [Ephemeron.K2] | Same as  | 
| check_suffix [Filename] | 
 | 
| chmod [UnixLabels] | Change the permissions of the named file. | 
| chmod [Unix] | Change the permissions of the named file. | 
| choose [Set.S] | Return one element of the given set, or raise  | 
| choose [MoreLabels.Set.S] | |
| choose [MoreLabels.Map.S] | |
| choose [Map.S] | Return one binding of the given map, or raise  | 
| choose [Event] | 
 | 
| choose_opt [Set.S] | Return one element of the given set, or  | 
| choose_opt [MoreLabels.Set.S] | |
| choose_opt [MoreLabels.Map.S] | |
| choose_opt [Map.S] | Return one binding of the given map, or  | 
| chop_extension [Filename] | Same as  | 
| chop_suffix [Filename] | 
 | 
| chop_suffix_opt [Filename] | 
 | 
| chown [UnixLabels] | Change the owner uid and owner gid of the named file. | 
| chown [Unix] | Change the owner uid and owner gid of the named file. | 
| chr [Char] | Return the character with the given ASCII code. | 
| chroot [UnixLabels] | Change the process root directory. | 
| chroot [Unix] | Change the process root directory. | 
| classify_float [Pervasives] | |
| classify_float [Float] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number. | 
| clean [Ephemeron.SeededS] | remove all dead bindings. | 
| clean [Ephemeron.S] | remove all dead bindings. | 
| clear [Weak.S] | Remove all elements from the table. | 
| clear [Stack] | Discard all elements from a stack. | 
| clear [Queue] | Discard all elements from a queue. | 
| clear [MoreLabels.Hashtbl.SeededS] | |
| clear [MoreLabels.Hashtbl.S] | |
| clear [MoreLabels.Hashtbl] | |
| clear [Hashtbl.SeededS] | |
| clear [Hashtbl.S] | |
| clear [Hashtbl] | Empty a hash table. | 
| clear [Buffer] | Empty the buffer. | 
| clear_close_on_exec [UnixLabels] | Clear the ``close-on-exec'' flag on the given descriptor. | 
| clear_close_on_exec [Unix] | Clear the ``close-on-exec'' flag on the given descriptor. | 
| clear_nonblock [UnixLabels] | Clear the ``non-blocking'' flag on the given descriptor. | 
| clear_nonblock [Unix] | Clear the ``non-blocking'' flag on the given descriptor. | 
| clear_parser [Parsing] | Empty the parser stack. | 
| clear_symbolic_output_buffer [Format] | 
 | 
| close [UnixLabels] | Close a file descriptor. | 
| close [Unix] | Close a file descriptor. | 
| close_box [Format] | Closes the most recently open pretty-printing box. | 
| close_in [Scanf.Scanning] | Closes the  | 
| close_in [Pervasives] | |
| close_in_noerr [Pervasives] | |
| close_out [Pervasives] | |
| close_out_noerr [Pervasives] | |
| close_process [UnixLabels] | Close channels opened by  | 
| close_process [Unix] | Close channels opened by  | 
| close_process_full [UnixLabels] | Close channels opened by  | 
| close_process_full [Unix] | Close channels opened by  | 
| close_process_in [UnixLabels] | Close channels opened by  | 
| close_process_in [Unix] | Close channels opened by  | 
| close_process_out [UnixLabels] | Close channels opened by  | 
| close_process_out [Unix] | Close channels opened by  | 
| close_stag [Format] | 
 | 
| close_tag [Format] | |
| close_tbox [Format] | Closes the most recently opened tabulation box. | 
| closedir [UnixLabels] | Close a directory descriptor. | 
| closedir [Unix] | Close a directory descriptor. | 
| closure_tag [Obj] | |
| code [Char] | Return the ASCII code of the argument. | 
| combine [ListLabels] | Transform a pair of lists into a list of pairs:
    | 
| combine [List] | Transform a pair of lists into a list of pairs:
    | 
| command [Sys] | Execute the given shell command and return its exit code. | 
| compact [Gc] | Perform a full major collection and compact the heap. | 
| compare [Unit] | 
 | 
| compare [Uchar] | 
 | 
| compare [String] | The comparison function for strings, with the same specification as
     | 
| compare [StringLabels] | The comparison function for strings, with the same specification as
     | 
| compare [Set.S] | Total ordering between sets. | 
| compare [Result] | 
 | 
| compare [Pervasives] | |
| compare [Option] | 
 | 
| compare [Nativeint] | The comparison function for native integers, with the same specification as
     | 
| compare [Set.OrderedType] | A total ordering function over the set elements. | 
| compare [MoreLabels.Set.S] | |
| compare [MoreLabels.Map.S] | |
| compare [Map.OrderedType] | A total ordering function over the keys. | 
| compare [Map.S] | Total ordering between maps. | 
| compare [Int64] | The comparison function for 64-bit integers, with the same specification as
     | 
| compare [Int32] | The comparison function for 32-bit integers, with the same specification as
     | 
| compare [Int] | 
 | 
| compare [Float] | 
 | 
| compare [Digest] | The comparison function for 16-character digest, with the same
    specification as  | 
| compare [Char] | The comparison function for characters, with the same specification as
     | 
| compare [BytesLabels] | The comparison function for byte sequences, with the same
    specification as  | 
| compare [Bytes] | The comparison function for byte sequences, with the same
    specification as  | 
| compare [Bool] | 
 | 
| compare_length_with [ListLabels] | Compare the length of a list to an integer. | 
| compare_length_with [List] | Compare the length of a list to an integer. | 
| compare_lengths [ListLabels] | Compare the lengths of two lists. | 
| compare_lengths [List] | Compare the lengths of two lists. | 
| complex32 [Bigarray] | See  | 
| complex64 [Bigarray] | See  | 
| concat [String] | 
 | 
| concat [StringLabels] | 
 | 
| concat [ListLabels] | Concatenate a list of lists. | 
| concat [List] | Concatenate a list of lists. | 
| concat [Float.ArrayLabels] | |
| concat [Float.Array] | Same as  | 
| concat [Filename] | 
 | 
| concat [BytesLabels] | 
 | 
| concat [Bytes] | 
 | 
| concat [ArrayLabels] | Same as  | 
| concat [Array] | Same as  | 
| concat_fmt [CamlinternalFormatBasics] | |
| concat_fmtty [CamlinternalFormatBasics] | |
| conj [Complex] | Conjugate: given the complex  | 
| connect [UnixLabels] | Connect a socket to an address. | 
| connect [Unix] | Connect a socket to an address. | 
| connect [ThreadUnix] | |
| cons [ListLabels] | 
 | 
| cons [List] | 
 | 
| const [Fun] | 
 | 
| contains [String] | 
 | 
| contains [StringLabels] | 
 | 
| contains [BytesLabels] | 
 | 
| contains [Bytes] | 
 | 
| contains_from [String] | 
 | 
| contains_from [StringLabels] | 
 | 
| contains_from [BytesLabels] | 
 | 
| contains_from [Bytes] | 
 | 
| contents [Buffer] | Return a copy of the current contents of the buffer. | 
| convert_raw_backtrace_slot [Printexc] | Extracts the user-friendly  | 
| 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] | 
 | 
| 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 [Float.ArrayLabels] | |
| copy [Float.Array] | 
 | 
| 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] | 
 | 
| copy [Array] | 
 | 
| copy_sign [Float] | 
 | 
| copysign [Pervasives] | |
| cos [Pervasives] | |
| cos [Float] | Cosine. | 
| cosh [Pervasives] | |
| cosh [Float] | 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  | 
| create [Thread] | 
 | 
| create [Weak.S] | 
 | 
| create [Weak] | 
 | 
| create [String] | 
 | 
| create [StringLabels] | 
 | 
| create [Stack] | Return a new stack, initially empty. | 
| create [Spacetime.Series] | 
 | 
| create [Queue] | Return a new queue, initially empty. | 
| create [Obj.Ephemeron] | 
 | 
| create [Mutex] | Return a new mutex. | 
| create [MoreLabels.Hashtbl.SeededS] | |
| create [MoreLabels.Hashtbl.S] | |
| create [MoreLabels.Hashtbl] | |
| create [Hashtbl.SeededS] | |
| create [Hashtbl.S] | |
| create [Hashtbl] | 
 | 
| create [Float.ArrayLabels] | |
| create [Float.Array] | 
 | 
| create [Ephemeron.Kn] | Same as  | 
| create [Ephemeron.K2] | Same as  | 
| create [Ephemeron.K1] | 
 | 
| create [Condition] | Return a new condition variable. | 
| create [BytesLabels] | 
 | 
| create [Bytes] | 
 | 
| create [Buffer] | 
 | 
| create [Bigarray.Array3] | 
 | 
| create [Bigarray.Array2] | 
 | 
| create [Bigarray.Array1] | 
 | 
| create [Bigarray.Array0] | 
 | 
| create [Bigarray.Genarray] | 
 | 
| create [ArrayLabels] | |
| create [Array] | |
| create_alarm [Gc] | 
 | 
| create_char_set [CamlinternalFormat] | |
| create_float [ArrayLabels] | 
 | 
| create_float [Array] | 
 | 
| create_matrix [ArrayLabels] | |
| create_matrix [Array] | |
| create_object [CamlinternalOO] | |
| create_object_and_run_initializers [CamlinternalOO] | |
| create_object_opt [CamlinternalOO] | |
| create_process [UnixLabels] | 
 | 
| create_process [Unix] | 
 | 
| create_process_env [UnixLabels] | 
 | 
| create_process_env [Unix] | 
 | 
| create_table [CamlinternalOO] | |
| current [Arg] | Position (in  | 
| current_dir_name [Filename] | The conventional name for the current directory (e.g. | 
| custom_tag [Obj] | |
| cygwin [Sys] | True if  | 
| D | |
| data_size [Marshal] | See  | 
| decr [Pervasives] | |
| delay [Thread] | 
 | 
| delete_alarm [Gc] | 
 | 
| 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. | 
| diff [Set.S] | Set difference:  | 
| diff [MoreLabels.Set.S] | |
| dim [Bigarray.Array1] | Return the size (dimension) of the given one-dimensional Bigarray. | 
| dim1 [Bigarray.Array3] | Return the first dimension of the given three-dimensional Bigarray. | 
| dim1 [Bigarray.Array2] | Return the first dimension of the given two-dimensional Bigarray. | 
| dim2 [Bigarray.Array3] | Return the second dimension of the given three-dimensional Bigarray. | 
| dim2 [Bigarray.Array2] | Return the second dimension of the given two-dimensional Bigarray. | 
| dim3 [Bigarray.Array3] | Return the third dimension of the given three-dimensional Bigarray. | 
| dims [Bigarray.Genarray] | 
 | 
| dir_sep [Filename] | The directory separator (e.g. | 
| dirname [Filename] | See  | 
| disjoint [Set.S] | Test if two sets are disjoint. | 
| disjoint [MoreLabels.Set.S] | |
| div [Nativeint] | Integer division. | 
| div [Int64] | Integer division. | 
| div [Int32] | Integer division. | 
| div [Int] | 
 | 
| div [Float] | Floating-point division. | 
| div [Complex] | Division | 
| do_at_exit [Pervasives] | |
| domain_of_sockaddr [UnixLabels] | Return the socket domain adequate for the given socket address. | 
| domain_of_sockaddr [Unix] | Return the socket domain adequate for the given socket address. | 
| double_array_tag [Obj] | |
| double_field [Obj] | |
| double_tag [Obj] | |
| dprintf [Format] | Same as  | 
| dummy_class [CamlinternalOO] | |
| dummy_pos [Lexing] | A value of type  | 
| dummy_table [CamlinternalOO] | |
| dup [UnixLabels] | Return a new file descriptor referencing the same file as the given descriptor. | 
| dup [Unix] | Return a new file descriptor referencing the same file as the given descriptor. | 
| dup [Obj] | |
| dup2 [UnixLabels] | 
 | 
| dup2 [Unix] | 
 | 
| E | |
| elements [Set.S] | Return the list of all elements of the given set. | 
| elements [MoreLabels.Set.S] | |
| empty [Stream] | Return  | 
| empty [Set.S] | The empty set. | 
| empty [Seq] | The empty sequence, containing no elements. | 
| empty [MoreLabels.Set.S] | |
| empty [MoreLabels.Map.S] | |
| empty [Map.S] | The empty map. | 
| empty [BytesLabels] | A byte sequence of size 0. | 
| empty [Bytes] | A byte sequence of size 0. | 
| enable_runtime_warnings [Sys] | Control whether the OCaml runtime system can emit warnings on stderr. | 
| enabled [Spacetime] | 
 | 
| end_of_input [Scanf.Scanning] | 
 | 
| 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  | 
| eprintf [Format] | Same as  | 
| epsilon [Float] | The difference between  | 
| epsilon_float [Pervasives] | |
| equal [Unit] | 
 | 
| equal [Uchar] | 
 | 
| equal [String] | The equal function for strings. | 
| equal [StringLabels] | The equal function for strings. | 
| equal [Set.S] | 
 | 
| equal [Result] | 
 | 
| equal [Option] | 
 | 
| equal [Nativeint] | The equal function for native ints. | 
| equal [MoreLabels.Set.S] | |
| equal [MoreLabels.Map.S] | |
| equal [Map.S] | 
 | 
| equal [Int64] | The equal function for int64s. | 
| equal [Int32] | The equal function for int32s. | 
| equal [Int] | 
 | 
| equal [Hashtbl.SeededHashedType] | The equality predicate used to compare keys. | 
| equal [Hashtbl.HashedType] | The equality predicate used to compare keys. | 
| equal [Float] | The equal function for floating-point numbers, compared using  | 
| equal [Digest] | The equal function for 16-character digest. | 
| equal [Char] | The equal function for chars. | 
| equal [BytesLabels] | The equality function for byte sequences. | 
| equal [Bytes] | The equality function for byte sequences. | 
| equal [Bool] | 
 | 
| erase_rel [CamlinternalFormatBasics] | |
| err_formatter [Format] | A formatter to write to standard error. | 
| error [Result] | 
 | 
| error_message [UnixLabels] | Return a string describing the given error code. | 
| error_message [Unix] | Return a string describing the given error code. | 
| error_message [Dynlink] | Convert an error description to a printable message. | 
| escaped [String] | 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. | 
| executable_name [Sys] | The name of the file containing the executable currently running. | 
| execv [UnixLabels] | 
 | 
| execv [Unix] | 
 | 
| execv [ThreadUnix] | |
| execve [UnixLabels] | Same as  | 
| execve [Unix] | Same as  | 
| execve [ThreadUnix] | |
| execvp [UnixLabels] | Same as  | 
| execvp [Unix] | Same as  | 
| execvp [ThreadUnix] | |
| execvpe [UnixLabels] | Same as  | 
| execvpe [Unix] | Same as  | 
| exists [Set.S] | 
 | 
| exists [MoreLabels.Set.S] | |
| exists [MoreLabels.Map.S] | |
| exists [Map.S] | 
 | 
| exists [ListLabels] | 
 | 
| exists [List] | 
 | 
| exists [Float.ArrayLabels] | |
| exists [Float.Array] | 
 | 
| exists [ArrayLabels] | 
 | 
| exists [Array] | 
 | 
| exists2 [ListLabels] | Same as  | 
| exists2 [List] | Same as  | 
| exit [Thread] | Terminate prematurely the currently executing thread. | 
| exit [Pervasives] | |
| exn_slot_id [Printexc] | 
 | 
| exn_slot_name [Printexc] | 
 | 
| exp [Pervasives] | |
| exp [Float] | Exponential. | 
| exp [Complex] | Exponentiation. | 
| expm1 [Pervasives] | |
| expm1 [Float] | 
 | 
| extend [BytesLabels] | 
 | 
| extend [Bytes] | 
 | 
| extension [Filename] | 
 | 
| extension_constructor [Obj] | |
| extension_id [Obj] | |
| extension_name [Obj] | |
| F | |
| failwith [Pervasives] | |
| fast_sort [ListLabels] | Same as  | 
| fast_sort [List] | Same as  | 
| fast_sort [Float.ArrayLabels] | |
| fast_sort [Float.Array] | Same as  | 
| fast_sort [ArrayLabels] | Same as  | 
| fast_sort [Array] | Same as  | 
| 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] | |
| 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] | 
 | 
| fill [String] | 
 | 
| fill [StringLabels] | 
 | 
| fill [Float.ArrayLabels] | |
| fill [Float.Array] | 
 | 
| fill [BytesLabels] | 
 | 
| fill [Bytes] | 
 | 
| fill [Bigarray.Array3] | Fill the given Bigarray with the given value. | 
| fill [Bigarray.Array2] | Fill the given Bigarray with the given value. | 
| fill [Bigarray.Array1] | Fill the given Bigarray with the given value. | 
| fill [Bigarray.Array0] | Fill the given Bigarray with the given value. | 
| fill [Bigarray.Genarray] | Set all elements of a Bigarray to a given value. | 
| fill [ArrayLabels] | 
 | 
| fill [Array] | 
 | 
| filter [Set.S] | 
 | 
| filter [Seq] | Remove from the sequence the elements that do not satisfy the given predicate. | 
| filter [MoreLabels.Set.S] | |
| filter [MoreLabels.Map.S] | |
| filter [Map.S] | 
 | 
| filter [ListLabels] | 
 | 
| filter [List] | 
 | 
| filter_map [Seq] | Apply the function to every element; if  | 
| filter_map [ListLabels] | 
 | 
| filter_map [List] | 
 | 
| 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] | 
 | 
| final_tag [Obj] | |
| finalise [Gc] | 
 | 
| finalise_last [Gc] | same as  | 
| finalise_release [Gc] | A finalisation function may call  | 
| find [Weak.S] | 
 | 
| find [Set.S] | 
 | 
| find [MoreLabels.Set.S] | |
| find [MoreLabels.Map.S] | |
| find [MoreLabels.Hashtbl.SeededS] | |
| find [MoreLabels.Hashtbl.S] | |
| find [MoreLabels.Hashtbl] | |
| find [Map.S] | 
 | 
| find [ListLabels] | 
 | 
| find [List] | 
 | 
| find [Hashtbl.SeededS] | |
| find [Hashtbl.S] | |
| find [Hashtbl] | 
 | 
| find_all [Weak.S] | 
 | 
| find_all [MoreLabels.Hashtbl.SeededS] | |
| find_all [MoreLabels.Hashtbl.S] | |
| find_all [MoreLabels.Hashtbl] | |
| find_all [ListLabels] | 
 | 
| find_all [List] | 
 | 
| find_all [Hashtbl.SeededS] | |
| find_all [Hashtbl.S] | |
| find_all [Hashtbl] | 
 | 
| find_first [Set.S] | 
 | 
| find_first [MoreLabels.Set.S] | |
| find_first [MoreLabels.Map.S] | |
| find_first [Map.S] | 
 | 
| find_first_opt [Set.S] | 
 | 
| find_first_opt [MoreLabels.Set.S] | |
| find_first_opt [MoreLabels.Map.S] | |
| find_first_opt [Map.S] | 
 | 
| find_last [Set.S] | 
 | 
| find_last [MoreLabels.Set.S] | |
| find_last [MoreLabels.Map.S] | |
| find_last [Map.S] | 
 | 
| find_last_opt [Set.S] | 
 | 
| find_last_opt [MoreLabels.Set.S] | |
| find_last_opt [MoreLabels.Map.S] | |
| find_last_opt [Map.S] | 
 | 
| find_opt [Weak.S] | 
 | 
| find_opt [Set.S] | 
 | 
| 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 [Map.S] | 
 | 
| find_opt [ListLabels] | 
 | 
| find_opt [List] | 
 | 
| find_opt [Hashtbl.SeededS] | |
| find_opt [Hashtbl.S] | |
| find_opt [Hashtbl] | 
 | 
| first_chars [Str] | 
 | 
| first_non_constant_constructor_tag [Obj] | |
| flat_map [Seq] | Map each element to a subsequence, then return each element of this sub-sequence in turn. | 
| flatten [ListLabels] | Same as  | 
| flatten [List] | An alias for  | 
| flip [Fun] | 
 | 
| float [Random.State] | |
| float [Random] | 
 | 
| float [Pervasives] | |
| float32 [Bigarray] | See  | 
| float64 [Bigarray] | See  | 
| 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  | 
| 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  | 
| float_of_int [Pervasives] | |
| float_of_string [Pervasives] | |
| float_of_string_opt [Pervasives] | |
| floor [Pervasives] | |
| floor [Float] | Round below to an integer value. | 
| flush [Pervasives] | |
| flush_all [Pervasives] | |
| 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  | 
| flush_symbolic_output_buffer [Format] | 
 | 
| fma [Float] | 
 | 
| fmt_ebb_of_string [CamlinternalFormat] | |
| fold [Weak.S] | 
 | 
| fold [Stack] | 
 | 
| fold [Set.S] | 
 | 
| fold [Result] | 
 | 
| fold [Queue] | 
 | 
| fold [Option] | 
 | 
| fold [MoreLabels.Set.S] | |
| fold [MoreLabels.Map.S] | |
| fold [MoreLabels.Hashtbl.SeededS] | |
| fold [MoreLabels.Hashtbl.S] | |
| fold [MoreLabels.Hashtbl] | |
| fold [Map.S] | 
 | 
| fold [Hashtbl.SeededS] | |
| fold [Hashtbl.S] | |
| fold [Hashtbl] | 
 | 
| fold_left [Seq] | Traverse the sequence from left to right, combining each element with the accumulator using the given function. | 
| fold_left [ListLabels] | 
 | 
| fold_left [List] | 
 | 
| fold_left [Float.ArrayLabels] | |
| fold_left [Float.Array] | 
 | 
| fold_left [ArrayLabels] | 
 | 
| fold_left [Array] | 
 | 
| fold_left2 [ListLabels] | 
 | 
| fold_left2 [List] | 
 | 
| fold_right [ListLabels] | 
 | 
| fold_right [List] | 
 | 
| fold_right [Float.ArrayLabels] | |
| fold_right [Float.Array] | 
 | 
| fold_right [ArrayLabels] | 
 | 
| fold_right [Array] | 
 | 
| fold_right2 [ListLabels] | 
 | 
| fold_right2 [List] | 
 | 
| for_all [Set.S] | 
 | 
| for_all [MoreLabels.Set.S] | |
| for_all [MoreLabels.Map.S] | |
| for_all [Map.S] | 
 | 
| for_all [ListLabels] | 
 | 
| for_all [List] | 
 | 
| for_all [Float.ArrayLabels] | |
| for_all [Float.Array] | 
 | 
| for_all [ArrayLabels] | 
 | 
| for_all [Array] | 
 | 
| for_all2 [ListLabels] | Same as  | 
| for_all2 [List] | Same as  | 
| force [Lazy] | 
 | 
| force [CamlinternalLazy] | |
| force_lazy_block [CamlinternalLazy] | |
| force_newline [Format] | Force a new line in the current pretty-printing box. | 
| force_val [Lazy] | 
 | 
| force_val [CamlinternalLazy] | |
| force_val_lazy_block [CamlinternalLazy] | |
| fork [UnixLabels] | Fork a new process. | 
| fork [Unix] | Fork a new process. | 
| format [Printexc.Slot] | 
 | 
| format_from_string [Scanf] | 
 | 
| format_of_string [Pervasives] | |
| format_of_string_fmtty [CamlinternalFormat] | |
| format_of_string_format [CamlinternalFormat] | |
| formatter_of_buffer [Format] | 
 | 
| formatter_of_out_channel [Format] | 
 | 
| formatter_of_out_functions [Format] | 
 | 
| formatter_of_symbolic_output_buffer [Format] | 
 | 
| fortran_layout [Bigarray] | |
| forward_tag [Obj] | |
| fprintf [Printf] | 
 | 
| fprintf [Format] | |
| freeze_char_set [CamlinternalFormat] | |
| frexp [Pervasives] | |
| frexp [Float] | 
 | 
| from [Stream] | 
 | 
| from_bytes [Marshal] | 
 | 
| from_channel [Scanf.Scanning] | 
 | 
| from_channel [Marshal] | 
 | 
| from_channel [Lexing] | Create a lexer buffer on the given input channel. | 
| from_file [Scanf.Scanning] | An alias for  | 
| from_file_bin [Scanf.Scanning] | An alias for  | 
| from_fun [Lazy] | 
 | 
| from_function [Scanf.Scanning] | 
 | 
| from_function [Lexing] | Create a lexer buffer with the given function as its reading method. | 
| from_hex [Digest] | Convert a hexadecimal representation back into the corresponding digest. | 
| from_string [Scanf.Scanning] | 
 | 
| from_string [Marshal] | Same as  | 
| from_string [Lexing] | Create a lexer buffer which reads from the given string. | 
| from_val [Lazy] | 
 | 
| fscanf [Scanf] | |
| fst [Pervasives] | |
| fstat [UnixLabels.LargeFile] | |
| fstat [UnixLabels] | Return the information for the file associated with the given descriptor. | 
| fstat [Unix.LargeFile] | |
| fstat [Unix] | Return the information for the file associated with the given descriptor. | 
| fsync [Unix] | Flush file buffers to disk. | 
| ftruncate [UnixLabels.LargeFile] | |
| ftruncate [UnixLabels] | Truncates the file corresponding to the given descriptor to the given size. | 
| ftruncate [Unix.LargeFile] | See  | 
| ftruncate [Unix] | Truncates the file corresponding to the given descriptor to the given size. | 
| full_init [Random] | Same as  | 
| full_major [Gc] | Do a minor collection, finish the current major collection cycle, and perform a complete new cycle. | 
| full_split [Str] | Same as  | 
| G | |
| genarray_of_array0 [Bigarray] | Return the generic Bigarray corresponding to the given zero-dimensional Bigarray. | 
| genarray_of_array1 [Bigarray] | Return the generic Bigarray corresponding to the given one-dimensional Bigarray. | 
| genarray_of_array2 [Bigarray] | Return the generic Bigarray corresponding to the given two-dimensional Bigarray. | 
| genarray_of_array3 [Bigarray] | Return the generic Bigarray corresponding to the given three-dimensional Bigarray. | 
| get [Weak] | 
 | 
| get [String] | 
 | 
| get [StringLabels] | 
 | 
| get [Option] | 
 | 
| get [Gc] | Return the current values of the GC parameters in a  | 
| get [Float.ArrayLabels] | |
| get [Float.Array] | 
 | 
| get [BytesLabels] | 
 | 
| get [Bytes] | 
 | 
| get [Bigarray.Array3] | 
 | 
| get [Bigarray.Array2] | 
 | 
| get [Bigarray.Array1] | 
 | 
| get [Bigarray.Array0] | 
 | 
| get [Bigarray.Genarray] | Read an element of a generic Bigarray. | 
| get [ArrayLabels] | 
 | 
| get [Array] | 
 | 
| get_all_formatter_output_functions [Format] | |
| get_backtrace [Printexc] | 
 | 
| get_bucket [Gc] | 
 | 
| get_callstack [Printexc] | 
 | 
| get_copy [Weak] | 
 | 
| get_credit [Gc] | 
 | 
| get_data [Obj.Ephemeron] | Same as  | 
| get_data [Ephemeron.Kn] | Same as  | 
| get_data [Ephemeron.K2] | Same as  | 
| get_data [Ephemeron.K1] | 
 | 
| get_data_copy [Obj.Ephemeron] | Same as  | 
| get_data_copy [Ephemeron.Kn] | Same as  | 
| get_data_copy [Ephemeron.K2] | Same as  | 
| get_data_copy [Ephemeron.K1] | 
 | 
| get_ellipsis_text [Format] | Return the text of the ellipsis. | 
| get_error [Result] | 
 | 
| get_formatter_out_functions [Format] | Return the current output functions of the pretty-printer, including line splitting and indentation functions. | 
| get_formatter_output_functions [Format] | Return the current output functions of the standard pretty-printer. | 
| get_formatter_stag_functions [Format] | Return the current semantic tag operation functions of the standard pretty-printer. | 
| get_formatter_tag_functions [Format] | |
| get_geometry [Format] | Return the current geometry of the formatter | 
| get_int16_be [BytesLabels] | 
 | 
| get_int16_be [Bytes] | 
 | 
| get_int16_le [BytesLabels] | 
 | 
| get_int16_le [Bytes] | 
 | 
| get_int16_ne [BytesLabels] | 
 | 
| get_int16_ne [Bytes] | 
 | 
| get_int32_be [BytesLabels] | 
 | 
| get_int32_be [Bytes] | 
 | 
| get_int32_le [BytesLabels] | 
 | 
| get_int32_le [Bytes] | 
 | 
| get_int32_ne [BytesLabels] | 
 | 
| get_int32_ne [Bytes] | 
 | 
| get_int64_be [BytesLabels] | 
 | 
| get_int64_be [Bytes] | 
 | 
| get_int64_le [BytesLabels] | 
 | 
| get_int64_le [Bytes] | 
 | 
| get_int64_ne [BytesLabels] | 
 | 
| get_int64_ne [Bytes] | 
 | 
| get_int8 [BytesLabels] | 
 | 
| get_int8 [Bytes] | 
 | 
| get_key [Obj.Ephemeron] | Same as  | 
| get_key [Ephemeron.Kn] | Same as  | 
| get_key [Ephemeron.K1] | 
 | 
| get_key1 [Ephemeron.K2] | Same as  | 
| get_key1_copy [Ephemeron.K2] | Same as  | 
| get_key2 [Ephemeron.K2] | Same as  | 
| get_key2_copy [Ephemeron.K2] | Same as  | 
| get_key_copy [Obj.Ephemeron] | Same as  | 
| get_key_copy [Ephemeron.Kn] | Same as  | 
| get_key_copy [Ephemeron.K1] | 
 | 
| get_margin [Format] | Returns the position of the right margin. | 
| get_mark_tags [Format] | Return the current status of tag-marking operations. | 
| get_max_boxes [Format] | Returns the maximum number of pretty-printing boxes allowed before ellipsis. | 
| get_max_indent [Format] | Return the maximum indentation limit (in characters). | 
| get_method [CamlinternalOO] | |
| get_method_label [CamlinternalOO] | |
| get_method_labels [CamlinternalOO] | |
| get_minor_free [Gc] | Return the current size of the free space inside the minor heap. | 
| get_ok [Result] | 
 | 
| get_print_tags [Format] | Return the current status of tag-printing operations. | 
| get_public_method [CamlinternalOO] | |
| get_raw_backtrace [Printexc] | 
 | 
| get_raw_backtrace_next_slot [Printexc] | 
 | 
| get_raw_backtrace_slot [Printexc] | 
 | 
| get_state [Random] | Return the current state of the generator used by the basic functions. | 
| get_symbolic_output_buffer [Format] | 
 | 
| get_temp_dir_name [Filename] | The name of the temporary directory:
    Under Unix, the value of the  | 
| get_uint16_be [BytesLabels] | 
 | 
| get_uint16_be [Bytes] | 
 | 
| get_uint16_le [BytesLabels] | 
 | 
| get_uint16_le [Bytes] | 
 | 
| get_uint16_ne [BytesLabels] | 
 | 
| get_uint16_ne [Bytes] | 
 | 
| get_uint8 [BytesLabels] | 
 | 
| get_uint8 [Bytes] | 
 | 
| get_variable [CamlinternalOO] | |
| get_variables [CamlinternalOO] | |
| getaddrinfo [UnixLabels] | 
 | 
| getaddrinfo [Unix] | 
 | 
| 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  | 
| 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  | 
| getgrgid [Unix] | Find an entry in  | 
| getgrnam [UnixLabels] | Find an entry in  | 
| getgrnam [Unix] | Find an entry in  | 
| 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  | 
| gethostbyaddr [Unix] | Find an entry in  | 
| gethostbyname [UnixLabels] | Find an entry in  | 
| gethostbyname [Unix] | Find an entry in  | 
| 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 [Unix] | 
 | 
| 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  | 
| getprotobyname [Unix] | Find an entry in  | 
| getprotobynumber [UnixLabels] | Find an entry in  | 
| getprotobynumber [Unix] | Find an entry in  | 
| getpwnam [UnixLabels] | Find an entry in  | 
| getpwnam [Unix] | Find an entry in  | 
| getpwuid [UnixLabels] | Find an entry in  | 
| getpwuid [Unix] | Find an entry in  | 
| getservbyname [UnixLabels] | Find an entry in  | 
| getservbyname [Unix] | Find an entry in  | 
| getservbyport [UnixLabels] | Find an entry in  | 
| getservbyport [Unix] | Find an entry in  | 
| 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  | 
| getsockopt_float [Unix] | Same as  | 
| getsockopt_int [UnixLabels] | Same as  | 
| getsockopt_int [Unix] | Same as  | 
| getsockopt_optint [UnixLabels] | Same as  | 
| getsockopt_optint [Unix] | Same as  | 
| gettimeofday [UnixLabels] | Same as  | 
| gettimeofday [Unix] | Same as  | 
| 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_substitute [Str] | 
 | 
| gmtime [UnixLabels] | Convert a time in seconds, as returned by  | 
| gmtime [Unix] | Convert a time in seconds, as returned by  | 
| group_beginning [Str] | 
 | 
| group_end [Str] | 
 | 
| guard [Event] | 
 | 
| H | |
| handle_unix_error [UnixLabels] | 
 | 
| handle_unix_error [Unix] | 
 | 
| has_symlink [UnixLabels] | Returns  | 
| has_symlink [Unix] | Returns  | 
| hash [Uchar] | 
 | 
| hash [MoreLabels.Hashtbl] | |
| hash [Hashtbl.SeededHashedType] | A seeded hashing function on keys. | 
| hash [Hashtbl.HashedType] | A hashing function on keys. | 
| hash [Hashtbl] | 
 | 
| hash [Float] | The hash function for floating-point numbers. | 
| hash_param [MoreLabels.Hashtbl] | |
| hash_param [Hashtbl] | 
 | 
| hd [ListLabels] | Return the first element of the given list. | 
| hd [List] | Return the first element of the given list. | 
| header_size [Marshal] | The bytes representing a marshaled value are composed of a fixed-size header and a variable-sized data part, whose size can be determined from the header. | 
| huge_fallback_count [Gc] | Return the number of times we tried to map huge pages and had to fall back to small pages. | 
| hypot [Pervasives] | |
| hypot [Float] | 
 | 
| I | |
| i [Complex] | The complex number  | 
| id [Thread] | Return the identifier of the given thread. | 
| id [Oo] | Return an integer identifying this object, unique for the current execution of the program. | 
| id [Obj.Extension_constructor] | |
| id [Fun] | 
 | 
| ifprintf [Printf] | Same as  | 
| ifprintf [Format] | Same as  | 
| ignore [Pervasives] | |
| ikfprintf [Printf] | Same as  | 
| ikfprintf [Format] | Same as  | 
| in_channel_length [Stdlib.LargeFile] | |
| in_channel_length [Pervasives] | |
| in_channel_of_descr [UnixLabels] | Create an input channel reading from the given descriptor. | 
| in_channel_of_descr [Unix] | Create an input channel reading from the given descriptor. | 
| incr [Pervasives] | |
| index [String] | 
 | 
| index [StringLabels] | 
 | 
| index [BytesLabels] | 
 | 
| index [Bytes] | 
 | 
| index_from [String] | 
 | 
| index_from [StringLabels] | 
 | 
| index_from [BytesLabels] | 
 | 
| index_from [Bytes] | 
 | 
| index_from_opt [String] | 
 | 
| index_from_opt [StringLabels] | 
 | 
| index_from_opt [BytesLabels] | 
 | 
| index_from_opt [Bytes] | 
 | 
| index_opt [String] | 
 | 
| index_opt [StringLabels] | 
 | 
| index_opt [BytesLabels] | 
 | 
| index_opt [Bytes] | 
 | 
| inet6_addr_any [UnixLabels] | A special IPv6 address, for use only with  | 
| inet6_addr_any [Unix] | A special IPv6 address, for use only with  | 
| inet6_addr_loopback [UnixLabels] | A special IPv6 address representing the host machine ( | 
| inet6_addr_loopback [Unix] | A special IPv6 address representing the host machine ( | 
| inet_addr_any [UnixLabels] | A special IPv4 address, for use only with  | 
| inet_addr_any [Unix] | A special IPv4 address, for use only with  | 
| inet_addr_loopback [UnixLabels] | A special IPv4 address representing the host machine ( | 
| inet_addr_loopback [Unix] | A special IPv4 address representing the host machine ( | 
| 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] | |
| infinity [Float] | Positive infinity. | 
| infix_tag [Obj] | |
| inherits [CamlinternalOO] | |
| init [String] | 
 | 
| init [StringLabels] | 
 | 
| init [Random] | Initialize the generator, using the argument as a seed. | 
| init [ListLabels] | 
 | 
| init [List] | 
 | 
| init [Float.ArrayLabels] | |
| init [Float.Array] | 
 | 
| init [BytesLabels] | 
 | 
| init [Bytes] | 
 | 
| init [ArrayLabels] | 
 | 
| init [Array] | 
 | 
| init_class [CamlinternalOO] | |
| init_mod [CamlinternalMod] | |
| initgroups [UnixLabels] | 
 | 
| initgroups [Unix] | 
 | 
| input [Pervasives] | |
| input [Digest] | Read a digest from the given input channel. | 
| input_binary_int [Pervasives] | |
| input_byte [Pervasives] | |
| input_char [Pervasives] | |
| input_line [Pervasives] | |
| input_value [Pervasives] | |
| int [Random.State] | |
| int [Random] | 
 | 
| int [Bigarray] | See  | 
| int16_signed [Bigarray] | See  | 
| int16_unsigned [Bigarray] | See  | 
| int32 [Random.State] | |
| int32 [Random] | 
 | 
| int32 [Bigarray] | See  | 
| int64 [Random.State] | |
| int64 [Random] | 
 | 
| int64 [Bigarray] | See  | 
| int8_signed [Bigarray] | See  | 
| int8_unsigned [Bigarray] | See  | 
| int_of_char [Pervasives] | |
| int_of_float [Pervasives] | |
| int_of_string [Pervasives] | |
| int_of_string_opt [Pervasives] | |
| int_size [Sys] | Size of  | 
| int_tag [Obj] | |
| inter [Set.S] | Set intersection. | 
| inter [MoreLabels.Set.S] | |
| interactive [Sys] | This reference is initially set to  | 
| inv [Complex] | Multiplicative inverse ( | 
| invalid_arg [Pervasives] | |
| is_block [Obj] | |
| is_char [Uchar] | 
 | 
| is_directory [Sys] | Returns  | 
| is_empty [Stack] | Return  | 
| is_empty [Set.S] | Test whether a set is empty or not. | 
| is_empty [Queue] | Return  | 
| is_empty [MoreLabels.Set.S] | |
| is_empty [MoreLabels.Map.S] | |
| is_empty [Map.S] | Test whether a map is empty or not. | 
| is_error [Result] | 
 | 
| is_finite [Float] | 
 | 
| is_implicit [Filename] | Return  | 
| is_in_char_set [CamlinternalFormat] | |
| is_infinite [Float] | 
 | 
| is_inline [Printexc.Slot] | 
 | 
| is_int [Obj] | |
| is_integer [Float] | 
 | 
| is_nan [Float] | 
 | 
| is_native [Dynlink] | 
 | 
| is_none [Option] | 
 | 
| is_ok [Result] | 
 | 
| is_raise [Printexc.Slot] | 
 | 
| is_randomized [MoreLabels.Hashtbl] | |
| is_randomized [Hashtbl] | return if the tables are currently created in randomized mode by default | 
| is_relative [Filename] | Return  | 
| is_some [Option] | 
 | 
| is_val [Lazy] | 
 | 
| is_valid [Uchar] | 
 | 
| isatty [UnixLabels] | Return  | 
| isatty [Unix] | Return  | 
| iter [Weak.S] | 
 | 
| iter [String] | 
 | 
| iter [Stream] | 
 | 
| iter [StringLabels] | 
 | 
| iter [Stack] | 
 | 
| iter [Set.S] | 
 | 
| iter [Seq] | Iterate on the sequence, calling the (imperative) function on every element. | 
| iter [Result] | 
 | 
| iter [Queue] | 
 | 
| iter [Option] | 
 | 
| iter [MoreLabels.Set.S] | |
| iter [MoreLabels.Map.S] | |
| iter [MoreLabels.Hashtbl.SeededS] | |
| iter [MoreLabels.Hashtbl.S] | |
| iter [MoreLabels.Hashtbl] | |
| iter [Map.S] | 
 | 
| iter [ListLabels] | 
 | 
| iter [List] | 
 | 
| iter [Hashtbl.SeededS] | |
| iter [Hashtbl.S] | |
| iter [Hashtbl] | 
 | 
| iter [Float.ArrayLabels] | |
| iter [Float.Array] | 
 | 
| iter [BytesLabels] | 
 | 
| iter [Bytes] | 
 | 
| iter [ArrayLabels] | 
 | 
| iter [Array] | 
 | 
| iter2 [ListLabels] | 
 | 
| iter2 [List] | 
 | 
| iter2 [Float.ArrayLabels] | |
| iter2 [Float.Array] | 
 | 
| iter2 [ArrayLabels] | 
 | 
| iter2 [Array] | 
 | 
| iter_error [Result] | 
 | 
| iteri [String] | Same as  | 
| iteri [StringLabels] | Same as  | 
| iteri [ListLabels] | Same as  | 
| iteri [List] | Same as  | 
| iteri [Float.ArrayLabels] | |
| iteri [Float.Array] | Same as  | 
| iteri [BytesLabels] | Same as  | 
| iteri [Bytes] | Same as  | 
| iteri [ArrayLabels] | Same as  | 
| iteri [Array] | Same as  | 
| J | |
| join [Thread] | 
 | 
| join [Result] | 
 | 
| join [Option] | 
 | 
| junk [Stream] | Remove the first element of the stream, possibly unfreezing it before. | 
| K | |
| kasprintf [Format] | Same as  | 
| kbprintf [Printf] | Same as  | 
| kdprintf [Format] | Same as  | 
| kfprintf [Printf] | Same as  | 
| kfprintf [Format] | Same as  | 
| kfscanf [Scanf] | |
| kill [UnixLabels] | 
 | 
| kill [Unix] | 
 | 
| kill [Thread] | Terminate prematurely the thread whose handle is given. | 
| kind [Bigarray.Array3] | Return the kind of the given Bigarray. | 
| kind [Bigarray.Array2] | Return the kind of the given Bigarray. | 
| kind [Bigarray.Array1] | Return the kind of the given Bigarray. | 
| kind [Bigarray.Array0] | Return the kind of the given Bigarray. | 
| kind [Bigarray.Genarray] | Return the kind of the given Bigarray. | 
| kind_size_in_bytes [Bigarray] | 
 | 
| kprintf [Printf] | A deprecated synonym for  | 
| kprintf [Format] | |
| kscanf [Scanf] | Same as  | 
| ksprintf [Printf] | Same as  | 
| ksprintf [Format] | Same as  | 
| ksscanf [Scanf] | Same as  | 
| L | |
| last_chars [Str] | 
 | 
| last_non_constant_constructor_tag [Obj] | |
| layout [Bigarray.Array3] | Return the layout of the given Bigarray. | 
| layout [Bigarray.Array2] | Return the layout of the given Bigarray. | 
| layout [Bigarray.Array1] | Return the layout of the given Bigarray. | 
| layout [Bigarray.Array0] | Return the layout of the given Bigarray. | 
| layout [Bigarray.Genarray] | Return the layout of the given Bigarray. | 
| lazy_from_fun [Lazy] | |
| lazy_from_val [Lazy] | |
| lazy_is_val [Lazy] | |
| lazy_tag [Obj] | |
| ldexp [Pervasives] | |
| ldexp [Float] | 
 | 
| length [Weak] | 
 | 
| 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 [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] | 
 | 
| length [Float.ArrayLabels] | |
| length [Float.Array] | Return the length (number of elements) of the given floatarray. | 
| length [BytesLabels] | Return the length (number of bytes) of the argument. | 
| length [Bytes] | Return the length (number of bytes) of the argument. | 
| length [Buffer] | Return the number of characters currently contained in the buffer. | 
| length [ArrayLabels] | Return the length (number of elements) of the given array. | 
| length [Array] | Return the length (number of elements) of the given array. | 
| lexeme [Lexing] | 
 | 
| lexeme_char [Lexing] | 
 | 
| lexeme_end [Lexing] | 
 | 
| lexeme_end_p [Lexing] | Like  | 
| lexeme_start [Lexing] | 
 | 
| lexeme_start_p [Lexing] | Like  | 
| link [UnixLabels] | 
 | 
| link [Unix] | 
 | 
| listen [UnixLabels] | Set up a socket for receiving connection requests. | 
| listen [Unix] | Set up a socket for receiving connection requests. | 
| lnot [Pervasives] | |
| loadfile [Dynlink] | In bytecode: load the given bytecode object file ( | 
| loadfile_private [Dynlink] | Same as  | 
| localtime [UnixLabels] | Convert a time in seconds, as returned by  | 
| localtime [Unix] | Convert a time in seconds, as returned by  | 
| location [Printexc.Slot] | 
 | 
| lock [Mutex] | Lock the given mutex. | 
| lockf [UnixLabels] | 
 | 
| lockf [Unix] | 
 | 
| log [Pervasives] | |
| log [Float] | Natural logarithm. | 
| log [Complex] | Natural logarithm (in base  | 
| log10 [Pervasives] | |
| log10 [Float] | Base 10 logarithm. | 
| log1p [Pervasives] | |
| log1p [Float] | 
 | 
| logand [Nativeint] | Bitwise logical and. | 
| logand [Int64] | Bitwise logical and. | 
| logand [Int32] | Bitwise logical and. | 
| logand [Int] | 
 | 
| lognot [Nativeint] | Bitwise logical negation. | 
| lognot [Int64] | Bitwise logical negation. | 
| lognot [Int32] | Bitwise logical negation. | 
| lognot [Int] | 
 | 
| logor [Nativeint] | Bitwise logical or. | 
| logor [Int64] | Bitwise logical or. | 
| logor [Int32] | Bitwise logical or. | 
| logor [Int] | 
 | 
| logxor [Nativeint] | Bitwise logical exclusive or. | 
| logxor [Int64] | Bitwise logical exclusive or. | 
| logxor [Int32] | Bitwise logical exclusive or. | 
| logxor [Int] | 
 | 
| lookup_tables [CamlinternalOO] | |
| lowercase [String] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. | 
| lowercase [StringLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. | 
| lowercase [Char] | Convert the given character to its equivalent lowercase character, using the ISO Latin-1 (8859-1) character set. | 
| lowercase [BytesLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. | 
| lowercase [Bytes] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. | 
| lowercase_ascii [String] | 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  | 
| 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  | 
| lstat [Unix.LargeFile] | |
| lstat [Unix] | Same as  | 
| M | |
| magic [Obj] | |
| main_program_units [Dynlink] | Return the list of compilation units that form the main program (i.e. | 
| major [Gc] | Do a minor collection and finish the current major collection cycle. | 
| major_slice [Gc] | 
 | 
| make [String] | 
 | 
| make [StringLabels] | 
 | 
| make [Random.State] | Create a new state and initialize it with the given seed. | 
| make [Float.ArrayLabels] | |
| make [Float.Array] | 
 | 
| make [BytesLabels] | 
 | 
| make [Bytes] | 
 | 
| make [ArrayLabels] | 
 | 
| make [Array] | 
 | 
| make_class [CamlinternalOO] | |
| make_class_store [CamlinternalOO] | |
| make_float [ArrayLabels] | |
| make_float [Array] | |
| make_formatter [Format] | 
 | 
| make_iprintf [CamlinternalFormat] | |
| make_lexer [Genlex] | Construct the lexer function. | 
| make_matrix [ArrayLabels] | 
 | 
| make_matrix [Array] | 
 | 
| make_printf [CamlinternalFormat] | |
| make_self_init [Random.State] | Create a new state and initialize it with a system-dependent low-entropy seed. | 
| make_symbolic_output_buffer [Format] | 
 | 
| map [String] | 
 | 
| map [StringLabels] | 
 | 
| map [Set.S] | 
 | 
| map [Seq] | 
 | 
| map [Result] | 
 | 
| map [Option] | 
 | 
| map [MoreLabels.Set.S] | |
| map [MoreLabels.Map.S] | |
| map [Map.S] | 
 | 
| map [ListLabels] | 
 | 
| map [List] | 
 | 
| map [Float.ArrayLabels] | |
| map [Float.Array] | 
 | 
| map [BytesLabels] | 
 | 
| map [Bytes] | 
 | 
| map [ArrayLabels] | 
 | 
| map [Array] | 
 | 
| map2 [ListLabels] | 
 | 
| map2 [List] | 
 | 
| map2 [Float.ArrayLabels] | |
| map2 [Float.Array] | 
 | 
| map2 [ArrayLabels] | 
 | 
| map2 [Array] | 
 | 
| map_error [Result] | 
 | 
| map_file [UnixLabels] | Memory mapping of a file as a Bigarray. | 
| map_file [Unix] | Memory mapping of a file as a Bigarray. | 
| map_from_array [Float.ArrayLabels] | |
| map_from_array [Float.Array] | 
 | 
| map_to_array [Float.ArrayLabels] | |
| map_to_array [Float.Array] | 
 | 
| mapi [String] | 
 | 
| mapi [StringLabels] | 
 | 
| mapi [MoreLabels.Map.S] | |
| mapi [Map.S] | Same as  | 
| mapi [ListLabels] | Same as  | 
| mapi [List] | Same as  | 
| mapi [Float.ArrayLabels] | |
| mapi [Float.Array] | Same as  | 
| mapi [BytesLabels] | 
 | 
| mapi [Bytes] | 
 | 
| mapi [ArrayLabels] | Same as  | 
| mapi [Array] | Same as  | 
| marshal [Obj] | |
| match_beginning [Str] | 
 | 
| match_end [Str] | 
 | 
| matched_group [Str] | 
 | 
| matched_string [Str] | 
 | 
| max [Uchar] | 
 | 
| max [Pervasives] | |
| max [Float] | 
 | 
| max_array_length [Sys] | Maximum length of a normal array (i.e. | 
| max_binding [MoreLabels.Map.S] | |
| max_binding [Map.S] | Same as  | 
| max_binding_opt [MoreLabels.Map.S] | |
| max_binding_opt [Map.S] | Same as  | 
| max_elt [Set.S] | Same as  | 
| max_elt [MoreLabels.Set.S] | |
| max_elt_opt [Set.S] | Same as  | 
| max_elt_opt [MoreLabels.Set.S] | |
| max_ephe_length [Obj.Ephemeron] | Maximum length of an ephemeron, ie the maximum number of keys an ephemeron could contain | 
| max_float [Pervasives] | |
| max_float [Float] | The largest positive finite value of type  | 
| max_floatarray_length [Sys] | Maximum length of a floatarray. | 
| max_int [Pervasives] | |
| max_int [Nativeint] | The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform. | 
| max_int [Int64] | The greatest representable 64-bit integer, 263 - 1. | 
| max_int [Int32] | The greatest representable 32-bit integer, 231 - 1. | 
| max_int [Int] | 
 | 
| max_num [Float] | 
 | 
| max_string_length [Sys] | Maximum length of strings and byte sequences. | 
| mem [Weak.S] | 
 | 
| mem [Set.S] | 
 | 
| mem [MoreLabels.Set.S] | |
| mem [MoreLabels.Map.S] | |
| mem [MoreLabels.Hashtbl.SeededS] | |
| mem [MoreLabels.Hashtbl.S] | |
| mem [MoreLabels.Hashtbl] | |
| mem [Map.S] | 
 | 
| mem [ListLabels] | 
 | 
| mem [List] | 
 | 
| mem [Hashtbl.SeededS] | |
| mem [Hashtbl.S] | |
| mem [Hashtbl] | 
 | 
| mem [Float.ArrayLabels] | |
| mem [Float.Array] | 
 | 
| mem [ArrayLabels] | 
 | 
| mem [Array] | 
 | 
| mem_assoc [ListLabels] | Same as  | 
| mem_assoc [List] | Same as  | 
| mem_assq [ListLabels] | Same as  | 
| mem_assq [List] | Same as  | 
| mem_ieee [Float.ArrayLabels] | |
| mem_ieee [Float.Array] | Same as  | 
| memq [ListLabels] | Same as  | 
| memq [List] | Same as  | 
| memq [ArrayLabels] | Same as  | 
| memq [Array] | Same as  | 
| merge [Weak.S] | 
 | 
| merge [MoreLabels.Map.S] | |
| merge [Map.S] | 
 | 
| merge [ListLabels] | Merge two lists:
    Assuming that  | 
| merge [List] | Merge two lists:
    Assuming that  | 
| min [Uchar] | 
 | 
| min [Pervasives] | |
| min [Float] | 
 | 
| min_binding [MoreLabels.Map.S] | |
| min_binding [Map.S] | Return the binding with the smallest key in a given map
       (with respect to the  | 
| min_binding_opt [MoreLabels.Map.S] | |
| min_binding_opt [Map.S] | Return the binding with the smallest key in the given map
       (with respect to the  | 
| min_elt [Set.S] | Return the smallest element of the given set
       (with respect to the  | 
| min_elt [MoreLabels.Set.S] | |
| min_elt_opt [Set.S] | Return the smallest element of the given set
       (with respect to the  | 
| min_elt_opt [MoreLabels.Set.S] | |
| min_float [Pervasives] | |
| min_float [Float] | The smallest positive, non-zero, non-denormalized value of type  | 
| min_int [Pervasives] | |
| min_int [Nativeint] | The smallest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform. | 
| min_int [Int64] | The smallest representable 64-bit integer, -263. | 
| min_int [Int32] | The smallest representable 32-bit integer, -231. | 
| min_int [Int] | 
 | 
| min_max [Float] | 
 | 
| min_max_num [Float] | 
 | 
| min_num [Float] | 
 | 
| minor [Gc] | Trigger a minor collection. | 
| minor_words [Gc] | Number of words allocated in the minor heap since the program was started. | 
| minus_one [Nativeint] | The native integer -1. | 
| minus_one [Int64] | The 64-bit integer -1. | 
| minus_one [Int32] | The 32-bit integer -1. | 
| minus_one [Int] | 
 | 
| minus_one [Float] | The floating-point -1. | 
| mkdir [UnixLabels] | Create a directory with the given permissions. | 
| mkdir [Unix] | Create a directory with the given permissions (see  | 
| mkfifo [UnixLabels] | Create a named pipe with the given permissions. | 
| mkfifo [Unix] | Create a named pipe with the given permissions (see  | 
| mktime [UnixLabels] | Convert a date and time, specified by the  | 
| mktime [Unix] | Convert a date and time, specified by the  | 
| mod_float [Pervasives] | |
| modf [Pervasives] | |
| modf [Float] | 
 | 
| mul [Nativeint] | Multiplication. | 
| mul [Int64] | Multiplication. | 
| mul [Int32] | Multiplication. | 
| mul [Int] | 
 | 
| mul [Float] | Floating-point multiplication. | 
| mul [Complex] | Multiplication | 
| N | |
| name [Obj.Extension_constructor] | |
| name_of_input [Scanf.Scanning] | 
 | 
| nan [Pervasives] | |
| nan [Float] | A special floating-point value denoting the result of an
    undefined operation such as  | 
| narrow [CamlinternalOO] | |
| nativeint [Random.State] | |
| nativeint [Random] | 
 | 
| nativeint [Bigarray] | See  | 
| neg [Nativeint] | Unary negation. | 
| neg [Int64] | Unary negation. | 
| neg [Int32] | Unary negation. | 
| neg [Int] | 
 | 
| neg [Float] | Unary negation. | 
| neg [Complex] | Unary negation. | 
| neg_infinity [Pervasives] | |
| neg_infinity [Float] | Negative infinity. | 
| negate [Fun] | 
 | 
| new_block [Obj] | |
| new_channel [Event] | Return a new channel. | 
| new_line [Lexing] | Update the  | 
| new_method [CamlinternalOO] | |
| new_methods_variables [CamlinternalOO] | |
| new_variable [CamlinternalOO] | |
| next [Stream] | Return the first element of the stream and remove it from the stream. | 
| next_after [Float] | 
 | 
| nice [UnixLabels] | Change the process priority. | 
| nice [Unix] | Change the process priority. | 
| no_scan_tag [Obj] | |
| none [Option] | 
 | 
| norm [Complex] | Norm: given  | 
| norm2 [Complex] | Norm squared: given  | 
| not [Pervasives] | |
| not [Bool] | 
 | 
| npeek [Stream] | 
 | 
| nth [ListLabels] | Return the  | 
| nth [List] | Return the  | 
| nth [Buffer] | Get the n-th character of the buffer. | 
| nth_dim [Bigarray.Genarray] | 
 | 
| nth_opt [ListLabels] | Return the  | 
| nth_opt [List] | Return the  | 
| num_dims [Bigarray.Genarray] | Return the number of dimensions of the given Bigarray. | 
| O | |
| obj [Obj] | |
| object_tag [Obj] | |
| ocaml_version [Sys] | 
 | 
| of_array [Bigarray.Array3] | Build a three-dimensional Bigarray initialized from the given array of arrays of arrays. | 
| of_array [Bigarray.Array2] | Build a two-dimensional Bigarray initialized from the given array of arrays. | 
| of_array [Bigarray.Array1] | Build a one-dimensional Bigarray initialized from the given array. | 
| of_bytes [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_float [Nativeint] | Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0). | 
| of_float [Int64] | Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0). | 
| of_float [Int32] | Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0). | 
| of_float [Int] | 
 | 
| of_int [Uchar] | 
 | 
| of_int [Nativeint] | Convert the given integer (type  | 
| of_int [Int64] | Convert the given integer (type  | 
| of_int [Int32] | Convert the given integer (type  | 
| of_int [Float] | Convert an integer to floating-point. | 
| of_int32 [Nativeint] | Convert the given 32-bit integer (type  | 
| of_int32 [Int64] | Convert the given 32-bit integer (type  | 
| of_list [Stream] | Return the stream holding the elements of the list in the same order. | 
| of_list [Set.S] | 
 | 
| of_list [MoreLabels.Set.S] | |
| of_list [Float.ArrayLabels] | |
| of_list [Float.Array] | 
 | 
| of_list [ArrayLabels] | 
 | 
| of_list [Array] | 
 | 
| of_nativeint [Int64] | Convert the given native integer (type  | 
| of_seq [String] | Create a string from the generator | 
| of_seq [StringLabels] | Create a string from the generator | 
| of_seq [Stack] | Create a stack from the iterator | 
| of_seq [Set.S] | Build a set from the given bindings | 
| of_seq [Queue] | Create a queue from the generator | 
| of_seq [MoreLabels.Set.S] | |
| of_seq [MoreLabels.Map.S] | |
| of_seq [MoreLabels.Hashtbl.SeededS] | |
| of_seq [MoreLabels.Hashtbl.S] | |
| of_seq [MoreLabels.Hashtbl] | |
| of_seq [Map.S] | Build a map from the given bindings | 
| of_seq [ListLabels] | Create a list from the iterator | 
| of_seq [List] | Create a list from the iterator | 
| of_seq [Hashtbl.SeededS] | |
| of_seq [Hashtbl.S] | |
| of_seq [Hashtbl] | Build a table from the given bindings. | 
| of_seq [Float.ArrayLabels] | |
| of_seq [Float.Array] | Create an array from the generator. | 
| of_seq [BytesLabels] | Create a string from the generator | 
| of_seq [Bytes] | Create a string from the generator | 
| of_seq [Buffer] | Create a buffer from the generator | 
| of_seq [ArrayLabels] | Create an array from the generator | 
| of_seq [Array] | Create an array from the generator | 
| of_string [Stream] | Return the stream of the characters of the string parameter. | 
| of_string [Nativeint] | Convert the given string to a native integer. | 
| of_string [Int64] | Convert the given string to a 64-bit integer. | 
| of_string [Int32] | Convert the given string to a 32-bit integer. | 
| of_string [Float] | Convert the given string to a float. | 
| of_string [BytesLabels] | Return a new byte sequence that contains the same bytes as the given string. | 
| of_string [Bytes] | Return a new byte sequence that contains the same bytes as the given string. | 
| of_string_opt [Nativeint] | Same as  | 
| of_string_opt [Int64] | Same as  | 
| of_string_opt [Int32] | Same as  | 
| of_string_opt [Float] | Same as  | 
| of_val [Obj.Extension_constructor] | |
| of_value [Bigarray.Array0] | Build a zero-dimensional Bigarray initialized from the given value. | 
| ok [Result] | 
 | 
| one [Nativeint] | The native integer 1. | 
| one [Int64] | The 64-bit integer 1. | 
| one [Int32] | The 32-bit integer 1. | 
| one [Int] | 
 | 
| one [Float] | The floating-point 1. | 
| one [Complex] | The complex number  | 
| opaque_identity [Sys] | For the purposes of optimization,  | 
| open_box [Format] | 
 | 
| 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_hbox [Format] | 
 | 
| open_hovbox [Format] | 
 | 
| open_hvbox [Format] | 
 | 
| open_in [Scanf.Scanning] | 
 | 
| open_in [Pervasives] | |
| open_in_bin [Scanf.Scanning] | 
 | 
| open_in_bin [Pervasives] | |
| open_in_gen [Pervasives] | |
| open_out [Pervasives] | |
| open_out_bin [Pervasives] | |
| open_out_gen [Pervasives] | |
| open_process [UnixLabels] | Same as  | 
| open_process [Unix] | Same as  | 
| open_process [ThreadUnix] | |
| open_process_args [UnixLabels] | Same as  | 
| open_process_args [Unix] | Same as  | 
| open_process_args_full [UnixLabels] | Similar to  | 
| open_process_args_full [Unix] | Similar to  | 
| open_process_args_in [UnixLabels] | High-level pipe and process management. | 
| open_process_args_in [Unix] | High-level pipe and process management. | 
| open_process_args_out [UnixLabels] | Same as  | 
| open_process_args_out [Unix] | Same as  | 
| open_process_full [UnixLabels] | Similar to  | 
| open_process_full [Unix] | Similar to  | 
| 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  | 
| open_process_out [Unix] | Same as  | 
| open_process_out [ThreadUnix] | |
| open_stag [Format] | 
 | 
| open_tag [Format] | |
| open_tbox [Format] | 
 | 
| open_temp_file [Filename] | Same as  | 
| open_vbox [Format] | 
 | 
| opendir [UnixLabels] | Open a descriptor on a directory | 
| opendir [Unix] | Open a descriptor on a directory | 
| openfile [UnixLabels] | Open the named file with the given flags. | 
| openfile [Unix] | Open the named file with the given flags. | 
| os_type [Sys] | Operating system currently executing the OCaml program. | 
| out_channel_length [Stdlib.LargeFile] | |
| out_channel_length [Pervasives] | |
| 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 [Digest] | Write a digest on the given output channel. | 
| output_acc [CamlinternalFormat] | |
| output_binary_int [Pervasives] | |
| output_buffer [Buffer] | 
 | 
| output_byte [Pervasives] | |
| output_bytes [Pervasives] | |
| output_char [Pervasives] | |
| output_string [Pervasives] | |
| output_substring [Pervasives] | |
| output_value [Pervasives] | |
| over_max_boxes [Format] | Tests if the maximum number of pretty-printing boxes allowed have already been opened. | 
| P | |
| param_format_of_ignored_format [CamlinternalFormat] | |
| params [CamlinternalOO] | |
| parent_dir_name [Filename] | The conventional name for the parent of the current directory (e.g. | 
| parse [Arg] | 
 | 
| parse_and_expand_argv_dynamic [Arg] | Same as  | 
| parse_argv [Arg] | 
 | 
| parse_argv_dynamic [Arg] | Same as  | 
| parse_dynamic [Arg] | Same as  | 
| parse_expand [Arg] | Same as  | 
| partition [Set.S] | 
 | 
| partition [MoreLabels.Set.S] | |
| partition [MoreLabels.Map.S] | |
| partition [Map.S] | 
 | 
| partition [ListLabels] | 
 | 
| partition [List] | 
 | 
| pause [UnixLabels] | Wait until a non-ignored, non-blocked signal is delivered. | 
| pause [Unix] | Wait until a non-ignored, non-blocked signal is delivered. | 
| peek [Stream] | Return  | 
| peek [Queue] | 
 | 
| peek_opt [Queue] | 
 | 
| pi [Float] | The constant pi. | 
| pipe [UnixLabels] | Create a pipe. | 
| pipe [Unix] | Create a pipe. | 
| pipe [ThreadUnix] | |
| polar [Complex] | 
 | 
| poll [Event] | Non-blocking version of  | 
| pop [Stack] | 
 | 
| pop [Queue] | 
 | 
| pop_opt [Stack] | 
 | 
| pos_in [Stdlib.LargeFile] | |
| pos_in [Pervasives] | |
| pos_out [Stdlib.LargeFile] | |
| pos_out [Pervasives] | |
| pow [Float] | Exponentiation. | 
| pow [Complex] | Power function. | 
| pp_close_box [Format] | |
| pp_close_stag [Format] | |
| pp_close_tag [Format] | |
| pp_close_tbox [Format] | |
| pp_force_newline [Format] | |
| pp_get_all_formatter_output_functions [Format] | |
| pp_get_ellipsis_text [Format] | |
| pp_get_formatter_out_functions [Format] | |
| pp_get_formatter_output_functions [Format] | |
| pp_get_formatter_stag_functions [Format] | |
| pp_get_formatter_tag_functions [Format] | |
| pp_get_geometry [Format] | |
| pp_get_margin [Format] | |
| pp_get_mark_tags [Format] | |
| pp_get_max_boxes [Format] | |
| pp_get_max_indent [Format] | |
| pp_get_print_tags [Format] | |
| pp_open_box [Format] | |
| pp_open_hbox [Format] | |
| pp_open_hovbox [Format] | |
| pp_open_hvbox [Format] | |
| pp_open_stag [Format] | |
| pp_open_tag [Format] | |
| pp_open_tbox [Format] | |
| pp_open_vbox [Format] | |
| pp_over_max_boxes [Format] | |
| pp_print_as [Format] | |
| pp_print_bool [Format] | |
| pp_print_break [Format] | |
| pp_print_char [Format] | |
| pp_print_custom_break [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_newline [Format] | |
| pp_print_option [Format] | 
 | 
| pp_print_result [Format] | 
 | 
| pp_print_space [Format] | |
| pp_print_string [Format] | |
| pp_print_tab [Format] | |
| pp_print_tbreak [Format] | |
| pp_print_text [Format] | 
 | 
| pp_safe_set_geometry [Format] | |
| pp_set_all_formatter_output_functions [Format] | |
| pp_set_ellipsis_text [Format] | |
| pp_set_formatter_out_channel [Format] | Redirecting the standard formatter output | 
| pp_set_formatter_out_functions [Format] | |
| pp_set_formatter_output_functions [Format] | |
| pp_set_formatter_stag_functions [Format] | |
| pp_set_formatter_tag_functions [Format] | This function will erase non-string tag formatting functions. | 
| pp_set_geometry [Format] | |
| pp_set_margin [Format] | |
| pp_set_mark_tags [Format] | |
| pp_set_max_boxes [Format] | |
| pp_set_max_indent [Format] | |
| pp_set_print_tags [Format] | |
| pp_set_tab [Format] | |
| pp_set_tags [Format] | |
| pred [Uchar] | 
 | 
| pred [Pervasives] | |
| pred [Nativeint] | Predecessor. | 
| pred [Int64] | Predecessor. | 
| pred [Int32] | Predecessor. | 
| pred [Int] | 
 | 
| pred [Float] | 
 | 
| prerr_bytes [Pervasives] | |
| prerr_char [Pervasives] | |
| prerr_endline [Pervasives] | |
| prerr_float [Pervasives] | |
| prerr_int [Pervasives] | |
| prerr_newline [Pervasives] | |
| prerr_string [Pervasives] | |
| print [Printexc] | 
 | 
| print_as [Format] | 
 | 
| print_backtrace [Printexc] | 
 | 
| print_bool [Format] | Print a boolean in the current pretty-printing box. | 
| print_break [Format] | 
 | 
| print_bytes [Pervasives] | |
| print_char [Pervasives] | |
| print_char [Format] | Print a character in the current pretty-printing box. | 
| print_cut [Format] | 
 | 
| print_endline [Pervasives] | |
| print_float [Pervasives] | |
| print_float [Format] | Print a floating point number in the current pretty-printing box. | 
| print_flush [Format] | End of pretty-printing: resets the pretty-printer to initial state. | 
| print_if_newline [Format] | Execute the next formatting command if the preceding line has just been split. | 
| print_int [Pervasives] | |
| print_int [Format] | Print an integer in the current pretty-printing box. | 
| print_newline [Pervasives] | |
| print_newline [Format] | End of pretty-printing: resets the pretty-printer to initial state. | 
| print_raw_backtrace [Printexc] | Print a raw backtrace in the same format
     | 
| print_space [Format] | 
 | 
| print_stat [Gc] | Print the current values of the memory management counters (in human-readable form) into the channel argument. | 
| print_string [Pervasives] | |
| print_string [Format] | 
 | 
| print_tab [Format] | 
 | 
| print_tbreak [Format] | 
 | 
| printf [Printf] | Same as  | 
| printf [Format] | Same as  | 
| process_full_pid [Unix] | Return the pid of a process opened via  | 
| process_in_pid [Unix] | Return the pid of a process opened via  | 
| process_out_pid [Unix] | Return the pid of a process opened via  | 
| process_pid [Unix] | Return the pid of a process opened via  | 
| prohibit [Dynlink] | 
 | 
| protect [Fun] | 
 | 
| public_dynamically_loaded_units [Dynlink] | Return the list of compilation units that have been dynamically loaded via
     | 
| public_method_label [CamlinternalOO] | |
| push [Stack] | 
 | 
| push [Queue] | 
 | 
| putenv [UnixLabels] | 
 | 
| putenv [Unix] | 
 | 
| Q | |
| quick_stat [Gc] | Same as  | 
| quote [Str] | 
 | 
| quote [Filename] | Return a quoted version of a file name, suitable for use as one argument in a command line, escaping all meta-characters. | 
| R | |
| raise [Pervasives] | |
| raise_notrace [Pervasives] | |
| 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  | 
| raw_backtrace_length [Printexc] | 
 | 
| raw_backtrace_to_string [Printexc] | Return a string from a raw backtrace, in the same format
     | 
| rcontains_from [String] | 
 | 
| rcontains_from [StringLabels] | 
 | 
| rcontains_from [BytesLabels] | 
 | 
| rcontains_from [Bytes] | 
 | 
| reachable_words [Obj] | Computes the total size (in words, including the headers) of all heap blocks accessible from the argument. | 
| read [UnixLabels] | 
 | 
| read [Unix] | 
 | 
| read [ThreadUnix] | |
| read_arg [Arg] | 
 | 
| read_arg0 [Arg] | Identical to  | 
| read_float [Pervasives] | |
| read_float_opt [Pervasives] | |
| read_int [Pervasives] | |
| read_int_opt [Pervasives] | |
| read_line [Pervasives] | |
| 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. | 
| really_input [Pervasives] | |
| really_input_string [Pervasives] | |
| recast [CamlinternalFormat] | |
| receive [Event] | 
 | 
| record_backtrace [Printexc] | 
 | 
| 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] | |
| ref [Pervasives] | |
| regexp [Str] | Compile a regular expression. | 
| regexp_case_fold [Str] | Same as  | 
| regexp_string [Str] | 
 | 
| regexp_string_case_fold [Str] | 
 | 
| register [Callback] | 
 | 
| register_exception [Callback] | 
 | 
| register_printer [Printexc] | 
 | 
| rem [Nativeint] | Integer remainder. | 
| rem [Int64] | Integer remainder. | 
| rem [Int32] | Integer remainder. | 
| rem [Int] | 
 | 
| rem [Float] | 
 | 
| remove [Weak.S] | 
 | 
| remove [Sys] | Remove the given file name from the file system. | 
| remove [Set.S] | 
 | 
| remove [MoreLabels.Set.S] | |
| remove [MoreLabels.Map.S] | |
| remove [MoreLabels.Hashtbl.SeededS] | |
| remove [MoreLabels.Hashtbl.S] | |
| remove [MoreLabels.Hashtbl] | |
| remove [Map.S] | 
 | 
| remove [Hashtbl.SeededS] | |
| remove [Hashtbl.S] | |
| remove [Hashtbl] | 
 | 
| remove_assoc [ListLabels] | 
 | 
| remove_assoc [List] | 
 | 
| remove_assq [ListLabels] | Same as  | 
| remove_assq [List] | Same as  | 
| remove_extension [Filename] | Return the given file name without its extension, as defined
    in  | 
| rename [UnixLabels] | 
 | 
| rename [Unix] | 
 | 
| rename [Sys] | Rename a file. | 
| rep [Uchar] | 
 | 
| replace [MoreLabels.Hashtbl.SeededS] | |
| replace [MoreLabels.Hashtbl.S] | |
| replace [MoreLabels.Hashtbl] | |
| replace [Hashtbl.SeededS] | |
| replace [Hashtbl.S] | |
| replace [Hashtbl] | 
 | 
| replace_first [Str] | Same as  | 
| replace_matched [Str] | 
 | 
| replace_seq [MoreLabels.Hashtbl.SeededS] | |
| replace_seq [MoreLabels.Hashtbl.S] | |
| replace_seq [MoreLabels.Hashtbl] | |
| replace_seq [Hashtbl.SeededS] | |
| replace_seq [Hashtbl.S] | |
| replace_seq [Hashtbl] | Add the given bindings to the table, using  | 
| repr [Obj] | |
| reset [MoreLabels.Hashtbl.SeededS] | |
| reset [MoreLabels.Hashtbl.S] | |
| reset [MoreLabels.Hashtbl] | |
| 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  | 
| reshape [Bigarray] | 
 | 
| reshape_0 [Bigarray] | Specialized version of  | 
| reshape_1 [Bigarray] | Specialized version of  | 
| reshape_2 [Bigarray] | Specialized version of  | 
| reshape_3 [Bigarray] | Specialized version of  | 
| return [Seq] | The singleton sequence containing only the given element. | 
| rev [ListLabels] | List reversal. | 
| rev [List] | List reversal. | 
| rev_append [ListLabels] | 
 | 
| rev_append [List] | 
 | 
| rev_char_set [CamlinternalFormat] | |
| rev_map [ListLabels] | |
| rev_map [List] | |
| rev_map2 [ListLabels] | |
| rev_map2 [List] | |
| rewinddir [UnixLabels] | Reposition the descriptor to the beginning of the directory | 
| rewinddir [Unix] | Reposition the descriptor to the beginning of the directory | 
| rhs_end [Parsing] | See  | 
| rhs_end_pos [Parsing] | Same as  | 
| rhs_start [Parsing] | Same as  | 
| rhs_start_pos [Parsing] | Same as  | 
| rindex [String] | 
 | 
| rindex [StringLabels] | 
 | 
| rindex [BytesLabels] | 
 | 
| rindex [Bytes] | 
 | 
| rindex_from [String] | 
 | 
| rindex_from [StringLabels] | 
 | 
| rindex_from [BytesLabels] | 
 | 
| rindex_from [Bytes] | 
 | 
| rindex_from_opt [String] | 
 | 
| rindex_from_opt [StringLabels] | 
 | 
| rindex_from_opt [BytesLabels] | 
 | 
| rindex_from_opt [Bytes] | 
 | 
| rindex_opt [String] | 
 | 
| rindex_opt [StringLabels] | 
 | 
| rindex_opt [BytesLabels] | 
 | 
| rindex_opt [Bytes] | 
 | 
| rmdir [UnixLabels] | Remove an empty directory. | 
| rmdir [Unix] | Remove an empty directory. | 
| round [Float] | 
 | 
| run_initializers [CamlinternalOO] | |
| run_initializers_opt [CamlinternalOO] | |
| runtime_parameters [Sys] | Return the value of the runtime parameters, in the same format
    as the contents of the  | 
| runtime_variant [Sys] | Return the name of the runtime variant the program is running on. | 
| runtime_warnings_enabled [Sys] | Return whether runtime warnings are currently enabled. | 
| S | |
| safe_set_geometry [Format] | 
 | 
| save_and_close [Spacetime.Series] | 
 | 
| save_event [Spacetime.Series] | 
 | 
| save_event_for_automatic_snapshots [Spacetime] | Like  | 
| scanf [Scanf] | Same as  | 
| search_backward [Str] | 
 | 
| search_forward [Str] | 
 | 
| seeded_hash [MoreLabels.Hashtbl] | |
| seeded_hash [Hashtbl] | A variant of  | 
| seeded_hash_param [MoreLabels.Hashtbl] | |
| seeded_hash_param [Hashtbl] | A variant of  | 
| seek_in [Stdlib.LargeFile] | |
| seek_in [Pervasives] | |
| seek_out [Stdlib.LargeFile] | |
| seek_out [Pervasives] | |
| 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 [CamlinternalOO] | |
| send_substring [UnixLabels] | Same as  | 
| send_substring [Unix] | Same as  | 
| 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_substring [Unix] | Same as  | 
| sendto_substring [ThreadUnix] | |
| set [Weak] | 
 | 
| set [String] | 
 | 
| set [StringLabels] | 
 | 
| set [Gc] | 
 | 
| set [Float.ArrayLabels] | |
| set [Float.Array] | 
 | 
| set [BytesLabels] | 
 | 
| set [Bytes] | 
 | 
| set [Bigarray.Array3] | 
 | 
| set [Bigarray.Array2] | 
 | 
| set [Bigarray.Array1] | 
 | 
| set [Bigarray.Array0] | 
 | 
| set [Bigarray.Genarray] | Assign an element of a generic Bigarray. | 
| set [ArrayLabels] | 
 | 
| set [Array] | 
 | 
| set_all_formatter_output_functions [Format] | |
| set_allowed_units [Dynlink] | Set the list of compilation units that may be referenced from units that are dynamically loaded in the future to be exactly the given value. | 
| set_binary_mode_in [Pervasives] | |
| set_binary_mode_out [Pervasives] | |
| set_close_on_exec [UnixLabels] | Set the ``close-on-exec'' flag on the given descriptor. | 
| set_close_on_exec [Unix] | Set the ``close-on-exec'' flag on the given descriptor. | 
| set_data [Obj.Ephemeron] | Same as  | 
| set_data [Ephemeron.Kn] | Same as  | 
| set_data [Ephemeron.K2] | Same as  | 
| set_data [Ephemeron.K1] | 
 | 
| set_double_field [Obj] | |
| set_ellipsis_text [Format] | Set the text of the ellipsis printed when too many pretty-printing boxes
  are open (a single dot,  | 
| set_field [Obj] | When using flambda: | 
| set_formatter_out_channel [Format] | Redirect the standard pretty-printer output to the given channel. | 
| set_formatter_out_functions [Format] | 
 | 
| set_formatter_output_functions [Format] | 
 | 
| set_formatter_stag_functions [Format] | 
 | 
| set_formatter_tag_functions [Format] | |
| set_geometry [Format] | |
| set_int16_be [BytesLabels] | 
 | 
| set_int16_be [Bytes] | 
 | 
| set_int16_le [BytesLabels] | 
 | 
| set_int16_le [Bytes] | 
 | 
| set_int16_ne [BytesLabels] | 
 | 
| set_int16_ne [Bytes] | 
 | 
| set_int32_be [BytesLabels] | 
 | 
| set_int32_be [Bytes] | 
 | 
| set_int32_le [BytesLabels] | 
 | 
| set_int32_le [Bytes] | 
 | 
| set_int32_ne [BytesLabels] | 
 | 
| set_int32_ne [Bytes] | 
 | 
| set_int64_be [BytesLabels] | 
 | 
| set_int64_be [Bytes] | 
 | 
| set_int64_le [BytesLabels] | 
 | 
| set_int64_le [Bytes] | 
 | 
| set_int64_ne [BytesLabels] | 
 | 
| set_int64_ne [Bytes] | 
 | 
| set_int8 [BytesLabels] | 
 | 
| set_int8 [Bytes] | 
 | 
| set_key [Obj.Ephemeron] | Same as  | 
| set_key [Ephemeron.Kn] | Same as  | 
| set_key [Ephemeron.K1] | 
 | 
| set_key1 [Ephemeron.K2] | Same as  | 
| set_key2 [Ephemeron.K2] | Same as  | 
| set_margin [Format] | 
 | 
| set_mark_tags [Format] | 
 | 
| set_max_boxes [Format] | 
 | 
| set_max_indent [Format] | 
 | 
| 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_print_tags [Format] | 
 | 
| set_signal [Sys] | Same as  | 
| set_state [Random] | Set the state of the generator used by the basic functions. | 
| set_tab [Format] | Sets a tabulation marker at current insertion point. | 
| set_tag [Obj] | |
| set_tags [Format] | 
 | 
| set_temp_dir_name [Filename] | Change the temporary directory returned by  | 
| set_trace [Parsing] | Control debugging support for  | 
| set_uint16_be [BytesLabels] | 
 | 
| set_uint16_be [Bytes] | 
 | 
| set_uint16_le [BytesLabels] | 
 | 
| set_uint16_le [Bytes] | 
 | 
| set_uint16_ne [BytesLabels] | 
 | 
| set_uint16_ne [Bytes] | 
 | 
| set_uint8 [BytesLabels] | 
 | 
| set_uint8 [Bytes] | 
 | 
| set_uncaught_exception_handler [Printexc] | 
 | 
| 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 [Unix] | 
 | 
| setitimer [UnixLabels] | 
 | 
| setitimer [Unix] | 
 | 
| 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  | 
| setsockopt_float [Unix] | Same as  | 
| setsockopt_int [UnixLabels] | Same as  | 
| setsockopt_int [Unix] | Same as  | 
| setsockopt_optint [UnixLabels] | Same as  | 
| setsockopt_optint [Unix] | Same as  | 
| setuid [UnixLabels] | Set the real user id and effective user id for the process. | 
| setuid [Unix] | Set the real user id and effective user id for the process. | 
| shift_left [Nativeint] | 
 | 
| shift_left [Int64] | 
 | 
| shift_left [Int32] | 
 | 
| shift_left [Int] | 
 | 
| shift_right [Nativeint] | 
 | 
| shift_right [Int64] | 
 | 
| shift_right [Int32] | 
 | 
| shift_right [Int] | 
 | 
| shift_right_logical [Nativeint] | 
 | 
| shift_right_logical [Int64] | 
 | 
| shift_right_logical [Int32] | 
 | 
| shift_right_logical [Int] | 
 | 
| shutdown [UnixLabels] | Shutdown a socket connection. | 
| shutdown [Unix] | Shutdown a socket connection. | 
| shutdown_connection [UnixLabels] | ``Shut down'' a connection established with  | 
| shutdown_connection [Unix] | ``Shut down'' a connection established with  | 
| 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] | 
 | 
| sign_bit [Float] | 
 | 
| signal [Sys] | Set the behavior of the system on receipt of a given signal. | 
| signal [Condition] | 
 | 
| 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 [Unix] | 
 | 
| sigprof [Sys] | Profiling interrupt | 
| sigquit [Sys] | Interactive termination | 
| sigsegv [Sys] | Invalid memory reference | 
| sigstop [Sys] | Stop | 
| sigsuspend [UnixLabels] | 
 | 
| sigsuspend [Unix] | 
 | 
| sigsys [Sys] | Bad argument to routine | 
| sigterm [Sys] | Termination | 
| sigtrap [Sys] | Trace/breakpoint trap | 
| sigtstp [Sys] | Interactive stop | 
| sigttin [Sys] | Terminal read from background process | 
| sigttou [Sys] | Terminal write from background process | 
| sigurg [Sys] | Urgent condition on socket | 
| sigusr1 [Sys] | Application-defined signal 1 | 
| sigusr2 [Sys] | Application-defined signal 2 | 
| sigvtalrm [Sys] | Timeout in virtual time | 
| sigxcpu [Sys] | Timeout in cpu time | 
| sigxfsz [Sys] | File size limit exceeded | 
| sin [Pervasives] | |
| sin [Float] | Sine. | 
| single_write [UnixLabels] | Same as  | 
| single_write [Unix] | Same as  | 
| single_write_substring [UnixLabels] | Same as  | 
| single_write_substring [Unix] | Same as  | 
| singleton [Set.S] | 
 | 
| singleton [MoreLabels.Set.S] | |
| singleton [MoreLabels.Map.S] | |
| singleton [Map.S] | 
 | 
| sinh [Pervasives] | |
| sinh [Float] | Hyperbolic sine. | 
| size [Obj] | |
| size [Nativeint] | The size in bits of a native integer. | 
| size_in_bytes [Bigarray.Array3] | 
 | 
| size_in_bytes [Bigarray.Array2] | 
 | 
| size_in_bytes [Bigarray.Array1] | 
 | 
| size_in_bytes [Bigarray.Array0] | 
 | 
| size_in_bytes [Bigarray.Genarray] | 
 | 
| sleep [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 Bigarray. | 
| slice_left [Bigarray.Array2] | Extract a row (one-dimensional slice) of the given two-dimensional Bigarray. | 
| slice_left [Bigarray.Genarray] | Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of the first (left-most) coordinates. | 
| slice_left_1 [Bigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the first two coordinates. | 
| slice_left_2 [Bigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional Bigarray by fixing the first coordinate. | 
| slice_right [Bigarray.Array2] | Extract a column (one-dimensional slice) of the given two-dimensional Bigarray. | 
| slice_right [Bigarray.Genarray] | Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of the last (right-most) coordinates. | 
| slice_right_1 [Bigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the last two coordinates. | 
| slice_right_2 [Bigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional Bigarray by fixing the last coordinate. | 
| snd [Pervasives] | |
| 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 [Option] | 
 | 
| sort [ListLabels] | Sort a list in increasing order according to a comparison function. | 
| sort [List] | Sort a list in increasing order according to a comparison function. | 
| sort [Float.ArrayLabels] | |
| sort [Float.Array] | Sort a floatarray in increasing order according to a comparison function. | 
| sort [ArrayLabels] | Sort an array in increasing order according to a comparison function. | 
| sort [Array] | Sort an array in increasing order according to a comparison function. | 
| sort_uniq [ListLabels] | Same as  | 
| sort_uniq [List] | Same as  | 
| split [Str] | 
 | 
| split [Set.S] | 
 | 
| split [MoreLabels.Set.S] | |
| split [MoreLabels.Map.S] | |
| split [Map.S] | 
 | 
| split [ListLabels] | Transform a list of pairs into a pair of lists:
    | 
| split [List] | Transform a list of pairs into a pair of lists:
    | 
| split_delim [Str] | Same as  | 
| split_on_char [String] | 
 | 
| split_on_char [StringLabels] | 
 | 
| sprintf [Printf] | Same as  | 
| sprintf [Format] | Same as  | 
| sqrt [Pervasives] | |
| sqrt [Float] | Square root. | 
| sqrt [Complex] | Square root. | 
| sscanf [Scanf] | Same as  | 
| sscanf_format [Scanf] | Same as  | 
| stable_sort [ListLabels] | Same as  | 
| stable_sort [List] | Same as  | 
| stable_sort [Float.ArrayLabels] | |
| stable_sort [Float.Array] | Same as  | 
| stable_sort [ArrayLabels] | Same as  | 
| stable_sort [Array] | Same as  | 
| 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
    | 
| 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] | 
 | 
| stats [CamlinternalOO] | |
| stats_alive [Ephemeron.SeededS] | same as  | 
| stats_alive [Ephemeron.S] | same as  | 
| std_formatter [Format] | The standard formatter to write to standard output. | 
| stdbuf [Format] | The string buffer in which  | 
| stderr [UnixLabels] | File descriptor for standard error. | 
| stderr [Unix] | File descriptor for standard error. | 
| stderr [Pervasives] | |
| stdib [Scanf.Scanning] | A deprecated alias for  | 
| stdin [UnixLabels] | File descriptor for standard input. | 
| stdin [Unix] | File descriptor for standard input. | 
| stdin [Scanf.Scanning] | The standard input notion for the  | 
| stdin [Pervasives] | |
| stdout [UnixLabels] | File descriptor for standard output. | 
| stdout [Unix] | File descriptor for standard output. | 
| stdout [Pervasives] | |
| str_formatter [Format] | A formatter to output to the  | 
| string [Digest] | Return the digest of the given string. | 
| string_after [Str] | 
 | 
| string_before [Str] | 
 | 
| string_match [Str] | 
 | 
| string_of_bool [Pervasives] | |
| string_of_float [Pervasives] | |
| string_of_fmt [CamlinternalFormat] | |
| string_of_fmtty [CamlinternalFormat] | |
| string_of_format [Pervasives] | |
| 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] | |
| string_partial_match [Str] | Similar to  | 
| string_tag [Obj] | |
| strput_acc [CamlinternalFormat] | |
| sub [String] | 
 | 
| sub [StringLabels] | 
 | 
| sub [Nativeint] | Subtraction. | 
| sub [Int64] | Subtraction. | 
| sub [Int32] | Subtraction. | 
| sub [Int] | 
 | 
| sub [Float.ArrayLabels] | |
| sub [Float.Array] | 
 | 
| sub [Float] | Floating-point subtraction. | 
| sub [Complex] | Subtraction | 
| sub [BytesLabels] | 
 | 
| sub [Bytes] | 
 | 
| sub [Buffer] | 
 | 
| sub [Bigarray.Array1] | Extract a sub-array of the given one-dimensional Bigarray. | 
| sub [ArrayLabels] | 
 | 
| sub [Array] | 
 | 
| sub_left [Bigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the first dimension. | 
| sub_left [Bigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the first dimension. | 
| sub_left [Bigarray.Genarray] | Extract a sub-array of the given Bigarray by restricting the first (left-most) dimension. | 
| sub_right [Bigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the second dimension. | 
| sub_right [Bigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the second dimension. | 
| sub_right [Bigarray.Genarray] | Extract a sub-array of the given Bigarray by restricting the last (right-most) dimension. | 
| sub_string [BytesLabels] | Same as  | 
| sub_string [Bytes] | Same as  | 
| subbytes [Digest] | 
 | 
| subset [Set.S] | 
 | 
| subset [MoreLabels.Set.S] | |
| substitute_first [Str] | Same as  | 
| substring [Digest] | 
 | 
| succ [Uchar] | 
 | 
| succ [Pervasives] | |
| succ [Nativeint] | Successor. | 
| succ [Int64] | Successor. | 
| succ [Int32] | Successor. | 
| succ [Int] | 
 | 
| succ [Float] | 
 | 
| symbol_end [Parsing] | See  | 
| symbol_end_pos [Parsing] | Same as  | 
| symbol_start [Parsing] | 
 | 
| symbol_start_pos [Parsing] | Same as  | 
| symlink [UnixLabels] | 
 | 
| symlink [Unix] | 
 | 
| symm [CamlinternalFormat] | |
| sync [Event] | 'Synchronize' on an event: offer all the communication possibilities specified in the event to the outside world, and block until one of the communications succeed. | 
| system [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] | |
| T | |
| tag [Obj] | |
| take [Spacetime.Snapshot] | 
 | 
| take [Queue] | 
 | 
| take_opt [Queue] | 
 | 
| tan [Pervasives] | |
| tan [Float] | Tangent. | 
| tanh [Pervasives] | |
| tanh [Float] | Hyperbolic tangent. | 
| tcdrain [UnixLabels] | Waits until all output written on the given file descriptor has been transmitted. | 
| tcdrain [Unix] | Waits until all output written on the given file descriptor has been transmitted. | 
| tcflow [UnixLabels] | Suspend or restart reception or transmission of data on
   the given file descriptor, depending on the second argument:
    | 
| tcflow [Unix] | Suspend or restart reception or transmission of data on
   the given file descriptor, depending on the second argument:
    | 
| 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:  | 
| 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:  | 
| 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  | 
| temp_file [Filename] | 
 | 
| time [UnixLabels] | Return the current time since 00:00:00 GMT, Jan. | 
| time [Unix] | Return the current time since 00:00:00 GMT, Jan. | 
| time [Sys] | Return the processor time, in seconds, used by the program since the beginning of execution. | 
| timed_read [ThreadUnix] | |
| timed_write [ThreadUnix] | Behave as  | 
| 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] | 
 | 
| to_bytes [Marshal] | 
 | 
| to_bytes [Buffer] | Return a copy of the current contents of the buffer. | 
| to_channel [Marshal] | 
 | 
| to_char [Uchar] | 
 | 
| to_float [Nativeint] | Convert the given native integer to a floating-point number. | 
| to_float [Int64] | Convert the given 64-bit integer to a floating-point number. | 
| to_float [Int32] | Convert the given 32-bit integer to a floating-point number. | 
| to_float [Int] | 
 | 
| to_float [Bool] | 
 | 
| to_hex [Digest] | Return the printable hexadecimal representation of the given digest. | 
| to_int [Uchar] | 
 | 
| to_int [Nativeint] | Convert the given native integer (type  | 
| to_int [Int64] | Convert the given 64-bit integer (type  | 
| to_int [Int32] | Convert the given 32-bit integer (type  | 
| to_int [Float] | Truncate the given floating-point number to an integer. | 
| to_int [Bool] | 
 | 
| to_int32 [Nativeint] | Convert the given native integer to a
   32-bit integer (type  | 
| to_int32 [Int64] | Convert the given 64-bit integer (type  | 
| to_list [Result] | 
 | 
| to_list [Option] | 
 | 
| to_list [Float.ArrayLabels] | |
| to_list [Float.Array] | 
 | 
| to_list [ArrayLabels] | 
 | 
| to_list [Array] | 
 | 
| to_nativeint [Int64] | Convert the given 64-bit integer (type  | 
| to_option [Result] | 
 | 
| to_result [Option] | 
 | 
| to_seq [String] | Iterate on the string, in increasing index order. | 
| to_seq [StringLabels] | Iterate on the string, in increasing index order. | 
| to_seq [Stack] | Iterate on the stack, top to bottom. | 
| to_seq [Set.S] | Iterate on the whole set, in ascending order | 
| to_seq [Result] | 
 | 
| to_seq [Queue] | Iterate on the queue, in front-to-back order. | 
| to_seq [Option] | 
 | 
| to_seq [MoreLabels.Set.S] | |
| to_seq [MoreLabels.Map.S] | |
| to_seq [MoreLabels.Hashtbl.SeededS] | |
| to_seq [MoreLabels.Hashtbl.S] | |
| to_seq [MoreLabels.Hashtbl] | |
| to_seq [Map.S] | Iterate on the whole map, in ascending order of keys | 
| to_seq [ListLabels] | Iterate on the list | 
| to_seq [List] | Iterate on the list | 
| to_seq [Hashtbl.SeededS] | |
| to_seq [Hashtbl.S] | |
| to_seq [Hashtbl] | Iterate on the whole table. | 
| to_seq [Float.ArrayLabels] | |
| to_seq [Float.Array] | Iterate on the floatarray, in increasing order. | 
| to_seq [BytesLabels] | Iterate on the string, in increasing index order. | 
| to_seq [Bytes] | Iterate on the string, in increasing index order. | 
| to_seq [Buffer] | Iterate on the buffer, in increasing order. | 
| to_seq [ArrayLabels] | Iterate on the array, in increasing order | 
| to_seq [Array] | Iterate on the array, in increasing order. | 
| to_seq_from [Set.S] | 
 | 
| to_seq_from [MoreLabels.Set.S] | |
| to_seq_from [MoreLabels.Map.S] | |
| to_seq_from [Map.S] | 
 | 
| to_seq_keys [MoreLabels.Hashtbl.SeededS] | |
| to_seq_keys [MoreLabels.Hashtbl.S] | |
| to_seq_keys [MoreLabels.Hashtbl] | |
| to_seq_keys [Hashtbl.SeededS] | |
| to_seq_keys [Hashtbl.S] | |
| to_seq_keys [Hashtbl] | Same as  | 
| to_seq_values [MoreLabels.Hashtbl.SeededS] | |
| to_seq_values [MoreLabels.Hashtbl.S] | |
| to_seq_values [MoreLabels.Hashtbl] | |
| to_seq_values [Hashtbl.SeededS] | |
| to_seq_values [Hashtbl.S] | |
| to_seq_values [Hashtbl] | Same as  | 
| to_seqi [String] | Iterate on the string, in increasing order, yielding indices along chars | 
| to_seqi [StringLabels] | Iterate on the string, in increasing order, yielding indices along chars | 
| to_seqi [Float.ArrayLabels] | |
| to_seqi [Float.Array] | Iterate on the floatarray, in increasing order, yielding indices along elements. | 
| to_seqi [BytesLabels] | Iterate on the string, in increasing order, yielding indices along chars | 
| to_seqi [Bytes] | Iterate on the string, in increasing order, yielding indices along chars | 
| to_seqi [Buffer] | Iterate on the buffer, in increasing order, yielding indices along chars. | 
| to_seqi [ArrayLabels] | Iterate on the array, in increasing order, yielding indices along elements | 
| to_seqi [Array] | Iterate on the array, in increasing order, yielding indices along elements. | 
| to_string [Unit] | 
 | 
| to_string [Printexc] | 
 | 
| to_string [Nativeint] | Return the string representation of its argument, in decimal. | 
| to_string [Marshal] | Same as  | 
| to_string [Int64] | Return the string representation of its argument, in decimal. | 
| to_string [Int32] | Return the string representation of its argument, in signed decimal. | 
| to_string [Int] | 
 | 
| to_string [Float] | Return the string representation of a floating-point number. | 
| to_string [BytesLabels] | Return a new string that contains the same bytes as the given byte sequence. | 
| to_string [Bytes] | Return a new string that contains the same bytes as the given byte sequence. | 
| to_string [Bool] | 
 | 
| to_string_default [Printexc] | 
 | 
| top [Stack] | 
 | 
| top [Queue] | 
 | 
| top_opt [Stack] | 
 | 
| total_size [Marshal] | See  | 
| trans [CamlinternalFormat] | |
| transfer [Queue] | 
 | 
| 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. | 
| trunc [Float] | 
 | 
| truncate [UnixLabels.LargeFile] | |
| truncate [UnixLabels] | Truncates the named file to the given size. | 
| truncate [Unix.LargeFile] | See  | 
| truncate [Unix] | Truncates the named file to the given size. | 
| truncate [Pervasives] | |
| truncate [Obj] | |
| truncate [Buffer] | 
 | 
| try_lock [Mutex] | Same as  | 
| type_format [CamlinternalFormat] | |
| U | |
| umask [UnixLabels] | Set the process's file mode creation mask, and return the previous mask. | 
| umask [Unix] | Set the process's file mode creation mask, and return the previous mask. | 
| unaligned_tag [Obj] | |
| uncapitalize [String] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.. | 
| uncapitalize [StringLabels] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.. | 
| uncapitalize [BytesLabels] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.. | 
| uncapitalize [Bytes] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.. | 
| uncapitalize_ascii [String] | 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] | 
 | 
| union [Set.S] | Set union. | 
| union [MoreLabels.Set.S] | |
| union [MoreLabels.Map.S] | |
| union [Map.S] | 
 | 
| unix [Sys] | True if  | 
| unlink [UnixLabels] | Removes the named file | 
| unlink [Unix] | Removes the named file. | 
| unlock [Mutex] | Unlock the given mutex. | 
| unmarshal [Obj] | |
| unsafe_environment [Unix] | Return the process environment, as an array of strings with the format ``variable=value''. | 
| unsafe_get [Float.ArrayLabels] | |
| unsafe_get [Float.Array] | |
| unsafe_get [Bigarray.Array3] | Like  | 
| unsafe_get [Bigarray.Array2] | Like  | 
| unsafe_get [Bigarray.Array1] | Like  | 
| unsafe_getenv [UnixLabels] | Return the value associated to a variable in the process environment. | 
| unsafe_getenv [Unix] | Return the value associated to a variable in the process environment. | 
| unsafe_of_string [Bytes] | Unsafely convert a shared string to a byte sequence that should not be mutated. | 
| unsafe_set [Float.ArrayLabels] | |
| unsafe_set [Float.Array] | |
| unsafe_set [Bigarray.Array3] | Like  | 
| unsafe_set [Bigarray.Array2] | Like  | 
| unsafe_set [Bigarray.Array1] | Like  | 
| unsafe_to_string [Bytes] | Unsafely convert a byte sequence into a string. | 
| unset_data [Obj.Ephemeron] | Same as  | 
| unset_data [Ephemeron.Kn] | Same as  | 
| unset_data [Ephemeron.K2] | Same as  | 
| unset_data [Ephemeron.K1] | 
 | 
| unset_key [Obj.Ephemeron] | Same as  | 
| unset_key [Ephemeron.Kn] | Same as  | 
| unset_key [Ephemeron.K1] | 
 | 
| unset_key1 [Ephemeron.K2] | Same as  | 
| unset_key2 [Ephemeron.K2] | Same as  | 
| unsigned_compare [Nativeint] | Same as  | 
| unsigned_compare [Int64] | Same as  | 
| unsigned_compare [Int32] | Same as  | 
| unsigned_div [Nativeint] | Same as  | 
| unsigned_div [Int64] | Same as  | 
| unsigned_div [Int32] | Same as  | 
| unsigned_rem [Nativeint] | Same as  | 
| unsigned_rem [Int64] | Same as  | 
| unsigned_rem [Int32] | Same as  | 
| unsigned_to_int [Nativeint] | Same as  | 
| unsigned_to_int [Int64] | Same as  | 
| unsigned_to_int [Int32] | Same as  | 
| update [MoreLabels.Map.S] | |
| update [Map.S] | 
 | 
| 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] | 
 | 
| usage_string [Arg] | Returns the message that would have been printed by  | 
| use_printers [Printexc] | 
 | 
| 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 | |
| valid_float_lexem [Pervasives] | |
| value [Result] | 
 | 
| value [Option] | 
 | 
| 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_pid [Thread] | 
 | 
| wait_read [Thread] | See  | 
| wait_signal [Thread] | 
 | 
| wait_timed_read [Thread] | |
| wait_timed_write [Thread] | Suspend the execution of the calling thread until at least
   one character or EOF is available for reading ( | 
| wait_write [Thread] | This function does nothing in this implementation. | 
| waitpid [UnixLabels] | Same as  | 
| waitpid [Unix] | Same as  | 
| waitpid [ThreadUnix] | |
| widen [CamlinternalOO] | |
| win32 [Sys] | True if  | 
| with_positions [Lexing] | Tell whether the lexer buffer keeps track of position fields
     | 
| with_tag [Obj] | |
| word_size [Sys] | Size of one word on the machine currently executing the OCaml program, in bits: 32 or 64. | 
| wrap [Event] | 
 | 
| wrap_abort [Event] | 
 | 
| write [UnixLabels] | 
 | 
| write [Unix] | 
 | 
| write [ThreadUnix] | |
| write_arg [Arg] | 
 | 
| write_arg0 [Arg] | Identical to  | 
| write_substring [UnixLabels] | Same as  | 
| write_substring [Unix] | Same as  | 
| write_substring [ThreadUnix] | |
| Y | |
| yield [Thread] | Re-schedule the calling thread without suspending it. | 
| Z | |
| zero [Nativeint] | The native integer 0. | 
| zero [Int64] | The 64-bit integer 0. | 
| zero [Int32] | The 32-bit integer 0. | 
| zero [Int] | 
 | 
| zero [Float] | The floating point 0. | 
| zero [Complex] | The complex number  |