| ( * ) [Stdlib] | Integer multiplication. |
| ( ** ) [Stdlib] | Exponentiation. |
| ( *. ) [Stdlib] | Floating-point multiplication. |
| (!) [Stdlib] |
|
| (!=) [Stdlib] | Negation of |
| (&&) [Stdlib] | The boolean 'and'. |
| (&&) [Bool] |
|
| (&) [Stdlib] | |
| (+) [Stdlib] | Integer addition. |
| (+.) [Stdlib] | Floating-point addition. |
| (-) [Stdlib] | Integer subtraction. |
| (-.) [Stdlib] | Floating-point subtraction. |
| (/) [Stdlib] | Integer division. |
| (/.) [Stdlib] | Floating-point division. |
| (:=) [Stdlib] |
|
| (<) [Stdlib] | See |
| (<=) [Stdlib] | See |
| (<>) [Stdlib] | Negation of |
| (=) [Stdlib] |
|
| (==) [Stdlib] |
|
| (>) [Stdlib] | See |
| (>=) [Stdlib] | Structural ordering functions. |
| (@) [Stdlib] | List concatenation. |
| (@@) [Stdlib] | Application operator: |
| (^) [Stdlib] | String concatenation. |
| (^^) [Stdlib] |
|
| (asr) [Stdlib] |
|
| (land) [Stdlib] | Bitwise logical and. |
| (lor) [Stdlib] | Bitwise logical or. |
| (lsl) [Stdlib] |
|
| (lsr) [Stdlib] |
|
| (lxor) [Stdlib] | Bitwise logical exclusive or. |
| (mod) [Stdlib] | Integer remainder. |
| (or) [Stdlib] | |
| (|>) [Stdlib] | Reverse-application operator: |
| (||) [Stdlib] | The boolean 'or'. |
| (||) [Bool] |
|
| (~+) [Stdlib] | Unary addition. |
| (~+.) [Stdlib] | Unary addition. |
| (~-) [Stdlib] | Unary negation. |
| (~-.) [Stdlib] | Unary negation. |
| __FILE__ [Stdlib] |
|
| __LINE_OF__ [Stdlib] |
|
| __LINE__ [Stdlib] |
|
| __LOC_OF__ [Stdlib] |
|
| __LOC__ [Stdlib] |
|
| __MODULE__ [Stdlib] |
|
| __POS_OF__ [Stdlib] |
|
| __POS__ [Stdlib] |
|
A | |
| abs [Stdlib] | Return the absolute value of the argument. |
| abs [Nativeint] | Return the absolute value of its argument. |
| abs [Int64] | Return the absolute value of its argument. |
| abs [Int32] | Return the absolute value of its argument. |
| abs [Int] |
|
| abs [Float] |
|
| abs_float [Stdlib] |
|
| 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 [Stdlib] | Arc cosine. |
| 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 [Seq] |
|
| 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 [Stdlib] | Arc sine. |
| 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 [Stdlib] | Register the given function to be called at program termination time. |
| atan [Stdlib] | Arc tangent. |
| atan [Float] | Arc tangent. |
| atan2 [Stdlib] |
|
| 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 [Stdlib] | Same as |
| bool_of_string_opt [Stdlib] | Convert the given string to a boolean. |
| 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 [Stdlib] | Round above to an integer value. |
| 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 [Stdlib] | Return the character with the given ASCII code. |
| chdir [UnixLabels] | Change the process working directory. |
| chdir [Unix] | Change the process working directory. |
| chdir [Sys] | Change the current working directory of the process. |
| check [Weak] |
|
| 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 [Stdlib] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number. |
| classify_float [Float] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number. |
| clean [Ephemeron.SeededS] | remove all dead bindings. |
| clean [Ephemeron.S] | remove all dead bindings. |
| clear [Weak.S] | Remove all elements from the table. |
| clear [Stack] | Discard all elements from a stack. |
| clear [Queue] | Discard all elements from a queue. |
| clear [MoreLabels.Hashtbl.SeededS] | |
| clear [MoreLabels.Hashtbl.S] | |
| clear [MoreLabels.Hashtbl] | |
| 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 [Stdlib] | Close the given channel. |
| close_in [Scanf.Scanning] | Closes the |
| close_in_noerr [Stdlib] | Same as |
| close_out [Stdlib] | Close the given channel, flushing all buffered write operations. |
| close_out_noerr [Stdlib] | Same as |
| 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 [Stdlib] |
|
| compare [StringLabels] | The comparison function for strings, with the same specification as
|
| compare [Set.S] | Total ordering between sets. |
| compare [Result] |
|
| 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] | |
| concat_map [ListLabels] |
|
| concat_map [List] |
|
| 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 [Seq] |
|
| 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 [Stdlib] |
|
| cos [Stdlib] | Cosine. |
| cos [Float] | Cosine. |
| cosh [Stdlib] | Hyperbolic cosine. |
| cosh [Float] | Hyperbolic cosine. |
| count [Weak.S] | Count the number of elements in the table. |
| 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 [Stdlib] | Decrement the integer contained in the given reference. |
| default_uncaught_exception_handler [Printexc] |
|
| 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 |
| 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 [Stdlib] | The difference between |
| 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. |
| eventlog_pause [Gc] |
|
| eventlog_resume [Gc] |
|
| 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 |
| exists2 [ArrayLabels] | Same as |
| exists2 [Array] | Same as |
| exit [Thread] | Terminate prematurely the currently executing thread. |
| exit [Stdlib] | Terminate the process, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure. |
| exn_slot_id [Printexc] |
|
| exn_slot_name [Printexc] |
|
| exp [Stdlib] | Exponential. |
| exp [Float] | Exponential. |
| exp [Complex] | Exponentiation. |
| expm1 [Stdlib] |
|
| expm1 [Float] |
|
| extend [BytesLabels] |
|
| extend [Bytes] |
|
| extension [Filename] |
|
| extension_constructor [Obj] | |
| extension_id [Obj] | |
| extension_name [Obj] | |
F | |
| failwith [Stdlib] | Raise exception |
| 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 [Set.S] |
|
| filter_map [Seq] | Apply the function to every element; if |
| filter_map [MoreLabels.Set.S] | |
| filter_map [MoreLabels.Map.S] | |
| filter_map [Map.S] |
|
| 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] |
|
| filteri [ListLabels] | Same as |
| filteri [List] | Same as |
| 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_map [ListLabels] |
|
| find_map [List] |
|
| 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 [Stdlib] | Same as |
| float [Random.State] | |
| float [Random] |
|
| 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 [Stdlib] | Convert an integer to floating-point. |
| float_of_string [Stdlib] | Same as |
| float_of_string_opt [Stdlib] | Convert the given string to a float. |
| floor [Stdlib] | Round below to an integer value. |
| floor [Float] | Round below to an integer value. |
| flush [Stdlib] | Flush the buffer associated with the given output channel, performing all pending writes on that channel. |
| flush_all [Stdlib] | Flush all open output channels; ignore errors. |
| flush_input [Lexing] | Discard the contents of the buffer and reset the current position to 0. |
| flush_str_formatter [Format] | Returns the material printed with |
| 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_left_map [ListLabels] |
|
| fold_left_map [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 |
| for_all2 [ArrayLabels] | Same as |
| for_all2 [Array] | 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 [Stdlib] |
|
| 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 [Stdlib] |
|
| 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 [Stdlib] | Return the first component of a pair. |
| fstat [UnixLabels.LargeFile] | |
| fstat [UnixLabels] | Return the information for the file associated with the given descriptor. |
| fstat [Unix.LargeFile] | |
| fstat [Unix] | Return the information for the file associated with the given descriptor. |
| fsync [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 [Stdlib] |
|
| hypot [Float] |
|
I | |
| i [Complex] | The complex number |
| ibprintf [Printf] | Same as |
| 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 [Stdlib] | Discard the value of its argument and return |
| ikbprintf [Printf] | Same as |
| ikfprintf [Printf] | Same as |
| ikfprintf [Format] | Same as |
| in_channel_length [Stdlib.LargeFile] | |
| in_channel_length [Stdlib] | Return the size (number of characters) of the regular file on which the given channel is opened. |
| in_channel_of_descr [UnixLabels] | Create an input channel reading from the given descriptor. |
| in_channel_of_descr [Unix] | Create an input channel reading from the given descriptor. |
| incr [Stdlib] | Increment the integer contained in the given reference. |
| 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 [Stdlib] | Positive infinity. |
| 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 [Stdlib] |
|
| input [Digest] | Read a digest from the given input channel. |
| input_binary_int [Stdlib] | Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. |
| input_byte [Stdlib] | Same as |
| input_char [Stdlib] | Read one character from the given input channel. |
| input_line [Stdlib] | Read characters from the given input channel, until a newline character is encountered. |
| input_value [Stdlib] | Read the representation of a structured value, as produced
by |
| 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 [Stdlib] | Return the ASCII code of the argument. |
| int_of_float [Stdlib] | Truncate the given floating-point number to an integer. |
| int_of_string [Stdlib] | Same as |
| int_of_string_opt [Stdlib] | Convert the given string to an integer. |
| 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 [Stdlib] | Raise exception |
| 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 [Stdlib] |
|
| 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 [Stdlib] | Bitwise logical negation. |
| 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 [Stdlib] | Natural logarithm. |
| log [Float] | Natural logarithm. |
| log [Complex] | Natural logarithm (in base |
| log10 [Stdlib] | Base 10 logarithm. |
| log10 [Float] | Base 10 logarithm. |
| log1p [Stdlib] |
|
| 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 [Stdlib] | Return the greater of the two arguments. |
| 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 [Stdlib] | The largest positive finite value of type |
| max_float [Float] | The largest positive finite value of type |
| max_floatarray_length [Sys] | Maximum length of a floatarray. |
| max_int [Stdlib] | The greatest representable integer. |
| max_int [Nativeint] | The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform. |
| max_int [Int64] | The greatest representable 64-bit integer, 263 - 1. |
| max_int [Int32] | The greatest representable 32-bit integer, 231 - 1. |
| max_int [Int] |
|
| max_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 [Stdlib] | Return the smaller of the two arguments. |
| 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 [Stdlib] | The smallest positive, non-zero, non-denormalized value of type |
| min_float [Float] | The smallest positive, non-zero, non-denormalized value of type |
| min_int [Stdlib] | The smallest representable integer. |
| min_int [Nativeint] | The smallest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform. |
| min_int [Int64] | The smallest representable 64-bit integer, -263. |
| min_int [Int32] | The smallest representable 32-bit integer, -231. |
| min_int [Int] |
|
| min_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 [Stdlib] |
|
| modf [Stdlib] |
|
| modf [Float] |
|
| mul [Nativeint] | Multiplication. |
| mul [Int64] | Multiplication. |
| mul [Int32] | Multiplication. |
| mul [Int] |
|
| mul [Float] | Floating-point multiplication. |
| mul [Complex] | Multiplication |
N | |
| name [Printexc.Slot] |
|
| name [Obj.Extension_constructor] | |
| name_of_input [Scanf.Scanning] |
|
| nan [Stdlib] | A special floating-point value denoting the result of an
undefined operation such as |
| 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 [Stdlib] | Negative infinity. |
| 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 [Stdlib] | The boolean negation. |
| 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 |
| null [Filename] |
|
| null_tracker [Gc.Memprof] | Default callbacks simply return |
| 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 [Stdlib] | Open the named file for reading, and return a new input channel on that file, positioned at the beginning of the file. |
| open_in [Scanf.Scanning] |
|
| open_in_bin [Stdlib] | Same as |
| open_in_bin [Scanf.Scanning] |
|
| open_in_gen [Stdlib] |
|
| open_out [Stdlib] | Open the named file for writing, and return a new output channel on that file, positioned at the beginning of the file. |
| open_out_bin [Stdlib] | Same as |
| open_out_gen [Stdlib] |
|
| 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 [Stdlib] | Return the size (number of characters) of the regular file on which the given channel is opened. |
| out_channel_of_descr [UnixLabels] | Create an output channel writing on the given descriptor. |
| out_channel_of_descr [Unix] | Create an output channel writing on the given descriptor. |
| out_of_heap_tag [Obj] | |
| output [Stdlib] |
|
| output [Digest] | Write a digest on the given output channel. |
| output_acc [CamlinternalFormat] | |
| output_binary_int [Stdlib] | Write one integer in binary format (4 bytes, big-endian) on the given output channel. |
| output_buffer [Buffer] |
|
| output_byte [Stdlib] | Write one 8-bit integer (as the single character with that code) on the given output channel. |
| output_bytes [Stdlib] | Write the byte sequence on the given output channel. |
| output_char [Stdlib] | Write the character on the given output channel. |
| output_string [Stdlib] | Write the string on the given output channel. |
| output_substring [Stdlib] | Same as |
| output_value [Stdlib] | Write the representation of a structured value of any type to a channel. |
| over_max_boxes [Format] | Tests if the maximum number of pretty-printing boxes allowed have already been opened. |
P | |
| param_format_of_ignored_format [CamlinternalFormat] | |
| params [CamlinternalOO] | |
| parent_dir_name [Filename] | The conventional name for the parent of the current directory (e.g. |
| parse [Arg] |
|
| 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 [Stdlib] | Return the current reading position for the given channel. |
| pos_out [Stdlib.LargeFile] | |
| pos_out [Stdlib] | Return the current writing position for the given channel. |
| pow [Float] | Exponentiation. |
| pow [Complex] | Power function. |
| pp_close_box [Format] | |
| pp_close_stag [Format] | |
| pp_close_tag [Format] | |
| pp_close_tbox [Format] | |
| pp_force_newline [Format] | |
| pp_get_all_formatter_output_functions [Format] | |
| pp_get_ellipsis_text [Format] | |
| pp_get_formatter_out_functions [Format] | |
| pp_get_formatter_output_functions [Format] | |
| pp_get_formatter_stag_functions [Format] | |
| pp_get_formatter_tag_functions [Format] | |
| pp_get_geometry [Format] | |
| pp_get_margin [Format] | |
| pp_get_mark_tags [Format] | |
| pp_get_max_boxes [Format] | |
| pp_get_max_indent [Format] | |
| pp_get_print_tags [Format] | |
| pp_open_box [Format] | |
| pp_open_hbox [Format] | |
| pp_open_hovbox [Format] | |
| pp_open_hvbox [Format] | |
| pp_open_stag [Format] | |
| pp_open_tag [Format] | |
| pp_open_tbox [Format] | |
| pp_open_vbox [Format] | |
| pp_over_max_boxes [Format] | |
| pp_print_as [Format] | |
| pp_print_bool [Format] | |
| pp_print_break [Format] | |
| pp_print_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] | |
| pp_update_geometry [Format] |
|
| pred [Uchar] |
|
| pred [Stdlib] |
|
| pred [Nativeint] | Predecessor. |
| pred [Int64] | Predecessor. |
| pred [Int32] | Predecessor. |
| pred [Int] |
|
| pred [Float] |
|
| prerr_bytes [Stdlib] | Print a byte sequence on standard error. |
| prerr_char [Stdlib] | Print a character on standard error. |
| prerr_endline [Stdlib] | Print a string, followed by a newline character on standard error and flush standard error. |
| prerr_float [Stdlib] | Print a floating-point number, in decimal, on standard error. |
| prerr_int [Stdlib] | Print an integer, in decimal, on standard error. |
| prerr_newline [Stdlib] | Print a newline character on standard error, and flush standard error. |
| prerr_string [Stdlib] | Print a string on standard error. |
| print [Printexc] |
|
| print_as [Format] |
|
| print_backtrace [Printexc] |
|
| print_bool [Format] | Print a boolean in the current pretty-printing box. |
| print_break [Format] |
|
| print_bytes [Stdlib] | Print a byte sequence on standard output. |
| print_char [Stdlib] | Print a character on standard output. |
| print_char [Format] | Print a character in the current pretty-printing box. |
| print_cut [Format] |
|
| print_endline [Stdlib] | Print a string, followed by a newline character, on standard output and flush standard output. |
| print_float [Stdlib] | Print a floating-point number, in decimal, on standard output. |
| print_float [Format] | Print a floating point number in the current pretty-printing box. |
| print_flush [Format] | End of pretty-printing: resets the pretty-printer to initial state. |
| print_if_newline [Format] | Execute the next formatting command if the preceding line has just been split. |
| print_int [Stdlib] | Print an integer, in decimal, on standard output. |
| print_int [Format] | Print an integer in the current pretty-printing box. |
| print_newline [Stdlib] | Print a newline character on standard output, and flush standard output. |
| print_newline [Format] | End of pretty-printing: resets the pretty-printer to initial state. |
| print_raw_backtrace [Printexc] | Print a raw backtrace in the same format
|
| 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 [Stdlib] | Print a string on standard output. |
| 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. |
| quote_command [Filename] |
|
R | |
| raise [Stdlib] | Raise the given exception value |
| raise_notrace [Stdlib] | A faster version |
| 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 [Stdlib] | Same as |
| read_float_opt [Stdlib] | Flush standard output, then read one line from standard input and convert it to a floating-point number. |
| read_int [Stdlib] | Same as |
| read_int_opt [Stdlib] | Flush standard output, then read one line from standard input and convert it to an integer. |
| read_line [Stdlib] | Flush standard output, then read characters from standard input until a newline character is encountered. |
| readdir [UnixLabels] | Return the next entry in a directory. |
| readdir [Unix] | Return the next entry in a directory. |
| readdir [Sys] | Return the names of all files present in the given directory. |
| readlink [UnixLabels] | Read the contents of a link. |
| readlink [Unix] | Read the contents of a symbolic link. |
| really_input [Stdlib] |
|
| really_input_string [Stdlib] |
|
| 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 [Stdlib] | Return a fresh reference containing the given value. |
| 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 [Sys.Immediate64.Make] | |
| 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 [Stdlib] |
|
| seek_out [Stdlib.LargeFile] | |
| seek_out [Stdlib] |
|
| 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 [Stdlib] |
|
| set_binary_mode_out [Stdlib] |
|
| 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_filename [Lexing] | Set filename in the initial tracked position to |
| 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_position [Lexing] | Set the initial tracked input position for |
| 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 [Stdlib] | Sine. |
| 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 [Stdlib] | Hyperbolic sine. |
| sinh [Float] | Hyperbolic sine. |
| size [Obj] | |
| size [Nativeint] | The size in bits of a native integer. |
| size_in_bytes [Bigarray.Array3] |
|
| size_in_bytes [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 [Stdlib] | Return the second component of a pair. |
| socket [UnixLabels] | Create a new socket in the given domain, and with the given kind. |
| socket [Unix] | Create a new socket in the given domain, and with the given kind. |
| 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 [Stdlib] | Square root. |
| 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 |
| start [Gc.Memprof] | Start the sampling with the given parameters. |
| 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 [Stdlib] | The standard error output for the process. |
| stdib [Scanf.Scanning] | A deprecated alias for |
| stdin [UnixLabels] | File descriptor for standard input. |
| stdin [Unix] | File descriptor for standard input. |
| stdin [Stdlib] | The standard input for the process. |
| stdin [Scanf.Scanning] | The standard input notion for the |
| stdout [UnixLabels] | File descriptor for standard output. |
| stdout [Unix] | File descriptor for standard output. |
| stdout [Stdlib] | The standard output for the process. |
| stop [Gc.Memprof] | Stop the sampling. |
| 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 [Stdlib] | Return the string representation of a boolean. |
| string_of_float [Stdlib] | Return the string representation of a floating-point number. |
| string_of_fmt [CamlinternalFormat] | |
| string_of_fmtty [CamlinternalFormat] | |
| string_of_format [Stdlib] | Converts a format string into a string. |
| string_of_formatting_lit [CamlinternalFormat] | |
| string_of_inet_addr [UnixLabels] | Return the printable representation of the given Internet address. |
| string_of_inet_addr [Unix] | Return the printable representation of the given Internet address. |
| string_of_int [Stdlib] | Return the string representation of an integer, in decimal. |
| string_partial_match [Str] | Similar to |
| 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 [Stdlib] |
|
| 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 [Stdlib] | Tangent. |
| tan [Float] | Tangent. |
| tanh [Stdlib] | Hyperbolic tangent. |
| tanh [Float] | Hyperbolic tangent. |
| tcdrain [UnixLabels] | Waits until all output written on the given file descriptor has been transmitted. |
| tcdrain [Unix] | Waits until all output written on the given file descriptor has been transmitted. |
| tcflow [UnixLabels] | Suspend or restart reception or transmission of data on
the given file descriptor, depending on the second argument:
|
| 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 [Stdlib] | Same as |
| 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] |
|
| unfold [Seq] | Build a sequence from a step function and an initial value. |
| 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_geometry [Format] | |
| update_mod [CamlinternalMod] | |
| uppercase [String] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
| uppercase [StringLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
| uppercase [Char] | Convert the given character to its equivalent uppercase character, using the ISO Latin-1 (8859-1) character set. |
| uppercase [BytesLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
| uppercase [Bytes] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
| uppercase_ascii [String] | 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 | |
| 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 |