Index of values

( * ) [Stdlib]

Integer multiplication.

( ** ) [Stdlib]

Exponentiation.

( *. ) [Stdlib]

Floating-point multiplication.

(!) [Stdlib]

!r returns the current contents of reference r.

(!=) [Stdlib]

Negation of (==).

(&&) [Stdlib]

The boolean 'and'.

(&&) [Bool]

e0 && e1 is the lazy boolean conjunction of expressions e0 and e1.

(&) [Stdlib]
(+) [Stdlib]

Integer addition.

(+.) [Stdlib]

Floating-point addition.

(-) [Stdlib]

Integer subtraction.

(-.) [Stdlib]

Floating-point subtraction.

(/) [Stdlib]

Integer division.

(/.) [Stdlib]

Floating-point division.

(:=) [Stdlib]

r := a stores the value of a in reference r.

(<) [Stdlib]

See (>=).

(<=) [Stdlib]

See (>=).

(<>) [Stdlib]

Negation of (=).

(=) [Stdlib]

e1 = e2 tests for structural equality of e1 and e2.

(==) [Stdlib]

e1 == e2 tests for physical equality of e1 and e2.

(>) [Stdlib]

See (>=).

(>=) [Stdlib]

Structural ordering functions.

(@) [Stdlib]

List concatenation.

(@@) [Stdlib]

Application operator: g @@ f @@ x is exactly equivalent to g (f (x)).

(^) [Stdlib]

String concatenation.

(^^) [Stdlib]

f1 ^^ f2 catenates format strings f1 and f2.

(asr) [Stdlib]

asr m shifts n to the right by m bits.

(land) [Stdlib]

Bitwise logical and.

(lor) [Stdlib]

Bitwise logical or.

(lsl) [Stdlib]

lsl m shifts n to the left by m bits.

(lsr) [Stdlib]

lsr m shifts n to the right by m bits.

(lxor) [Stdlib]

Bitwise logical exclusive or.

(mod) [Stdlib]

Integer remainder.

(or) [Stdlib]
(|>) [Stdlib]

Reverse-application operator: x |> f |> g is exactly equivalent to g (f (x)).

(||) [Stdlib]

The boolean 'or'.

(||) [Bool]

e0 || e1 is the lazy boolean disjunction of expressions e0 and e1.

(~+) [Stdlib]

Unary addition.

(~+.) [Stdlib]

Unary addition.

(~-) [Stdlib]

Unary negation.

(~-.) [Stdlib]

Unary negation.

__FILE__ [Stdlib]

__FILE__ returns the name of the file currently being parsed by the compiler.

__FUNCTION__ [Stdlib]

__FUNCTION__ returns the name of the current function or method, including any enclosing modules or classes.

__LINE_OF__ [Stdlib]

__LINE_OF__ expr returns a pair (line, expr), where line is the line number at which the expression expr appears in the file currently being parsed by the compiler.

__LINE__ [Stdlib]

__LINE__ returns the line number at which this expression appears in the file currently being parsed by the compiler.

__LOC_OF__ [Stdlib]

__LOC_OF__ expr returns a pair (loc, expr) where loc is the location of expr in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".

__LOC__ [Stdlib]

__LOC__ returns the location at which this expression appears in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".

__MODULE__ [Stdlib]

__MODULE__ returns the module name of the file being parsed by the compiler.

__POS_OF__ [Stdlib]

__POS_OF__ expr returns a pair (loc,expr), where loc is a tuple (file,lnum,cnum,enum) corresponding to the location at which the expression expr appears in the file currently being parsed by the compiler.

__POS__ [Stdlib]

__POS__ returns a tuple (file,lnum,cnum,enum), corresponding to the location at which this expression appears in the file currently being parsed by the compiler.

_exit [UnixLabels]

Terminate the calling process immediately, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure.

_exit [Unix]

Terminate the calling process immediately, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure.

A
abs [Stdlib]

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 x is the absolute value of x.

abs [Float]

abs f returns the absolute value of f.

abs_float [Stdlib]

abs_float f returns the absolute value of f.

abstract_tag [Obj]
accept [UnixLabels]

Accept connections on the given socket.

accept [Unix]

Accept connections on the given socket.

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.

acosh [Stdlib]

Hyperbolic arc cosine.

acosh [Float]

Hyperbolic arc cosine.

acquire [Semaphore.Binary]

acquire s blocks the calling thread until the semaphore s has value 1 (is available), then atomically sets it to 0 and returns.

acquire [Semaphore.Counting]

acquire s blocks the calling thread until the value of semaphore s is not zero, then atomically decrements the value of s and returns.

adapt_filename [Dynlink]

In bytecode, the identity function.

add [Weak.S]

add t x adds x to t.

add [Set.S]

add x s returns a set containing all elements of s, plus x.

add [Queue]

add x q adds the element x at the end of the queue q.

add [Nativeint]

Addition.

add [MoreLabels.Set.S]

add x s returns a set containing all elements of s, plus x.

add [MoreLabels.Map.S]

add ~key ~data m returns a map containing the same bindings as m, plus a binding of key to data.

add [MoreLabels.Hashtbl.SeededS]
add [MoreLabels.Hashtbl.S]
add [MoreLabels.Hashtbl]

Hashtbl.add tbl ~key ~data adds a binding of key to data in table tbl.

add [Map.S]

add key data m returns a map containing the same bindings as m, plus a binding of key to data.

add [Int64]

Addition.

add [Int32]

Addition.

add [Int]

add x y is the addition x + y.

add [Hashtbl.SeededS]
add [Hashtbl.S]
add [Hashtbl]

Hashtbl.add tbl key data adds a binding of key to data in table tbl.

add [Float]

Floating-point addition.

add [Complex]

Addition

add_buffer [Buffer]

add_buffer b1 b2 appends the current contents of buffer b2 at the end of buffer b1.

add_bytes [Buffer]

add_bytes b s appends the byte sequence s at the end of buffer b.

add_channel [Buffer]

add_channel b ic n reads at most n characters from the input channel ic and stores them at the end of buffer b.

add_char [Buffer]

add_char b c appends the character c at the end of buffer b.

add_in_char_set [CamlinternalFormat]
add_initializer [CamlinternalOO]
add_int16_be [Buffer]

add_int16_be b i appends a binary big-endian signed 16-bit integer i to b.

add_int16_le [Buffer]

add_int16_le b i appends a binary little-endian signed 16-bit integer i to b.

add_int16_ne [Buffer]

add_int16_ne b i appends a binary native-endian signed 16-bit integer i to b.

add_int32_be [Buffer]

add_int32_be b i appends a binary big-endian 32-bit integer i to b.

add_int32_le [Buffer]

add_int32_le b i appends a binary little-endian 32-bit integer i to b.

add_int32_ne [Buffer]

add_int32_ne b i appends a binary native-endian 32-bit integer i to b.

add_int64_be [Buffer]

add_int64_be b i appends a binary big-endian 64-bit integer i to b.

add_int64_le [Buffer]

add_int64_ne b i appends a binary little-endian 64-bit integer i to b.

add_int64_ne [Buffer]

add_int64_ne b i appends a binary native-endian 64-bit integer i to b.

add_int8 [Buffer]

add_int8 b i appends a binary signed 8-bit integer i to b.

add_offset [Obj]
add_seq [Stack]

Add the elements from the sequence on the top of the stack.

add_seq [Set.S]

Add the given elements to the set, in order.

add_seq [Queue]

Add the elements from a sequence to the end of the queue.

add_seq [MoreLabels.Set.S]

Add the given elements to the set, in order.

add_seq [MoreLabels.Map.S]

Add the given bindings to the map, in order.

add_seq [MoreLabels.Hashtbl.SeededS]
add_seq [MoreLabels.Hashtbl.S]
add_seq [MoreLabels.Hashtbl]

Add the given bindings to the table, using MoreLabels.Hashtbl.add

add_seq [Map.S]

Add the given bindings to the map, in order.

add_seq [Hashtbl.SeededS]
add_seq [Hashtbl.S]
add_seq [Hashtbl]

Add the given bindings to the table, using Hashtbl.add

add_seq [Buffer]

Add chars to the buffer

add_string [Buffer]

add_string b s appends the string s at the end of buffer b.

add_subbytes [Buffer]

add_subbytes b s ofs len takes len characters from offset ofs in byte sequence s and appends them at the end of buffer b.

add_substitute [Buffer]

add_substitute b f s appends the string pattern s at the end of buffer b with substitution.

add_substring [Buffer]

add_substring b s ofs len takes len characters from offset ofs in string s and appends them at the end of buffer b.

add_symbolic_output_item [Format]

add_symbolic_output_item sob itm adds item itm to buffer sob.

add_uint16_be [Buffer]

add_uint16_be b i appends a binary big-endian unsigned 16-bit integer i to b.

add_uint16_le [Buffer]

add_uint16_le b i appends a binary little-endian unsigned 16-bit integer i to b.

add_uint16_ne [Buffer]

add_uint16_ne b i appends a binary native-endian unsigned 16-bit integer i to b.

add_uint8 [Buffer]

add_uint8 b i appends a binary unsigned 8-bit integer i to b.

add_utf_16be_uchar [Buffer]

add_utf_16be_uchar b u appends the UTF-16BE encoding of u at the end of buffer b.

add_utf_16le_uchar [Buffer]

add_utf_16le_uchar b u appends the UTF-16LE encoding of u at the end of buffer b.

add_utf_8_uchar [Buffer]

add_utf_8_uchar b u appends the UTF-8 encoding of u at the end of buffer b.

alarm [UnixLabels]

Schedule a SIGALRM signal after the given number of seconds.

alarm [Unix]

Schedule a SIGALRM signal after the given number of seconds.

align [Arg]

Align the documentation strings by inserting spaces at the first alignment separator (tab or, if tab is not found, space), according to the length of the keyword.

all_units [Dynlink]

Return the list of compilation units that form the main program together with those that have been dynamically loaded via loadfile (and not via loadfile_private).

allocated_bytes [Gc]

Return the total number of bytes allocated since the program was started.

allow_only [Dynlink]

allow_only units sets the list of allowed units to be the intersection of the existing allowed units and the given list of units.

allow_unsafe_modules [Dynlink]

Govern whether unsafe object files are allowed to be dynamically linked.

always [Event]

always v returns an event that is always ready for synchronization.

append [Seq]

append xs ys is the sequence xs followed by the sequence ys

append [ListLabels]

Concatenate two lists.

append [List]

Concatenate two lists.

append [Float.ArrayLabels]

append v1 v2 returns a fresh floatarray containing the concatenation of the floatarrays v1 and v2.

append [Float.Array]

append v1 v2 returns a fresh floatarray containing the concatenation of the floatarrays v1 and v2.

append [ArrayLabels]

append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.

append [Array]

append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.

arg [Complex]

Argument.

argv [Sys]

The command line arguments given to the process.

array0_of_genarray [Bigarray]

Return the zero-dimensional Bigarray corresponding to the given generic Bigarray.

array1_of_genarray [Bigarray]

Return the one-dimensional Bigarray corresponding to the given generic Bigarray.

array2_of_genarray [Bigarray]

Return the two-dimensional Bigarray corresponding to the given generic Bigarray.

array3_of_genarray [Bigarray]

Return the three-dimensional Bigarray corresponding to the given generic Bigarray.

asin [Stdlib]

Arc sine.

asin [Float]

Arc sine.

asinh [Stdlib]

Hyperbolic arc sine.

asinh [Float]

Hyperbolic arc sine.

asprintf [Format]

Same as printf above, but instead of printing on a formatter, returns a string containing the result of formatting the arguments.

assoc [ListLabels]

assoc a l returns the value associated with key a in the list of pairs l.

assoc [List]

assoc a l returns the value associated with key a in the list of pairs l.

assoc_opt [ListLabels]

assoc_opt a l returns the value associated with key a in the list of pairs l.

assoc_opt [List]

assoc_opt a l returns the value associated with key a in the list of pairs l.

assq [ListLabels]

Same as ListLabels.assoc, but uses physical equality instead of structural equality to compare keys.

assq [List]

Same as List.assoc, but uses physical equality instead of structural equality to compare keys.

assq_opt [ListLabels]

Same as ListLabels.assoc_opt, but uses physical equality instead of structural equality to compare keys.

assq_opt [List]

Same as List.assoc_opt, but uses physical equality instead of structural equality to compare keys.

at_exit [Stdlib]

Register the given function to be called at program termination time.

atan [Stdlib]

Arc tangent.

atan [Float]

Arc tangent.

atan2 [Stdlib]

atan2 y x returns the arc tangent of y /. x.

atan2 [Float]

atan2 y x returns the arc tangent of y /. x.

atanh [Stdlib]

Hyperbolic arc tangent.

atanh [Float]

Hyperbolic arc tangent.

B
backend_type [Sys]

Backend type currently executing the OCaml program.

backtrace_slots [Printexc]

Returns the slots of a raw backtrace, or None if none of them contain useful information.

backtrace_slots_of_raw_entry [Printexc]

Returns the slots of a single raw backtrace entry, or None if this entry lacks debug information.

backtrace_status [Printexc]

Printexc.backtrace_status() returns true if exception backtraces are currently recorded, false if not.

basename [Filename]

Split a file name into directory name / base file name.

beginning_of_input [Scanf.Scanning]

Scanning.beginning_of_input ic tests the beginning of input condition of the given Scanf.Scanning.in_channel formatted input channel.

big_endian [Sys]

Whether the machine currently executing the Caml program is big-endian.

bind [UnixLabels]

Bind a socket to an address.

bind [Unix]

Bind a socket to an address.

bind [Result]

bind r f is f v if r is Ok v and r if r is Error _.

bind [Option]

bind o f is f v if o is Some v and None if o is None.

bindings [MoreLabels.Map.S]

Return the list of all bindings of the given map.

bindings [Map.S]

Return the list of all bindings of the given map.

bits [Random.State]
bits [Random]

Return 30 random bits in a nonnegative integer.

bits_of_float [Int64]

Return the internal representation of the given float according to the IEEE 754 floating-point 'double format' bit layout.

bits_of_float [Int32]

Return the internal representation of the given float according to the IEEE 754 floating-point 'single format' bit layout.

blit [Weak]

Weak.blit ar1 off1 ar2 off2 len copies len weak pointers from ar1 (starting at off1) to ar2 (starting at off2).

blit [String]

blit src src_pos dst dst_pos len copies len bytes from the string src, starting at index src_pos, to byte sequence dst, starting at character number dst_pos.

blit [StringLabels]

blit ~src ~src_pos ~dst ~dst_pos ~len copies len bytes from the string src, starting at index src_pos, to byte sequence dst, starting at character number dst_pos.

blit [Float.ArrayLabels]

blit ~src ~src_pos ~dst ~dst_pos ~len copies len elements from floatarray src, starting at element number src_pos, to floatarray dst, starting at element number dst_pos.

blit [Float.Array]

blit src src_pos dst dst_pos len copies len elements from floatarray src, starting at element number src_pos, to floatarray dst, starting at element number dst_pos.

blit [BytesLabels]

blit ~src ~src_pos ~dst ~dst_pos ~len copies len bytes from sequence src, starting at index src_pos, to sequence dst, starting at index dst_pos.

blit [Bytes]

blit src src_pos dst dst_pos len copies len bytes from sequence src, starting at index src_pos, to sequence dst, starting at index dst_pos.

blit [Buffer]

Buffer.blit src srcoff dst dstoff len copies len characters from the current contents of the buffer src, starting at offset srcoff to dst, starting at character dstoff.

blit [Bigarray.Array3]

Copy the first Bigarray to the second Bigarray.

blit [Bigarray.Array2]

Copy the first Bigarray to the second Bigarray.

blit [Bigarray.Array1]

Copy the first Bigarray to the second Bigarray.

blit [Bigarray.Array0]

Copy the first Bigarray to the second Bigarray.

blit [Bigarray.Genarray]

Copy all elements of a Bigarray in another Bigarray.

blit [ArrayLabels]

blit ~src ~src_pos ~dst ~dst_pos ~len copies len elements from array src, starting at element number src_pos, to array dst, starting at element number dst_pos.

blit [Array]

blit src src_pos dst dst_pos len copies len elements from array src, starting at element number src_pos, to array dst, starting at element number dst_pos.

blit_data [Obj.Ephemeron]
blit_data [Ephemeron.Kn]
blit_data [Ephemeron.K2]
blit_data [Ephemeron.K1]

Ephemeron.K1.blit_data eph1 eph2 sets the data of eph2 with the data of eph1.

blit_key [Obj.Ephemeron]
blit_key [Ephemeron.Kn]
blit_key [Ephemeron.K1]

Ephemeron.K1.blit_key eph1 eph2 sets the key of eph2 with the key of eph1.

blit_key1 [Ephemeron.K2]
blit_key12 [Ephemeron.K2]
blit_key2 [Ephemeron.K2]
blit_string [BytesLabels]

blit ~src ~src_pos ~dst ~dst_pos ~len copies len bytes from string src, starting at index src_pos, to byte sequence dst, starting at index dst_pos.

blit_string [Bytes]

blit src src_pos dst dst_pos len copies len bytes from string src, starting at index src_pos, to byte sequence dst, starting at index dst_pos.

bom [Uchar]

bom is U+FEFF, the byte order mark (BOM) character.

bool [Random.State]

These functions are the same as the basic functions, except that they use (and update) the given PRNG state instead of the default one.

bool [Random]

Random.bool () returns true or false with probability 0.5 each.

bool_of_string [Stdlib]

Same as bool_of_string_opt, but raise Invalid_argument "bool_of_string" instead of returning None.

bool_of_string_opt [Stdlib]

Convert the given string to a boolean.

bounded_full_split [Str]

Same as Str.bounded_split_delim, but returns the delimiters as well as the substrings contained between delimiters.

bounded_split [Str]

Same as Str.split, but splits into at most n substrings, where n is the extra integer parameter.

bounded_split_delim [Str]

Same as Str.bounded_split, but occurrences of the delimiter at the beginning and at the end of the string are recognized and returned as empty strings in the result.

bprintf [Printf]

Same as Printf.fprintf, but instead of printing on an output channel, append the formatted arguments to the given extensible buffer (see module Buffer).

bprintf [Format]
broadcast [Condition]

broadcast c restarts all processes waiting on the condition variable c.

bscanf [Scanf]
bscanf_format [Scanf]

bscanf_format ic fmt f reads a format string token from the formatted input channel ic, according to the given format string fmt, and applies f to the resulting format string value.

bufput_acc [CamlinternalFormat]
bytes [Digest]

Return the digest of the given byte sequence.

C
c_layout [Bigarray]
capitalize [String]

Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set..

capitalize [StringLabels]

Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set..

capitalize [BytesLabels]

Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.

capitalize [Bytes]

Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.

capitalize_ascii [String]

capitalize_ascii s is s with the first character set to uppercase, using the US-ASCII character set.

capitalize_ascii [StringLabels]

capitalize_ascii s is s with the first character set to uppercase, using the US-ASCII character set.

capitalize_ascii [BytesLabels]

Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set.

capitalize_ascii [Bytes]

Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set.

cardinal [Set.S]

Return the number of elements of a set.

cardinal [MoreLabels.Set.S]

Return the number of elements of a set.

cardinal [MoreLabels.Map.S]

Return the number of bindings of a map.

cardinal [Map.S]

Return the number of bindings of a map.

cat [String]

cat s1 s2 concatenates s1 and s2 (s1 ^ s2).

cat [StringLabels]

cat s1 s2 concatenates s1 and s2 (s1 ^ s2).

cat [BytesLabels]

cat s1 s2 concatenates s1 and s2 and returns the result as a new byte sequence.

cat [Bytes]

cat s1 s2 concatenates s1 and s2 and returns the result as a new byte sequence.

catch [Printexc]

Printexc.catch fn x is similar to Printexc.print, but aborts the program with exit code 2 after printing the uncaught exception.

catch_break [Sys]

catch_break governs whether interactive interrupt (ctrl-C) terminates the program or raises the Break exception.

cbrt [Float]

Cube root.

ceil [Stdlib]

Round above to an integer value.

ceil [Float]

Round above to an integer value.

change_layout [Bigarray.Array3]

Array3.change_layout a layout returns a Bigarray with the specified layout, sharing the data with a (and hence having the same dimensions as a).

change_layout [Bigarray.Array2]

Array2.change_layout a layout returns a Bigarray with the specified layout, sharing the data with a (and hence having the same dimensions as a).

change_layout [Bigarray.Array1]

Array1.change_layout a layout returns a Bigarray with the specified layout, sharing the data with a (and hence having the same dimension as a).

change_layout [Bigarray.Array0]

Array0.change_layout a layout returns a Bigarray with the specified layout, sharing the data with a.

change_layout [Bigarray.Genarray]

Genarray.change_layout a layout returns a Bigarray with the specified layout, sharing the data with a (and hence having the same dimensions as a).

channel [Digest]

If len is nonnegative, Digest.channel ic len reads len characters from channel ic and returns their digest, or raises End_of_file if end-of-file is reached before len characters are read.

char [Bigarray]

As shown by the types of the values above, Bigarrays of kind float32_elt and float64_elt are accessed using the OCaml type float.

char_of_iconv [CamlinternalFormat]
char_of_int [Stdlib]

Return the character with the given ASCII code.

chdir [UnixLabels]

Change the process working directory.

chdir [Unix]

Change the process working directory.

chdir [Sys]

Change the current working directory of the process.

check [Weak]

Weak.check ar n returns true if the nth cell of ar is full, false if it is empty.

check_data [Obj.Ephemeron]
check_data [Ephemeron.Kn]
check_data [Ephemeron.K2]
check_data [Ephemeron.K1]

Ephemeron.K1.check_data eph returns true if the data of the eph is full, false if it is empty.

check_geometry [Format]

Check if the formatter geometry is valid: 1 < max_indent < margin

check_key [Obj.Ephemeron]
check_key [Ephemeron.Kn]
check_key [Ephemeron.K1]

Ephemeron.K1.check_key eph returns true if the key of the eph is full, false if it is empty.

check_key1 [Ephemeron.K2]
check_key2 [Ephemeron.K2]
check_suffix [Filename]

check_suffix name suff returns true if the filename name ends with the suffix suff.

chmod [UnixLabels]

Change the permissions of the named file.

chmod [Unix]

Change the permissions of the named file.

choose [Set.S]

Return one element of the given set, or raise Not_found if the set is empty.

choose [MoreLabels.Set.S]

Return one element of the given set, or raise Not_found if the set is empty.

choose [MoreLabels.Map.S]

Return one binding of the given map, or raise Not_found if the map is empty.

choose [Map.S]

Return one binding of the given map, or raise Not_found if the map is empty.

choose [Event]

choose evl returns the event that is the alternative of all the events in the list evl.

choose_opt [Set.S]

Return one element of the given set, or None if the set is empty.

choose_opt [MoreLabels.Set.S]

Return one element of the given set, or None if the set is empty.

choose_opt [MoreLabels.Map.S]

Return one binding of the given map, or None if the map is empty.

choose_opt [Map.S]

Return one binding of the given map, or None if the map is empty.

chop_extension [Filename]

Same as Filename.remove_extension, but raise Invalid_argument if the given name has an empty extension.

chop_suffix [Filename]

chop_suffix name suff removes the suffix suff from the filename name.

chop_suffix_opt [Filename]

chop_suffix_opt ~suffix filename removes the suffix from the filename if possible, or returns None if the filename does not end with the suffix.

chown [UnixLabels]

Change the owner uid and owner gid of the named file.

chown [Unix]

Change the owner uid and owner gid of the named file.

chr [Char]

Return the character with the given ASCII code.

chroot [UnixLabels]

Change the process root directory.

chroot [Unix]

Change the process root directory.

classify_float [Stdlib]

Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.

classify_float [Float]

Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.

clean [Ephemeron.SeededS]

remove all dead bindings.

clean [Ephemeron.S]

remove all dead bindings.

clear [Weak.S]

Remove all elements from the table.

clear [Stack]

Discard all elements from a stack.

clear [Queue]

Discard all elements from a queue.

clear [MoreLabels.Hashtbl.SeededS]
clear [MoreLabels.Hashtbl.S]
clear [MoreLabels.Hashtbl]

Empty a hash table.

clear [Hashtbl.SeededS]
clear [Hashtbl.S]
clear [Hashtbl]

Empty a hash table.

clear [Buffer]

Empty the buffer.

clear_close_on_exec [UnixLabels]

Clear the ``close-on-exec'' flag on the given descriptor.

clear_close_on_exec [Unix]

Clear the ``close-on-exec'' flag on the given descriptor.

clear_nonblock [UnixLabels]

Clear the ``non-blocking'' flag on the given descriptor.

clear_nonblock [Unix]

Clear the ``non-blocking'' flag on the given descriptor.

clear_parser [Parsing]

Empty the parser stack.

clear_symbolic_output_buffer [Format]

clear_symbolic_output_buffer sob resets buffer sob.

close [UnixLabels]

Close a file descriptor.

close [Unix]

Close a file descriptor.

close_box [Format]

Closes the most recently open pretty-printing box.

close_in [Stdlib]

Close the given channel.

close_in [Scanf.Scanning]

Closes the in_channel associated with the given Scanf.Scanning.in_channel formatted input channel.

close_in_noerr [Stdlib]

Same as close_in, but ignore all errors.

close_out [Stdlib]

Close the given channel, flushing all buffered write operations.

close_out_noerr [Stdlib]

Same as close_out, but ignore all errors.

close_process [UnixLabels]

Close channels opened by UnixLabels.open_process, wait for the associated command to terminate, and return its termination status.

close_process [Unix]

Close channels opened by Unix.open_process, wait for the associated command to terminate, and return its termination status.

close_process_full [UnixLabels]

Close channels opened by UnixLabels.open_process_full, wait for the associated command to terminate, and return its termination status.

close_process_full [Unix]

Close channels opened by Unix.open_process_full, wait for the associated command to terminate, and return its termination status.

close_process_in [UnixLabels]

Close channels opened by UnixLabels.open_process_in, wait for the associated command to terminate, and return its termination status.

close_process_in [Unix]

Close channels opened by Unix.open_process_in, wait for the associated command to terminate, and return its termination status.

close_process_out [UnixLabels]

Close channels opened by UnixLabels.open_process_out, wait for the associated command to terminate, and return its termination status.

close_process_out [Unix]

Close channels opened by Unix.open_process_out, wait for the associated command to terminate, and return its termination status.

close_stag [Format]

pp_close_stag ppf () closes the most recently opened semantic tag t.

close_tag [Format]
close_tbox [Format]

Closes the most recently opened tabulation box.

closedir [UnixLabels]

Close a directory descriptor.

closedir [Unix]

Close a directory descriptor.

closure_tag [Obj]
code [Char]

Return the ASCII code of the argument.

combine [ListLabels]

Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].

combine [List]

Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].

combine [ArrayLabels]

combine [|a1; ...; an|] [|b1; ...; bn|] is [|(a1,b1); ...; (an,bn)|].

combine [Array]

combine [|a1; ...; an|] [|b1; ...; bn|] is [|(a1,b1); ...; (an,bn)|].

command [Sys]

Execute the given shell command and return its exit code.

compact [Gc]

Perform a full major collection and compact the heap.

compare [Unit]

compare u1 u2 is 0.

compare [Uchar]

compare u u' is Stdlib.compare u u'.

compare [String]

compare s0 s1 sorts s0 and s1 in lexicographical order.

compare [Stdlib]

compare x y returns 0 if x is equal to y, a negative integer if x is less than y, and a positive integer if x is greater than y.

compare [StringLabels]

compare s0 s1 sorts s0 and s1 in lexicographical order.

compare [Set.OrderedType]

A total ordering function over the set elements.

compare [Set.S]

Total ordering between sets.

compare [Result]

compare ~ok ~error r0 r1 totally orders r0 and r1 using ok and error to respectively compare values wrapped by Ok _  and Error _.

compare [Option]

compare cmp o0 o1 is a total order on options using cmp to compare values wrapped by Some _.

compare [Nativeint]

The comparison function for native integers, with the same specification as compare.

compare [MoreLabels.Set.OrderedType]

A total ordering function over the set elements.

compare [MoreLabels.Set.S]

Total ordering between sets.

compare [MoreLabels.Map.OrderedType]

A total ordering function over the keys.

compare [MoreLabels.Map.S]

Total ordering between maps.

compare [Map.OrderedType]

A total ordering function over the keys.

compare [Map.S]

Total ordering between maps.

compare [ListLabels]

compare cmp [a1; ...; an] [b1; ...; bm] performs a lexicographic comparison of the two input lists, using the same '-> '-> int interface as compare:

compare [List]

compare cmp [a1; ...; an] [b1; ...; bm] performs a lexicographic comparison of the two input lists, using the same '-> '-> int interface as compare:

compare [Int64]

The comparison function for 64-bit integers, with the same specification as compare.

compare [Int32]

The comparison function for 32-bit integers, with the same specification as compare.

compare [Int]

compare x y is compare x y but more efficient.

compare [Float]

compare x y returns 0 if x is equal to y, a negative integer if x is less than y, and a positive integer if x is greater than y.

compare [Either]

compare ~left ~right e0 e1 totally orders e0 and e1 using left and right to respectively compare values wrapped by Left _  and Right _.

compare [Digest]

The comparison function for 16-character digest, with the same specification as compare and the implementation shared with String.compare.

compare [Char]

The comparison function for characters, with the same specification as compare.

compare [BytesLabels]

The comparison function for byte sequences, with the same specification as compare.

compare [Bytes]

The comparison function for byte sequences, with the same specification as compare.

compare [Bool]

compare b0 b1 is a total order on boolean values.

compare_and_set [CamlinternalAtomic]
compare_and_set [Atomic]

compare_and_set r seen v sets the new value of r to v only if its current value is physically equal to seen -- the comparison and the set occur atomically.

compare_length_with [ListLabels]

Compare the length of a list to an integer.

compare_length_with [List]

Compare the length of a list to an integer.

compare_lengths [ListLabels]

Compare the lengths of two lists.

compare_lengths [List]

Compare the lengths of two lists.

complex32 [Bigarray]
complex64 [Bigarray]
concat [String]

concat sep ss concatenates the list of strings ss, inserting the separator string sep between each.

concat [StringLabels]

concat ~sep ss concatenates the list of strings ss, inserting the separator string sep between each.

concat [Seq]

concatenate a sequence of sequences.

concat [ListLabels]

Concatenate a list of lists.

concat [List]

Concatenate a list of lists.

concat [Float.ArrayLabels]

Same as Float.ArrayLabels.append, but concatenates a list of floatarrays.

concat [Float.Array]

Same as Float.Array.append, but concatenates a list of floatarrays.

concat [Filename]

concat dir file returns a file name that designates file file in directory dir.

concat [BytesLabels]

concat ~sep sl concatenates the list of byte sequences sl, inserting the separator byte sequence sep between each, and returns the result as a new byte sequence.

concat [Bytes]

concat sep sl concatenates the list of byte sequences sl, inserting the separator byte sequence sep between each, and returns the result as a new byte sequence.

concat [ArrayLabels]

Same as ArrayLabels.append, but concatenates a list of arrays.

concat [Array]

Same as Array.append, but concatenates a list of arrays.

concat_fmt [CamlinternalFormatBasics]
concat_fmtty [CamlinternalFormatBasics]
concat_map [Seq]

Alias for Seq.flat_map.

concat_map [ListLabels]

concat_map ~f l gives the same result as ListLabels.concat (ListLabels.map f l).

concat_map [List]

concat_map f l gives the same result as List.concat (List.map f l).

conj [Complex]

Conjugate: given the complex x + i.y, returns x - i.y.

connect [UnixLabels]

Connect a socket to an address.

connect [Unix]

Connect a socket to an address.

connect [ThreadUnix]
cons [Seq]

cons x xs is the sequence containing the element x followed by the sequence xs

cons [ListLabels]

cons x xs is x :: xs

cons [List]

cons x xs is x :: xs

const [Fun]

const c is a function that always returns the value c.

contains [String]

contains s c is String.contains_from s 0 c.

contains [StringLabels]

contains s c is String.contains_from s 0 c.

contains [BytesLabels]

contains s c tests if byte c appears in s.

contains [Bytes]

contains s c tests if byte c appears in s.

contains_from [String]

contains_from s start c is true if and only if c appears in s after position start.

contains_from [StringLabels]

contains_from s start c is true if and only if c appears in s after position start.

contains_from [BytesLabels]

contains_from s start c tests if byte c appears in s after position start.

contains_from [Bytes]

contains_from s start c tests if byte c appears in s after position start.

contents [Buffer]

Return a copy of the current contents of the buffer.

convert_raw_backtrace_slot [Printexc]

Extracts the user-friendly backtrace_slot from a low-level raw_backtrace_slot.

copy [CamlinternalOO]
copy [String]

Return a copy of the given string.

copy [StringLabels]

Return a copy of the given string.

copy [Stack]

Return a copy of the given stack.

copy [Random.State]

Return a copy of the given state.

copy [Queue]

Return a copy of the given queue.

copy [Oo]

Oo.copy o returns a copy of object o, that is a fresh object with the same methods and instance variables as o.

copy [MoreLabels.Hashtbl.SeededS]
copy [MoreLabels.Hashtbl.S]
copy [MoreLabels.Hashtbl]

Return a copy of the given hashtable.

copy [Hashtbl.SeededS]
copy [Hashtbl.S]
copy [Hashtbl]

Return a copy of the given hashtable.

copy [Float.ArrayLabels]

copy a returns a copy of a, that is, a fresh floatarray containing the same elements as a.

copy [Float.Array]

copy a returns a copy of a, that is, a fresh floatarray containing the same elements as a.

copy [BytesLabels]

Return a new byte sequence that contains the same bytes as the argument.

copy [Bytes]

Return a new byte sequence that contains the same bytes as the argument.

copy [ArrayLabels]

copy a returns a copy of a, that is, a fresh array containing the same elements as a.

copy [Array]

copy a returns a copy of a, that is, a fresh array containing the same elements as a.

copy_sign [Float]

copy_sign x y returns a float whose absolute value is that of x and whose sign is that of y.

copysign [Stdlib]

copysign x y returns a float whose absolute value is that of x and whose sign is that of y.

cos [Stdlib]

Cosine.

cos [Float]

Cosine.

cosh [Stdlib]

Hyperbolic cosine.

cosh [Float]

Hyperbolic cosine.

count [Weak.S]

Count the number of elements in the table.

count [Stream]

Return the current count of the stream elements, i.e.

counters [Gc]

Return (minor_words, promoted_words, major_words).

create [Thread]

Thread.create funct arg creates a new thread of control, in which the function application funct arg is executed concurrently with the other threads of the program.

create [Weak.S]

create n creates a new empty weak hash set, of initial size n.

create [Weak]

Weak.create n returns a new weak array of length n.

create [String]

create n returns a fresh byte sequence of length n.

create [StringLabels]

create n returns a fresh byte sequence of length n.

create [Stack]

Return a new stack, initially empty.

create [Queue]

Return a new queue, initially empty.

create [Obj.Ephemeron]

create n returns an ephemeron with n keys.

create [Mutex]

Return a new mutex.

create [MoreLabels.Hashtbl.SeededS]
create [MoreLabels.Hashtbl.S]
create [MoreLabels.Hashtbl]

Hashtbl.create n creates a new, empty hash table, with initial size n.

create [Hashtbl.SeededS]
create [Hashtbl.S]
create [Hashtbl]

Hashtbl.create n creates a new, empty hash table, with initial size n.

create [Float.ArrayLabels]

create n returns a fresh floatarray of length n, with uninitialized data.

create [Float.Array]

create n returns a fresh floatarray of length n, with uninitialized data.

create [Ephemeron.Kn]
create [Ephemeron.K2]
create [Ephemeron.K1]

Ephemeron.K1.create () creates an ephemeron with one key.

create [Condition]

Return a new condition variable.

create [BytesLabels]

create n returns a new byte sequence of length n.

create [Bytes]

create n returns a new byte sequence of length n.

create [Buffer]

create n returns a fresh buffer, initially empty.

create [Bigarray.Array3]

Array3.create kind layout dim1 dim2 dim3 returns a new Bigarray of three dimensions, whose size is dim1 in the first dimension, dim2 in the second dimension, and dim3 in the third.

create [Bigarray.Array2]

Array2.create kind layout dim1 dim2 returns a new Bigarray of two dimensions, whose size is dim1 in the first dimension and dim2 in the second dimension.

create [Bigarray.Array1]

Array1.create kind layout dim returns a new Bigarray of one dimension, whose size is dim.

create [Bigarray.Array0]

Array0.create kind layout returns a new Bigarray of zero dimension.

create [Bigarray.Genarray]

Genarray.create kind layout dimensions returns a new Bigarray whose element kind is determined by the parameter kind (one of float32, float64, int8_signed, etc) and whose layout is determined by the parameter layout (one of c_layout or fortran_layout).

create [ArrayLabels]
create [Array]
create_alarm [Gc]

create_alarm f will arrange for f to be called at the end of each major GC cycle, starting with the current cycle or the next one.

create_char_set [CamlinternalFormat]
create_float [ArrayLabels]

create_float n returns a fresh float array of length n, with uninitialized data.

create_float [Array]

create_float n returns a fresh float array of length n, with uninitialized data.

create_matrix [ArrayLabels]
create_matrix [Array]
create_object [CamlinternalOO]
create_object_and_run_initializers [CamlinternalOO]
create_object_opt [CamlinternalOO]
create_process [UnixLabels]

create_process ~prog ~args ~stdin ~stdout ~stderr forks a new process that executes the program in file prog, with arguments args.

create_process [Unix]

create_process prog args stdin stdout stderr forks a new process that executes the program in file prog, with arguments args.

create_process_env [UnixLabels]

create_process_env ~prog ~args ~env ~stdin ~stdout ~stderr works as UnixLabels.create_process, except that the extra argument env specifies the environment passed to the program.

create_process_env [Unix]

create_process_env prog args env stdin stdout stderr works as Unix.create_process, except that the extra argument env specifies the environment passed to the program.

create_table [CamlinternalOO]
current [Arg]

Position (in Sys.argv) of the argument being processed.

current_dir_name [Filename]

The conventional name for the current directory (e.g.

custom_tag [Obj]
cygwin [Sys]

True if Sys.os_type = "Cygwin".

D
data_size [Marshal]
decr [CamlinternalAtomic]
decr [Stdlib]

Decrement the integer contained in the given reference.

decr [Atomic]

decr r atomically decrements the value of r by 1.

default_uncaught_exception_handler [Printexc]

Printexc.default_uncaught_exception_handler prints the exception and backtrace on standard error output.

delay [Thread]

delay d suspends the execution of the calling thread for d seconds.

delete_alarm [Gc]

delete_alarm a will stop the calls to the function associated to a.

descr_of_in_channel [UnixLabels]

Return the descriptor corresponding to an input channel.

descr_of_in_channel [Unix]

Return the descriptor corresponding to an input channel.

descr_of_out_channel [UnixLabels]

Return the descriptor corresponding to an output channel.

descr_of_out_channel [Unix]

Return the descriptor corresponding to an output channel.

diff [Set.S]

Set difference: diff s1 s2 contains the elements of s1 that are not in s2.

diff [MoreLabels.Set.S]

Set difference: diff s1 s2 contains the elements of s1 that are not in s2.

dim [Bigarray.Array1]

Return the size (dimension) of the given one-dimensional Bigarray.

dim1 [Bigarray.Array3]

Return the first dimension of the given three-dimensional Bigarray.

dim1 [Bigarray.Array2]

Return the first dimension of the given two-dimensional Bigarray.

dim2 [Bigarray.Array3]

Return the second dimension of the given three-dimensional Bigarray.

dim2 [Bigarray.Array2]

Return the second dimension of the given two-dimensional Bigarray.

dim3 [Bigarray.Array3]

Return the third dimension of the given three-dimensional Bigarray.

dims [Bigarray.Genarray]

Genarray.dims a returns all dimensions of the Bigarray a, as an array of integers of length Genarray.num_dims a.

dir_sep [Filename]

The directory separator (e.g.

dirname [Filename]
disjoint [Set.S]

Test if two sets are disjoint.

disjoint [MoreLabels.Set.S]

Test if two sets are disjoint.

div [Nativeint]

Integer division.

div [Int64]

Integer division.

div [Int32]

Integer division.

div [Int]

div x y is the division x / y.

div [Float]

Floating-point division.

div [Complex]

Division

domain_of_sockaddr [UnixLabels]

Return the socket domain adequate for the given socket address.

domain_of_sockaddr [Unix]

Return the socket domain adequate for the given socket address.

double_array_tag [Obj]
double_field [Obj]
double_tag [Obj]
dprintf [Format]

Same as Format.fprintf, except the formatter is the last argument.

dummy_class [CamlinternalOO]
dummy_pos [Lexing]

A value of type position, guaranteed to be different from any valid position.

dummy_table [CamlinternalOO]
dup [UnixLabels]

Return a new file descriptor referencing the same file as the given descriptor.

dup [Unix]

Return a new file descriptor referencing the same file as the given descriptor.

dup [Obj]
dup2 [UnixLabels]

dup2 ~src ~dst duplicates src to dst, closing dst if already opened.

dup2 [Unix]

dup2 src dst duplicates src to dst, closing dst if already opened.

E
elements [Set.S]

Return the list of all elements of the given set.

elements [MoreLabels.Set.S]

Return the list of all elements of the given set.

empty [String]

The empty string.

empty [Stream]

Return () if the stream is empty, else raise Stream.Failure.

empty [StringLabels]

The empty string.

empty [Set.S]

The empty set.

empty [Seq]

The empty sequence, containing no elements.

empty [MoreLabels.Set.S]

The empty set.

empty [MoreLabels.Map.S]

The empty map.

empty [Map.S]

The empty map.

empty [BytesLabels]

A byte sequence of size 0.

empty [Bytes]

A byte sequence of size 0.

enable_runtime_warnings [Sys]

Control whether the OCaml runtime system can emit warnings on stderr.

end_of_input [Scanf.Scanning]

Scanning.end_of_input ic tests the end-of-input condition of the given Scanf.Scanning.in_channel formatted input channel.

ends_with [String]

ends_with suffix s is true if and only if s ends with suffix.

ends_with [StringLabels]

ends_with ~suffix s is true if and only if s ends with suffix.

ends_with [BytesLabels]

ends_with suffix s is true if and only if s ends with suffix.

ends_with [Bytes]

ends_with suffix s is true if and only if s ends with suffix.

environment [UnixLabels]

Return the process environment, as an array of strings with the format ``variable=value''.

environment [Unix]

Return the process environment, as an array of strings with the format ``variable=value''.

eprintf [Printf]

Same as Printf.fprintf, but output on stderr.

eprintf [Format]

Same as fprintf above, but output on err_formatter.

epsilon [Float]

The difference between 1.0 and the smallest exactly representable floating-point number greater than 1.0.

epsilon_float [Stdlib]

The difference between 1.0 and the smallest exactly representable floating-point number greater than 1.0.

equal [Unit]

equal u1 u2 is true.

equal [Uchar]

equal u u' is u = u'.

equal [String]

equal s0 s1 is true if and only if s0 and s1 are character-wise equal.

equal [StringLabels]

equal s0 s1 is true if and only if s0 and s1 are character-wise equal.

equal [Set.S]

equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.

equal [Result]

equal ~ok ~error r0 r1 tests equality of r0 and r1 using ok and error to respectively compare values wrapped by Ok _ and Error _.

equal [Option]

equal eq o0 o1 is true if and only if o0 and o1 are both None or if they are Some v0 and Some v1 and eq v0 v1 is true.

equal [Nativeint]

The equal function for native ints.

equal [MoreLabels.Set.S]

equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.

equal [MoreLabels.Map.S]

equal ~cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data.

equal [MoreLabels.Hashtbl.SeededHashedType]

The equality predicate used to compare keys.

equal [MoreLabels.Hashtbl.HashedType]

The equality predicate used to compare keys.

equal [Map.S]

equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data.

equal [ListLabels]

equal eq [a1; ...; an] [b1; ..; bm] holds when the two input lists have the same length, and for each pair of elements ai, bi at the same position we have eq ai bi.

equal [List]

equal eq [a1; ...; an] [b1; ..; bm] holds when the two input lists have the same length, and for each pair of elements ai, bi at the same position we have eq ai bi.

equal [Int64]

The equal function for int64s.

equal [Int32]

The equal function for int32s.

equal [Int]

equal x y is true if and only if x = y.

equal [Hashtbl.SeededHashedType]

The equality predicate used to compare keys.

equal [Hashtbl.HashedType]

The equality predicate used to compare keys.

equal [Float]

The equal function for floating-point numbers, compared using Float.compare.

equal [Either]

equal ~left ~right e0 e1 tests equality of e0 and e1 using left and right to respectively compare values wrapped by Left _ and Right _.

equal [Digest]

The equal function for 16-character digest.

equal [Char]

The equal function for chars.

equal [BytesLabels]

The equality function for byte sequences.

equal [Bytes]

The equality function for byte sequences.

equal [Bool]

equal b0 b1 is true if and only if b0 and b1 are both true or both false.

erase_rel [CamlinternalFormatBasics]
erf [Float]

Error function.

erfc [Float]

Complementary error function (erfc x = 1 - erf x).

err_formatter [Format]

A formatter to write to standard error.

error [Result]

error e is Error e.

error_message [UnixLabels]

Return a string describing the given error code.

error_message [Unix]

Return a string describing the given error code.

error_message [Dynlink]

Convert an error description to a printable message.

escaped [String]

escaped s is s with special characters represented by escape sequences, following the lexical conventions of OCaml.

escaped [StringLabels]

escaped s is s with special characters represented by escape sequences, following the lexical conventions of OCaml.

escaped [Char]

Return a string representing the given character, with special characters escaped following the lexical conventions of OCaml.

escaped [BytesLabels]

Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml.

escaped [Bytes]

Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml.

establish_server [UnixLabels]

Establish a server on the given address.

establish_server [Unix]

Establish a server on the given address.

eventlog_pause [Gc]

eventlog_pause () will pause the collection of traces in the runtime.

eventlog_resume [Gc]

eventlog_resume () will resume the collection of traces in the runtime.

exchange [CamlinternalAtomic]
exchange [Atomic]

Set a new value for the atomic reference, and return the current value.

executable_name [Sys]

The name of the file containing the executable currently running.

execv [UnixLabels]

execv ~prog ~args execute the program in file prog, with the arguments args, and the current process environment.

execv [Unix]

execv prog args execute the program in file prog, with the arguments args, and the current process environment.

execv [ThreadUnix]
execve [UnixLabels]

Same as UnixLabels.execv, except that the third argument provides the environment to the program executed.

execve [Unix]

Same as Unix.execv, except that the third argument provides the environment to the program executed.

execve [ThreadUnix]
execvp [UnixLabels]

Same as UnixLabels.execv, except that the program is searched in the path.

execvp [Unix]

Same as Unix.execv, except that the program is searched in the path.

execvp [ThreadUnix]
execvpe [UnixLabels]

Same as UnixLabels.execve, except that the program is searched in the path.

execvpe [Unix]

Same as Unix.execve, except that the program is searched in the path.

exists [String]

exists p s checks if at least one character of s satisfies the predicate p.

exists [StringLabels]

exists p s checks if at least one character of s satisfies the predicate p.

exists [Set.S]

exists f s checks if at least one element of the set satisfies the predicate f.

exists [MoreLabels.Set.S]

exists ~f s checks if at least one element of the set satisfies the predicate f.

exists [MoreLabels.Map.S]

exists ~f m checks if at least one binding of the map satisfies the predicate f.

exists [Map.S]

exists f m checks if at least one binding of the map satisfies the predicate f.

exists [ListLabels]

exists ~f [a1; ...; an] checks if at least one element of the list satisfies the predicate f.

exists [List]

exists f [a1; ...; an] checks if at least one element of the list satisfies the predicate f.

exists [Float.ArrayLabels]

exists f [|a1; ...; an|] checks if at least one element of the floatarray satisfies the predicate f.

exists [Float.Array]

exists f [|a1; ...; an|] checks if at least one element of the floatarray satisfies the predicate f.

exists [BytesLabels]

exists p s checks if at least one character of s satisfies the predicate p.

exists [Bytes]

exists p s checks if at least one character of s satisfies the predicate p.

exists [ArrayLabels]

exists ~f [|a1; ...; an|] checks if at least one element of the array satisfies the predicate f.

exists [Array]

exists f [|a1; ...; an|] checks if at least one element of the array satisfies the predicate f.

exists2 [ListLabels]

Same as ListLabels.exists, but for a two-argument predicate.

exists2 [List]

Same as List.exists, but for a two-argument predicate.

exists2 [ArrayLabels]

Same as ArrayLabels.exists, but for a two-argument predicate.

exists2 [Array]

Same as Array.exists, but for a two-argument predicate.

exit [Thread]

Terminate prematurely the currently executing thread.

exit [Stdlib]

Terminate the process, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure.

exn_slot_id [Printexc]

Printexc.exn_slot_id returns an integer which uniquely identifies the constructor used to create the exception value exn (in the current runtime).

exn_slot_name [Printexc]

Printexc.exn_slot_name exn returns the internal name of the constructor used to create the exception value exn.

exp [Stdlib]

Exponential.

exp [Float]

Exponential.

exp [Complex]

Exponentiation.

exp2 [Float]

Base 2 exponential function.

expm1 [Stdlib]

expm1 x computes exp x -. 1.0, giving numerically-accurate results even if x is close to 0.0.

expm1 [Float]

expm1 x computes exp x -. 1.0, giving numerically-accurate results even if x is close to 0.0.

extend [BytesLabels]

extend s ~left ~right returns a new byte sequence that contains the bytes of s, with left uninitialized bytes prepended and right uninitialized bytes appended to it.

extend [Bytes]

extend s left right returns a new byte sequence that contains the bytes of s, with left uninitialized bytes prepended and right uninitialized bytes appended to it.

extension [Filename]

extension name is the shortest suffix ext of name0 where:

extension_constructor [Obj]
extension_id [Obj]
extension_name [Obj]
F
failwith [Stdlib]

Raise exception Failure with the given string.

fast_sort [ListLabels]

Same as ListLabels.sort or ListLabels.stable_sort, whichever is faster on typical input.

fast_sort [List]

Same as List.sort or List.stable_sort, whichever is faster on typical input.

fast_sort [Float.ArrayLabels]

Same as Float.ArrayLabels.sort or Float.ArrayLabels.stable_sort, whichever is faster on typical input.

fast_sort [Float.Array]

Same as Float.Array.sort or Float.Array.stable_sort, whichever is faster on typical input.

fast_sort [ArrayLabels]

Same as ArrayLabels.sort or ArrayLabels.stable_sort, whichever is faster on typical input.

fast_sort [Array]

Same as Array.sort or Array.stable_sort, whichever is faster on typical input.

fchmod [UnixLabels]

Change the permissions of an opened file.

fchmod [Unix]

Change the permissions of an opened file.

fchown [UnixLabels]

Change the owner uid and owner gid of an opened file.

fchown [Unix]

Change the owner uid and owner gid of an opened file.

fetch_and_add [CamlinternalAtomic]
fetch_and_add [Atomic]

fetch_and_add r n atomically increments the value of r by n, and returns the current value (before the increment).

field [Obj]
file [Digest]

Return the digest of the file whose name is given.

file_exists [Sys]

Test if a file with the given name exists.

fill [Weak]

Weak.fill ar ofs len el sets to el all pointers of ar from ofs to ofs + len - 1.

fill [String]

fill s pos len c modifies byte sequence s in place, replacing len bytes by c, starting at pos.

fill [StringLabels]

fill s ~pos ~len c modifies byte sequence s in place, replacing len bytes by c, starting at pos.

fill [Float.ArrayLabels]

fill a ~pos ~len x modifies the floatarray a in place, storing x in elements number pos to pos + len - 1.

fill [Float.Array]

fill a pos len x modifies the floatarray a in place, storing x in elements number pos to pos + len - 1.

fill [BytesLabels]

fill s ~pos ~len c modifies s in place, replacing len characters with c, starting at pos.

fill [Bytes]

fill s pos len c modifies s in place, replacing len characters with c, starting at pos.

fill [Bigarray.Array3]

Fill the given Bigarray with the given value.

fill [Bigarray.Array2]

Fill the given Bigarray with the given value.

fill [Bigarray.Array1]

Fill the given Bigarray with the given value.

fill [Bigarray.Array0]

Fill the given Bigarray with the given value.

fill [Bigarray.Genarray]

Set all elements of a Bigarray to a given value.

fill [ArrayLabels]

fill a ~pos ~len x modifies the array a in place, storing x in elements number pos to pos + len - 1.

fill [Array]

fill a pos len x modifies the array a in place, storing x in elements number pos to pos + len - 1.

filter [Set.S]

filter f s returns the set of all elements in s that satisfy predicate f.

filter [Seq]

Remove from the sequence the elements that do not satisfy the given predicate.

filter [MoreLabels.Set.S]

filter ~f s returns the set of all elements in s that satisfy predicate f.

filter [MoreLabels.Map.S]

filter ~f m returns the map with all the bindings in m that satisfy predicate p.

filter [Map.S]

filter f m returns the map with all the bindings in m that satisfy predicate p.

filter [ListLabels]

filter ~f l returns all the elements of the list l that satisfy the predicate f.

filter [List]

filter f l returns all the elements of the list l that satisfy the predicate f.

filter_map [Set.S]

filter_map f s returns the set of all v such that f x = Some v for some element x of s.

filter_map [Seq]

Apply the function to every element; if f x = None then x is dropped; if f x = Some y then y is returned.

filter_map [MoreLabels.Set.S]

filter_map ~f s returns the set of all v such that f x = Some v for some element x of s.

filter_map [MoreLabels.Map.S]

filter_map ~f m applies the function f to every binding of m, and builds a map from the results.

filter_map [Map.S]

filter_map f m applies the function f to every binding of m, and builds a map from the results.

filter_map [ListLabels]

filter_map ~f l applies f to every element of l, filters out the None elements and returns the list of the arguments of the Some elements.

filter_map [List]

filter_map f l applies f to every element of l, filters out the None elements and returns the list of the arguments of the Some elements.

filter_map_inplace [MoreLabels.Hashtbl.SeededS]
filter_map_inplace [MoreLabels.Hashtbl.S]
filter_map_inplace [MoreLabels.Hashtbl]

Hashtbl.filter_map_inplace ~f tbl applies f to all bindings in table tbl and update each binding depending on the result of f.

filter_map_inplace [Hashtbl.SeededS]
filter_map_inplace [Hashtbl.S]
filter_map_inplace [Hashtbl]

Hashtbl.filter_map_inplace f tbl applies f to all bindings in table tbl and update each binding depending on the result of f.

filteri [ListLabels]

Same as ListLabels.filter, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.

filteri [List]

Same as List.filter, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.

final_tag [Obj]
finalise [Gc]

finalise f v registers f as a finalisation function for v.

finalise_last [Gc]

same as Gc.finalise except the value is not given as argument.

finalise_release [Gc]

A finalisation function may call finalise_release to tell the GC that it can launch the next finalisation function without waiting for the current one to return.

find [Weak.S]

find t x returns an instance of x found in t.

find [Set.S]

find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.

find [MoreLabels.Set.S]

find x s returns the element of s equal to x (according to Ord.compare), or raise Not_found if no such element exists.

find [MoreLabels.Map.S]

find x m returns the current value of x in m, or raises Not_found if no binding for x exists.

find [MoreLabels.Hashtbl.SeededS]
find [MoreLabels.Hashtbl.S]
find [MoreLabels.Hashtbl]

Hashtbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.

find [Map.S]

find x m returns the current value of x in m, or raises Not_found if no binding for x exists.

find [ListLabels]

find ~f l returns the first element of the list l that satisfies the predicate f.

find [List]

find f l returns the first element of the list l that satisfies the predicate f.

find [Hashtbl.SeededS]
find [Hashtbl.S]
find [Hashtbl]

Hashtbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.

find_all [Weak.S]

find_all t x returns a list of all the instances of x found in t.

find_all [MoreLabels.Hashtbl.SeededS]
find_all [MoreLabels.Hashtbl.S]
find_all [MoreLabels.Hashtbl]

Hashtbl.find_all tbl x returns the list of all data associated with x in tbl.

find_all [ListLabels]

find_all is another name for ListLabels.filter.

find_all [List]

find_all is another name for List.filter.

find_all [Hashtbl.SeededS]
find_all [Hashtbl.S]
find_all [Hashtbl]

Hashtbl.find_all tbl x returns the list of all data associated with x in tbl.

find_first [Set.S]

find_first f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.

find_first [MoreLabels.Set.S]

find_first ~f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.

find_first [MoreLabels.Map.S]

find_first ~f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.

find_first [Map.S]

find_first f m, where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists.

find_first_opt [Set.S]

find_first_opt f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.

find_first_opt [MoreLabels.Set.S]

find_first_opt ~f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists.

find_first_opt [MoreLabels.Map.S]

find_first_opt ~f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.

find_first_opt [Map.S]

find_first_opt f m, where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists.

find_last [Set.S]

find_last f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.

find_last [MoreLabels.Set.S]

find_last ~f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists.

find_last [MoreLabels.Map.S]

find_last ~f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.

find_last [Map.S]

find_last f m, where f is a monotonically decreasing function, returns the binding of m with the highest key k such that f k, or raises Not_found if no such key exists.

find_last_opt [Set.S]

find_last_opt f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.

find_last_opt [MoreLabels.Set.S]

find_last_opt ~f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists.

find_last_opt [MoreLabels.Map.S]

find_last_opt ~f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.

find_last_opt [Map.S]

find_last_opt f m, where f is a monotonically decreasing function, returns an option containing the binding of m with the highest key k such that f k, or None if no such key exists.

find_left [Either]

find_left (Left v) is Some v, find_left (Right _) is None

find_map [ListLabels]

find_map ~f l applies f to the elements of l in order, and returns the first result of the form Some v, or None if none exist.

find_map [List]

find_map f l applies f to the elements of l in order, and returns the first result of the form Some v, or None if none exist.

find_map [ArrayLabels]

find_map ~f a applies f to the elements of a in order, and returns the first result of the form Some v, or None if none exist.

find_map [Array]

find_map f a applies f to the elements of a in order, and returns the first result of the form Some v, or None if none exist.

find_opt [Weak.S]

find_opt t x returns an instance of x found in t or None if there is no such element.

find_opt [Set.S]

find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.

find_opt [MoreLabels.Set.S]

find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists.

find_opt [MoreLabels.Map.S]

find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.

find_opt [MoreLabels.Hashtbl.SeededS]
find_opt [MoreLabels.Hashtbl.S]
find_opt [MoreLabels.Hashtbl]

Hashtbl.find_opt tbl x returns the current binding of x in tbl, or None if no such binding exists.

find_opt [Map.S]

find_opt x m returns Some v if the current value of x in m is v, or None if no binding for x exists.

find_opt [ListLabels]

find ~f l returns the first element of the list l that satisfies the predicate f.

find_opt [List]

find f l returns the first element of the list l that satisfies the predicate f.

find_opt [Hashtbl.SeededS]
find_opt [Hashtbl.S]
find_opt [Hashtbl]

Hashtbl.find_opt tbl x returns the current binding of x in tbl, or None if no such binding exists.

find_opt [ArrayLabels]

find_opt ~f a returns the first element of the array a that satisfies the predicate f, or None if there is no value that satisfies f in the array a.

find_opt [Array]

find_opt f a returns the first element of the array a that satisfies the predicate f, or None if there is no value that satisfies f in the array a.

find_right [Either]

find_right (Right v) is Some v, find_right (Left _) is None

first_chars [Str]

first_chars s n returns the first n characters of s.

first_non_constant_constructor_tag [Obj]
flat_map [Seq]

Map each element to a subsequence, then return each element of this sub-sequence in turn.

flatten [ListLabels]
flatten [List]

Same as List.concat.

flip [Fun]

flip f reverses the argument order of the binary function f.

float [Stdlib]

Same as float_of_int.

float [Random.State]
float [Random]

Random.float bound returns a random floating-point number between 0 and bound (inclusive).

float32 [Bigarray]
float64 [Bigarray]
float_of_bits [Int64]

Return the floating-point number whose internal representation, according to the IEEE 754 floating-point 'double format' bit layout, is the given int64.

float_of_bits [Int32]

Return the floating-point number whose internal representation, according to the IEEE 754 floating-point 'single format' bit layout, is the given int32.

float_of_int [Stdlib]

Convert an integer to floating-point.

float_of_string [Stdlib]

Same as float_of_string_opt, but raise Failure "float_of_string" instead of returning None.

float_of_string_opt [Stdlib]

Convert the given string to a float.

floor [Stdlib]

Round below to an integer value.

floor [Float]

Round below to an integer value.

flush [Stdlib]

Flush the buffer associated with the given output channel, performing all pending writes on that channel.

flush_all [Stdlib]

Flush all open output channels; ignore errors.

flush_input [Lexing]

Discard the contents of the buffer and reset the current position to 0.

flush_str_formatter [Format]

Returns the material printed with str_formatter, flushes the formatter and resets the corresponding buffer.

flush_symbolic_output_buffer [Format]

flush_symbolic_output_buffer sob returns the contents of buffer sob and resets buffer sob.

fma [Float]

fma x y z returns x * y + z, with a best effort for computing this expression with a single rounding, using either hardware instructions (providing full IEEE compliance) or a software emulation.

fmt_ebb_of_string [CamlinternalFormat]
fold [Weak.S]

fold f t init computes (f d1 (... (f dN init))) where d1 ... dN are the elements of t in some unspecified order.

fold [Stack]

fold f accu s is (f (... (f (f accu x1) x2) ...) xn) where x1 is the top of the stack, x2 the second element, and xn the bottom element.

fold [Set.S]

fold f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.

fold [Result]

fold ~ok ~error r is ok v if r is Ok v and error e if r is Error e.

fold [Queue]

fold f accu q is equivalent to List.fold_left f accu l, where l is the list of q's elements.

fold [Option]

fold ~none ~some o is none if o is None and some v if o is Some v.

fold [MoreLabels.Set.S]

fold ~f s init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order.

fold [MoreLabels.Map.S]

fold ~f m ~init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.

fold [MoreLabels.Hashtbl.SeededS]
fold [MoreLabels.Hashtbl.S]
fold [MoreLabels.Hashtbl]

Hashtbl.fold ~f tbl ~init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values.

fold [Map.S]

fold f m init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.

fold [Hashtbl.SeededS]
fold [Hashtbl.S]
fold [Hashtbl]

Hashtbl.fold f tbl init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values.

fold [Either]

fold ~left ~right (Left v) is left v, and fold ~left ~right (Right v) is right v.

fold_left [String]

fold_left f x s computes f (... (f (f x s.[0]) s.[1]) ...) s.[n-1], where n is the length of the string s.

fold_left [StringLabels]

fold_left f x s computes f (... (f (f x s.[0]) s.[1]) ...) s.[n-1], where n is the length of the string s.

fold_left [Seq]

Traverse the sequence from left to right, combining each element with the accumulator using the given function.

fold_left [ListLabels]

fold_left ~f ~init [b1; ...; bn] is f (... (f (f init b1) b2) ...) bn.

fold_left [List]

fold_left f init [b1; ...; bn] is f (... (f (f init b1) b2) ...) bn.

fold_left [Float.ArrayLabels]

fold_left ~f x ~init computes f (... (f (f x init.(0)) init.(1)) ...) init.(n-1), where n is the length of the floatarray init.

fold_left [Float.Array]

fold_left f x init computes f (... (f (f x init.(0)) init.(1)) ...) init.(n-1), where n is the length of the floatarray init.

fold_left [BytesLabels]

fold_left f x s computes f (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1)), where n is the length of s.

fold_left [Bytes]

fold_left f x s computes f (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1)), where n is the length of s.

fold_left [ArrayLabels]

fold_left ~f ~init a computes f (... (f (f init a.(0)) a.(1)) ...) a.(n-1), where n is the length of the array a.

fold_left [Array]

fold_left f init a computes f (... (f (f init a.(0)) a.(1)) ...) a.(n-1), where n is the length of the array a.

fold_left2 [ListLabels]

fold_left2 ~f ~init [a1; ...; an] [b1; ...; bn] is f (... (f (f init a1 b1) a2 b2) ...) an bn.

fold_left2 [List]

fold_left2 f init [a1; ...; an] [b1; ...; bn] is f (... (f (f init a1 b1) a2 b2) ...) an bn.

fold_left_map [ListLabels]

fold_left_map is a combination of fold_left and map that threads an accumulator through calls to f.

fold_left_map [List]

fold_left_map is a combination of fold_left and map that threads an accumulator through calls to f.

fold_left_map [ArrayLabels]

fold_left_map is a combination of ArrayLabels.fold_left and ArrayLabels.map that threads an accumulator through calls to f.

fold_left_map [Array]

fold_left_map is a combination of Array.fold_left and Array.map that threads an accumulator through calls to f.

fold_right [String]

fold_right f s x computes f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...)), where n is the length of the string s.

fold_right [StringLabels]

fold_right f s x computes f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...)), where n is the length of the string s.

fold_right [ListLabels]

fold_right ~f [a1; ...; an] ~init is f a1 (f a2 (... (f an init) ...)).

fold_right [List]

fold_right f [a1; ...; an] init is f a1 (f a2 (... (f an init) ...)).

fold_right [Float.ArrayLabels]

fold_right f a init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the floatarray a.

fold_right [Float.Array]

fold_right f a init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the floatarray a.

fold_right [BytesLabels]

fold_right f s x computes f (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...)), where n is the length of s.

fold_right [Bytes]

fold_right f s x computes f (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...)), where n is the length of s.

fold_right [ArrayLabels]

fold_right ~f a ~init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the array a.

fold_right [Array]

fold_right f a init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the array a.

fold_right2 [ListLabels]

fold_right2 ~f [a1; ...; an] [b1; ...; bn] ~init is f a1 b1 (f a2 b2 (... (f an bn init) ...)).

fold_right2 [List]

fold_right2 f [a1; ...; an] [b1; ...; bn] init is f a1 b1 (f a2 b2 (... (f an bn init) ...)).

for_all [String]

for_all p s checks if all characters in s satisfy the predicate p.

for_all [StringLabels]

for_all p s checks if all characters in s satisfy the predicate p.

for_all [Set.S]

for_all f s checks if all elements of the set satisfy the predicate f.

for_all [MoreLabels.Set.S]

for_all ~f s checks if all elements of the set satisfy the predicate f.

for_all [MoreLabels.Map.S]

for_all ~f m checks if all the bindings of the map satisfy the predicate f.

for_all [Map.S]

for_all f m checks if all the bindings of the map satisfy the predicate f.

for_all [ListLabels]

for_all ~f [a1; ...; an] checks if all elements of the list satisfy the predicate f.

for_all [List]

for_all f [a1; ...; an] checks if all elements of the list satisfy the predicate f.

for_all [Float.ArrayLabels]

for_all ~f [|a1; ...; an|] checks if all elements of the floatarray satisfy the predicate f.

for_all [Float.Array]

for_all f [|a1; ...; an|] checks if all elements of the floatarray satisfy the predicate f.

for_all [Either]

for_all ~left ~right (Left v) is left v, and for_all ~left ~right (Right v) is right v.

for_all [BytesLabels]

for_all p s checks if all characters in s satisfy the predicate p.

for_all [Bytes]

for_all p s checks if all characters in s satisfy the predicate p.

for_all [ArrayLabels]

for_all ~f [|a1; ...; an|] checks if all elements of the array satisfy the predicate f.

for_all [Array]

for_all f [|a1; ...; an|] checks if all elements of the array satisfy the predicate f.

for_all2 [ListLabels]

Same as ListLabels.for_all, but for a two-argument predicate.

for_all2 [List]

Same as List.for_all, but for a two-argument predicate.

for_all2 [ArrayLabels]

Same as ArrayLabels.for_all, but for a two-argument predicate.

for_all2 [Array]

Same as Array.for_all, but for a two-argument predicate.

force [CamlinternalLazy]
force [Lazy]

force x forces the suspension x and returns its result.

force_lazy_block [CamlinternalLazy]
force_newline [Format]

Force a new line in the current pretty-printing box.

force_val [CamlinternalLazy]
force_val [Lazy]

force_val x forces the suspension x and returns its result.

force_val_lazy_block [CamlinternalLazy]
fork [UnixLabels]

Fork a new process.

fork [Unix]

Fork a new process.

format [Printexc.Slot]

format pos slot returns the string representation of slot as raw_backtrace_to_string would format it, assuming it is the pos-th element of the backtrace: the 0-th element is pretty-printed differently than the others.

format_from_string [Scanf]

format_from_string s fmt converts a string argument to a format string, according to the given format string fmt.

format_of_string [Stdlib]

format_of_string s returns a format string read from the string literal s.

format_of_string_fmtty [CamlinternalFormat]
format_of_string_format [CamlinternalFormat]
formatter_of_buffer [Format]

formatter_of_buffer b returns a new formatter writing to buffer b.

formatter_of_out_channel [Format]

formatter_of_out_channel oc returns a new formatter writing to the corresponding output channel oc.

formatter_of_out_functions [Format]

formatter_of_out_functions out_funs returns a new formatter that writes with the set of output functions out_funs.

formatter_of_symbolic_output_buffer [Format]

formatter_of_symbolic_output_buffer sob returns a symbolic formatter that outputs to symbolic_output_buffer sob.

fortran_layout [Bigarray]
forward_tag [Obj]
fprintf [Printf]

fprintf outchan format arg1 ... argN formats the arguments arg1 to argN according to the format string format, and outputs the resulting string on the channel outchan.

fprintf [Format]
freeze_char_set [CamlinternalFormat]
frexp [Stdlib]

frexp f returns the pair of the significant and the exponent of f.

frexp [Float]

frexp f returns the pair of the significant and the exponent of f.

from [Stream]

Stream.from f returns a stream built from the function f.

from_bytes [Marshal]

Marshal.from_bytes buff ofs unmarshals a structured value like Marshal.from_channel does, except that the byte representation is not read from a channel, but taken from the byte sequence buff, starting at position ofs.

from_channel [Scanf.Scanning]

Scanning.from_channel ic returns a Scanf.Scanning.in_channel formatted input channel which reads from the regular in_channel input channel ic argument.

from_channel [Marshal]

Marshal.from_channel chan reads from channel chan the byte representation of a structured value, as produced by one of the Marshal.to_* functions, and reconstructs and returns the corresponding value.

from_channel [Lexing]

Create a lexer buffer on the given input channel.

from_file [Scanf.Scanning]

An alias for Scanf.Scanning.open_in above.

from_file_bin [Scanf.Scanning]

An alias for Scanf.Scanning.open_in_bin above.

from_fun [Lazy]

from_fun f is the same as lazy (f ()) but slightly more efficient.

from_function [Scanf.Scanning]

Scanning.from_function f returns a Scanf.Scanning.in_channel formatted input channel with the given function as its reading method.

from_function [Lexing]

Create a lexer buffer with the given function as its reading method.

from_hex [Digest]

Convert a hexadecimal representation back into the corresponding digest.

from_string [Scanf.Scanning]

Scanning.from_string s returns a Scanf.Scanning.in_channel formatted input channel which reads from the given string.

from_string [Marshal]

Same as from_bytes but take a string as argument instead of a byte sequence.

from_string [Lexing]

Create a lexer buffer which reads from the given string.

from_val [Lazy]

from_val v evaluates v first (as any function would) and returns an already-forced suspension of its result.

fscanf [Scanf]
fst [Stdlib]

Return the first component of a pair.

fstat [UnixLabels.LargeFile]
fstat [UnixLabels]

Return the information for the file associated with the given descriptor.

fstat [Unix.LargeFile]
fstat [Unix]

Return the information for the file associated with the given descriptor.

fsync [UnixLabels]

Flush file buffers to disk.

fsync [Unix]

Flush file buffers to disk.

ftruncate [UnixLabels.LargeFile]

See ftruncate.

ftruncate [UnixLabels]

Truncates the file corresponding to the given descriptor to the given size.

ftruncate [Unix.LargeFile]

See ftruncate.

ftruncate [Unix]

Truncates the file corresponding to the given descriptor to the given size.

full_init [Random]

Same as Random.init but takes more data as seed.

full_int [Random.State]
full_int [Random]

Random.full_int bound returns a random integer between 0 (inclusive) and bound (exclusive).

full_major [Gc]

Do a minor collection, finish the current major collection cycle, and perform a complete new cycle.

full_split [Str]

Same as Str.split_delim, but returns the delimiters as well as the substrings contained between delimiters.

G
genarray_of_array0 [Bigarray]

Return the generic Bigarray corresponding to the given zero-dimensional Bigarray.

genarray_of_array1 [Bigarray]

Return the generic Bigarray corresponding to the given one-dimensional Bigarray.

genarray_of_array2 [Bigarray]

Return the generic Bigarray corresponding to the given two-dimensional Bigarray.

genarray_of_array3 [Bigarray]

Return the generic Bigarray corresponding to the given three-dimensional Bigarray.

get [CamlinternalAtomic]
get [Weak]

Weak.get ar n returns None if the nth cell of ar is empty, Some x (where x is the value) if it is full.

get [String]

get s i is the character at index i in s.

get [StringLabels]

get s i is the character at index i in s.

get [Option]

get o is v if o is Some v and

get [Gc]

Return the current values of the GC parameters in a control record.

get [Float.ArrayLabels]

get a n returns the element number n of floatarray a.

get [Float.Array]

get a n returns the element number n of floatarray a.

get [BytesLabels]

get s n returns the byte at index n in argument s.

get [Bytes]

get s n returns the byte at index n in argument s.

get [Bigarray.Array3]

Array3.get a x y z, also written a.{x,y,z}, returns the element of a at coordinates (x, y, z).

get [Bigarray.Array2]

Array2.get a x y, also written a.{x,y}, returns the element of a at coordinates (x, y).

get [Bigarray.Array1]

Array1.get a x, or alternatively a.{x}, returns the element of a at index x.

get [Bigarray.Array0]

Array0.get a returns the only element in a.

get [Bigarray.Genarray]

Read an element of a generic Bigarray.

get [Atomic]

Get the current value of the atomic reference.

get [ArrayLabels]

get a n returns the element number n of array a.

get [Array]

get a n returns the element number n of array a.

get_all_formatter_output_functions [Format]
get_backtrace [Printexc]

Printexc.get_backtrace () returns a string containing the same exception backtrace that Printexc.print_backtrace would print.

get_bucket [Gc]

get_bucket n returns the current size of the n-th future bucket of the GC smoothing system.

get_callstack [Printexc]

Printexc.get_callstack n returns a description of the top of the call stack on the current program point (for the current thread), with at most n entries.

get_copy [Weak]

Weak.get_copy ar n returns None if the nth cell of ar is empty, Some x (where x is a (shallow) copy of the value) if it is full.

get_credit [Gc]

get_credit () returns the current size of the "work done in advance" counter of the GC smoothing system.

get_data [Obj.Ephemeron]
get_data [Ephemeron.Kn]
get_data [Ephemeron.K2]
get_data [Ephemeron.K1]

Ephemeron.K1.get_data eph returns None if the data of eph is empty, Some x (where x is the data) if it is full.

get_data_copy [Obj.Ephemeron]
get_data_copy [Ephemeron.Kn]
get_data_copy [Ephemeron.K2]
get_data_copy [Ephemeron.K1]

Ephemeron.K1.get_data_copy eph returns None if the data of eph is empty, Some x (where x is a (shallow) copy of the data) if it is full.

get_ellipsis_text [Format]

Return the text of the ellipsis.

get_error [Result]

get_error r is e if r is Error e and

get_formatter_out_functions [Format]

Return the current output functions of the pretty-printer, including line splitting and indentation functions.

get_formatter_output_functions [Format]

Return the current output functions of the standard pretty-printer.

get_formatter_stag_functions [Format]

Return the current semantic tag operation functions of the standard pretty-printer.

get_formatter_tag_functions [Format]
get_geometry [Format]

Return the current geometry of the formatter

get_int16_be [String]

get_int16_be b i is b's big-endian signed 16-bit integer starting at character index i.

get_int16_be [StringLabels]

get_int16_be b i is b's big-endian signed 16-bit integer starting at character index i.

get_int16_be [BytesLabels]

get_int16_be b i is b's big-endian signed 16-bit integer starting at byte index i.

get_int16_be [Bytes]

get_int16_be b i is b's big-endian signed 16-bit integer starting at byte index i.

get_int16_le [String]

get_int16_le b i is b's little-endian signed 16-bit integer starting at character index i.

get_int16_le [StringLabels]

get_int16_le b i is b's little-endian signed 16-bit integer starting at character index i.

get_int16_le [BytesLabels]

get_int16_le b i is b's little-endian signed 16-bit integer starting at byte index i.

get_int16_le [Bytes]

get_int16_le b i is b's little-endian signed 16-bit integer starting at byte index i.

get_int16_ne [String]

get_int16_ne b i is b's native-endian signed 16-bit integer starting at character index i.

get_int16_ne [StringLabels]

get_int16_ne b i is b's native-endian signed 16-bit integer starting at character index i.

get_int16_ne [BytesLabels]

get_int16_ne b i is b's native-endian signed 16-bit integer starting at byte index i.

get_int16_ne [Bytes]

get_int16_ne b i is b's native-endian signed 16-bit integer starting at byte index i.

get_int32_be [String]

get_int32_be b i is b's big-endian 32-bit integer starting at character index i.

get_int32_be [StringLabels]

get_int32_be b i is b's big-endian 32-bit integer starting at character index i.

get_int32_be [BytesLabels]

get_int32_be b i is b's big-endian 32-bit integer starting at byte index i.

get_int32_be [Bytes]

get_int32_be b i is b's big-endian 32-bit integer starting at byte index i.

get_int32_le [String]

get_int32_le b i is b's little-endian 32-bit integer starting at character index i.

get_int32_le [StringLabels]

get_int32_le b i is b's little-endian 32-bit integer starting at character index i.

get_int32_le [BytesLabels]

get_int32_le b i is b's little-endian 32-bit integer starting at byte index i.

get_int32_le [Bytes]

get_int32_le b i is b's little-endian 32-bit integer starting at byte index i.

get_int32_ne [String]

get_int32_ne b i is b's native-endian 32-bit integer starting at character index i.

get_int32_ne [StringLabels]

get_int32_ne b i is b's native-endian 32-bit integer starting at character index i.

get_int32_ne [BytesLabels]

get_int32_ne b i is b's native-endian 32-bit integer starting at byte index i.

get_int32_ne [Bytes]

get_int32_ne b i is b's native-endian 32-bit integer starting at byte index i.

get_int64_be [String]

get_int64_be b i is b's big-endian 64-bit integer starting at character index i.

get_int64_be [StringLabels]

get_int64_be b i is b's big-endian 64-bit integer starting at character index i.

get_int64_be [BytesLabels]

get_int64_be b i is b's big-endian 64-bit integer starting at byte index i.

get_int64_be [Bytes]

get_int64_be b i is b's big-endian 64-bit integer starting at byte index i.

get_int64_le [String]

get_int64_le b i is b's little-endian 64-bit integer starting at character index i.

get_int64_le [StringLabels]

get_int64_le b i is b's little-endian 64-bit integer starting at character index i.

get_int64_le [BytesLabels]

get_int64_le b i is b's little-endian 64-bit integer starting at byte index i.

get_int64_le [Bytes]

get_int64_le b i is b's little-endian 64-bit integer starting at byte index i.

get_int64_ne [String]

get_int64_ne b i is b's native-endian 64-bit integer starting at character index i.

get_int64_ne [StringLabels]

get_int64_ne b i is b's native-endian 64-bit integer starting at character index i.

get_int64_ne [BytesLabels]

get_int64_ne b i is b's native-endian 64-bit integer starting at byte index i.

get_int64_ne [Bytes]

get_int64_ne b i is b's native-endian 64-bit integer starting at byte index i.

get_int8 [String]

get_int8 b i is b's signed 8-bit integer starting at character index i.

get_int8 [StringLabels]

get_int8 b i is b's signed 8-bit integer starting at character index i.

get_int8 [BytesLabels]

get_int8 b i is b's signed 8-bit integer starting at byte index i.

get_int8 [Bytes]

get_int8 b i is b's signed 8-bit integer starting at byte index i.

get_key [Obj.Ephemeron]
get_key [Ephemeron.Kn]
get_key [Ephemeron.K1]

Ephemeron.K1.get_key eph returns None if the key of eph is empty, Some x (where x is the key) if it is full.

get_key1 [Ephemeron.K2]
get_key1_copy [Ephemeron.K2]
get_key2 [Ephemeron.K2]
get_key2_copy [Ephemeron.K2]
get_key_copy [Obj.Ephemeron]
get_key_copy [Ephemeron.Kn]
get_key_copy [Ephemeron.K1]

Ephemeron.K1.get_key_copy eph returns None if the key of eph is empty, Some x (where x is a (shallow) copy of the key) if it is full.

get_margin [Format]

Returns the position of the right margin.

get_mark_tags [Format]

Return the current status of tag-marking operations.

get_max_boxes [Format]

Returns the maximum number of pretty-printing boxes allowed before ellipsis.

get_max_indent [Format]

Return the maximum indentation limit (in characters).

get_method [CamlinternalOO]
get_method_label [CamlinternalOO]
get_method_labels [CamlinternalOO]
get_minor_free [Gc]

Return the current size of the free space inside the minor heap.

get_ok [Result]

get_ok r is v if r is Ok v and

get_print_tags [Format]

Return the current status of tag-printing operations.

get_public_method [CamlinternalOO]
get_raw_backtrace [Printexc]

Printexc.get_raw_backtrace () returns the same exception backtrace that Printexc.print_backtrace would print, but in a raw format.

get_raw_backtrace_next_slot [Printexc]

get_raw_backtrace_next_slot slot returns the next slot inlined, if any.

get_raw_backtrace_slot [Printexc]

get_raw_backtrace_slot bckt pos returns the slot in position pos in the backtrace bckt.

get_state [Random]

Return the current state of the generator used by the basic functions.

get_symbolic_output_buffer [Format]

get_symbolic_output_buffer sob returns the contents of buffer sob.

get_temp_dir_name [Filename]

The name of the temporary directory: Under Unix, the value of the TMPDIR environment variable, or "/tmp" if the variable is not set.

get_uint16_be [String]

get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at character index i.

get_uint16_be [StringLabels]

get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at character index i.

get_uint16_be [BytesLabels]

get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at byte index i.

get_uint16_be [Bytes]

get_uint16_be b i is b's big-endian unsigned 16-bit integer starting at byte index i.

get_uint16_le [String]

get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at character index i.

get_uint16_le [StringLabels]

get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at character index i.

get_uint16_le [BytesLabels]

get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at byte index i.

get_uint16_le [Bytes]

get_uint16_le b i is b's little-endian unsigned 16-bit integer starting at byte index i.

get_uint16_ne [String]

get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at character index i.

get_uint16_ne [StringLabels]

get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at character index i.

get_uint16_ne [BytesLabels]

get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at byte index i.

get_uint16_ne [Bytes]

get_uint16_ne b i is b's native-endian unsigned 16-bit integer starting at byte index i.

get_uint8 [String]

get_uint8 b i is b's unsigned 8-bit integer starting at character index i.

get_uint8 [StringLabels]

get_uint8 b i is b's unsigned 8-bit integer starting at character index i.

get_uint8 [BytesLabels]

get_uint8 b i is b's unsigned 8-bit integer starting at byte index i.

get_uint8 [Bytes]

get_uint8 b i is b's unsigned 8-bit integer starting at byte index i.

get_value [Semaphore.Counting]

get_value s returns the current value of semaphore s.

get_variable [CamlinternalOO]
get_variables [CamlinternalOO]
getaddrinfo [UnixLabels]

getaddrinfo host service opts returns a list of UnixLabels.addr_info records describing socket parameters and addresses suitable for communicating with the given host and service.

getaddrinfo [Unix]

getaddrinfo host service opts returns a list of Unix.addr_info records describing socket parameters and addresses suitable for communicating with the given host and service.

getcwd [UnixLabels]

Return the name of the current working directory.

getcwd [Unix]

Return the name of the current working directory.

getcwd [Sys]

Return the current working directory of the process.

getegid [UnixLabels]

Return the effective group id under which the process runs.

getegid [Unix]

Return the effective group id under which the process runs.

getenv [UnixLabels]

Return the value associated to a variable in the process environment, unless the process has special privileges.

getenv [Unix]

Return the value associated to a variable in the process environment, unless the process has special privileges.

getenv [Sys]

Return the value associated to a variable in the process environment.

getenv_opt [Sys]

Return the value associated to a variable in the process environment or None if the variable is unbound.

geteuid [UnixLabels]

Return the effective user id under which the process runs.

geteuid [Unix]

Return the effective user id under which the process runs.

getgid [UnixLabels]

Return the group id of the user executing the process.

getgid [Unix]

Return the group id of the user executing the process.

getgrgid [UnixLabels]

Find an entry in group with the given group id.

getgrgid [Unix]

Find an entry in group with the given group id.

getgrnam [UnixLabels]

Find an entry in group with the given name.

getgrnam [Unix]

Find an entry in group with the given name.

getgroups [UnixLabels]

Return the list of groups to which the user executing the process belongs.

getgroups [Unix]

Return the list of groups to which the user executing the process belongs.

gethostbyaddr [UnixLabels]

Find an entry in hosts with the given address.

gethostbyaddr [Unix]

Find an entry in hosts with the given address.

gethostbyname [UnixLabels]

Find an entry in hosts with the given name.

gethostbyname [Unix]

Find an entry in hosts with the given name.

gethostname [UnixLabels]

Return the name of the local host.

gethostname [Unix]

Return the name of the local host.

getitimer [UnixLabels]

Return the current status of the given interval timer.

getitimer [Unix]

Return the current status of the given interval timer.

getlogin [UnixLabels]

Return the login name of the user executing the process.

getlogin [Unix]

Return the login name of the user executing the process.

getnameinfo [UnixLabels]

getnameinfo addr opts returns the host name and service name corresponding to the socket address addr.

getnameinfo [Unix]

getnameinfo addr opts returns the host name and service name corresponding to the socket address addr.

getpeername [UnixLabels]

Return the address of the host connected to the given socket.

getpeername [Unix]

Return the address of the host connected to the given socket.

getpid [UnixLabels]

Return the pid of the process.

getpid [Unix]

Return the pid of the process.

getppid [UnixLabels]

Return the pid of the parent process.

getppid [Unix]

Return the pid of the parent process.

getprotobyname [UnixLabels]

Find an entry in protocols with the given name.

getprotobyname [Unix]

Find an entry in protocols with the given name.

getprotobynumber [UnixLabels]

Find an entry in protocols with the given protocol number.

getprotobynumber [Unix]

Find an entry in protocols with the given protocol number.

getpwnam [UnixLabels]

Find an entry in passwd with the given name.

getpwnam [Unix]

Find an entry in passwd with the given name.

getpwuid [UnixLabels]

Find an entry in passwd with the given user id.

getpwuid [Unix]

Find an entry in passwd with the given user id.

getservbyname [UnixLabels]

Find an entry in services with the given name.

getservbyname [Unix]

Find an entry in services with the given name.

getservbyport [UnixLabels]

Find an entry in services with the given service number.

getservbyport [Unix]

Find an entry in services with the given service number.

getsockname [UnixLabels]

Return the address of the given socket.

getsockname [Unix]

Return the address of the given socket.

getsockopt [UnixLabels]

Return the current status of a boolean-valued option in the given socket.

getsockopt [Unix]

Return the current status of a boolean-valued option in the given socket.

getsockopt_error [UnixLabels]

Return the error condition associated with the given socket, and clear it.

getsockopt_error [Unix]

Return the error condition associated with the given socket, and clear it.

getsockopt_float [UnixLabels]

Same as UnixLabels.getsockopt for a socket option whose value is a floating-point number.

getsockopt_float [Unix]

Same as Unix.getsockopt for a socket option whose value is a floating-point number.

getsockopt_int [UnixLabels]

Same as UnixLabels.getsockopt for an integer-valued socket option.

getsockopt_int [Unix]

Same as Unix.getsockopt for an integer-valued socket option.

getsockopt_optint [UnixLabels]

Same as UnixLabels.getsockopt for a socket option whose value is an int option.

getsockopt_optint [Unix]

Same as Unix.getsockopt for a socket option whose value is an int option.

gettimeofday [UnixLabels]

Same as UnixLabels.time, but with resolution better than 1 second.

gettimeofday [Unix]

Same as Unix.time, but with resolution better than 1 second.

getuid [UnixLabels]

Return the user id of the user executing the process.

getuid [Unix]

Return the user id of the user executing the process.

global_replace [Str]

global_replace regexp templ s returns a string identical to s, except that all substrings of s that match regexp have been replaced by templ.

global_substitute [Str]

global_substitute regexp subst s returns a string identical to s, except that all substrings of s that match regexp have been replaced by the result of function subst.

gmtime [UnixLabels]

Convert a time in seconds, as returned by UnixLabels.time, into a date and a time.

gmtime [Unix]

Convert a time in seconds, as returned by Unix.time, into a date and a time.

group_beginning [Str]

group_beginning n returns the position of the first character of the substring that was matched by the nth group of the regular expression that was matched by the last call to a matching or searching function (see Str.matched_string for details).

group_end [Str]

group_end n returns the position of the character following the last character of substring that was matched by the nth group of the regular expression that was matched by the last call to a matching or searching function (see Str.matched_string for details).

guard [Event]

guard fn returns the event that, when synchronized, computes fn() and behaves as the resulting event.

H
handle_unix_error [UnixLabels]

handle_unix_error f x applies f to x and returns the result.

handle_unix_error [Unix]

handle_unix_error f x applies f to x and returns the result.

has_symlink [UnixLabels]

Returns true if the user is able to create symbolic links.

has_symlink [Unix]

Returns true if the user is able to create symbolic links.

hash [Uchar]

hash u associates a non-negative integer to u.

hash [MoreLabels.Hashtbl.SeededHashedType]

A seeded hashing function on keys.

hash [MoreLabels.Hashtbl.HashedType]

A hashing function on keys.

hash [MoreLabels.Hashtbl]

Hashtbl.hash x associates a nonnegative integer to any value of any type.

hash [Hashtbl.SeededHashedType]

A seeded hashing function on keys.

hash [Hashtbl.HashedType]

A hashing function on keys.

hash [Hashtbl]

Hashtbl.hash x associates a nonnegative integer to any value of any type.

hash [Float]

The hash function for floating-point numbers.

hash_param [MoreLabels.Hashtbl]

Hashtbl.hash_param meaningful total x computes a hash value for x, with the same properties as for hash.

hash_param [Hashtbl]

Hashtbl.hash_param meaningful total x computes a hash value for x, with the same properties as for hash.

hd [ListLabels]

Return the first element of the given list.

hd [List]

Return the first element of the given list.

header_size [Marshal]

The bytes representing a marshaled value are composed of a fixed-size header and a variable-sized data part, whose size can be determined from the header.

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 x y returns sqrt(x *. x + y *. y), that is, the length of the hypotenuse of a right-angled triangle with sides of length x and y, or, equivalently, the distance of the point (x,y) to origin.

hypot [Float]

hypot x y returns sqrt(x *. x + y *. y), that is, the length of the hypotenuse of a right-angled triangle with sides of length x and y, or, equivalently, the distance of the point (x,y) to origin.

I
i [Complex]

The complex number i.

ibprintf [Printf]

Same as Printf.bprintf, but does not print anything.

id [Thread]

Return the identifier of the given thread.

id [Oo]

Return an integer identifying this object, unique for the current execution of the program.

id [Obj.Extension_constructor]
id [Fun]

id is the identity function.

ifprintf [Printf]

Same as Printf.fprintf, but does not print anything.

ifprintf [Format]

Same as fprintf above, but does not print anything.

ignore [Stdlib]

Discard the value of its argument and return ().

ikbprintf [Printf]

Same as kbprintf above, but does not print anything.

ikfprintf [Printf]

Same as kfprintf above, but does not print anything.

ikfprintf [Format]

Same as kfprintf above, but does not print anything.

in_channel_length [Stdlib.LargeFile]
in_channel_length [Stdlib]

Return the size (number of characters) of the regular file on which the given channel is opened.

in_channel_of_descr [UnixLabels]

Create an input channel reading from the given descriptor.

in_channel_of_descr [Unix]

Create an input channel reading from the given descriptor.

incr [CamlinternalAtomic]
incr [Stdlib]

Increment the integer contained in the given reference.

incr [Atomic]

incr r atomically increments the value of r by 1.

index [String]

index s c is String.index_from s 0 c.

index [StringLabels]

index s c is String.index_from s 0 c.

index [BytesLabels]

index s c returns the index of the first occurrence of byte c in s.

index [Bytes]

index s c returns the index of the first occurrence of byte c in s.

index_from [String]

index_from s i c is the index of the first occurrence of c in s after position i.

index_from [StringLabels]

index_from s i c is the index of the first occurrence of c in s after position i.

index_from [BytesLabels]

index_from s i c returns the index of the first occurrence of byte c in s after position i.

index_from [Bytes]

index_from s i c returns the index of the first occurrence of byte c in s after position i.

index_from_opt [String]

index_from_opt s i c is the index of the first occurrence of c in s after position i (if any).

index_from_opt [StringLabels]

index_from_opt s i c is the index of the first occurrence of c in s after position i (if any).

index_from_opt [BytesLabels]

index_from_opt s i c returns the index of the first occurrence of byte c in s after position i or None if c does not occur in s after position i.

index_from_opt [Bytes]

index_from_opt s i c returns the index of the first occurrence of byte c in s after position i or None if c does not occur in s after position i.

index_opt [String]

index_opt s c is String.index_from_opt s 0 c.

index_opt [StringLabels]

index_opt s c is String.index_from_opt s 0 c.

index_opt [BytesLabels]

index_opt s c returns the index of the first occurrence of byte c in s or None if c does not occur in s.

index_opt [Bytes]

index_opt s c returns the index of the first occurrence of byte c in s or None if c does not occur in s.

inet6_addr_any [UnixLabels]

A special IPv6 address, for use only with bind, representing all the Internet addresses that the host machine possesses.

inet6_addr_any [Unix]

A special IPv6 address, for use only with bind, representing all the Internet addresses that the host machine possesses.

inet6_addr_loopback [UnixLabels]

A special IPv6 address representing the host machine (::1).

inet6_addr_loopback [Unix]

A special IPv6 address representing the host machine (::1).

inet_addr_any [UnixLabels]

A special IPv4 address, for use only with bind, representing all the Internet addresses that the host machine possesses.

inet_addr_any [Unix]

A special IPv4 address, for use only with bind, representing all the Internet addresses that the host machine possesses.

inet_addr_loopback [UnixLabels]

A special IPv4 address representing the host machine (127.0.0.1).

inet_addr_loopback [Unix]

A special IPv4 address representing the host machine (127.0.0.1).

inet_addr_of_string [UnixLabels]

Conversion from the printable representation of an Internet address to its internal representation.

inet_addr_of_string [Unix]

Conversion from the printable representation of an Internet address to its internal representation.

infinity [Stdlib]

Positive infinity.

infinity [Float]

Positive infinity.

infix_tag [Obj]
info [Obj.Closure]
inherits [CamlinternalOO]
init [String]

init n f is a string of length n with index i holding the character f i (called in increasing index order).

init [StringLabels]

init n ~f is a string of length n with index i holding the character f i (called in increasing index order).

init [Random]

Initialize the generator, using the argument as a seed.

init [ListLabels]

init ~len ~f is f 0; f 1; ...; f (len-1), evaluated left to right.

init [List]

init len f is f 0; f 1; ...; f (len-1), evaluated left to right.

init [Float.ArrayLabels]

init n ~f returns a fresh floatarray of length n, with element number i initialized to the result of f i.

init [Float.Array]

init n f returns a fresh floatarray of length n, with element number i initialized to the result of f i.

init [BytesLabels]

init n f returns a fresh byte sequence of length n, with character i initialized to the result of f i (in increasing index order).

init [Bytes]

init n f returns a fresh byte sequence of length n, with character i initialized to the result of f i (in increasing index order).

init [Bigarray.Array3]

Array3.init kind layout dim1 dim2 dim3 f returns a new Bigarray b of three dimensions, whose size is dim1 in the first dimension, dim2 in the second dimension, and dim3 in the third.

init [Bigarray.Array2]

Array2.init kind layout dim1 dim2 f returns a new Bigarray b of two dimensions, whose size is dim2 in the first dimension and dim2 in the second dimension.

init [Bigarray.Array1]

Array1.init kind layout dim f returns a new Bigarray b of one dimension, whose size is dim.

init [Bigarray.Array0]

Array0.init kind layout v behaves like Array0.create kind layout except that the element is additionally initialized to the value v.

init [Bigarray.Genarray]

Genarray.init kind layout dimensions f returns a new Bigarray b whose element kind is determined by the parameter kind (one of float32, float64, int8_signed, etc) and whose layout is determined by the parameter layout (one of c_layout or fortran_layout).

init [ArrayLabels]

init n ~f returns a fresh array of length n, with element number i initialized to the result of f i.

init [Array]

init n f returns a fresh array of length n, with element number i initialized to the result of f i.

init_class [CamlinternalOO]
init_mod [CamlinternalMod]
initgroups [UnixLabels]

initgroups user group initializes the group access list by reading the group database /etc/group and using all groups of which user is a member.

initgroups [Unix]

initgroups user group initializes the group access list by reading the group database /etc/group and using all groups of which user is a member.

input [Stdlib]

input ic buf pos len reads up to len characters from the given channel ic, storing them in byte sequence buf, starting at character number pos.

input [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, but return the 8-bit integer representing the character.

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 output_value, and return the corresponding value.

int [Random.State]
int [Random]

Random.int bound returns a random integer between 0 (inclusive) and bound (exclusive).

int [Bigarray]
int16_signed [Bigarray]
int16_unsigned [Bigarray]
int32 [Random.State]
int32 [Random]

Random.int32 bound returns a random integer between 0 (inclusive) and bound (exclusive).

int32 [Bigarray]
int64 [Random.State]
int64 [Random]

Random.int64 bound returns a random integer between 0 (inclusive) and bound (exclusive).

int64 [Bigarray]
int8_signed [Bigarray]
int8_unsigned [Bigarray]
int_of_char [Stdlib]

Return the ASCII code of the argument.

int_of_float [Stdlib]

Truncate the given floating-point number to an integer.

int_of_string [Stdlib]

Same as int_of_string_opt, but raise Failure "int_of_string" instead of returning None.

int_of_string_opt [Stdlib]

Convert the given string to an integer.

int_size [Sys]

Size of int, in bits.

int_tag [Obj]
inter [Set.S]

Set intersection.

inter [MoreLabels.Set.S]

Set intersection.

interactive [Sys]

This reference is initially set to false in standalone programs and to true if the code is being executed under the interactive toplevel system ocaml.

inv [Complex]

Multiplicative inverse (1/z).

invalid_arg [Stdlib]

Raise exception Invalid_argument with the given string.

is_block [Obj]
is_char [Uchar]

is_char u is true if and only if u is a latin1 OCaml character.

is_directory [Sys]

Returns true if the given name refers to a directory, false if it refers to another kind of file.

is_empty [Stack]

Return true if the given stack is empty, false otherwise.

is_empty [Set.S]

Test whether a set is empty or not.

is_empty [Queue]

Return true if the given queue is empty, false otherwise.

is_empty [MoreLabels.Set.S]

Test whether a set is empty or not.

is_empty [MoreLabels.Map.S]

Test whether a map is empty or not.

is_empty [Map.S]

Test whether a map is empty or not.

is_error [Result]

is_error r is true if and only if r is Error _.

is_finite [Float]

is_finite x is true if and only if x is finite i.e., not infinite and not Float.nan.

is_implicit [Filename]

Return true if the file name is relative and does not start with an explicit reference to the current directory (./ or ../ in Unix), false if it starts with an explicit reference to the root directory or the current directory.

is_in_char_set [CamlinternalFormat]
is_inet6_addr [UnixLabels]

Whether the given inet_addr is an IPv6 address.

is_inet6_addr [Unix]

Whether the given inet_addr is an IPv6 address.

is_infinite [Float]

is_infinite x is true if and only if x is Float.infinity or Float.neg_infinity.

is_inline [Printexc.Slot]

is_inline slot is true when slot refers to a call that got inlined by the compiler, and false when it comes from any other context.

is_int [Obj]
is_integer [Float]

is_integer x is true if and only if x is an integer.

is_left [Either]

is_left (Left v) is true, is_left (Right v) is false.

is_nan [Float]

is_nan x is true if and only if x is not a number (see Float.nan).

is_native [Dynlink]

true if the program is native, false if the program is bytecode.

is_none [Option]

is_none o is true if and only if o is None.

is_ok [Result]

is_ok r is true if and only if r is Ok _.

is_raise [Printexc.Slot]

is_raise slot is true when slot refers to a raising point in the code, and false when it comes from a simple function call.

is_randomized [MoreLabels.Hashtbl]

Return true if the tables are currently created in randomized mode by default, false otherwise.

is_randomized [Hashtbl]

Return true if the tables are currently created in randomized mode by default, false otherwise.

is_relative [Filename]

Return true if the file name is relative to the current directory, false if it is absolute (i.e.

is_right [Either]

is_right (Left v) is false, is_right (Right v) is true.

is_some [Option]

is_some o is true if and only if o is Some o.

is_val [Lazy]

is_val x returns true if x has already been forced and did not raise an exception.

is_valid [Uchar]

is_valid n is true if and only if n is a Unicode scalar value (i.e.

isatty [UnixLabels]

Return true if the given file descriptor refers to a terminal or console window, false otherwise.

isatty [Unix]

Return true if the given file descriptor refers to a terminal or console window, false otherwise.

iter [Weak.S]

iter f t calls f on each element of t, in some unspecified order.

iter [String]

iter f s applies function f in turn to all the characters of s.

iter [Stream]

Stream.iter f s scans the whole stream s, applying function f in turn to each stream element encountered.

iter [StringLabels]

iter ~f s applies function f in turn to all the characters of s.

iter [Stack]

iter f s applies f in turn to all elements of s, from the element at the top of the stack to the element at the bottom of the stack.

iter [Set.S]

iter f s applies f in turn to all elements of s.

iter [Seq]

Iterate on the sequence, calling the (imperative) function on every element.

iter [Result]

iter f r is f v if r is Ok v and () otherwise.

iter [Queue]

iter f q applies f in turn to all elements of q, from the least recently entered to the most recently entered.

iter [Option]

iter f o is f v if o is Some v and () otherwise.

iter [MoreLabels.Set.S]

iter ~f s applies f in turn to all elements of s.

iter [MoreLabels.Map.S]

iter ~f m applies f to all bindings in map m.

iter [MoreLabels.Hashtbl.SeededS]
iter [MoreLabels.Hashtbl.S]
iter [MoreLabels.Hashtbl]

Hashtbl.iter ~f tbl applies f to all bindings in table tbl.

iter [Map.S]

iter f m applies f to all bindings in map m.

iter [ListLabels]

iter ~f [a1; ...; an] applies function f in turn to a1; ...; an.

iter [List]

iter f [a1; ...; an] applies function f in turn to a1; ...; an.

iter [Hashtbl.SeededS]
iter [Hashtbl.S]
iter [Hashtbl]

Hashtbl.iter f tbl applies f to all bindings in table tbl.

iter [Float.ArrayLabels]

iter ~f a applies function f in turn to all the elements of a.

iter [Float.Array]

iter f a applies function f in turn to all the elements of a.

iter [Either]

iter ~left ~right (Left v) is left v, and iter ~left ~right (Right v) is right v.

iter [BytesLabels]

iter ~f s applies function f in turn to all the bytes of s.

iter [Bytes]

iter f s applies function f in turn to all the bytes of s.

iter [ArrayLabels]

iter ~f a applies function f in turn to all the elements of a.

iter [Array]

iter f a applies function f in turn to all the elements of a.

iter2 [ListLabels]

iter2 ~f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.

iter2 [List]

iter2 f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.

iter2 [Float.ArrayLabels]

Array.iter2 ~f a b applies function f to all the elements of a and b.

iter2 [Float.Array]

Array.iter2 f a b applies function f to all the elements of a and b.

iter2 [ArrayLabels]

iter2 ~f a b applies function f to all the elements of a and b.

iter2 [Array]

iter2 f a b applies function f to all the elements of a and b.

iter_error [Result]

iter_error f r is f e if r is Error e and () otherwise.

iteri [String]

iteri is like String.iter, but the function is also given the corresponding character index.

iteri [StringLabels]

iteri is like StringLabels.iter, but the function is also given the corresponding character index.

iteri [ListLabels]

Same as ListLabels.iter, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.

iteri [List]

Same as List.iter, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.

iteri [Float.ArrayLabels]

Same as Float.ArrayLabels.iter, but the function is applied with the index of the element as first argument, and the element itself as second argument.

iteri [Float.Array]

Same as Float.Array.iter, but the function is applied with the index of the element as first argument, and the element itself as second argument.

iteri [BytesLabels]

Same as BytesLabels.iter, but the function is applied to the index of the byte as first argument and the byte itself as second argument.

iteri [Bytes]

Same as Bytes.iter, but the function is applied to the index of the byte as first argument and the byte itself as second argument.

iteri [ArrayLabels]

Same as ArrayLabels.iter, but the function is applied to the index of the element as first argument, and the element itself as second argument.

iteri [Array]

Same as Array.iter, but the function is applied to the index of the element as first argument, and the element itself as second argument.

J
join [Thread]

join th suspends the execution of the calling thread until the thread th has terminated.

join [Result]

join rr is r if rr is Ok r and rr if rr is Error _.

join [Option]

join oo is Some v if oo is Some (Some v) and None otherwise.

junk [Stream]

Remove the first element of the stream, possibly unfreezing it before.

K
kasprintf [Format]

Same as asprintf above, but instead of returning the string, passes it to the first argument.

kbprintf [Printf]

Same as bprintf, but instead of returning immediately, passes the buffer to its first argument at the end of printing.

kdprintf [Format]

Same as Format.dprintf above, but instead of returning immediately, passes the suspended printer to its first argument at the end of printing.

kfprintf [Printf]

Same as fprintf, but instead of returning immediately, passes the out channel to its first argument at the end of printing.

kfprintf [Format]

Same as fprintf above, but instead of returning immediately, passes the formatter to its first argument at the end of printing.

kfscanf [Scanf]
kill [UnixLabels]

kill ~pid ~signal sends signal number signal to the process with id pid.

kill [Unix]

kill pid signal sends signal number signal to the process with id pid.

kill [Thread]

This function was supposed to 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]

kind_size_in_bytes k is the number of bytes used to store an element of type k.

kprintf [Printf]

A deprecated synonym for ksprintf.

kprintf [Format]
kscanf [Scanf]

Same as Scanf.bscanf, but takes an additional function argument ef that is called in case of error: if the scanning process or some conversion fails, the scanning function aborts and calls the error handling function ef with the formatted input channel and the exception that aborted the scanning process as arguments.

ksprintf [Printf]

Same as sprintf above, but instead of returning the string, passes it to the first argument.

ksprintf [Format]

Same as sprintf above, but instead of returning the string, passes it to the first argument.

ksscanf [Scanf]

Same as Scanf.kscanf but reads from the given string.

L
last_chars [Str]

last_chars s n returns the last n characters of s.

last_non_constant_constructor_tag [Obj]
layout [Bigarray.Array3]

Return the layout of the given Bigarray.

layout [Bigarray.Array2]

Return the layout of the given Bigarray.

layout [Bigarray.Array1]

Return the layout of the given Bigarray.

layout [Bigarray.Array0]

Return the layout of the given Bigarray.

layout [Bigarray.Genarray]

Return the layout of the given Bigarray.

lazy_from_fun [Lazy]
lazy_from_val [Lazy]
lazy_is_val [Lazy]
lazy_tag [Obj]
ldexp [Stdlib]

ldexp x n returns x *. 2 ** n.

ldexp [Float]

ldexp x n returns x *. 2 ** n.

left [Either]

left v is Left v.

length [Weak]

Weak.length ar returns the length (number of elements) of ar.

length [String]

length s is the length (number of bytes/characters) of s.

length [StringLabels]

length s is the length (number of bytes/characters) of s.

length [Stack]

Return the number of elements in a stack.

length [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]

Hashtbl.length tbl returns the number of bindings in tbl.

length [ListLabels]

Return the length (number of elements) of the given list.

length [List]

Return the length (number of elements) of the given list.

length [Hashtbl.SeededS]
length [Hashtbl.S]
length [Hashtbl]

Hashtbl.length tbl returns the number of bindings in tbl.

length [Float.ArrayLabels]

Return the length (number of elements) of the given floatarray.

length [Float.Array]

Return the length (number of elements) of the given floatarray.

length [BytesLabels]

Return the length (number of bytes) of the argument.

length [Bytes]

Return the length (number of bytes) of the argument.

length [Buffer]

Return the number of characters currently contained in the buffer.

length [ArrayLabels]

Return the length (number of elements) of the given array.

length [Array]

Return the length (number of elements) of the given array.

lexeme [Lexing]

Lexing.lexeme lexbuf returns the string matched by the regular expression.

lexeme_char [Lexing]

Lexing.lexeme_char lexbuf i returns character number i in the matched string.

lexeme_end [Lexing]

Lexing.lexeme_end lexbuf returns the offset in the input stream of the character following the last character of the matched string.

lexeme_end_p [Lexing]

Like lexeme_end, but return a complete position instead of an offset.

lexeme_start [Lexing]

Lexing.lexeme_start lexbuf returns the offset in the input stream of the first character of the matched string.

lexeme_start_p [Lexing]

Like lexeme_start, but return a complete position instead of an offset.

link [UnixLabels]

link ?follow ~src ~dst creates a hard link named dst to the file named src.

link [Unix]

link ?follow src dst creates a hard link named dst to the file named src.

listen [UnixLabels]

Set up a socket for receiving connection requests.

listen [Unix]

Set up a socket for receiving connection requests.

lnot [Stdlib]

Bitwise logical negation.

loadfile [Dynlink]

In bytecode: load the given bytecode object file (.cmo file) or bytecode library file (.cma file), and link it with the running program.

loadfile_private [Dynlink]

Same as loadfile, except that the compilation units just loaded are hidden (cannot be referenced) from other modules dynamically loaded afterwards.

localtime [UnixLabels]

Convert a time in seconds, as returned by UnixLabels.time, into a date and a time.

localtime [Unix]

Convert a time in seconds, as returned by Unix.time, into a date and a time.

location [Printexc.Slot]

location slot returns the location information of the slot, if available, and None otherwise.

lock [Mutex]

Lock the given mutex.

lockf [UnixLabels]

lockf fd ~mode ~len puts a lock on a region of the file opened as fd.

lockf [Unix]

lockf fd mode len puts a lock on a region of the file opened as fd.

log [Stdlib]

Natural logarithm.

log [Float]

Natural logarithm.

log [Complex]

Natural logarithm (in base e).

log10 [Stdlib]

Base 10 logarithm.

log10 [Float]

Base 10 logarithm.

log1p [Stdlib]

log1p x computes log(1.0 +. x) (natural logarithm), giving numerically-accurate results even if x is close to 0.0.

log1p [Float]

log1p x computes log(1.0 +. x) (natural logarithm), giving numerically-accurate results even if x is close to 0.0.

log2 [Float]

Base 2 logarithm.

logand [Nativeint]

Bitwise logical and.

logand [Int64]

Bitwise logical and.

logand [Int32]

Bitwise logical and.

logand [Int]

logand x y is the bitwise logical and of x and y.

lognot [Nativeint]

Bitwise logical negation.

lognot [Int64]

Bitwise logical negation.

lognot [Int32]

Bitwise logical negation.

lognot [Int]

lognot x is the bitwise logical negation of x.

logor [Nativeint]

Bitwise logical or.

logor [Int64]

Bitwise logical or.

logor [Int32]

Bitwise logical or.

logor [Int]

logor x y is the bitwise logical or of x and y.

logxor [Nativeint]

Bitwise logical exclusive or.

logxor [Int64]

Bitwise logical exclusive or.

logxor [Int32]

Bitwise logical exclusive or.

logxor [Int]

logxor x y is the bitwise logical exclusive or of x and y.

lookup_tables [CamlinternalOO]
lowercase [String]

Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.

lowercase [StringLabels]

Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.

lowercase [Char]

Convert the given character to its equivalent lowercase character, using the ISO Latin-1 (8859-1) character set.

lowercase [BytesLabels]

Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.

lowercase [Bytes]

Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.

lowercase_ascii [String]

lowercase_ascii s is s with all uppercase letters translated to lowercase, using the US-ASCII character set.

lowercase_ascii [StringLabels]

lowercase_ascii s is s with all uppercase letters translated to lowercase, using the US-ASCII character set.

lowercase_ascii [Char]

Convert the given character to its equivalent lowercase character, using the US-ASCII character set.

lowercase_ascii [BytesLabels]

Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set.

lowercase_ascii [Bytes]

Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set.

lseek [UnixLabels.LargeFile]

See lseek.

lseek [UnixLabels]

Set the current position for a file descriptor, and return the resulting offset (from the beginning of the file).

lseek [Unix.LargeFile]

See lseek.

lseek [Unix]

Set the current position for a file descriptor, and return the resulting offset (from the beginning of the file).

lstat [UnixLabels.LargeFile]
lstat [UnixLabels]

Same as UnixLabels.stat, but in case the file is a symbolic link, return the information for the link itself.

lstat [Unix.LargeFile]
lstat [Unix]

Same as Unix.stat, but in case the file is a symbolic link, return the information for the link itself.

M
magic [Obj]
main_program_units [Dynlink]

Return the list of compilation units that form the main program (i.e.

major [Gc]

Do a minor collection and finish the current major collection cycle.

major_slice [Gc]

major_slice n Do a minor collection and a slice of major collection.

make [CamlinternalAtomic]
make [String]

make n c is a string of length n with each index holding the character c.

make [StringLabels]

make n c is a string of length n with each index holding the character c.

make [Semaphore.Binary]

make b returns a new binary semaphore.

make [Semaphore.Counting]

make n returns a new counting semaphore, with initial value n.

make [Random.State]

Create a new state and initialize it with the given seed.

make [Float.ArrayLabels]

make n x returns a fresh floatarray of length n, initialized with x.

make [Float.Array]

make n x returns a fresh floatarray of length n, initialized with x.

make [BytesLabels]

make n c returns a new byte sequence of length n, filled with the byte c.

make [Bytes]

make n c returns a new byte sequence of length n, filled with the byte c.

make [Atomic]

Create an atomic reference.

make [ArrayLabels]

make n x returns a fresh array of length n, initialized with x.

make [Array]

make n x returns a fresh array of length n, initialized with x.

make_class [CamlinternalOO]
make_class_store [CamlinternalOO]
make_float [ArrayLabels]
make_float [Array]
make_formatter [Format]

make_formatter out flush returns a new formatter that outputs with function out, and flushes with function flush.

make_iprintf [CamlinternalFormat]
make_lexer [Genlex]

Construct the lexer function.

make_matrix [ArrayLabels]

make_matrix ~dimx ~dimy e returns a two-dimensional array (an array of arrays) with first dimension dimx and second dimension dimy.

make_matrix [Array]

make_matrix dimx dimy e returns a two-dimensional array (an array of arrays) with first dimension dimx and second dimension dimy.

make_printf [CamlinternalFormat]
make_self_init [Random.State]

Create a new state and initialize it with a system-dependent low-entropy seed.

make_symbolic_output_buffer [Format]

make_symbolic_output_buffer () returns a fresh buffer for symbolic output.

map [String]

map f s is the string resulting from applying f to all the characters of s in increasing order.

map [StringLabels]

map f s is the string resulting from applying f to all the characters of s in increasing order.

map [Set.S]

map f s is the set whose elements are f a0,f a1...

map [Seq]

map f seq returns a new sequence whose elements are the elements of seq, transformed by f.

map [Result]

map f r is Ok (f v) if r is Ok v and r if r is Error _.

map [Option]

map f o is None if o is None and Some (f v) is o is Some v.

map [MoreLabels.Set.S]

map ~f s is the set whose elements are f a0,f a1...

map [MoreLabels.Map.S]

map ~f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a.

map [Map.S]

map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a.

map [ListLabels]

map ~f [a1; ...; an] applies function f to a1, ..., an, and builds the list [f a1; ...; f an] with the results returned by f.

map [List]

map f [a1; ...; an] applies function f to a1, ..., an, and builds the list [f a1; ...; f an] with the results returned by f.

map [Lazy]

map f x returns a suspension that, when forced, forces x and applies f to its value.

map [Float.ArrayLabels]

map ~f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.

map [Float.Array]

map f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.

map [Either]

map ~left ~right (Left v) is Left (left v), map ~left ~right (Right v) is Right (right v).

map [BytesLabels]

map ~f s applies function f in turn to all the bytes of s (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.

map [Bytes]

map f s applies function f in turn to all the bytes of s (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.

map [ArrayLabels]

map ~f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(length a - 1) |].

map [Array]

map f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(length a - 1) |].

map2 [ListLabels]

map2 ~f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn].

map2 [List]

map2 f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn].

map2 [Float.ArrayLabels]

map2 ~f a b applies function f to all the elements of a and b, and builds a floatarray with the results returned by f: [| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].

map2 [Float.Array]

map2 f a b applies function f to all the elements of a and b, and builds a floatarray with the results returned by f: [| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].

map2 [ArrayLabels]

map2 ~f a b applies function f to all the elements of a and b, and builds an array with the results returned by f: [| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].

map2 [Array]

map2 f a b applies function f to all the elements of a and b, and builds an array with the results returned by f: [| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].

map_error [Result]

map_error f r is Error (f e) if r is Error e and r if r is Ok _.

map_file [UnixLabels]

Memory mapping of a file as a Bigarray.

map_file [Unix]

Memory mapping of a file as a Bigarray.

map_from_array [Float.ArrayLabels]

map_from_array ~f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.

map_from_array [Float.Array]

map_from_array f a applies function f to all the elements of a, and builds a floatarray with the results returned by f.

map_left [Either]

map_left f e is Left (f v) if e is Left v and e if e is Right _.

map_right [Either]

map_right f e is Right (f v) if e is Right v and e if e is Left _.

map_to_array [Float.ArrayLabels]

map_to_array ~f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(length a - 1) |].

map_to_array [Float.Array]

map_to_array f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(length a - 1) |].

map_val [Lazy]

map_val f x applies f directly if x is already forced, otherwise it behaves as map f x.

mapi [String]

mapi f s is like String.map but the index of the character is also passed to f.

mapi [StringLabels]

mapi ~f s is like StringLabels.map but the index of the character is also passed to f.

mapi [MoreLabels.Map.S]

Same as MoreLabels.Map.S.map, but the function receives as arguments both the key and the associated value for each binding of the map.

mapi [Map.S]

Same as Map.S.map, but the function receives as arguments both the key and the associated value for each binding of the map.

mapi [ListLabels]

Same as ListLabels.map, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.

mapi [List]

Same as List.map, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.

mapi [Float.ArrayLabels]

Same as Float.ArrayLabels.map, but the function is applied to the index of the element as first argument, and the element itself as second argument.

mapi [Float.Array]

Same as Float.Array.map, but the function is applied to the index of the element as first argument, and the element itself as second argument.

mapi [BytesLabels]

mapi ~f s calls f with each character of s and its index (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.

mapi [Bytes]

mapi f s calls f with each character of s and its index (in increasing index order) and stores the resulting bytes in a new sequence that is returned as the result.

mapi [ArrayLabels]

Same as ArrayLabels.map, but the function is applied to the index of the element as first argument, and the element itself as second argument.

mapi [Array]

Same as Array.map, but the function is applied to the index of the element as first argument, and the element itself as second argument.

marshal [Obj]
match_beginning [Str]

match_beginning() returns the position of the first character of the substring that was matched by the last call to a matching or searching function (see Str.matched_string for details).

match_end [Str]

match_end() returns the position of the character following the last character of the substring that was matched by the last call to a matching or searching function (see Str.matched_string for details).

matched_group [Str]

matched_group n s returns the substring of s that was matched by the nth group \(...\) of the regular expression that was matched by the last call to a matching or searching function (see Str.matched_string for details).

matched_string [Str]

matched_string s returns the substring of s that was matched by the last call to one of the following matching or searching functions: Str.string_match, Str.search_forward, Str.search_backward, Str.string_partial_match, Str.global_substitute, Str.substitute_first provided that none of the following functions was called in between: Str.global_replace, Str.replace_first, Str.split, Str.bounded_split, Str.split_delim, Str.bounded_split_delim, Str.full_split, Str.bounded_full_split Note: in the case of global_substitute and substitute_first, a call to matched_string is only valid within the subst argument, not after global_substitute or substitute_first returns.

max [Uchar]

max is U+10FFFF.

max [Stdlib]

Return the greater of the two arguments.

max [Nativeint]

Return the greater of the two arguments.

max [Int64]

Return the greater of the two arguments.

max [Int32]

Return the greater of the two arguments.

max [Int]

Return the greater of the two arguments.

max [Float]

max x y returns the maximum of x and y.

max_array_length [Sys]

Maximum length of a normal array (i.e.

max_binding [MoreLabels.Map.S]

Same as MoreLabels.Map.S.min_binding, but returns the binding with the largest key in the given map.

max_binding [Map.S]

Same as Map.S.min_binding, but returns the binding with the largest key in the given map.

max_binding_opt [MoreLabels.Map.S]

Same as MoreLabels.Map.S.min_binding_opt, but returns the binding with the largest key in the given map.

max_binding_opt [Map.S]

Same as Map.S.min_binding_opt, but returns the binding with the largest key in the given map.

max_elt [Set.S]

Same as Set.S.min_elt, but returns the largest element of the given set.

max_elt [MoreLabels.Set.S]

Same as MoreLabels.Set.S.min_elt, but returns the largest element of the given set.

max_elt_opt [Set.S]

Same as Set.S.min_elt_opt, but returns the largest element of the given set.

max_elt_opt [MoreLabels.Set.S]

Same as MoreLabels.Set.S.min_elt_opt, but returns the largest element of the given set.

max_ephe_length [Obj.Ephemeron]

Maximum length of an ephemeron, ie the maximum number of keys an ephemeron could contain

max_float [Stdlib]

The largest positive finite value of type float.

max_float [Float]

The largest positive finite value of type float.

max_floatarray_length [Sys]

Maximum length of a floatarray.

max_int [Stdlib]

The greatest representable integer.

max_int [Nativeint]

The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.

max_int [Int64]

The greatest representable 64-bit integer, 263 - 1.

max_int [Int32]

The greatest representable 32-bit integer, 231 - 1.

max_int [Int]

max_int is the greatest representable integer, 2{^[Sys.int_size - 1]} - 1.

max_num [Float]

max_num x y returns the maximum of x and y treating nan as missing values.

max_string_length [Sys]

Maximum length of strings and byte sequences.

mem [Weak.S]

mem t x returns true if there is at least one instance of x in t, false otherwise.

mem [Set.S]

mem x s tests whether x belongs to the set s.

mem [MoreLabels.Set.S]

mem x s tests whether x belongs to the set s.

mem [MoreLabels.Map.S]

mem x m returns true if m contains a binding for x, and false otherwise.

mem [MoreLabels.Hashtbl.SeededS]
mem [MoreLabels.Hashtbl.S]
mem [MoreLabels.Hashtbl]

Hashtbl.mem tbl x checks if x is bound in tbl.

mem [Map.S]

mem x m returns true if m contains a binding for x, and false otherwise.

mem [ListLabels]

mem a ~set is true if and only if a is equal to an element of set.

mem [List]

mem a set is true if and only if a is equal to an element of set.

mem [Hashtbl.SeededS]
mem [Hashtbl.S]
mem [Hashtbl]

Hashtbl.mem tbl x checks if x is bound in tbl.

mem [Float.ArrayLabels]

mem a ~set is true if and only if there is an element of set that is structurally equal to a, i.e.

mem [Float.Array]

mem a set is true if and only if there is an element of set that is structurally equal to a, i.e.

mem [ArrayLabels]

mem a ~set is true if and only if a is structurally equal to an element of l (i.e.

mem [Array]

mem a set is true if and only if a is structurally equal to an element of l (i.e.

mem_assoc [ListLabels]

Same as ListLabels.assoc, but simply return true if a binding exists, and false if no bindings exist for the given key.

mem_assoc [List]

Same as List.assoc, but simply return true if a binding exists, and false if no bindings exist for the given key.

mem_assq [ListLabels]

Same as ListLabels.mem_assoc, but uses physical equality instead of structural equality to compare keys.

mem_assq [List]

Same as List.mem_assoc, but uses physical equality instead of structural equality to compare keys.

mem_ieee [Float.ArrayLabels]

Same as Float.ArrayLabels.mem, but uses IEEE equality instead of structural equality.

mem_ieee [Float.Array]

Same as Float.Array.mem, but uses IEEE equality instead of structural equality.

memq [ListLabels]

Same as ListLabels.mem, but uses physical equality instead of structural equality to compare list elements.

memq [List]

Same as List.mem, but uses physical equality instead of structural equality to compare list elements.

memq [ArrayLabels]

Same as ArrayLabels.mem, but uses physical equality instead of structural equality to compare list elements.

memq [Array]

Same as Array.mem, but uses physical equality instead of structural equality to compare list elements.

merge [Weak.S]

merge t x returns an instance of x found in t if any, or else adds x to t and return x.

merge [MoreLabels.Map.S]

merge ~f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2.

merge [Map.S]

merge f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2.

merge [ListLabels]

Merge two lists: Assuming that l1 and l2 are sorted according to the comparison function cmp, merge ~cmp l1 l2 will return a sorted list containing all the elements of l1 and l2.

merge [List]

Merge two lists: Assuming that l1 and l2 are sorted according to the comparison function cmp, merge cmp l1 l2 will return a sorted list containing all the elements of l1 and l2.

min [Uchar]

min is U+0000.

min [Stdlib]

Return the smaller of the two arguments.

min [Nativeint]

Return the smaller of the two arguments.

min [Int64]

Return the smaller of the two arguments.

min [Int32]

Return the smaller of the two arguments.

min [Int]

Return the smaller of the two arguments.

min [Float]

min x y returns the minimum of x and y.

min_binding [MoreLabels.Map.S]

Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.

min_binding [Map.S]

Return the binding with the smallest key in a given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.

min_binding_opt [MoreLabels.Map.S]

Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.

min_binding_opt [Map.S]

Return the binding with the smallest key in the given map (with respect to the Ord.compare ordering), or None if the map is empty.

min_elt [Set.S]

Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.

min_elt [MoreLabels.Set.S]

Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.

min_elt_opt [Set.S]

Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.

min_elt_opt [MoreLabels.Set.S]

Return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty.

min_float [Stdlib]

The smallest positive, non-zero, non-denormalized value of type float.

min_float [Float]

The smallest positive, non-zero, non-denormalized value of type float.

min_int [Stdlib]

The smallest representable integer.

min_int [Nativeint]

The smallest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.

min_int [Int64]

The smallest representable 64-bit integer, -263.

min_int [Int32]

The smallest representable 32-bit integer, -231.

min_int [Int]

min_int is the smallest representable integer, -2{^[Sys.int_size - 1]}.

min_max [Float]

min_max x y is (min x y, max x y), just more efficient.

min_max_num [Float]

min_max_num x y is (min_num x y, max_num x y), just more efficient.

min_num [Float]

min_num x y returns the minimum of x and y treating nan as missing values.

minor [Gc]

Trigger a minor collection.

minor_words [Gc]

Number of words allocated in the minor heap 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 is the integer -1.

minus_one [Float]

The floating-point -1.

mkdir [UnixLabels]

Create a directory with the given permissions (see UnixLabels.umask).

mkdir [Unix]

Create a directory with the given permissions (see Unix.umask).

mkdir [Sys]

Create a directory with the given permissions.

mkfifo [UnixLabels]

Create a named pipe with the given permissions (see UnixLabels.umask).

mkfifo [Unix]

Create a named pipe with the given permissions (see Unix.umask).

mktime [UnixLabels]

Convert a date and time, specified by the tm argument, into a time in seconds, as returned by UnixLabels.time.

mktime [Unix]

Convert a date and time, specified by the tm argument, into a time in seconds, as returned by Unix.time.

mod_float [Stdlib]

mod_float a b returns the remainder of a with respect to b.

modf [Stdlib]

modf f returns the pair of the fractional and integral part of f.

modf [Float]

modf f returns the pair of the fractional and integral part of f.

mul [Nativeint]

Multiplication.

mul [Int64]

Multiplication.

mul [Int32]

Multiplication.

mul [Int]

mul x y is the multiplication x * y.

mul [Float]

Floating-point multiplication.

mul [Complex]

Multiplication

N
name [Printexc.Slot]

name slot returns the name of the function or definition enclosing the location referred to by the slot.

name [Obj.Extension_constructor]
name_of_input [Scanf.Scanning]

Scanning.name_of_input ic returns the name of the character source for the given Scanf.Scanning.in_channel formatted input channel.

nan [Stdlib]

A special floating-point value denoting the result of an undefined operation such as 0.0 /. 0.0.

nan [Float]

A special floating-point value denoting the result of an undefined operation such as 0.0 /. 0.0.

narrow [CamlinternalOO]
nativeint [Random.State]
nativeint [Random]

Random.nativeint bound returns a random integer between 0 (inclusive) and bound (exclusive).

nativeint [Bigarray]
neg [Nativeint]

Unary negation.

neg [Int64]

Unary negation.

neg [Int32]

Unary negation.

neg [Int]

neg x is ~-x.

neg [Float]

Unary negation.

neg [Complex]

Unary negation.

neg_infinity [Stdlib]

Negative infinity.

neg_infinity [Float]

Negative infinity.

negate [Fun]

negate p is the negation of the predicate function p.

new_block [Obj]
new_channel [Event]

Return a new channel.

new_line [Lexing]

Update the lex_curr_p field of the lexbuf to reflect the start of a new line.

new_method [CamlinternalOO]
new_methods_variables [CamlinternalOO]
new_variable [CamlinternalOO]
next [Stream]

Return the first element of the stream and remove it from the stream.

next_after [Float]

next_after x y returns the next representable floating-point value following x in the direction of y.

nice [UnixLabels]

Change the process priority.

nice [Unix]

Change the process priority.

no_scan_tag [Obj]
none [Option]

none is None.

norm [Complex]

Norm: given x + i.y, returns sqrt(x^2 + y^2).

norm2 [Complex]

Norm squared: given x + i.y, returns x^2 + y^2.

not [Stdlib]

The boolean negation.

not [Bool]

not b is the boolean negation of b.

npeek [Stream]

npeek n returns the list of the n first elements of the stream, or all its remaining elements if less than n elements are available.

nth [ListLabels]

Return the n-th element of the given list.

nth [List]

Return the n-th element of the given list.

nth [Buffer]

Get the n-th character of the buffer.

nth_dim [Bigarray.Genarray]

Genarray.nth_dim a n returns the n-th dimension of the Bigarray a.

nth_opt [ListLabels]

Return the n-th element of the given list.

nth_opt [List]

Return the n-th element of the given list.

null [Filename]

null is "/dev/null" on POSIX and "NUL" on Windows.

null_tracker [Gc.Memprof]

Default callbacks simply return None or ()

num_dims [Bigarray.Genarray]

Return the number of dimensions of the given Bigarray.

O
obj [Obj]
object_tag [Obj]
ocaml_version [Sys]

ocaml_version is the version of OCaml.

of_array [Bigarray.Array3]

Build a three-dimensional Bigarray initialized from the given array of arrays of arrays.

of_array [Bigarray.Array2]

Build a two-dimensional Bigarray initialized from the given array of arrays.

of_array [Bigarray.Array1]

Build a one-dimensional Bigarray initialized from the given array.

of_bytes [String]

Return a new string that contains the same bytes as the given byte sequence.

of_bytes [Stream]

Return the stream of the characters of the bytes parameter.

of_bytes [StringLabels]

Return a new string that contains the same bytes as the given byte sequence.

of_channel [Stream]

Return the stream of the characters read from the input channel.

of_char [Uchar]

of_char c is c as a Unicode character.

of_float [Nativeint]

Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0).

of_float [Int64]

Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0).

of_float [Int32]

Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0).

of_float [Int]

of_float x truncates x to an integer.

of_int [Uchar]

of_int i is i as a Unicode character.

of_int [Nativeint]

Convert the given integer (type int) to a native integer (type nativeint).

of_int [Int64]

Convert the given integer (type int) to a 64-bit integer (type int64).

of_int [Int32]

Convert the given integer (type int) to a 32-bit integer (type int32).

of_int [Float]

Convert an integer to floating-point.

of_int32 [Nativeint]

Convert the given 32-bit integer (type int32) to a native integer.

of_int32 [Int64]

Convert the given 32-bit integer (type int32) to a 64-bit integer (type int64).

of_list [Stream]

Return the stream holding the elements of the list in the same order.

of_list [Set.S]

of_list l creates a set from a list of elements.

of_list [MoreLabels.Set.S]

of_list l creates a set from a list of elements.

of_list [Float.ArrayLabels]

of_list l returns a fresh floatarray containing the elements of l.

of_list [Float.Array]

of_list l returns a fresh floatarray containing the elements of l.

of_list [ArrayLabels]

of_list l returns a fresh array containing the elements of l.

of_list [Array]

of_list l returns a fresh array containing the elements of l.

of_nativeint [Int64]

Convert the given native integer (type nativeint) to a 64-bit integer (type int64).

of_seq [String]

of_seq s is a string made of the sequence's characters.

of_seq [StringLabels]

of_seq s is a string made of the sequence's characters.

of_seq [Stack]

Create a stack from the sequence.

of_seq [Set.S]

Build a set from the given bindings

of_seq [Queue]

Create a queue from a sequence.

of_seq [MoreLabels.Set.S]

Build a set from the given bindings

of_seq [MoreLabels.Map.S]

Build a map from the given bindings

of_seq [MoreLabels.Hashtbl.SeededS]
of_seq [MoreLabels.Hashtbl.S]
of_seq [MoreLabels.Hashtbl]

Build a table from the given bindings.

of_seq [Map.S]

Build a map from the given bindings

of_seq [ListLabels]

Create a list from a sequence.

of_seq [List]

Create a list from a sequence.

of_seq [Hashtbl.SeededS]
of_seq [Hashtbl.S]
of_seq [Hashtbl]

Build a table from the given bindings.

of_seq [Float.ArrayLabels]

Create an array from the generator.

of_seq [Float.Array]

Create an array from the generator.

of_seq [BytesLabels]

Create a string from the generator

of_seq [Bytes]

Create a string from the generator

of_seq [Buffer]

Create a buffer from the generator

of_seq [ArrayLabels]

Create an array from the generator

of_seq [Array]

Create an array from the generator

of_string [Stream]

Return the stream of the characters of the string parameter.

of_string [Nativeint]

Convert the given string to a native integer.

of_string [Int64]

Convert the given string to a 64-bit integer.

of_string [Int32]

Convert the given string to a 32-bit integer.

of_string [Float]

Convert the given string to a float.

of_string [BytesLabels]

Return a new byte sequence that contains the same bytes as the given string.

of_string [Bytes]

Return a new byte sequence that contains the same bytes as the given string.

of_string_opt [Nativeint]

Same as of_string, but return None instead of raising.

of_string_opt [Int64]

Same as of_string, but return None instead of raising.

of_string_opt [Int32]

Same as of_string, but return None instead of raising.

of_string_opt [Float]

Same as of_string, but returns None instead of raising.

of_val [Obj.Extension_constructor]
of_value [Bigarray.Array0]

Build a zero-dimensional Bigarray initialized from the given value.

ok [Result]

ok v is Ok v.

one [Nativeint]

The native integer 1.

one [Int64]

The 64-bit integer 1.

one [Int32]

The 32-bit integer 1.

one [Int]

one is the integer 1.

one [Float]

The floating-point 1.

one [Complex]

The complex number 1.

opaque_identity [Sys]

For the purposes of optimization, opaque_identity behaves like an unknown (and thus possibly side-effecting) function.

open_box [Format]

pp_open_box ppf d opens a new compacting pretty-printing box with offset d in the formatter ppf.

open_box_of_string [CamlinternalFormat]
open_connection [UnixLabels]

Connect to a server at the given address.

open_connection [Unix]

Connect to a server at the given address.

open_connection [ThreadUnix]
open_hbox [Format]

pp_open_hbox ppf () opens a new 'horizontal' pretty-printing box.

open_hovbox [Format]

pp_open_hovbox ppf d opens a new 'horizontal-or-vertical' pretty-printing box with offset d.

open_hvbox [Format]

pp_open_hvbox ppf d opens a new 'horizontal/vertical' pretty-printing box with offset d.

open_in [Stdlib]

Open the named file for reading, and return a new input channel on that file, positioned at the beginning of the file.

open_in [Scanf.Scanning]

Scanning.open_in fname returns a Scanf.Scanning.in_channel formatted input channel for bufferized reading in text mode from file fname.

open_in_bin [Stdlib]

Same as open_in, but the file is opened in binary mode, so that no translation takes place during reads.

open_in_bin [Scanf.Scanning]

Scanning.open_in_bin fname returns a Scanf.Scanning.in_channel formatted input channel for bufferized reading in binary mode from file fname.

open_in_gen [Stdlib]

open_in_gen mode perm filename opens the named file for reading, as described above.

open_out [Stdlib]

Open the named file for writing, and return a new output channel on that file, positioned at the beginning of the file.

open_out_bin [Stdlib]

Same as open_out, but the file is opened in binary mode, so that no translation takes place during writes.

open_out_gen [Stdlib]

open_out_gen mode perm filename opens the named file for writing, as described above.

open_process [UnixLabels]

Same as UnixLabels.open_process_out, but redirects both the standard input and standard output of the command to pipes connected to the two returned channels.

open_process [Unix]

Same as Unix.open_process_out, but redirects both the standard input and standard output of the command to pipes connected to the two returned channels.

open_process [ThreadUnix]
open_process_args [UnixLabels]

Same as UnixLabels.open_process_args_out, but redirects both the standard input and standard output of the new process to pipes connected to the two returned channels.

open_process_args [Unix]

Same as Unix.open_process_args_out, but redirects both the standard input and standard output of the new process to pipes connected to the two returned channels.

open_process_args_full [UnixLabels]

Similar to UnixLabels.open_process_args, but the third argument specifies the environment passed to the new process.

open_process_args_full [Unix]

Similar to Unix.open_process_args, but the third argument specifies the environment passed to the new process.

open_process_args_in [UnixLabels]

open_process_args_in prog args runs the program prog with arguments args.

open_process_args_in [Unix]

open_process_args_in prog args runs the program prog with arguments args.

open_process_args_out [UnixLabels]

Same as UnixLabels.open_process_args_in, but redirect the standard input of the new process to a pipe.

open_process_args_out [Unix]

Same as Unix.open_process_args_in, but redirect the standard input of the new process to a pipe.

open_process_full [UnixLabels]

Similar to UnixLabels.open_process, but the second argument specifies the environment passed to the command.

open_process_full [Unix]

Similar to Unix.open_process, but the second argument specifies the environment passed to the command.

open_process_in [UnixLabels]

High-level pipe and process management.

open_process_in [Unix]

High-level pipe and process management.

open_process_in [ThreadUnix]
open_process_out [UnixLabels]

Same as UnixLabels.open_process_in, but redirect the standard input of the command to a pipe.

open_process_out [Unix]

Same as Unix.open_process_in, but redirect the standard input of the command to a pipe.

open_process_out [ThreadUnix]
open_stag [Format]

pp_open_stag ppf t opens the semantic tag named t.

open_tag [Format]
open_tbox [Format]

open_tbox () opens a new tabulation box.

open_temp_file [Filename]

Same as Filename.temp_file, but returns both the name of a fresh temporary file, and an output channel opened (atomically) on this file.

open_vbox [Format]

pp_open_vbox ppf d opens a new 'vertical' pretty-printing box with offset d.

opendir [UnixLabels]

Open a descriptor on a directory

opendir [Unix]

Open a descriptor on a directory

openfile [UnixLabels]

Open the named file with the given flags.

openfile [Unix]

Open the named file with the given flags.

os_type [Sys]

Operating system currently executing the OCaml program.

out_channel_length [Stdlib.LargeFile]
out_channel_length [Stdlib]

Return the size (number of characters) of the regular file on which the given channel is opened.

out_channel_of_descr [UnixLabels]

Create an output channel writing on the given descriptor.

out_channel_of_descr [Unix]

Create an output channel writing on the given descriptor.

out_of_heap_tag [Obj]
output [Stdlib]

output oc buf pos len writes len characters from byte sequence buf, starting at offset pos, to the given output channel oc.

output [Digest]

Write a digest on the given output channel.

output_acc [CamlinternalFormat]
output_binary_int [Stdlib]

Write one integer in binary format (4 bytes, big-endian) on the given output channel.

output_buffer [Buffer]

output_buffer oc b writes the current contents of buffer b on the output channel oc.

output_byte [Stdlib]

Write one 8-bit integer (as the single character with that code) on the given output channel.

output_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 but take a string as argument instead of a byte sequence.

output_value [Stdlib]

Write the representation of a structured value of any type to a channel.

over_max_boxes [Format]

Tests if the maximum number of pretty-printing boxes allowed have already been opened.

P
param_format_of_ignored_format [CamlinternalFormat]
params [CamlinternalOO]
parent_dir_name [Filename]

The conventional name for the parent of the current directory (e.g.

parse [Arg]

Arg.parse speclist anon_fun usage_msg parses the command line.

parse_and_expand_argv_dynamic [Arg]

Same as Arg.parse_argv_dynamic, except that the argv argument is a reference and may be updated during the parsing of Expand arguments.

parse_argv [Arg]

Arg.parse_argv ~current args speclist anon_fun usage_msg parses the array args as if it were the command line.

parse_argv_dynamic [Arg]

Same as Arg.parse_argv, except that the speclist argument is a reference and may be updated during the parsing.

parse_dynamic [Arg]

Same as Arg.parse, except that the speclist argument is a reference and may be updated during the parsing.

parse_expand [Arg]

Same as Arg.parse, except that the Expand arguments are allowed and the Arg.current reference is not updated.

partition [Set.S]

partition f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.

partition [MoreLabels.Set.S]

partition ~f s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate f, and s2 is the set of all the elements of s that do not satisfy f.

partition [MoreLabels.Map.S]

partition ~f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.

partition [Map.S]

partition f m returns a pair of maps (m1, m2), where m1 contains all the bindings of m that satisfy the predicate f, and m2 is the map with all the bindings of m that do not satisfy f.

partition [ListLabels]

partition ~f l returns a pair of lists (l1, l2), where l1 is the list of all the elements of l that satisfy the predicate f, and l2 is the list of all the elements of l that do not satisfy f.

partition [List]

partition f l returns a pair of lists (l1, l2), where l1 is the list of all the elements of l that satisfy the predicate f, and l2 is the list of all the elements of l that do not satisfy f.

partition_map [ListLabels]

partition_map f l returns a pair of lists (l1, l2) such that, for each element x of the input list l: if f x is Left y1, then y1 is in l1, and, if f x is Right y2, then y2 is in l2. The output elements are included in l1 and l2 in the same relative order as the corresponding input elements in l.

partition_map [List]

partition_map f l returns a pair of lists (l1, l2) such that, for each element x of the input list l: if f x is Left y1, then y1 is in l1, and, if f x is Right y2, then y2 is in l2. The output elements are included in l1 and l2 in the same relative order as the corresponding input elements in l.

pause [UnixLabels]

Wait until a non-ignored, non-blocked signal is delivered.

pause [Unix]

Wait until a non-ignored, non-blocked signal is delivered.

peek [Stream]

Return Some of "the first element" of the stream, or None if the stream is empty.

peek [Queue]

peek q returns the first element in queue q, without removing it from the queue, or raises Queue.Empty if the queue is empty.

peek_opt [Queue]

peek_opt q returns the first element in queue q, without removing it from the queue, or returns None if the queue is empty.

pi [Float]

The constant pi.

pipe [UnixLabels]

Create a pipe.

pipe [Unix]

Create a pipe.

pipe [ThreadUnix]
polar [Complex]

polar norm arg returns the complex having norm norm and argument arg.

poll [Event]

Non-blocking version of Event.sync: offer all the communication possibilities specified in the event to the outside world, and if one can take place immediately, perform it and return Some r where r is the result value of that communication.

pop [Stack]

pop s removes and returns the topmost element in stack s, or raises Stack.Empty if the stack is empty.

pop [Queue]

pop is a synonym for take.

pop_opt [Stack]

pop_opt s removes and returns the topmost element in stack s, or returns None if the stack is empty.

pos_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_bytes [Format]
pp_print_char [Format]
pp_print_custom_break [Format]

pp_print_custom_break ppf ~fits:(s1, n, s2) ~breaks:(s3, m, s4) emits a custom break hint: the pretty-printer may split the line at this point.

pp_print_cut [Format]
pp_print_either [Format]

pp_print_either ~left ~right ppf e prints e on ppf using left if e is Either.Left _ and right if e is Either.Right _.

pp_print_float [Format]
pp_print_flush [Format]
pp_print_if_newline [Format]
pp_print_int [Format]
pp_print_list [Format]

pp_print_list ?pp_sep pp_v ppf l prints items of list l, using pp_v to print each item, and calling pp_sep between items (pp_sep defaults to Format.pp_print_cut.

pp_print_newline [Format]
pp_print_option [Format]

pp_print_option ?none pp_v ppf o prints o on ppf using pp_v if o is Some v and none if it is None.

pp_print_result [Format]

pp_print_result ~ok ~error ppf r prints r on ppf using ok if r is Ok _ and error if r is Error _.

pp_print_seq [Format]

pp_print_seq ?pp_sep pp_v ppf s prints items of sequence s, using pp_v to print each item, and calling pp_sep between items (pp_sep defaults to Format.pp_print_cut.

pp_print_space [Format]
pp_print_string [Format]
pp_print_tab [Format]
pp_print_tbreak [Format]
pp_print_text [Format]

pp_print_text ppf s prints s with spaces and newlines respectively printed using Format.pp_print_space and Format.pp_force_newline.

pp_safe_set_geometry [Format]
pp_set_all_formatter_output_functions [Format]
pp_set_ellipsis_text [Format]
pp_set_formatter_out_channel [Format]

Redirecting the standard formatter output

pp_set_formatter_out_functions [Format]
pp_set_formatter_output_functions [Format]
pp_set_formatter_stag_functions [Format]
pp_set_formatter_tag_functions [Format]

This function will erase non-string tag formatting functions.

pp_set_geometry [Format]
pp_set_margin [Format]
pp_set_mark_tags [Format]
pp_set_max_boxes [Format]
pp_set_max_indent [Format]
pp_set_print_tags [Format]
pp_set_tab [Format]
pp_set_tags [Format]
pp_update_geometry [Format]

pp_update_geometry ppf (fun geo -> { geo with ... }) lets you update a formatter's geometry in a way that is robust to extension of the geometry record with new fields.

pred [Uchar]

pred u is the scalar value before u in the set of Unicode scalar values.

pred [Stdlib]

pred x is x - 1.

pred [Nativeint]

Predecessor.

pred [Int64]

Predecessor.

pred [Int32]

Predecessor.

pred [Int]

pred x is sub x 1.

pred [Float]

pred x returns the floating-point number right before x i.e., the greatest floating-point number smaller than x.

prerr_bytes [Stdlib]

Print a byte sequence on standard error.

prerr_char [Stdlib]

Print a character on standard error.

prerr_endline [Stdlib]

Print a string, followed by a newline character on standard error and flush standard error.

prerr_float [Stdlib]

Print a floating-point number, in decimal, on standard error.

prerr_int [Stdlib]

Print an integer, in decimal, on standard error.

prerr_newline [Stdlib]

Print a newline character on standard error, and flush standard error.

prerr_string [Stdlib]

Print a string on standard error.

print [Printexc]

Printexc.print fn x applies fn to x and returns the result.

print_as [Format]

pp_print_as ppf len s prints s in the current pretty-printing box.

print_backtrace [Printexc]

Printexc.print_backtrace oc prints an exception backtrace on the output channel oc.

print_bool [Format]

Print a boolean in the current pretty-printing box.

print_break [Format]

pp_print_break ppf nspaces offset emits a 'full' break hint: the pretty-printer may split the line at this point, otherwise it prints nspaces spaces.

print_bytes [Stdlib]

Print a byte sequence on standard output.

print_bytes [Format]

pp_print_bytes ppf b prints b in the current pretty-printing box.

print_char [Stdlib]

Print a character on standard output.

print_char [Format]

Print a character in the current pretty-printing box.

print_cut [Format]

pp_print_cut ppf () emits a 'cut' break hint: the pretty-printer may split the line at this point, otherwise it prints nothing.

print_endline [Stdlib]

Print a string, followed by a newline character, on standard output and flush standard output.

print_float [Stdlib]

Print a floating-point number, in decimal, on standard output.

print_float [Format]

Print a floating point number in the current pretty-printing box.

print_flush [Format]

End of pretty-printing: resets the pretty-printer to initial state.

print_if_newline [Format]

Execute the next formatting command if the preceding line has just been split.

print_int [Stdlib]

Print an integer, in decimal, on standard output.

print_int [Format]

Print an integer in the current pretty-printing box.

print_newline [Stdlib]

Print a newline character on standard output, and flush standard output.

print_newline [Format]

End of pretty-printing: resets the pretty-printer to initial state.

print_raw_backtrace [Printexc]

Print a raw backtrace in the same format Printexc.print_backtrace uses.

print_space [Format]

pp_print_space ppf () emits a 'space' break hint: the pretty-printer may split the line at this point, otherwise it prints one space.

print_stat [Gc]

Print the current values of the memory management counters (in human-readable form) into the channel argument.

print_string [Stdlib]

Print a string on standard output.

print_string [Format]

pp_print_string ppf s prints s in the current pretty-printing box.

print_tab [Format]

print_tab () emits a 'next' tabulation break hint: if not already set on a tabulation marker, the insertion point moves to the first tabulation marker on the right, or the pretty-printer splits the line and insertion point moves to the leftmost tabulation marker.

print_tbreak [Format]

print_tbreak nspaces offset emits a 'full' tabulation break hint.

printf [Printf]

Same as Printf.fprintf, but output on stdout.

printf [Format]

Same as fprintf above, but output on std_formatter.

process_full_pid [UnixLabels]

Return the pid of a process opened via UnixLabels.open_process_full or UnixLabels.open_process_args_full.

process_full_pid [Unix]

Return the pid of a process opened via Unix.open_process_full or Unix.open_process_args_full.

process_in_pid [UnixLabels]

Return the pid of a process opened via UnixLabels.open_process_in or UnixLabels.open_process_args_in.

process_in_pid [Unix]

Return the pid of a process opened via Unix.open_process_in or Unix.open_process_args_in.

process_out_pid [UnixLabels]

Return the pid of a process opened via UnixLabels.open_process_out or UnixLabels.open_process_args_out.

process_out_pid [Unix]

Return the pid of a process opened via Unix.open_process_out or Unix.open_process_args_out.

process_pid [UnixLabels]

Return the pid of a process opened via UnixLabels.open_process or UnixLabels.open_process_args.

process_pid [Unix]

Return the pid of a process opened via Unix.open_process or Unix.open_process_args.

prohibit [Dynlink]

prohibit units prohibits dynamically-linked units from referencing the units named in list units by removing such units from the allowed units list.

protect [Fun]

protect ~finally work invokes work () and then finally () before work () returns with its value or an exception.

public_dynamically_loaded_units [Dynlink]

Return the list of compilation units that have been dynamically loaded via loadfile (and not via loadfile_private).

public_method_label [CamlinternalOO]
push [Stack]

push x s adds the element x at the top of stack s.

push [Queue]

push is a synonym for add.

putenv [UnixLabels]

putenv name value sets the value associated to a variable in the process environment.

putenv [Unix]

putenv name value sets the value associated to a variable in the process environment.

Q
quick_stat [Gc]

Same as stat except that live_words, live_blocks, free_words, free_blocks, largest_free, and fragments are set to 0.

quote [Str]

Str.quote s returns a regexp string that matches exactly s and nothing else.

quote [Filename]

Return a quoted version of a file name, suitable for use as one argument in a command line, escaping all meta-characters.

quote_command [Filename]

quote_command cmd args returns a quoted command line, suitable for use as an argument to Sys.command, Unix.system, and the Unix.open_process functions.

R
raise [Stdlib]

Raise the given exception value

raise_notrace [Stdlib]

A faster version raise which does not record the backtrace.

raise_with_backtrace [Printexc]

Reraise the exception using the given raw_backtrace for the origin of the exception

randomize [MoreLabels.Hashtbl]

After a call to Hashtbl.randomize(), hash tables are created in randomized mode by default: MoreLabels.Hashtbl.create returns randomized hash tables, unless the ~random:false optional parameter is given.

randomize [Hashtbl]

After a call to Hashtbl.randomize(), hash tables are created in randomized mode by default: Hashtbl.create returns randomized hash tables, unless the ~random:false optional parameter is given.

raw_backtrace_entries [Printexc]
raw_backtrace_length [Printexc]

raw_backtrace_length bckt returns the number of slots in the backtrace bckt.

raw_backtrace_to_string [Printexc]

Return a string from a raw backtrace, in the same format Printexc.get_backtrace uses.

raw_field [Obj]
rcontains_from [String]

rcontains_from s stop c is true if and only if c appears in s before position stop+1.

rcontains_from [StringLabels]

rcontains_from s stop c is true if and only if c appears in s before position stop+1.

rcontains_from [BytesLabels]

rcontains_from s stop c tests if byte c appears in s before position stop+1.

rcontains_from [Bytes]

rcontains_from s stop c tests if byte c appears in s before position stop+1.

reachable_words [Obj]

Computes the total size (in words, including the headers) of all heap blocks accessible from the argument.

read [UnixLabels]

read fd ~buf ~pos ~len reads len bytes from descriptor fd, storing them in byte sequence buf, starting at position pos in buf.

read [Unix]

read fd buf pos len reads len bytes from descriptor fd, storing them in byte sequence buf, starting at position pos in buf.

read [ThreadUnix]
read_arg [Arg]

Arg.read_arg file reads newline-terminated command line arguments from file file.

read_arg0 [Arg]

Identical to Arg.read_arg but assumes null character terminated command line arguments.

read_float [Stdlib]

Same as read_float_opt, but raise Failure "float_of_string" instead of returning None.

read_float_opt [Stdlib]

Flush standard output, then read one line from standard input and convert it to a floating-point number.

read_int [Stdlib]

Same as read_int_opt, but raise Failure "int_of_string" instead of returning None.

read_int_opt [Stdlib]

Flush standard output, then read one line from standard input and convert it to an integer.

read_line [Stdlib]

Flush standard output, then read characters from standard input until a newline character is encountered.

readdir [UnixLabels]

Return the next entry in a directory.

readdir [Unix]

Return the next entry in a directory.

readdir [Sys]

Return the names of all files present in the given directory.

readlink [UnixLabels]

Read the contents of a symbolic link.

readlink [Unix]

Read the contents of a symbolic link.

really_input [Stdlib]

really_input ic buf pos len reads len characters from channel ic, storing them in byte sequence buf, starting at character number pos.

really_input_string [Stdlib]

really_input_string ic len reads len characters from channel ic and returns them in a new string.

realpath [UnixLabels]

realpath p is an absolute pathname for p obtained by resolving all extra / characters, relative path segments and symbolic links.

realpath [Unix]

realpath p is an absolute pathname for p obtained by resolving all extra / characters, relative path segments and symbolic links.

rebuild [MoreLabels.Hashtbl]

Return a copy of the given hashtable.

rebuild [Hashtbl]

Return a copy of the given hashtable.

recast [CamlinternalFormat]
receive [Event]

receive ch returns the event consisting in receiving a value from the channel ch.

record_backtrace [Printexc]

Printexc.record_backtrace b turns recording of exception backtraces on (if b = true) or off (if b = false).

recv [UnixLabels]

Receive data from a connected socket.

recv [Unix]

Receive data from a connected socket.

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, but the compiled expression will match text in a case-insensitive way: uppercase and lowercase letters will be considered equivalent.

regexp_string [Str]

Str.regexp_string s returns a regular expression that matches exactly s and nothing else.

regexp_string_case_fold [Str]

Str.regexp_string_case_fold is similar to Str.regexp_string, but the regexp matches in a case-insensitive way.

register [Callback]

Callback.register n v registers the value v under the name n.

register_exception [Callback]

Callback.register_exception n exn registers the exception contained in the exception value exn under the name n.

register_printer [Printexc]

Printexc.register_printer fn registers fn as an exception printer.

release [Semaphore.Binary]

release s sets the value of semaphore s to 1, putting it in the "available" state.

release [Semaphore.Counting]

release s increments the value of semaphore s.

rem [Nativeint]

Integer remainder.

rem [Int64]

Integer remainder.

rem [Int32]

Integer remainder.

rem [Int]

rem x y is the remainder mod y.

rem [Float]

rem a b returns the remainder of a with respect to b.

remove [Weak.S]

remove t x removes from t one instance of x.

remove [Sys]

Remove the given file name from the file system.

remove [Set.S]

remove x s returns a set containing all elements of s, except x.

remove [MoreLabels.Set.S]

remove x s returns a set containing all elements of s, except x.

remove [MoreLabels.Map.S]

remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map.

remove [MoreLabels.Hashtbl.SeededS]
remove [MoreLabels.Hashtbl.S]
remove [MoreLabels.Hashtbl]

Hashtbl.remove tbl x removes the current binding of x in tbl, restoring the previous binding if it exists.

remove [Map.S]

remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map.

remove [Hashtbl.SeededS]
remove [Hashtbl.S]
remove [Hashtbl]

Hashtbl.remove tbl x removes the current binding of x in tbl, restoring the previous binding if it exists.

remove_assoc [ListLabels]

remove_assoc a l returns the list of pairs l without the first pair with key a, if any.

remove_assoc [List]

remove_assoc a l returns the list of pairs l without the first pair with key a, if any.

remove_assq [ListLabels]

Same as ListLabels.remove_assoc, but uses physical equality instead of structural equality to compare keys.

remove_assq [List]

Same as List.remove_assoc, but uses physical equality instead of structural equality to compare keys.

remove_extension [Filename]

Return the given file name without its extension, as defined in Filename.extension.

rename [UnixLabels]

rename ~src ~dst changes the name of a file from src to dst, moving it between directories if needed.

rename [Unix]

rename src dst changes the name of a file from src to dst, moving it between directories if needed.

rename [Sys]

Rename a file.

rep [Uchar]

rep is U+FFFD, the replacement character.

replace [MoreLabels.Hashtbl.SeededS]
replace [MoreLabels.Hashtbl.S]
replace [MoreLabels.Hashtbl]

Hashtbl.replace tbl ~key ~data replaces the current binding of key in tbl by a binding of key to data.

replace [Hashtbl.SeededS]
replace [Hashtbl.S]
replace [Hashtbl]

Hashtbl.replace tbl key data replaces the current binding of key in tbl by a binding of key to data.

replace_first [Str]

Same as Str.global_replace, except that only the first substring matching the regular expression is replaced.

replace_matched [Str]

replace_matched repl s returns the replacement text repl in which \1, \2, etc.

replace_seq [MoreLabels.Hashtbl.SeededS]
replace_seq [MoreLabels.Hashtbl.S]
replace_seq [MoreLabels.Hashtbl]

Add the given bindings to the table, using MoreLabels.Hashtbl.replace

replace_seq [Hashtbl.SeededS]
replace_seq [Hashtbl.S]
replace_seq [Hashtbl]

Add the given bindings to the table, using Hashtbl.replace

repr [Sys.Immediate64.Make]
repr [Obj]
reset [MoreLabels.Hashtbl.SeededS]
reset [MoreLabels.Hashtbl.S]
reset [MoreLabels.Hashtbl]

Empty a hash table and shrink the size of the bucket table to its initial size.

reset [Hashtbl.SeededS]
reset [Hashtbl.S]
reset [Hashtbl]

Empty a hash table and shrink the size of the bucket table to its initial size.

reset [Buffer]

Empty the buffer and deallocate the internal byte sequence holding the buffer contents, replacing it with the initial internal byte sequence of length n that was allocated by Buffer.create n.

reshape [Bigarray]

reshape b [|d1;...;dN|] converts the Bigarray b to a N-dimensional array of dimensions d1...

reshape_0 [Bigarray]

Specialized version of Bigarray.reshape for reshaping to zero-dimensional arrays.

reshape_1 [Bigarray]

Specialized version of Bigarray.reshape for reshaping to one-dimensional arrays.

reshape_2 [Bigarray]

Specialized version of Bigarray.reshape for reshaping to two-dimensional arrays.

reshape_3 [Bigarray]

Specialized version of Bigarray.reshape for reshaping to three-dimensional arrays.

return [Seq]

The singleton sequence containing only the given element.

rev [ListLabels]

List reversal.

rev [List]

List reversal.

rev_append [ListLabels]

rev_append l1 l2 reverses l1 and concatenates it with l2.

rev_append [List]

rev_append l1 l2 reverses l1 and concatenates it with l2.

rev_char_set [CamlinternalFormat]
rev_map [ListLabels]

rev_map ~f l gives the same result as ListLabels.rev (ListLabels.map f l), but is tail-recursive and more efficient.

rev_map [List]

rev_map f l gives the same result as List.rev (List.map f l), but is tail-recursive and more efficient.

rev_map2 [ListLabels]

rev_map2 ~f l1 l2 gives the same result as ListLabels.rev (ListLabels.map2 f l1 l2), but is tail-recursive and more efficient.

rev_map2 [List]

rev_map2 f l1 l2 gives the same result as List.rev (List.map2 f l1 l2), but is tail-recursive and more efficient.

rewinddir [UnixLabels]

Reposition the descriptor to the beginning of the directory

rewinddir [Unix]

Reposition the descriptor to the beginning of the directory

rhs_end [Parsing]
rhs_end_pos [Parsing]

Same as rhs_end, but return a position instead of an offset.

rhs_start [Parsing]

Same as Parsing.symbol_start and Parsing.symbol_end, but return the offset of the string matching the nth item on the right-hand side of the rule, where n is the integer parameter to rhs_start and rhs_end.

rhs_start_pos [Parsing]

Same as rhs_start, but return a position instead of an offset.

right [Either]

right v is Right v.

rindex [String]

rindex s c is String.rindex_from s (length s - 1) c.

rindex [StringLabels]

rindex s c is String.rindex_from s (length s - 1) c.

rindex [BytesLabels]

rindex s c returns the index of the last occurrence of byte c in s.

rindex [Bytes]

rindex s c returns the index of the last occurrence of byte c in s.

rindex_from [String]

rindex_from s i c is the index of the last occurrence of c in s before position i+1.

rindex_from [StringLabels]

rindex_from s i c is the index of the last occurrence of c in s before position i+1.

rindex_from [BytesLabels]

rindex_from s i c returns the index of the last occurrence of byte c in s before position i+1.

rindex_from [Bytes]

rindex_from s i c returns the index of the last occurrence of byte c in s before position i+1.

rindex_from_opt [String]

rindex_from_opt s i c is the index of the last occurrence of c in s before position i+1 (if any).

rindex_from_opt [StringLabels]

rindex_from_opt s i c is the index of the last occurrence of c in s before position i+1 (if any).

rindex_from_opt [BytesLabels]

rindex_from_opt s i c returns the index of the last occurrence of byte c in s before position i+1 or None if c does not occur in s before position i+1.

rindex_from_opt [Bytes]

rindex_from_opt s i c returns the index of the last occurrence of byte c in s before position i+1 or None if c does not occur in s before position i+1.

rindex_opt [String]

rindex_opt s c is String.rindex_from_opt s (length s - 1) c.

rindex_opt [StringLabels]

rindex_opt s c is String.rindex_from_opt s (length s - 1) c.

rindex_opt [BytesLabels]

rindex_opt s c returns the index of the last occurrence of byte c in s or None if c does not occur in s.

rindex_opt [Bytes]

rindex_opt s c returns the index of the last occurrence of byte c in s or None if c does not occur in s.

rmdir [UnixLabels]

Remove an empty directory.

rmdir [Unix]

Remove an empty directory.

rmdir [Sys]

Remove an empty directory.

round [Float]

round x rounds x to the nearest integer with ties (fractional values of 0.5) rounded away from zero, regardless of the current rounding direction.

run_initializers [CamlinternalOO]
run_initializers_opt [CamlinternalOO]
runtime_parameters [Sys]

Return the value of the runtime parameters, in the same format as the contents of the OCAMLRUNPARAM environment variable.

runtime_variant [Sys]

Return the name of the runtime variant the program is running on.

runtime_warnings_enabled [Sys]

Return whether runtime warnings are currently enabled.

S
safe_set_geometry [Format]

pp_set_geometry ppf ~max_indent ~margin sets both the margin and maximum indentation limit for ppf.

scanf [Scanf]

Same as Scanf.bscanf, but reads from the predefined formatted input channel Scanf.Scanning.stdin that is connected to stdin.

search_backward [Str]

search_backward r s last searches the string s for a substring matching the regular expression r.

search_forward [Str]

search_forward r s start searches the string s for a substring matching the regular expression r.

seeded_hash [MoreLabels.Hashtbl]

A variant of MoreLabels.Hashtbl.hash that is further parameterized by an integer seed.

seeded_hash [Hashtbl]

A variant of Hashtbl.hash that is further parameterized by an integer seed.

seeded_hash_param [MoreLabels.Hashtbl]

A variant of MoreLabels.Hashtbl.hash_param that is further parameterized by an integer seed.

seeded_hash_param [Hashtbl]

A variant of Hashtbl.hash_param that is further parameterized by an integer seed.

seek_in [Stdlib.LargeFile]
seek_in [Stdlib]

seek_in chan pos sets the current reading position to pos for channel chan.

seek_out [Stdlib.LargeFile]
seek_out [Stdlib]

seek_out chan pos sets the current writing position to pos for channel chan.

select [UnixLabels]

Wait until some input/output operations become possible on some channels.

select [Unix]

Wait until some input/output operations become possible on some channels.

select [ThreadUnix]
select [Thread]

Same function as Unix.select.

select [Event]

'Synchronize' on an alternative of events.

self [Thread]

Return the handle for the thread currently executing.

self_init [Random]

Initialize the generator with a random seed chosen in a system-dependent way.

send [CamlinternalOO]
send [UnixLabels]

Send data over a connected socket.

send [Unix]

Send data over a connected socket.

send [ThreadUnix]
send [Event]

send ch v returns the event consisting in sending the value v over the channel ch.

send_substring [UnixLabels]

Same as send, but take the data from a string instead of a byte sequence.

send_substring [Unix]

Same as send, but take the data from a string instead of a byte sequence.

send_substring [ThreadUnix]
sendcache [CamlinternalOO]
sendself [CamlinternalOO]
sendto [UnixLabels]

Send data over an unconnected socket.

sendto [Unix]

Send data over an unconnected socket.

sendto [ThreadUnix]
sendto_substring [UnixLabels]

Same as sendto, but take the data from a string instead of a byte sequence.

sendto_substring [Unix]

Same as sendto, but take the data from a string instead of a byte sequence.

sendto_substring [ThreadUnix]
set [CamlinternalAtomic]
set [Weak]

Weak.set ar n (Some el) sets the nth cell of ar to be a (full) pointer to el; Weak.set ar n None sets the nth cell of ar to empty.

set [String]

set s n c modifies byte sequence s in place, replacing the byte at index n with c.

set [StringLabels]

set s n c modifies byte sequence s in place, replacing the byte at index n with c.

set [Gc]

set r changes the GC parameters according to the control record r.

set [Float.ArrayLabels]

set a n x modifies floatarray a in place, replacing element number n with x.

set [Float.Array]

set a n x modifies floatarray a in place, replacing element number n with x.

set [BytesLabels]

set s n c modifies s in place, replacing the byte at index n with c.

set [Bytes]

set s n c modifies s in place, replacing the byte at index n with c.

set [Bigarray.Array3]

Array3.set a x y v, or alternatively a.{x,y,z} <- v, stores the value v at coordinates (x, y, z) in a.

set [Bigarray.Array2]

Array2.set a x y v, or alternatively a.{x,y} <- v, stores the value v at coordinates (x, y) in a.

set [Bigarray.Array1]

Array1.set a x v, also written a.{x} <- v, stores the value v at index x in a.

set [Bigarray.Array0]

Array0.set a x v stores the value v in a.

set [Bigarray.Genarray]

Assign an element of a generic Bigarray.

set [Atomic]

Set a new value for the atomic reference.

set [ArrayLabels]

set a n x modifies array a in place, replacing element number n with x.

set [Array]

set a n x modifies array a in place, replacing element number n with x.

set_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_in ic true sets the channel ic to binary mode: no translations take place during input.

set_binary_mode_out [Stdlib]

set_binary_mode_out oc true sets the channel oc to binary mode: no translations take place during output.

set_close_on_exec [UnixLabels]

Set the ``close-on-exec'' flag on the given descriptor.

set_close_on_exec [Unix]

Set the ``close-on-exec'' flag on the given descriptor.

set_data [Obj.Ephemeron]
set_data [Ephemeron.Kn]
set_data [Ephemeron.K2]
set_data [Ephemeron.K1]

Ephemeron.K1.set_data eph el sets the data of eph to be a (full) data to el

set_double_field [Obj]
set_ellipsis_text [Format]

Set the text of the ellipsis printed when too many pretty-printing boxes are open (a single dot, ., by default).

set_field [Obj]

When using flambda:

set_filename [Lexing]

Set filename in the initial tracked position to file in lexbuf.

set_formatter_out_channel [Format]

Redirect the standard pretty-printer output to the given channel.

set_formatter_out_functions [Format]

pp_set_formatter_out_functions ppf out_funs Set all the pretty-printer output functions of ppf to those of argument out_funs,

set_formatter_output_functions [Format]

pp_set_formatter_output_functions ppf out flush redirects the standard pretty-printer output functions to the functions out and flush.

set_formatter_stag_functions [Format]

pp_set_formatter_stag_functions ppf tag_funs changes the meaning of opening and closing semantic tag operations to use the functions in tag_funs when printing on ppf.

set_formatter_tag_functions [Format]
set_geometry [Format]
set_int16_be [BytesLabels]

set_int16_be b i v sets b's big-endian signed 16-bit integer starting at byte index i to v.

set_int16_be [Bytes]

set_int16_be b i v sets b's big-endian signed 16-bit integer starting at byte index i to v.

set_int16_le [BytesLabels]

set_int16_le b i v sets b's little-endian signed 16-bit integer starting at byte index i to v.

set_int16_le [Bytes]

set_int16_le b i v sets b's little-endian signed 16-bit integer starting at byte index i to v.

set_int16_ne [BytesLabels]

set_int16_ne b i v sets b's native-endian signed 16-bit integer starting at byte index i to v.

set_int16_ne [Bytes]

set_int16_ne b i v sets b's native-endian signed 16-bit integer starting at byte index i to v.

set_int32_be [BytesLabels]

set_int32_be b i v sets b's big-endian 32-bit integer starting at byte index i to v.

set_int32_be [Bytes]

set_int32_be b i v sets b's big-endian 32-bit integer starting at byte index i to v.

set_int32_le [BytesLabels]

set_int32_le b i v sets b's little-endian 32-bit integer starting at byte index i to v.

set_int32_le [Bytes]

set_int32_le b i v sets b's little-endian 32-bit integer starting at byte index i to v.

set_int32_ne [BytesLabels]

set_int32_ne b i v sets b's native-endian 32-bit integer starting at byte index i to v.

set_int32_ne [Bytes]

set_int32_ne b i v sets b's native-endian 32-bit integer starting at byte index i to v.

set_int64_be [BytesLabels]

set_int64_be b i v sets b's big-endian 64-bit integer starting at byte index i to v.

set_int64_be [Bytes]

set_int64_be b i v sets b's big-endian 64-bit integer starting at byte index i to v.

set_int64_le [BytesLabels]

set_int64_le b i v sets b's little-endian 64-bit integer starting at byte index i to v.

set_int64_le [Bytes]

set_int64_le b i v sets b's little-endian 64-bit integer starting at byte index i to v.

set_int64_ne [BytesLabels]

set_int64_ne b i v sets b's native-endian 64-bit integer starting at byte index i to v.

set_int64_ne [Bytes]

set_int64_ne b i v sets b's native-endian 64-bit integer starting at byte index i to v.

set_int8 [BytesLabels]

set_int8 b i v sets b's signed 8-bit integer starting at byte index i to v.

set_int8 [Bytes]

set_int8 b i v sets b's signed 8-bit integer starting at byte index i to v.

set_key [Obj.Ephemeron]
set_key [Ephemeron.Kn]
set_key [Ephemeron.K1]

Ephemeron.K1.set_key eph el sets the key of eph to be a (full) key to el

set_key1 [Ephemeron.K2]
set_key2 [Ephemeron.K2]
set_margin [Format]

pp_set_margin ppf d sets the right margin to d (in characters): the pretty-printer splits lines that overflow the right margin according to the break hints given.

set_mark_tags [Format]

pp_set_mark_tags ppf b turns on or off the tag-marking operations.

set_max_boxes [Format]

pp_set_max_boxes ppf max sets the maximum number of pretty-printing boxes simultaneously open.

set_max_indent [Format]

pp_set_max_indent ppf d sets the maximum indentation limit of lines to d (in characters): once this limit is reached, new pretty-printing boxes are rejected to the left, unless the enclosing box fully fits on the current line.

set_method [CamlinternalOO]
set_methods [CamlinternalOO]
set_nonblock [UnixLabels]

Set the ``non-blocking'' flag on the given descriptor.

set_nonblock [Unix]

Set the ``non-blocking'' flag on the given descriptor.

set_position [Lexing]

Set the initial tracked input position for lexbuf to a custom value.

set_print_tags [Format]

pp_set_print_tags ppf b turns on or off the tag-printing operations.

set_raw_field [Obj]
set_signal [Sys]

Same as Sys.signal but return value is ignored.

set_state [Random]

Set the state of the generator used by the basic functions.

set_tab [Format]

Sets a tabulation marker at current insertion point.

set_tag [Obj]
set_tags [Format]

pp_set_tags ppf b turns on or off the treatment of semantic tags (default is off).

set_temp_dir_name [Filename]

Change the temporary directory returned by Filename.get_temp_dir_name and used by Filename.temp_file and Filename.open_temp_file.

set_trace [Parsing]

Control debugging support for ocamlyacc-generated parsers.

set_uint16_be [BytesLabels]

set_uint16_be b i v sets b's big-endian unsigned 16-bit integer starting at byte index i to v.

set_uint16_be [Bytes]

set_uint16_be b i v sets b's big-endian unsigned 16-bit integer starting at byte index i to v.

set_uint16_le [BytesLabels]

set_uint16_le b i v sets b's little-endian unsigned 16-bit integer starting at byte index i to v.

set_uint16_le [Bytes]

set_uint16_le b i v sets b's little-endian unsigned 16-bit integer starting at byte index i to v.

set_uint16_ne [BytesLabels]

set_uint16_ne b i v sets b's native-endian unsigned 16-bit integer starting at byte index i to v.

set_uint16_ne [Bytes]

set_uint16_ne b i v sets b's native-endian unsigned 16-bit integer starting at byte index i to v.

set_uint8 [BytesLabels]

set_uint8 b i v sets b's unsigned 8-bit integer starting at byte index i to v.

set_uint8 [Bytes]

set_uint8 b i v sets b's unsigned 8-bit integer starting at byte index i to v.

set_uncaught_exception_handler [Printexc]

Printexc.set_uncaught_exception_handler fn registers fn as the handler for uncaught exceptions.

setgid [UnixLabels]

Set the real group id and effective group id for the process.

setgid [Unix]

Set the real group id and effective group id for the process.

setgroups [UnixLabels]

setgroups groups sets the supplementary group IDs for the calling process.

setgroups [Unix]

setgroups groups sets the supplementary group IDs for the calling process.

setitimer [UnixLabels]

setitimer t s sets the interval timer t and returns its previous status.

setitimer [Unix]

setitimer t s sets the interval timer t and returns its previous status.

setsid [UnixLabels]

Put the calling process in a new session and detach it from its controlling terminal.

setsid [Unix]

Put the calling process in a new session and detach it from its controlling terminal.

setsockopt [UnixLabels]

Set or clear a boolean-valued option in the given socket.

setsockopt [Unix]

Set or clear a boolean-valued option in the given socket.

setsockopt_float [UnixLabels]

Same as UnixLabels.setsockopt for a socket option whose value is a floating-point number.

setsockopt_float [Unix]

Same as Unix.setsockopt for a socket option whose value is a floating-point number.

setsockopt_int [UnixLabels]

Same as UnixLabels.setsockopt for an integer-valued socket option.

setsockopt_int [Unix]

Same as Unix.setsockopt for an integer-valued socket option.

setsockopt_optint [UnixLabels]

Same as UnixLabels.setsockopt for a socket option whose value is an int option.

setsockopt_optint [Unix]

Same as Unix.setsockopt for a socket option whose value is an int option.

setuid [UnixLabels]

Set the real user id and effective user id for the process.

setuid [Unix]

Set the real user id and effective user id for the process.

shift_left [Nativeint]

Nativeint.shift_left x y shifts x to the left by y bits.

shift_left [Int64]

Int64.shift_left x y shifts x to the left by y bits.

shift_left [Int32]

Int32.shift_left x y shifts x to the left by y bits.

shift_left [Int]

shift_left x n shifts x to the left by n bits.

shift_right [Nativeint]

Nativeint.shift_right x y shifts x to the right by y bits.

shift_right [Int64]

Int64.shift_right x y shifts x to the right by y bits.

shift_right [Int32]

Int32.shift_right x y shifts x to the right by y bits.

shift_right [Int]

shift_right x n shifts x to the right by n bits.

shift_right_logical [Nativeint]

Nativeint.shift_right_logical x y shifts x to the right by y bits.

shift_right_logical [Int64]

Int64.shift_right_logical x y shifts x to the right by y bits.

shift_right_logical [Int32]

Int32.shift_right_logical x y shifts x to the right by y bits.

shift_right_logical [Int]

shift_right x n shifts x to the right by n bits.

shutdown [UnixLabels]

Shutdown a socket connection.

shutdown [Unix]

Shutdown a socket connection.

shutdown_connection [UnixLabels]

``Shut down'' a connection established with UnixLabels.open_connection; that is, transmit an end-of-file condition to the server reading on the other side of the connection.

shutdown_connection [Unix]

``Shut down'' a connection established with Unix.open_connection; that is, transmit an end-of-file condition to the server reading on the other side of the connection.

sigabrt [Sys]

Abnormal termination

sigalrm [Sys]

Timeout

sigbus [Sys]

Bus error

sigchld [Sys]

Child process terminated

sigcont [Sys]

Continue

sigfpe [Sys]

Arithmetic exception

sighup [Sys]

Hangup on controlling terminal

sigill [Sys]

Invalid hardware instruction

sigint [Sys]

Interactive interrupt (ctrl-C)

sigkill [Sys]

Termination (cannot be ignored)

sigmask [Thread]

sigmask cmd sigs changes the set of blocked signals for the calling thread.

sign_bit [Float]

sign_bit x is true if and only if the sign bit of x is set.

signal [Sys]

Set the behavior of the system on receipt of a given signal.

signal [Condition]

signal c restarts one of the processes waiting on the condition variable c.

sigpending [UnixLabels]

Return the set of blocked signals that are currently pending.

sigpending [Unix]

Return the set of blocked signals that are currently pending.

sigpipe [Sys]

Broken pipe

sigpoll [Sys]

Pollable event

sigprocmask [UnixLabels]

sigprocmask ~mode sigs changes the set of blocked signals.

sigprocmask [Unix]

sigprocmask mode sigs changes the set of blocked signals.

sigprof [Sys]

Profiling interrupt

sigquit [Sys]

Interactive termination

sigsegv [Sys]

Invalid memory reference

sigstop [Sys]

Stop

sigsuspend [UnixLabels]

sigsuspend sigs atomically sets the blocked signals to sigs and waits for a non-ignored, non-blocked signal to be delivered.

sigsuspend [Unix]

sigsuspend sigs atomically sets the blocked signals to sigs and waits for a non-ignored, non-blocked signal to be delivered.

sigsys [Sys]

Bad argument to routine

sigterm [Sys]

Termination

sigtrap [Sys]

Trace/breakpoint trap

sigtstp [Sys]

Interactive stop

sigttin [Sys]

Terminal read from background process

sigttou [Sys]

Terminal write from background process

sigurg [Sys]

Urgent condition on socket

sigusr1 [Sys]

Application-defined signal 1

sigusr2 [Sys]

Application-defined signal 2

sigvtalrm [Sys]

Timeout in virtual time

sigxcpu [Sys]

Timeout in cpu time

sigxfsz [Sys]

File size limit exceeded

sin [Stdlib]

Sine.

sin [Float]

Sine.

single_write [UnixLabels]

Same as UnixLabels.write, but attempts to write only once.

single_write [Unix]

Same as Unix.write, but attempts to write only once.

single_write_substring [UnixLabels]

Same as UnixLabels.single_write, but take the data from a string instead of a byte sequence.

single_write_substring [Unix]

Same as Unix.single_write, but take the data from a string instead of a byte sequence.

singleton [Set.S]

singleton x returns the one-element set containing only x.

singleton [MoreLabels.Set.S]

singleton x returns the one-element set containing only x.

singleton [MoreLabels.Map.S]

singleton x y returns the one-element map that contains a binding y for x.

singleton [Map.S]

singleton x y returns the one-element map that contains a binding y for x.

sinh [Stdlib]

Hyperbolic sine.

sinh [Float]

Hyperbolic sine.

size [Obj]
size [Nativeint]

The size in bits of a native integer.

size_in_bytes [Bigarray.Array3]

size_in_bytes a is the number of elements in a multiplied by a's Bigarray.kind_size_in_bytes.

size_in_bytes [Bigarray.Array2]

size_in_bytes a is the number of elements in a multiplied by a's Bigarray.kind_size_in_bytes.

size_in_bytes [Bigarray.Array1]

size_in_bytes a is the number of elements in a multiplied by a's Bigarray.kind_size_in_bytes.

size_in_bytes [Bigarray.Array0]

size_in_bytes a is a's Bigarray.kind_size_in_bytes.

size_in_bytes [Bigarray.Genarray]

size_in_bytes a is the number of elements in a multiplied by a's Bigarray.kind_size_in_bytes.

sleep [UnixLabels]

Stop execution for the given number of seconds.

sleep [Unix]

Stop execution for the given number of seconds.

sleep [ThreadUnix]
sleepf [UnixLabels]

Stop execution for the given number of seconds.

sleepf [Unix]

Stop execution for the given number of seconds.

slice [Bigarray.Array1]

Extract a scalar (zero-dimensional slice) of the given one-dimensional Bigarray.

slice_left [Bigarray.Array2]

Extract a row (one-dimensional slice) of the given two-dimensional Bigarray.

slice_left [Bigarray.Genarray]

Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of the first (left-most) coordinates.

slice_left_1 [Bigarray.Array3]

Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the first two coordinates.

slice_left_2 [Bigarray.Array3]

Extract a two-dimensional slice of the given three-dimensional Bigarray by fixing the first coordinate.

slice_right [Bigarray.Array2]

Extract a column (one-dimensional slice) of the given two-dimensional Bigarray.

slice_right [Bigarray.Genarray]

Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of the last (right-most) coordinates.

slice_right_1 [Bigarray.Array3]

Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the last two coordinates.

slice_right_2 [Bigarray.Array3]

Extract a two-dimensional slice of the given three-dimensional Bigarray by fixing the last coordinate.

snd [Stdlib]

Return the second component of a pair.

socket [UnixLabels]

Create a new socket in the given domain, and with the given kind.

socket [Unix]

Create a new socket in the given domain, and with the given kind.

socket [ThreadUnix]
socketpair [UnixLabels]

Create a pair of unnamed sockets, connected together.

socketpair [Unix]

Create a pair of unnamed sockets, connected together.

some [Option]

some v is Some v.

sort [ListLabels]

Sort a list in increasing order according to a comparison function.

sort [List]

Sort a list in increasing order according to a comparison function.

sort [Float.ArrayLabels]

Sort a floatarray in increasing order according to a comparison function.

sort [Float.Array]

Sort a floatarray in increasing order according to a comparison function.

sort [ArrayLabels]

Sort an array in increasing order according to a comparison function.

sort [Array]

Sort an array in increasing order according to a comparison function.

sort_uniq [ListLabels]

Same as ListLabels.sort, but also remove duplicates.

sort_uniq [List]

Same as List.sort, but also remove duplicates.

split [Str]

split r s splits s into substrings, taking as delimiters the substrings that match r, and returns the list of substrings.

split [Set.S]

split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.

split [MoreLabels.Set.S]

split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.

split [MoreLabels.Map.S]

split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.

split [Map.S]

split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.

split [ListLabels]

Transform a list of pairs into a pair of lists: split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]).

split [List]

Transform a list of pairs into a pair of lists: split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]).

split [ArrayLabels]

split [|(a1,b1); ...; (an,bn)|] is ([|a1; ...; an|], [|b1; ...; bn|]).

split [Array]

split [|(a1,b1); ...; (an,bn)|] is ([|a1; ...; an|], [|b1; ...; bn|]).

split_delim [Str]

Same as Str.split but occurrences of the delimiter at the beginning and at the end of the string are recognized and returned as empty strings in the result.

split_on_char [String]

split_on_char sep s is the list of all (possibly empty) substrings of s that are delimited by the character sep.

split_on_char [StringLabels]

split_on_char ~sep s is the list of all (possibly empty) substrings of s that are delimited by the character sep.

split_on_char [BytesLabels]

split_on_char sep s returns the list of all (possibly empty) subsequences of s that are delimited by the sep character.

split_on_char [Bytes]

split_on_char sep s returns the list of all (possibly empty) subsequences of s that are delimited by the sep character.

sprintf [Printf]

Same as Printf.fprintf, but instead of printing on an output channel, return a string containing the result of formatting the arguments.

sprintf [Format]

Same as printf above, but instead of printing on a formatter, returns a string containing the result of formatting the arguments.

sqrt [Stdlib]

Square root.

sqrt [Float]

Square root.

sqrt [Complex]

Square root.

sscanf [Scanf]

Same as Scanf.bscanf, but reads from the given string.

sscanf_format [Scanf]

Same as Scanf.bscanf_format, but reads from the given string.

stable_sort [ListLabels]

Same as ListLabels.sort, but the sorting algorithm is guaranteed to be stable (i.e.

stable_sort [List]

Same as List.sort, but the sorting algorithm is guaranteed to be stable (i.e.

stable_sort [Float.ArrayLabels]

Same as Float.ArrayLabels.sort, but the sorting algorithm is stable (i.e.

stable_sort [Float.Array]

Same as Float.Array.sort, but the sorting algorithm is stable (i.e.

stable_sort [ArrayLabels]

Same as ArrayLabels.sort, but the sorting algorithm is stable (i.e.

stable_sort [Array]

Same as Array.sort, but the sorting algorithm is stable (i.e.

start [Gc.Memprof]

Start the sampling with the given parameters.

starts_with [String]

starts_with ~prefix s is true if and only if s starts with prefix.

starts_with [StringLabels]

starts_with ~prefix s is true if and only if s starts with prefix.

starts_with [BytesLabels]

starts_with ~prefix s is true if and only if s starts with prefix.

starts_with [Bytes]

starts_with ~prefix s is true if and only if s starts with prefix.

stat [UnixLabels.LargeFile]
stat [UnixLabels]

Return the information for the named file.

stat [Unix.LargeFile]
stat [Unix]

Return the information for the named file.

stat [Gc]

Return the current values of the memory management counters in a stat record.

stats [CamlinternalOO]
stats [Weak.S]

Return statistics on the table.

stats [MoreLabels.Hashtbl.SeededS]
stats [MoreLabels.Hashtbl.S]
stats [MoreLabels.Hashtbl]

Hashtbl.stats tbl returns statistics about the table tbl: number of buckets, size of the biggest bucket, distribution of buckets by size.

stats [Hashtbl.SeededS]
stats [Hashtbl.S]
stats [Hashtbl]

Hashtbl.stats tbl returns statistics about the table tbl: number of buckets, size of the biggest bucket, distribution of buckets by size.

stats_alive [Ephemeron.SeededS]

same as Hashtbl.SeededS.stats but only count the alive bindings

stats_alive [Ephemeron.S]

same as Hashtbl.SeededS.stats but only count the alive bindings

std_formatter [Format]

The standard formatter to write to standard output.

stdbuf [Format]

The string buffer in which str_formatter writes.

stderr [UnixLabels]

File descriptor for standard error.

stderr [Unix]

File descriptor for standard error.

stderr [Stdlib]

The standard error output for the process.

stdib [Scanf.Scanning]

A deprecated alias for Scanf.Scanning.stdin, the scanning buffer reading from stdin.

stdin [UnixLabels]

File descriptor for standard input.

stdin [Unix]

File descriptor for standard input.

stdin [Stdlib]

The standard input for the process.

stdin [Scanf.Scanning]

The standard input notion for the Scanf module.

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 Format.stdbuf string buffer.

string [Digest]

Return the digest of the given string.

string_after [Str]

string_after s n returns the substring of all characters of s that follow position n (including the character at position n).

string_before [Str]

string_before s n returns the substring of all characters of s that precede position n (excluding the character at position n).

string_match [Str]

string_match r s start tests whether a substring of s that starts at position start matches the regular expression r.

string_of_bool [Stdlib]

Return the string representation of a boolean.

string_of_float [Stdlib]

Return the string representation of a floating-point number.

string_of_fmt [CamlinternalFormat]
string_of_fmtty [CamlinternalFormat]
string_of_format [Stdlib]

Converts a format string into a string.

string_of_formatting_lit [CamlinternalFormat]
string_of_inet_addr [UnixLabels]

Return the printable representation of the given Internet address.

string_of_inet_addr [Unix]

Return the printable representation of the given Internet address.

string_of_int [Stdlib]

Return the string representation of an integer, in decimal.

string_partial_match [Str]

Similar to Str.string_match, but also returns true if the argument string is a prefix of a string that matches.

string_tag [Obj]
strput_acc [CamlinternalFormat]
sub [String]

sub s pos len is a string of length len, containing the substring of s that starts at position pos and has length len.

sub [StringLabels]

sub s ~pos ~len is a string of length len, containing the substring of s that starts at position pos and has length len.

sub [Nativeint]

Subtraction.

sub [Int64]

Subtraction.

sub [Int32]

Subtraction.

sub [Int]

sub x y is the subtraction x - y.

sub [Float.ArrayLabels]

sub a ~pos ~len returns a fresh floatarray of length len, containing the elements number pos to pos + len - 1 of floatarray a.

sub [Float.Array]

sub a pos len returns a fresh floatarray of length len, containing the elements number pos to pos + len - 1 of floatarray a.

sub [Float]

Floating-point subtraction.

sub [Complex]

Subtraction

sub [BytesLabels]

sub s ~pos ~len returns a new byte sequence of length len, containing the subsequence of s that starts at position pos and has length len.

sub [Bytes]

sub s pos len returns a new byte sequence of length len, containing the subsequence of s that starts at position pos and has length len.

sub [Buffer]

Buffer.sub b off len returns a copy of len bytes from the current contents of the buffer b, starting at offset off.

sub [Bigarray.Array1]

Extract a sub-array of the given one-dimensional Bigarray.

sub [ArrayLabels]

sub a ~pos ~len returns a fresh array of length len, containing the elements number pos to pos + len - 1 of array a.

sub [Array]

sub a pos len returns a fresh array of length len, containing the elements number pos to pos + len - 1 of array a.

sub_left [Bigarray.Array3]

Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the first dimension.

sub_left [Bigarray.Array2]

Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the first dimension.

sub_left [Bigarray.Genarray]

Extract a sub-array of the given Bigarray by restricting the first (left-most) dimension.

sub_right [Bigarray.Array3]

Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the second dimension.

sub_right [Bigarray.Array2]

Extract a two-dimensional sub-array of the given two-dimensional Bigarray by restricting the second dimension.

sub_right [Bigarray.Genarray]

Extract a sub-array of the given Bigarray by restricting the last (right-most) dimension.

sub_string [BytesLabels]

Same as BytesLabels.sub but return a string instead of a byte sequence.

sub_string [Bytes]

Same as Bytes.sub but return a string instead of a byte sequence.

subbytes [Digest]

Digest.subbytes s ofs len returns the digest of the subsequence of s starting at index ofs and containing len bytes.

subset [Set.S]

subset s1 s2 tests whether the set s1 is a subset of the set s2.

subset [MoreLabels.Set.S]

subset s1 s2 tests whether the set s1 is a subset of the set s2.

substitute_first [Str]

Same as Str.global_substitute, except that only the first substring matching the regular expression is replaced.

substring [Digest]

Digest.substring s ofs len returns the digest of the substring of s starting at index ofs and containing len characters.

succ [Uchar]

succ u is the scalar value after u in the set of Unicode scalar values.

succ [Stdlib]

succ x is x + 1.

succ [Nativeint]

Successor.

succ [Int64]

Successor.

succ [Int32]

Successor.

succ [Int]

succ x is add x 1.

succ [Float]

succ x returns the floating point number right after x i.e., the smallest floating-point number greater than x.

symbol_end [Parsing]
symbol_end_pos [Parsing]

Same as symbol_end, but return a position instead of an offset.

symbol_start [Parsing]

symbol_start and Parsing.symbol_end are to be called in the action part of a grammar rule only.

symbol_start_pos [Parsing]

Same as symbol_start, but return a position instead of an offset.

symlink [UnixLabels]

symlink ?to_dir ~src ~dst creates the file dst as a symbolic link to the file src.

symlink [Unix]

symlink ?to_dir src dst creates the file dst as a symbolic link to the file src.

symm [CamlinternalFormat]
sync [Event]

'Synchronize' on an event: offer all the communication possibilities specified in the event to the outside world, and block until one of the communications succeed.

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 [Queue]

take q removes and returns the first element in queue q, or raises Queue.Empty if the queue is empty.

take_opt [Queue]

take_opt q removes and returns the first element in queue q, or returns None if the queue is empty.

tan [Stdlib]

Tangent.

tan [Float]

Tangent.

tanh [Stdlib]

Hyperbolic tangent.

tanh [Float]

Hyperbolic tangent.

tcdrain [UnixLabels]

Waits until all output written on the given file descriptor has been transmitted.

tcdrain [Unix]

Waits until all output written on the given file descriptor has been transmitted.

tcflow [UnixLabels]

Suspend or restart reception or transmission of data on the given file descriptor, depending on the second argument: TCOOFF suspends output, TCOON restarts output, TCIOFF transmits a STOP character to suspend input, and TCION transmits a START character to restart input.

tcflow [Unix]

Suspend or restart reception or transmission of data on the given file descriptor, depending on the second argument: TCOOFF suspends output, TCOON restarts output, TCIOFF transmits a STOP character to suspend input, and TCION transmits a START character to restart input.

tcflush [UnixLabels]

Discard data written on the given file descriptor but not yet transmitted, or data received but not yet read, depending on the second argument: TCIFLUSH flushes data received but not read, TCOFLUSH flushes data written but not transmitted, and TCIOFLUSH flushes both.

tcflush [Unix]

Discard data written on the given file descriptor but not yet transmitted, or data received but not yet read, depending on the second argument: TCIFLUSH flushes data received but not read, TCOFLUSH flushes data written but not transmitted, and TCIOFLUSH flushes both.

tcgetattr [UnixLabels]

Return the status of the terminal referred to by the given file descriptor.

tcgetattr [Unix]

Return the status of the terminal referred to by the given file descriptor.

tcsendbreak [UnixLabels]

Send a break condition on the given file descriptor.

tcsendbreak [Unix]

Send a break condition on the given file descriptor.

tcsetattr [UnixLabels]

Set the status of the terminal referred to by the given file descriptor.

tcsetattr [Unix]

Set the status of the terminal referred to by the given file descriptor.

temp_dir_name [Filename]

The name of the initial temporary directory: Under Unix, the value of the TMPDIR environment variable, or "/tmp" if the variable is not set.

temp_file [Filename]

temp_file prefix suffix returns the name of a fresh temporary file in the temporary directory.

time [UnixLabels]

Return the current time since 00:00:00 GMT, Jan.

time [Unix]

Return the current time since 00:00:00 GMT, Jan.

time [Sys]

Return the processor time, in seconds, used by the program since the beginning of execution.

timed_read [ThreadUnix]
timed_write [ThreadUnix]

Behave as ThreadUnix.read and ThreadUnix.write, except that Unix_error(ETIMEDOUT,_,_) is raised if no data is available for reading or ready for writing after d seconds.

timed_write_substring [ThreadUnix]
times [UnixLabels]

Return the execution times of the process.

times [Unix]

Return the execution times of the process.

tl [ListLabels]

Return the given list without its first element.

tl [List]

Return the given list without its first element.

to_buffer [Marshal]

Marshal.to_buffer buff ofs len v flags marshals the value v, storing its byte representation in the sequence buff, starting at index ofs, and writing at most len bytes.

to_bytes [String]

Return a new byte sequence that contains the same bytes as the given string.

to_bytes [StringLabels]

Return a new byte sequence that contains the same bytes as the given string.

to_bytes [Marshal]

Marshal.to_bytes v flags returns a byte sequence containing the representation of v.

to_bytes [Buffer]

Return a copy of the current contents of the buffer.

to_channel [Marshal]

Marshal.to_channel chan v flags writes the representation of v on channel chan.

to_char [Uchar]

to_char u is u as an OCaml latin1 character.

to_float [Nativeint]

Convert the given native integer to a floating-point number.

to_float [Int64]

Convert the given 64-bit integer to a floating-point number.

to_float [Int32]

Convert the given 32-bit integer to a floating-point number.

to_float [Int]

to_float x is x as a floating point number.

to_float [Bool]

to_float b is 0. if b is false and 1. if b is true.

to_hex [Digest]

Return the printable hexadecimal representation of the given digest.

to_int [Uchar]

to_int u is u as an integer.

to_int [Nativeint]

Convert the given native integer (type nativeint) to an integer (type int).

to_int [Int64]

Convert the given 64-bit integer (type int64) to an integer (type int).

to_int [Int32]

Convert the given 32-bit integer (type int32) to an integer (type int).

to_int [Float]

Truncate the given floating-point number to an integer.

to_int [Bool]

to_int b is 0 if b is false and 1 if b is true.

to_int32 [Nativeint]

Convert the given native integer to a 32-bit integer (type int32).

to_int32 [Int64]

Convert the given 64-bit integer (type int64) to a 32-bit integer (type int32).

to_list [Result]

to_list r is [v] if r is Ok v and [] otherwise.

to_list [Option]

to_list o is [] if o is None and [v] if o is Some v.

to_list [Float.ArrayLabels]

to_list a returns the list of all the elements of a.

to_list [Float.Array]

to_list a returns the list of all the elements of a.

to_list [ArrayLabels]

to_list a returns the list of all the elements of a.

to_list [Array]

to_list a returns the list of all the elements of a.

to_nativeint [Int64]

Convert the given 64-bit integer (type int64) to a native integer.

to_option [Result]

to_option r is r as an option, mapping Ok v to Some v and Error _ to None.

to_result [Option]

to_result ~none o is Ok v if o is Some v and Error none otherwise.

to_rev_seq [Set.S]

Iterate on the whole set, in descending order

to_rev_seq [MoreLabels.Set.S]

Iterate on the whole set, in descending order

to_rev_seq [MoreLabels.Map.S]

Iterate on the whole map, in descending order of keys

to_rev_seq [Map.S]

Iterate on the whole map, in descending order of keys

to_seq [String]

to_seq s is a sequence made of the string's characters in increasing order.

to_seq [StringLabels]

to_seq s is a sequence made of the string's characters in increasing order.

to_seq [Stack]

Iterate on the stack, top to bottom.

to_seq [Set.S]

Iterate on the whole set, in ascending order

to_seq [Result]

to_seq r is r as a sequence.

to_seq [Queue]

Iterate on the queue, in front-to-back order.

to_seq [Option]

to_seq o is o as a sequence.

to_seq [MoreLabels.Set.S]

Iterate on the whole set, in ascending order

to_seq [MoreLabels.Map.S]

Iterate on the whole map, in ascending order of keys

to_seq [MoreLabels.Hashtbl.SeededS]
to_seq [MoreLabels.Hashtbl.S]
to_seq [MoreLabels.Hashtbl]

Iterate on the whole table.

to_seq [Map.S]

Iterate on the whole map, in ascending order of keys

to_seq [ListLabels]

Iterate on the list.

to_seq [List]

Iterate on the list.

to_seq [Hashtbl.SeededS]
to_seq [Hashtbl.S]
to_seq [Hashtbl]

Iterate on the whole table.

to_seq [Float.ArrayLabels]

Iterate on the floatarray, in increasing order.

to_seq [Float.Array]

Iterate on the floatarray, in increasing order.

to_seq [BytesLabels]

Iterate on the string, in increasing index order.

to_seq [Bytes]

Iterate on the string, in increasing index order.

to_seq [Buffer]

Iterate on the buffer, in increasing order.

to_seq [ArrayLabels]

Iterate on the array, in increasing order.

to_seq [Array]

Iterate on the array, in increasing order.

to_seq_from [Set.S]

to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.

to_seq_from [MoreLabels.Set.S]

to_seq_from x s iterates on a subset of the elements of s in ascending order, from x or above.

to_seq_from [MoreLabels.Map.S]

to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.

to_seq_from [Map.S]

to_seq_from k m iterates on a subset of the bindings of m, in ascending order of keys, from key k or above.

to_seq_keys [MoreLabels.Hashtbl.SeededS]
to_seq_keys [MoreLabels.Hashtbl.S]
to_seq_keys [MoreLabels.Hashtbl]

Same as Seq.map fst (to_seq m)

to_seq_keys [Hashtbl.SeededS]
to_seq_keys [Hashtbl.S]
to_seq_keys [Hashtbl]

Same as Seq.map fst (to_seq m)

to_seq_values [MoreLabels.Hashtbl.SeededS]
to_seq_values [MoreLabels.Hashtbl.S]
to_seq_values [MoreLabels.Hashtbl]

Same as Seq.map snd (to_seq m)

to_seq_values [Hashtbl.SeededS]
to_seq_values [Hashtbl.S]
to_seq_values [Hashtbl]

Same as Seq.map snd (to_seq m)

to_seqi [String]

to_seqi s is like String.to_seq but also tuples the corresponding index.

to_seqi [StringLabels]

to_seqi s is like StringLabels.to_seq but also tuples the corresponding index.

to_seqi [Float.ArrayLabels]

Iterate on the floatarray, in increasing order, yielding indices along elements.

to_seqi [Float.Array]

Iterate on the floatarray, in increasing order, yielding indices along elements.

to_seqi [BytesLabels]

Iterate on the string, in increasing order, yielding indices along chars

to_seqi [Bytes]

Iterate on the string, in increasing order, yielding indices along chars

to_seqi [Buffer]

Iterate on the buffer, in increasing order, yielding indices along chars.

to_seqi [ArrayLabels]

Iterate on the array, in increasing order, yielding indices along elements.

to_seqi [Array]

Iterate on the array, in increasing order, yielding indices along elements.

to_string [Unit]

to_string b is "()".

to_string [Printexc]

Printexc.to_string e returns a string representation of the exception e.

to_string [Nativeint]

Return the string representation of its argument, in decimal.

to_string [Marshal]

Same as to_bytes but return the result as a string instead of a byte sequence.

to_string [Int64]

Return the string representation of its argument, in decimal.

to_string [Int32]

Return the string representation of its argument, in signed decimal.

to_string [Int]

to_string x is the written representation of x in decimal.

to_string [Float]

Return 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 b is "true" if b is true and "false" if b is false.

to_string_default [Printexc]

Printexc.to_string_default e returns a string representation of the exception e, ignoring all registered exception printers.

top [Stack]

top s returns the topmost element in stack s, or raises Stack.Empty if the stack is empty.

top [Queue]

top is a synonym for peek.

top_opt [Stack]

top_opt s returns the topmost element in stack s, or None if the stack is empty.

total_size [Marshal]
trans [CamlinternalFormat]
transfer [Queue]

transfer q1 q2 adds all of q1's elements at the end of the queue q2, then clears q1.

trim [String]

trim s is s without leading and trailing whitespace.

trim [StringLabels]

trim s is s without leading and trailing whitespace.

trim [BytesLabels]

Return a copy of the argument, without leading and trailing whitespace.

trim [Bytes]

Return a copy of the argument, without leading and trailing whitespace.

trunc [Float]

trunc x rounds x to the nearest integer whose absolute value is less than or equal to x.

truncate [UnixLabels.LargeFile]

See truncate.

truncate [UnixLabels]

Truncates the named file to the given size.

truncate [Unix.LargeFile]

See truncate.

truncate [Unix]

Truncates the named file to the given size.

truncate [Stdlib]

Same as int_of_float.

truncate [Obj]
truncate [Buffer]

truncate b len truncates the length of b to len Note: the internal byte sequence is not shortened.

try_acquire [Semaphore.Binary]

try_acquire s immediately returns false if the semaphore s has value 0.

try_acquire [Semaphore.Counting]

try_acquire s immediately returns false if the value of semaphore s is zero.

try_lock [Mutex]

Same as Mutex.lock, but does not suspend the calling thread if the mutex is already locked: just return false immediately in that case.

type_format [CamlinternalFormat]
U
umask [UnixLabels]

Set the process's file mode creation mask, and return the previous mask.

umask [Unix]

Set the process's file mode creation mask, and return the previous mask.

unaligned_tag [Obj]
uncapitalize [String]

Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.

uncapitalize [StringLabels]

Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.

uncapitalize [BytesLabels]

Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.

uncapitalize [Bytes]

Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.

uncapitalize_ascii [String]

uncapitalize_ascii s is s with the first character set to lowercase, using the US-ASCII character set.

uncapitalize_ascii [StringLabels]

uncapitalize_ascii s is s with the first character set to lowercase, using the US-ASCII character set.

uncapitalize_ascii [BytesLabels]

Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.

uncapitalize_ascii [Bytes]

Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set.

unescaped [Scanf]

unescaped s return a copy of s with escape sequences (according to the lexical conventions of OCaml) replaced by their corresponding special characters.

unfold [Seq]

Build a sequence from a step function and an initial value.

union [Set.S]

Set union.

union [MoreLabels.Set.S]

Set union.

union [MoreLabels.Map.S]

union ~f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2.

union [Map.S]

union f m1 m2 computes a map whose keys are a subset of the keys of m1 and of m2.

unix [Sys]

True if Sys.os_type = "Unix".

unlink [UnixLabels]

Removes the named file.

unlink [Unix]

Removes the named file.

unlock [Mutex]

Unlock the given mutex.

unmarshal [Obj]
unsafe_environment [UnixLabels]

Return the process environment, as an array of strings with the format ``variable=value''.

unsafe_environment [Unix]

Return the process environment, as an array of strings with the format ``variable=value''.

unsafe_get [Bigarray.Array3]

Like Bigarray.Array3.get, but bounds checking is not always performed.

unsafe_get [Bigarray.Array2]

Like Bigarray.Array2.get, but bounds checking is not always performed.

unsafe_get [Bigarray.Array1]

Like Bigarray.Array1.get, but bounds checking is not always performed.

unsafe_getenv [UnixLabels]

Return the value associated to a variable in the process environment.

unsafe_getenv [Unix]

Return the value associated to a variable in the process environment.

unsafe_of_string [BytesLabels]

Unsafely convert a shared string to a byte sequence that should not be mutated.

unsafe_of_string [Bytes]

Unsafely convert a shared string to a byte sequence that should not be mutated.

unsafe_set [Bigarray.Array3]

Like Bigarray.Array3.set, but bounds checking is not always performed.

unsafe_set [Bigarray.Array2]

Like Bigarray.Array2.set, but bounds checking is not always performed.

unsafe_set [Bigarray.Array1]

Like Bigarray.Array1.set, but bounds checking is not always performed.

unsafe_to_string [BytesLabels]

Unsafely convert a byte sequence into a string.

unsafe_to_string [Bytes]

Unsafely convert a byte sequence into a string.

unset_data [Obj.Ephemeron]
unset_data [Ephemeron.Kn]
unset_data [Ephemeron.K2]
unset_data [Ephemeron.K1]

Ephemeron.K1.unset_data eph el sets the key of eph to be an empty key.

unset_key [Obj.Ephemeron]
unset_key [Ephemeron.Kn]
unset_key [Ephemeron.K1]

Ephemeron.K1.unset_key eph el sets the key of eph to be an empty key.

unset_key1 [Ephemeron.K2]
unset_key2 [Ephemeron.K2]
unsigned_compare [Nativeint]

Same as Nativeint.compare, except that arguments are interpreted as unsigned native integers.

unsigned_compare [Int64]

Same as Int64.compare, except that arguments are interpreted as unsigned 64-bit integers.

unsigned_compare [Int32]

Same as Int32.compare, except that arguments are interpreted as unsigned 32-bit integers.

unsigned_div [Nativeint]

Same as Nativeint.div, except that arguments and result are interpreted as unsigned native integers.

unsigned_div [Int64]

Same as Int64.div, except that arguments and result are interpreted as unsigned 64-bit integers.

unsigned_div [Int32]

Same as Int32.div, except that arguments and result are interpreted as unsigned 32-bit integers.

unsigned_rem [Nativeint]

Same as Nativeint.rem, except that arguments and result are interpreted as unsigned native integers.

unsigned_rem [Int64]

Same as Int64.rem, except that arguments and result are interpreted as unsigned 64-bit integers.

unsigned_rem [Int32]

Same as Int32.rem, except that arguments and result are interpreted as unsigned 32-bit integers.

unsigned_to_int [Nativeint]

Same as Nativeint.to_int, but interprets the argument as an unsigned integer.

unsigned_to_int [Int64]

Same as Int64.to_int, but interprets the argument as an unsigned integer.

unsigned_to_int [Int32]

Same as Int32.to_int, but interprets the argument as an unsigned integer.

update [MoreLabels.Map.S]

update ~key ~f m returns a map containing the same bindings as m, except for the binding of key.

update [Map.S]

update key f m returns a map containing the same bindings as m, except for the binding of key.

update_geometry [Format]
update_mod [CamlinternalMod]
uppercase [String]

Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.

uppercase [StringLabels]

Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.

uppercase [Char]

Convert the given character to its equivalent uppercase character, using the ISO Latin-1 (8859-1) character set.

uppercase [BytesLabels]

Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.

uppercase [Bytes]

Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.

uppercase_ascii [String]

uppercase_ascii s is s with all lowercase letters translated to uppercase, using the US-ASCII character set.

uppercase_ascii [StringLabels]

uppercase_ascii s is s with all lowercase letters translated to uppercase, using the US-ASCII character set.

uppercase_ascii [Char]

Convert the given character to its equivalent uppercase character, using the US-ASCII character set.

uppercase_ascii [BytesLabels]

Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set.

uppercase_ascii [Bytes]

Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set.

usage [Arg]

Arg.usage speclist usage_msg prints to standard error an error message that includes the list of valid options.

usage_string [Arg]

Returns the message that would have been printed by Arg.usage, if provided with the same parameters.

use_printers [Printexc]

Printexc.use_printers e returns None if there are no registered printers and Some s with else as the resulting string otherwise.

utimes [UnixLabels]

Set the last access time (second arg) and last modification time (third arg) for a file.

utimes [Unix]

Set the last access time (second arg) and last modification time (third arg) for a file.

V
value [Result]

value r ~default is v if r is Ok v and default otherwise.

value [Option]

value o ~default is v if o is Some v and default otherwise.

W
wait [UnixLabels]

Wait until one of the children processes die, and return its pid and termination status.

wait [Unix]

Wait until one of the children processes die, and return its pid and termination status.

wait [ThreadUnix]
wait [Condition]

wait c m atomically unlocks the mutex m and suspends the calling process on the condition variable c.

wait_pid [Thread]

Same function as Unix.waitpid.

wait_read [Thread]

This function does nothing in the current implementation of the threading library and can be removed from all user programs.

wait_signal [Thread]

wait_signal sigs suspends the execution of the calling thread until the process receives one of the signals specified in the list sigs.

wait_timed_read [Thread]
wait_timed_write [Thread]

Suspend the execution of the calling thread until at least one character or EOF is available for reading (wait_timed_read) or one character can be written without blocking (wait_timed_write) on the given Unix file descriptor.

wait_write [Thread]

This function does nothing in the current implementation of the threading library and can be removed from all user programs.

waitpid [UnixLabels]

Same as UnixLabels.wait, but waits for the child process whose pid is given.

waitpid [Unix]

Same as Unix.wait, but waits for the child process whose pid is given.

waitpid [ThreadUnix]
widen [CamlinternalOO]
win32 [Sys]

True if Sys.os_type = "Win32".

with_positions [Lexing]

Tell whether the lexer buffer keeps track of position fields lex_curr_p / lex_start_p, as determined by the corresponding optional argument for functions that create lexer buffers (whose default value is true).

with_tag [Obj]
word_size [Sys]

Size of one word on the machine currently executing the OCaml program, in bits: 32 or 64.

wrap [Event]

wrap ev fn returns the event that performs the same communications as ev, then applies the post-processing function fn on the return value.

wrap_abort [Event]

wrap_abort ev fn returns the event that performs the same communications as ev, but if it is not selected the function fn is called after the synchronization.

write [UnixLabels]

write fd ~buf ~pos ~len writes len bytes to descriptor fd, taking them from byte sequence buf, starting at position pos in buff.

write [Unix]

write fd buf pos len writes len bytes to descriptor fd, taking them from byte sequence buf, starting at position pos in buff.

write [ThreadUnix]
write_arg [Arg]

Arg.write_arg file args writes the arguments args newline-terminated into the file file.

write_arg0 [Arg]

Identical to Arg.write_arg but uses the null character for terminator instead of newline.

write_substring [UnixLabels]

Same as UnixLabels.write, but take the data from a string instead of a byte sequence.

write_substring [Unix]

Same as Unix.write, but take the data from a string instead of a byte sequence.

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 is the integer 0.

zero [Float]

The floating point 0.

zero [Complex]

The complex number 0.