( * ) [Pervasives] | |
( ** ) [Pervasives] | |
( *. ) [Pervasives] | |
(!) [Pervasives] | |
(!=) [Pervasives] | |
(&&) [Pervasives] | |
(&) [Pervasives] | |
(+) [Pervasives] | |
(+.) [Pervasives] | |
(-) [Pervasives] | |
(-.) [Pervasives] | |
(/) [Pervasives] | |
(/.) [Pervasives] | |
(:=) [Pervasives] | |
(<) [Pervasives] | |
(<=) [Pervasives] | |
(<>) [Pervasives] | |
(=) [Pervasives] | |
(==) [Pervasives] | |
(>) [Pervasives] | |
(>=) [Pervasives] | |
(@) [Pervasives] | |
(@@) [Pervasives] | |
(^) [Pervasives] | |
(^^) [Pervasives] | |
(asr) [Pervasives] | |
(land) [Pervasives] | |
(lor) [Pervasives] | |
(lsl) [Pervasives] | |
(lsr) [Pervasives] | |
(lxor) [Pervasives] | |
(mod) [Pervasives] | |
(or) [Pervasives] | |
(|>) [Pervasives] | |
(||) [Pervasives] | |
(~+) [Pervasives] | |
(~+.) [Pervasives] | |
(~-) [Pervasives] | |
(~-.) [Pervasives] | |
__FILE__ [Pervasives] | |
__LINE_OF__ [Pervasives] | |
__LINE__ [Pervasives] | |
__LOC_OF__ [Pervasives] | |
__LOC__ [Pervasives] | |
__MODULE__ [Pervasives] | |
__POS_OF__ [Pervasives] | |
__POS__ [Pervasives] | |
A | |
abs [Pervasives] | |
abs [Nativeint] | Return the absolute value of its argument. |
abs [Int64] | Return the absolute value of its argument. |
abs [Int32] | Return the absolute value of its argument. |
abs [Float] |
|
abs_float [Pervasives] | |
abstract_tag [Obj] | |
accept [UnixLabels] | Accept connections on the given socket. |
accept [Unix] | Accept connections on the given socket. |
accept [ThreadUnix] | |
access [UnixLabels] | Check that the process has the given permissions over the named file. |
access [Unix] | Check that the process has the given permissions over the named file. |
acos [Pervasives] | |
acos [Float] | Arc cosine. |
adapt_filename [Dynlink] | In bytecode, the identity function. |
add [Weak.S] |
|
add [Set.S] |
|
add [Queue] |
|
add [Nativeint] | Addition. |
add [MoreLabels.Set.S] | |
add [MoreLabels.Map.S] | |
add [MoreLabels.Hashtbl.SeededS] | |
add [MoreLabels.Hashtbl.S] | |
add [MoreLabels.Hashtbl] | |
add [Map.S] |
|
add [Int64] | Addition. |
add [Int32] | Addition. |
add [Hashtbl.SeededS] | |
add [Hashtbl.S] | |
add [Hashtbl] |
|
add [Float] | Floating-point addition. |
add [Complex] | Addition |
add_available_units [Dynlink] | Same as |
add_buffer [Buffer] |
|
add_bytes [Buffer] |
|
add_channel [Buffer] |
|
add_char [Buffer] |
|
add_in_char_set [CamlinternalFormat] | |
add_initializer [CamlinternalOO] | |
add_interfaces [Dynlink] |
|
add_offset [Obj] | |
add_seq [Stack] | Add the elements from the iterator on the top of the stack. |
add_seq [Set.S] | Add the given elements to the set, in order. |
add_seq [Queue] | Add the elements from the generator to the end of the queue |
add_seq [MoreLabels.Set.S] | |
add_seq [MoreLabels.Map.S] | |
add_seq [MoreLabels.Hashtbl.SeededS] | |
add_seq [MoreLabels.Hashtbl.S] | |
add_seq [MoreLabels.Hashtbl] | |
add_seq [Map.S] | Add the given bindings to the map, in order. |
add_seq [Hashtbl.SeededS] | |
add_seq [Hashtbl.S] | |
add_seq [Hashtbl] | Add the given bindings to the table, using |
add_seq [Buffer] | Add chars to the buffer |
add_string [Buffer] |
|
add_subbytes [Buffer] |
|
add_substitute [Buffer] |
|
add_substring [Buffer] |
|
add_symbolic_output_item [Format] |
|
add_utf_16be_uchar [Buffer] |
|
add_utf_16le_uchar [Buffer] |
|
add_utf_8_uchar [Buffer] |
|
alarm [UnixLabels] | Schedule a |
alarm [Unix] | Schedule a |
align [Arg] | Align the documentation strings by inserting spaces at the first alignment separator (tab or, if tab is not found, space), according to the length of the keyword. |
allocated_bytes [Gc] | Return the total number of bytes allocated since the program was started. |
allow_only [Dynlink] |
|
allow_unsafe_modules [Dynlink] | Govern whether unsafe object files are allowed to be dynamically linked. |
always [Event] |
|
append [ListLabels] | Catenate two lists. |
append [List] | Concatenate two lists. |
append [ArrayLabels] |
|
append [Array] |
|
arg [Complex] | Argument. |
argv [Sys] | The command line arguments given to the process. |
array0_of_genarray [Bigarray] | Return the zero-dimensional big array corresponding to the given generic big array. |
array1_of_genarray [Bigarray] | Return the one-dimensional big array corresponding to the given generic big array. |
array2_of_genarray [Bigarray] | Return the two-dimensional big array corresponding to the given generic big array. |
array3_of_genarray [Bigarray] | Return the three-dimensional big array corresponding to the given generic big array. |
asin [Pervasives] | |
asin [Float] | Arc sine. |
asprintf [Format] | Same as |
assoc [ListLabels] |
|
assoc [List] |
|
assoc_opt [ListLabels] |
|
assoc_opt [List] |
|
assq [ListLabels] | Same as |
assq [List] | Same as |
assq_opt [ListLabels] | Same as |
assq_opt [List] | Same as |
at_exit [Pervasives] | |
atan [Pervasives] | |
atan [Float] | Arc tangent. |
atan2 [Pervasives] | |
atan2 [Float] |
|
auto_synchronize [Graphics] | By default, drawing takes place both on the window displayed on screen, and in a memory area (the 'backing store'). |
B | |
backend_type [Sys] | Backend type currently executing the OCaml program. |
background [Graphics] | See |
backtrace_slots [Printexc] | Returns the slots of a raw backtrace, or |
backtrace_status [Printexc] |
|
basename [Filename] | Split a file name into directory name / base file name. |
beginning_of_input [Scanf.Scanning] |
|
big_endian [Sys] | Whether the machine currently executing the Caml program is big-endian. |
bind [UnixLabels] | Bind a socket to an address. |
bind [Unix] | Bind a socket to an address. |
bind [Result] |
|
bind [Option] |
|
bindings [MoreLabels.Map.S] | |
bindings [Map.S] | Return the list of all bindings of the given map. |
bits [Random.State] | |
bits [Random] | Return 30 random bits in a nonnegative integer. |
bits_of_float [Int64] | Return the internal representation of the given float according to the IEEE 754 floating-point 'double format' bit layout. |
bits_of_float [Int32] | Return the internal representation of the given float according to the IEEE 754 floating-point 'single format' bit layout. |
black [Graphics] | |
blit [Weak] |
|
blit [String] | Same as |
blit [StringLabels] |
|
blit [BytesLabels] |
|
blit [Bytes] |
|
blit [Buffer] |
|
blit [Bigarray.Array3] | Copy the first big array to the second big array. |
blit [Bigarray.Array2] | Copy the first big array to the second big array. |
blit [Bigarray.Array1] | Copy the first big array to the second big array. |
blit [Bigarray.Array0] | Copy the first big array to the second big array. |
blit [Bigarray.Genarray] | Copy all elements of a big array in another big array. |
blit [ArrayLabels] |
|
blit [Array] |
|
blit_data [Obj.Ephemeron] | Same as |
blit_data [Ephemeron.Kn] | Same as |
blit_data [Ephemeron.K2] | Same as |
blit_data [Ephemeron.K1] |
|
blit_image [Graphics] |
|
blit_key [Obj.Ephemeron] | Same as |
blit_key [Ephemeron.Kn] | Same as |
blit_key [Ephemeron.K1] |
|
blit_key1 [Ephemeron.K2] | Same as |
blit_key12 [Ephemeron.K2] | Same as |
blit_key2 [Ephemeron.K2] | Same as |
blit_string [BytesLabels] |
|
blit_string [Bytes] |
|
blue [Graphics] | |
bom [Uchar] |
|
bool [Random.State] | These functions are the same as the basic functions, except that they use (and update) the given PRNG state instead of the default one. |
bool [Random] |
|
bool_of_string [Pervasives] | |
bool_of_string_opt [Pervasives] | |
bounded_full_split [Str] | Same as |
bounded_split [Str] | Same as |
bounded_split_delim [Str] | Same as |
bprintf [Printf] | Same as |
bprintf [Format] | |
broadcast [Condition] |
|
bscanf [Scanf] | |
bscanf_format [Scanf] |
|
bufput_acc [CamlinternalFormat] | |
button_down [Graphics] | Return |
bytes [Digest] | Return the digest of the given byte sequence. |
C | |
c_layout [Bigarray] | |
capitalize [String] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.. |
capitalize [StringLabels] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.. |
capitalize [BytesLabels] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.. |
capitalize [Bytes] | Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set.. |
capitalize_ascii [String] | Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set. |
capitalize_ascii [StringLabels] | Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set. |
capitalize_ascii [BytesLabels] | Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set. |
capitalize_ascii [Bytes] | Return a copy of the argument, with the first character set to uppercase, using the US-ASCII character set. |
cardinal [Set.S] | Return the number of elements of a set. |
cardinal [MoreLabels.Set.S] | |
cardinal [MoreLabels.Map.S] | |
cardinal [Map.S] | Return the number of bindings of a map. |
cat [BytesLabels] |
|
cat [Bytes] |
|
catch [Printexc] |
|
catch_break [Sys] |
|
ceil [Pervasives] | |
ceil [Float] | Round above to an integer value. |
change_layout [Bigarray.Array3] |
|
change_layout [Bigarray.Array2] |
|
change_layout [Bigarray.Array1] |
|
change_layout [Bigarray.Array0] |
|
change_layout [Bigarray.Genarray] |
|
channel [Digest] | If |
char [Bigarray] | As shown by the types of the values above,
big arrays of kind |
char_of_iconv [CamlinternalFormat] | |
char_of_int [Pervasives] | |
chdir [UnixLabels] | Change the process working directory. |
chdir [Unix] | Change the process working directory. |
chdir [Sys] | Change the current working directory of the process. |
check [Weak] |
|
check_data [Obj.Ephemeron] | Same as |
check_data [Ephemeron.Kn] | Same as |
check_data [Ephemeron.K2] | Same as |
check_data [Ephemeron.K1] |
|
check_key [Obj.Ephemeron] | Same as |
check_key [Ephemeron.Kn] | Same as |
check_key [Ephemeron.K1] |
|
check_key1 [Ephemeron.K2] | Same as |
check_key2 [Ephemeron.K2] | Same as |
check_suffix [Filename] |
|
chmod [UnixLabels] | Change the permissions of the named file. |
chmod [Unix] | Change the permissions of the named file. |
choose [Set.S] | Return one element of the given set, or raise |
choose [MoreLabels.Set.S] | |
choose [MoreLabels.Map.S] | |
choose [Map.S] | Return one binding of the given map, or raise |
choose [Event] |
|
choose_opt [Set.S] | Return one element of the given set, or |
choose_opt [MoreLabels.Set.S] | |
choose_opt [MoreLabels.Map.S] | |
choose_opt [Map.S] | Return one binding of the given map, or |
chop_extension [Filename] | Same as |
chop_suffix [Filename] |
|
chown [UnixLabels] | Change the owner uid and owner gid of the named file. |
chown [Unix] | Change the owner uid and owner gid of the named file. |
chr [Char] | Return the character with the given ASCII code. |
chroot [UnixLabels] | Change the process root directory. |
chroot [Unix] | Change the process root directory. |
classify_float [Pervasives] | |
classify_float [Float] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number. |
clean [Ephemeron.SeededS] | remove all dead bindings. |
clean [Ephemeron.S] | remove all dead bindings. |
clear [Weak.S] | Remove all elements from the table. |
clear [Stack] | Discard all elements from a stack. |
clear [Queue] | Discard all elements from a queue. |
clear [MoreLabels.Hashtbl.SeededS] | |
clear [MoreLabels.Hashtbl.S] | |
clear [MoreLabels.Hashtbl] | |
clear [Hashtbl.SeededS] | |
clear [Hashtbl.S] | |
clear [Hashtbl] | Empty a hash table. |
clear [Buffer] | Empty the buffer. |
clear_available_units [Dynlink] | Empty the list of compilation units accessible to dynamically-linked programs. |
clear_close_on_exec [UnixLabels] | Clear the ``close-on-exec'' flag on the given descriptor. |
clear_close_on_exec [Unix] | Clear the ``close-on-exec'' flag on the given descriptor. |
clear_graph [Graphics] | Erase the graphics window. |
clear_nonblock [UnixLabels] | Clear the ``non-blocking'' flag on the given descriptor. |
clear_nonblock [Unix] | Clear the ``non-blocking'' flag on the given descriptor. |
clear_parser [Parsing] | Empty the parser stack. |
clear_symbolic_output_buffer [Format] |
|
close [UnixLabels] | Close a file descriptor. |
close [Unix] | Close a file descriptor. |
close_box [Format] | Closes the most recently open pretty-printing box. |
close_graph [Graphics] | Delete the graphics window or switch the screen back to text mode. |
close_in [Scanf.Scanning] | Closes the |
close_in [Pervasives] | |
close_in_noerr [Pervasives] | |
close_out [Pervasives] | |
close_out_noerr [Pervasives] | |
close_process [UnixLabels] | Close channels opened by |
close_process [Unix] | Close channels opened by |
close_process_full [UnixLabels] | Close channels opened by |
close_process_full [Unix] | Close channels opened by |
close_process_in [UnixLabels] | Close channels opened by |
close_process_in [Unix] | Close channels opened by |
close_process_out [UnixLabels] | Close channels opened by |
close_process_out [Unix] | Close channels opened by |
close_stag [Format] |
|
close_subwindow [GraphicsX11] | Close the sub-window having the given identifier. |
close_tag [Format] | |
close_tbox [Format] | Closes the most recently opened tabulation box. |
closedir [UnixLabels] | Close a directory descriptor. |
closedir [Unix] | Close a directory descriptor. |
closure_tag [Obj] | |
code [Char] | Return the ASCII code of the argument. |
combine [ListLabels] | Transform a pair of lists into a list of pairs:
|
combine [List] | Transform a pair of lists into a list of pairs:
|
command [Sys] | Execute the given shell command and return its exit code. |
compact [Gc] | Perform a full major collection and compact the heap. |
compare [Uchar] |
|
compare [String] | The comparison function for strings, with the same specification as
|
compare [StringLabels] | The comparison function for strings, with the same specification as
|
compare [Set.S] | Total ordering between sets. |
compare [Result] |
|
compare [Pervasives] | |
compare [Option] |
|
compare [Nativeint] | The comparison function for native integers, with the same specification as
|
compare [Set.OrderedType] | A total ordering function over the set elements. |
compare [MoreLabels.Set.S] | |
compare [MoreLabels.Map.S] | |
compare [Map.OrderedType] | A total ordering function over the keys. |
compare [Map.S] | Total ordering between maps. |
compare [Int64] | The comparison function for 64-bit integers, with the same specification as
|
compare [Int32] | The comparison function for 32-bit integers, with the same specification as
|
compare [Float] |
|
compare [Digest] | The comparison function for 16-character digest, with the same
specification as |
compare [Char] | The comparison function for characters, with the same specification as
|
compare [BytesLabels] | The comparison function for byte sequences, with the same
specification as |
compare [Bytes] | The comparison function for byte sequences, with the same
specification as |
compare_length_with [ListLabels] | Compare the length of a list to an integer. |
compare_length_with [List] | Compare the length of a list to an integer. |
compare_lengths [ListLabels] | Compare the lengths of two lists. |
compare_lengths [List] | Compare the lengths of two lists. |
complex32 [Bigarray] | See |
complex64 [Bigarray] | See |
concat [String] |
|
concat [StringLabels] |
|
concat [ListLabels] | Concatenate a list of lists. |
concat [List] | Concatenate a list of lists. |
concat [Filename] |
|
concat [BytesLabels] |
|
concat [Bytes] |
|
concat [ArrayLabels] | Same as |
concat [Array] | Same as |
concat_fmt [CamlinternalFormatBasics] | |
concat_fmtty [CamlinternalFormatBasics] | |
conj [Complex] | Conjugate: given the complex |
connect [UnixLabels] | Connect a socket to an address. |
connect [Unix] | Connect a socket to an address. |
connect [ThreadUnix] | |
cons [ListLabels] |
|
cons [List] |
|
contains [String] |
|
contains [StringLabels] |
|
contains [BytesLabels] |
|
contains [Bytes] |
|
contains_from [String] |
|
contains_from [StringLabels] |
|
contains_from [BytesLabels] |
|
contains_from [Bytes] |
|
contents [Buffer] | Return a copy of the current contents of the buffer. |
convert_raw_backtrace_slot [Printexc] | Extracts the user-friendly |
copy [String] | Return a copy of the given string. |
copy [StringLabels] | Return a copy of the given string. |
copy [Stack] | Return a copy of the given stack. |
copy [Random.State] | Return a copy of the given state. |
copy [Queue] | Return a copy of the given queue. |
copy [Oo] |
|
copy [MoreLabels.Hashtbl.SeededS] | |
copy [MoreLabels.Hashtbl.S] | |
copy [MoreLabels.Hashtbl] | |
copy [Hashtbl.SeededS] | |
copy [Hashtbl.S] | |
copy [Hashtbl] | Return a copy of the given hashtable. |
copy [CamlinternalOO] | |
copy [BytesLabels] | Return a new byte sequence that contains the same bytes as the argument. |
copy [Bytes] | Return a new byte sequence that contains the same bytes as the argument. |
copy [ArrayLabels] |
|
copy [Array] |
|
copysign [Pervasives] | |
copysign [Float] |
|
cos [Pervasives] | |
cos [Float] | Cosine. |
cosh [Pervasives] | |
cosh [Float] | Hyperbolic cosine. |
count [Weak.S] | Count the number of elements in the table. |
count [Stream] | Return the current count of the stream elements, i.e. |
counters [Gc] | Return |
create [Thread] |
|
create [Weak.S] |
|
create [Weak] |
|
create [String] |
|
create [StringLabels] |
|
create [Stack] | Return a new stack, initially empty. |
create [Spacetime.Series] |
|
create [Queue] | Return a new queue, initially empty. |
create [Obj.Ephemeron] |
|
create [Mutex] | Return a new mutex. |
create [MoreLabels.Hashtbl.SeededS] | |
create [MoreLabels.Hashtbl.S] | |
create [MoreLabels.Hashtbl] | |
create [Hashtbl.SeededS] | |
create [Hashtbl.S] | |
create [Hashtbl] |
|
create [Float.Array] | |
create [Ephemeron.Kn] | Same as |
create [Ephemeron.K2] | Same as |
create [Ephemeron.K1] |
|
create [Condition] | Return a new condition variable. |
create [BytesLabels] |
|
create [Bytes] |
|
create [Buffer] |
|
create [Bigarray.Array3] |
|
create [Bigarray.Array2] |
|
create [Bigarray.Array1] |
|
create [Bigarray.Array0] |
|
create [Bigarray.Genarray] |
|
create [ArrayLabels] | |
create [Array] | |
create_alarm [Gc] |
|
create_char_set [CamlinternalFormat] | |
create_float [ArrayLabels] |
|
create_float [Array] |
|
create_image [Graphics] |
|
create_matrix [ArrayLabels] | |
create_matrix [Array] | |
create_object [CamlinternalOO] | |
create_object_and_run_initializers [CamlinternalOO] | |
create_object_opt [CamlinternalOO] | |
create_process [UnixLabels] |
|
create_process [Unix] |
|
create_process_env [UnixLabels] |
|
create_process_env [Unix] |
|
create_table [CamlinternalOO] | |
current [Arg] | Position (in |
current_dir_name [Filename] | The conventional name for the current directory (e.g. |
current_point [Graphics] | Return the position of the current point. |
current_x [Graphics] | Return the abscissa of the current point. |
current_y [Graphics] | Return the ordinate of the current point. |
curveto [Graphics] |
|
custom_tag [Obj] | |
cyan [Graphics] | |
cygwin [Sys] | True if |
D | |
data_size [Marshal] | See |
decr [Pervasives] | |
default_available_units [Dynlink] | Reset the set of units that can be referenced from dynamically-linked code to its default value, that is, all units composing the currently running program. |
delay [Thread] |
|
delete_alarm [Gc] |
|
descr_of_in_channel [UnixLabels] | Return the descriptor corresponding to an input channel. |
descr_of_in_channel [Unix] | Return the descriptor corresponding to an input channel. |
descr_of_out_channel [UnixLabels] | Return the descriptor corresponding to an output channel. |
descr_of_out_channel [Unix] | Return the descriptor corresponding to an output channel. |
diff [Set.S] | Set difference. |
diff [MoreLabels.Set.S] | |
dim [Bigarray.Array1] | Return the size (dimension) of the given one-dimensional big array. |
dim1 [Bigarray.Array3] | Return the first dimension of the given three-dimensional big array. |
dim1 [Bigarray.Array2] | Return the first dimension of the given two-dimensional big array. |
dim2 [Bigarray.Array3] | Return the second dimension of the given three-dimensional big array. |
dim2 [Bigarray.Array2] | Return the second dimension of the given two-dimensional big array. |
dim3 [Bigarray.Array3] | Return the third dimension of the given three-dimensional big array. |
dims [Bigarray.Genarray] |
|
dir_sep [Filename] | The directory separator (e.g. |
dirname [Filename] | See |
disjoint [Set.S] | Test if two sets are disjoint. |
disjoint [MoreLabels.Set.S] | |
display_mode [Graphics] | Set display mode on or off. |
div [Nativeint] | Integer division. |
div [Int64] | Integer division. |
div [Int32] | Integer division. |
div [Float] | Floating-point division. |
div [Complex] | Division |
do_at_exit [Pervasives] | |
domain_of_sockaddr [UnixLabels] | Return the socket domain adequate for the given socket address. |
domain_of_sockaddr [Unix] | Return the socket domain adequate for the given socket address. |
double_array_tag [Obj] | |
double_field [Obj] | |
double_tag [Obj] | |
dprintf [Format] | Same as |
draw_arc [Graphics] |
|
draw_char [Graphics] | See |
draw_circle [Graphics] |
|
draw_ellipse [Graphics] |
|
draw_image [Graphics] | Draw the given image with lower left corner at the given point. |
draw_poly [Graphics] |
|
draw_poly_line [Graphics] |
|
draw_rect [Graphics] |
|
draw_segments [Graphics] |
|
draw_string [Graphics] | Draw a character or a character string with lower left corner at current position. |
dummy_class [CamlinternalOO] | |
dummy_pos [Lexing] | A value of type |
dummy_table [CamlinternalOO] | |
dump_image [Graphics] | Convert an image to a color matrix. |
dup [UnixLabels] | Return a new file descriptor referencing the same file as the given descriptor. |
dup [Unix] | Return a new file descriptor referencing the same file as the given descriptor. |
dup [Obj] | |
dup2 [UnixLabels] |
|
dup2 [Unix] |
|
E | |
elements [Set.S] | Return the list of all elements of the given set. |
elements [MoreLabels.Set.S] | |
empty [Stream] | Return |
empty [Set.S] | The empty set. |
empty [Seq] | The empty sequence, containing no elements. |
empty [MoreLabels.Set.S] | |
empty [MoreLabels.Map.S] | |
empty [Map.S] | The empty map. |
empty [BytesLabels] | A byte sequence of size 0. |
empty [Bytes] | A byte sequence of size 0. |
enable_runtime_warnings [Sys] | Control whether the OCaml runtime system can emit warnings on stderr. |
enabled [Spacetime] |
|
end_of_input [Scanf.Scanning] |
|
environment [UnixLabels] | Return the process environment, as an array of strings with the format ``variable=value''. |
environment [Unix] | Return the process environment, as an array of strings with the format ``variable=value''. |
eprintf [Printf] | Same as |
eprintf [Format] | Same as |
epsilon [Float] | The difference between |
epsilon_float [Pervasives] | |
equal [Uchar] |
|
equal [String] | The equal function for strings. |
equal [StringLabels] | The equal function for strings. |
equal [Set.S] |
|
equal [Result] |
|
equal [Option] |
|
equal [Nativeint] | The equal function for native ints. |
equal [MoreLabels.Set.S] | |
equal [MoreLabels.Map.S] | |
equal [Map.S] |
|
equal [Int64] | The equal function for int64s. |
equal [Int32] | The equal function for int32s. |
equal [Hashtbl.SeededHashedType] | The equality predicate used to compare keys. |
equal [Hashtbl.HashedType] | The equality predicate used to compare keys. |
equal [Float] | The equal function for floating-point numbers, compared using |
equal [Digest] | The equal function for 16-character digest. |
equal [Char] | The equal function for chars. |
equal [BytesLabels] | The equality function for byte sequences. |
equal [Bytes] | The equality function for byte sequences. |
erase_rel [CamlinternalFormatBasics] | |
err_formatter [Format] | A formatter to write to standard error. |
error [Result] |
|
error_message [UnixLabels] | Return a string describing the given error code. |
error_message [Unix] | Return a string describing the given error code. |
error_message [Dynlink] | Convert an error description to a printable message. |
escaped [String] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml. |
escaped [StringLabels] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml. |
escaped [Char] | Return a string representing the given character, with special characters escaped following the lexical conventions of OCaml. |
escaped [BytesLabels] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml. |
escaped [Bytes] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of OCaml. |
establish_server [UnixLabels] | Establish a server on the given address. |
establish_server [Unix] | Establish a server on the given address. |
executable_name [Sys] | The name of the file containing the executable currently running. |
execv [UnixLabels] |
|
execv [Unix] |
|
execv [ThreadUnix] | |
execve [UnixLabels] | Same as |
execve [Unix] | Same as |
execve [ThreadUnix] | |
execvp [UnixLabels] | Same as |
execvp [Unix] | Same as |
execvp [ThreadUnix] | |
execvpe [UnixLabels] | Same as |
execvpe [Unix] | Same as |
exists [Set.S] |
|
exists [MoreLabels.Set.S] | |
exists [MoreLabels.Map.S] | |
exists [Map.S] |
|
exists [ListLabels] |
|
exists [List] |
|
exists [ArrayLabels] |
|
exists [Array] |
|
exists2 [ListLabels] | Same as |
exists2 [List] | Same as |
exit [Thread] | Terminate prematurely the currently executing thread. |
exit [Pervasives] | |
exn_slot_id [Printexc] |
|
exn_slot_name [Printexc] |
|
exp [Pervasives] | |
exp [Float] | Exponential. |
exp [Complex] | Exponentiation. |
expm1 [Pervasives] | |
expm1 [Float] |
|
extend [BytesLabels] |
|
extend [Bytes] |
|
extension [Filename] |
|
extension_constructor [Obj] | |
extension_id [Obj] | |
extension_name [Obj] | |
F | |
failwith [Pervasives] | |
fast_sort [ListLabels] | Same as |
fast_sort [List] | Same as |
fast_sort [ArrayLabels] | Same as |
fast_sort [Array] | Same as |
fchmod [UnixLabels] | Change the permissions of an opened file. |
fchmod [Unix] | Change the permissions of an opened file. |
fchown [UnixLabels] | Change the owner uid and owner gid of an opened file. |
fchown [Unix] | Change the owner uid and owner gid of an opened file. |
field [Obj] | |
file [Digest] | Return the digest of the file whose name is given. |
file_exists [Sys] | Test if a file with the given name exists. |
fill [Weak] |
|
fill [String] |
|
fill [StringLabels] |
|
fill [BytesLabels] |
|
fill [Bytes] |
|
fill [Bigarray.Array3] | Fill the given big array with the given value. |
fill [Bigarray.Array2] | Fill the given big array with the given value. |
fill [Bigarray.Array1] | Fill the given big array with the given value. |
fill [Bigarray.Array0] | Fill the given big array with the given value. |
fill [Bigarray.Genarray] | Set all elements of a big array to a given value. |
fill [ArrayLabels] |
|
fill [Array] |
|
fill_arc [Graphics] | Fill an elliptical pie slice with the current color. |
fill_circle [Graphics] | Fill a circle with the current color. |
fill_ellipse [Graphics] | Fill an ellipse with the current color. |
fill_poly [Graphics] | Fill the given polygon with the current color. |
fill_rect [Graphics] |
|
filter [Set.S] |
|
filter [Seq] | Remove from the sequence the elements that do not satisfy the given predicate. |
filter [MoreLabels.Set.S] | |
filter [MoreLabels.Map.S] | |
filter [Map.S] |
|
filter [ListLabels] |
|
filter [List] |
|
filter_map [Seq] | Apply the function to every element; if |
filter_map_inplace [MoreLabels.Hashtbl.SeededS] | |
filter_map_inplace [MoreLabels.Hashtbl.S] | |
filter_map_inplace [MoreLabels.Hashtbl] | |
filter_map_inplace [Hashtbl.SeededS] | |
filter_map_inplace [Hashtbl.S] | |
filter_map_inplace [Hashtbl] |
|
final_tag [Obj] | |
finalise [Gc] |
|
finalise_last [Gc] | same as |
finalise_release [Gc] | A finalisation function may call |
find [Weak.S] |
|
find [Set.S] |
|
find [MoreLabels.Set.S] | |
find [MoreLabels.Map.S] | |
find [MoreLabels.Hashtbl.SeededS] | |
find [MoreLabels.Hashtbl.S] | |
find [MoreLabels.Hashtbl] | |
find [Map.S] |
|
find [ListLabels] |
|
find [List] |
|
find [Hashtbl.SeededS] | |
find [Hashtbl.S] | |
find [Hashtbl] |
|
find_all [Weak.S] |
|
find_all [MoreLabels.Hashtbl.SeededS] | |
find_all [MoreLabels.Hashtbl.S] | |
find_all [MoreLabels.Hashtbl] | |
find_all [ListLabels] |
|
find_all [List] |
|
find_all [Hashtbl.SeededS] | |
find_all [Hashtbl.S] | |
find_all [Hashtbl] |
|
find_first [Set.S] |
|
find_first [MoreLabels.Set.S] | |
find_first [MoreLabels.Map.S] | |
find_first [Map.S] |
|
find_first_opt [Set.S] |
|
find_first_opt [MoreLabels.Set.S] | |
find_first_opt [MoreLabels.Map.S] | |
find_first_opt [Map.S] |
|
find_last [Set.S] |
|
find_last [MoreLabels.Set.S] | |
find_last [MoreLabels.Map.S] | |
find_last [Map.S] |
|
find_last_opt [Set.S] |
|
find_last_opt [MoreLabels.Set.S] | |
find_last_opt [MoreLabels.Map.S] | |
find_last_opt [Map.S] |
|
find_opt [Weak.S] |
|
find_opt [Set.S] |
|
find_opt [MoreLabels.Set.S] | |
find_opt [MoreLabels.Map.S] | |
find_opt [MoreLabels.Hashtbl.SeededS] | |
find_opt [MoreLabels.Hashtbl.S] | |
find_opt [MoreLabels.Hashtbl] | |
find_opt [Map.S] |
|
find_opt [ListLabels] |
|
find_opt [List] |
|
find_opt [Hashtbl.SeededS] | |
find_opt [Hashtbl.S] | |
find_opt [Hashtbl] |
|
first_chars [Str] |
|
first_non_constant_constructor_tag [Obj] | |
flat_map [Seq] | Map each element to a subsequence, then return each element of this sub-sequence in turn. |
flatten [ListLabels] | Same as |
flatten [List] | An alias for |
float [Random.State] | |
float [Random] |
|
float [Pervasives] | |
float32 [Bigarray] | See |
float64 [Bigarray] | See |
float_of_bits [Int64] | Return the floating-point number whose internal representation,
according to the IEEE 754 floating-point 'double format' bit layout,
is the given |
float_of_bits [Int32] | Return the floating-point number whose internal representation,
according to the IEEE 754 floating-point 'single format' bit layout,
is the given |
float_of_int [Pervasives] | |
float_of_string [Pervasives] | |
float_of_string_opt [Pervasives] | |
floor [Pervasives] | |
floor [Float] | Round below to an integer value. |
flush [Pervasives] | |
flush_all [Pervasives] | |
flush_input [Lexing] | Discard the contents of the buffer and reset the current position to 0. |
flush_str_formatter [Format] | Returns the material printed with |
flush_symbolic_output_buffer [Format] |
|
fmt_ebb_of_string [CamlinternalFormat] | |
fold [Weak.S] |
|
fold [Stack] |
|
fold [Set.S] |
|
fold [Result] |
|
fold [Queue] |
|
fold [Option] |
|
fold [MoreLabels.Set.S] | |
fold [MoreLabels.Map.S] | |
fold [MoreLabels.Hashtbl.SeededS] | |
fold [MoreLabels.Hashtbl.S] | |
fold [MoreLabels.Hashtbl] | |
fold [Map.S] |
|
fold [Hashtbl.SeededS] | |
fold [Hashtbl.S] | |
fold [Hashtbl] |
|
fold_left [Seq] | Traverse the sequence from left to right, combining each element with the accumulator using the given function. |
fold_left [ListLabels] |
|
fold_left [List] |
|
fold_left [ArrayLabels] |
|
fold_left [Array] |
|
fold_left2 [ListLabels] |
|
fold_left2 [List] |
|
fold_right [ListLabels] |
|
fold_right [List] |
|
fold_right [ArrayLabels] |
|
fold_right [Array] |
|
fold_right2 [ListLabels] |
|
fold_right2 [List] |
|
for_all [Set.S] |
|
for_all [MoreLabels.Set.S] | |
for_all [MoreLabels.Map.S] | |
for_all [Map.S] |
|
for_all [ListLabels] |
|
for_all [List] |
|
for_all [ArrayLabels] |
|
for_all [Array] |
|
for_all2 [ListLabels] | Same as |
for_all2 [List] | Same as |
force [Lazy] |
|
force [CamlinternalLazy] | |
force_lazy_block [CamlinternalLazy] | |
force_newline [Format] | Force a new line in the current pretty-printing box. |
force_val [Lazy] |
|
force_val [CamlinternalLazy] | |
force_val_lazy_block [CamlinternalLazy] | |
foreground [Graphics] | Default background and foreground colors (usually, either black foreground on a white background or white foreground on a black background). |
fork [UnixLabels] | Fork a new process. |
fork [Unix] | Fork a new process. |
format [Printexc.Slot] |
|
format_from_string [Scanf] |
|
format_of_string [Pervasives] | |
format_of_string_fmtty [CamlinternalFormat] | |
format_of_string_format [CamlinternalFormat] | |
formatter_of_buffer [Format] |
|
formatter_of_out_channel [Format] |
|
formatter_of_out_functions [Format] |
|
formatter_of_symbolic_output_buffer [Format] |
|
fortran_layout [Bigarray] | |
forward_tag [Obj] | |
fprintf [Printf] |
|
fprintf [Format] | |
freeze_char_set [CamlinternalFormat] | |
frexp [Pervasives] | |
frexp [Float] |
|
from [Stream] |
|
from_bytes [Marshal] |
|
from_channel [Scanf.Scanning] |
|
from_channel [Marshal] |
|
from_channel [Lexing] | Create a lexer buffer on the given input channel. |
from_file [Scanf.Scanning] | An alias for |
from_file_bin [Scanf.Scanning] | An alias for |
from_fun [Lazy] |
|
from_function [Scanf.Scanning] |
|
from_function [Lexing] | Create a lexer buffer with the given function as its reading method. |
from_hex [Digest] | Convert a hexadecimal representation back into the corresponding digest. |
from_string [Scanf.Scanning] |
|
from_string [Marshal] | Same as |
from_string [Lexing] | Create a lexer buffer which reads from the given string. |
from_val [Lazy] |
|
fscanf [Scanf] | |
fst [Pervasives] | |
fstat [UnixLabels.LargeFile] | |
fstat [UnixLabels] | Return the information for the file associated with the given descriptor. |
fstat [Unix.LargeFile] | |
fstat [Unix] | Return the information for the file associated with the given descriptor. |
fsync [Unix] | Flush file buffers to disk. |
ftruncate [UnixLabels.LargeFile] | |
ftruncate [UnixLabels] | Truncates the file corresponding to the given descriptor to the given size. |
ftruncate [Unix.LargeFile] | See |
ftruncate [Unix] | Truncates the file corresponding to the given descriptor to the given size. |
full_init [Random] | Same as |
full_major [Gc] | Do a minor collection, finish the current major collection cycle, and perform a complete new cycle. |
full_split [Str] | Same as |
G | |
genarray_of_array0 [Bigarray] | Return the generic big array corresponding to the given zero-dimensional big array. |
genarray_of_array1 [Bigarray] | Return the generic big array corresponding to the given one-dimensional big array. |
genarray_of_array2 [Bigarray] | Return the generic big array corresponding to the given two-dimensional big array. |
genarray_of_array3 [Bigarray] | Return the generic big array corresponding to the given three-dimensional big array. |
get [Weak] |
|
get [String] |
|
get [StringLabels] |
|
get [Option] |
|
get [Gc] | Return the current values of the GC parameters in a |
get [Float.Array] | |
get [BytesLabels] |
|
get [Bytes] |
|
get [Bigarray.Array3] |
|
get [Bigarray.Array2] |
|
get [Bigarray.Array1] |
|
get [Bigarray.Array0] |
|
get [Bigarray.Genarray] | Read an element of a generic big array. |
get [ArrayLabels] |
|
get [Array] |
|
get_all_formatter_output_functions [Format] | |
get_backtrace [Printexc] |
|
get_bucket [Gc] |
|
get_callstack [Printexc] |
|
get_copy [Weak] |
|
get_credit [Gc] |
|
get_data [Obj.Ephemeron] | Same as |
get_data [Ephemeron.Kn] | Same as |
get_data [Ephemeron.K2] | Same as |
get_data [Ephemeron.K1] |
|
get_data_copy [Obj.Ephemeron] | Same as |
get_data_copy [Ephemeron.Kn] | Same as |
get_data_copy [Ephemeron.K2] | Same as |
get_data_copy [Ephemeron.K1] |
|
get_ellipsis_text [Format] | Return the text of the ellipsis. |
get_error [Result] |
|
get_formatter_out_functions [Format] | Return the current output functions of the pretty-printer, including line splitting and indentation functions. |
get_formatter_output_functions [Format] | Return the current output functions of the standard pretty-printer. |
get_formatter_stag_functions [Format] | Return the current semantic tag operation functions of the standard pretty-printer. |
get_formatter_tag_functions [Format] | |
get_image [Graphics] | Capture the contents of a rectangle on the screen as an image. |
get_key [Obj.Ephemeron] | Same as |
get_key [Ephemeron.Kn] | Same as |
get_key [Ephemeron.K1] |
|
get_key1 [Ephemeron.K2] | Same as |
get_key1_copy [Ephemeron.K2] | Same as |
get_key2 [Ephemeron.K2] | Same as |
get_key2_copy [Ephemeron.K2] | Same as |
get_key_copy [Obj.Ephemeron] | Same as |
get_key_copy [Ephemeron.Kn] | Same as |
get_key_copy [Ephemeron.K1] |
|
get_margin [Format] | Returns the position of the right margin. |
get_mark_tags [Format] | Return the current status of tag-marking operations. |
get_max_boxes [Format] | Returns the maximum number of pretty-printing boxes allowed before ellipsis. |
get_max_indent [Format] | Return the maximum indentation limit (in characters). |
get_method [CamlinternalOO] | |
get_method_label [CamlinternalOO] | |
get_method_labels [CamlinternalOO] | |
get_minor_free [Gc] | Return the current size of the free space inside the minor heap. |
get_ok [Result] |
|
get_print_tags [Format] | Return the current status of tag-printing operations. |
get_public_method [CamlinternalOO] | |
get_raw_backtrace [Printexc] |
|
get_raw_backtrace_next_slot [Printexc] |
|
get_raw_backtrace_slot [Printexc] |
|
get_state [Random] | Return the current state of the generator used by the basic functions. |
get_symbolic_output_buffer [Format] |
|
get_temp_dir_name [Filename] | The name of the temporary directory:
Under Unix, the value of the |
get_variable [CamlinternalOO] | |
get_variables [CamlinternalOO] | |
getaddrinfo [UnixLabels] |
|
getaddrinfo [Unix] |
|
getcwd [UnixLabels] | Return the name of the current working directory. |
getcwd [Unix] | Return the name of the current working directory. |
getcwd [Sys] | Return the current working directory of the process. |
getegid [UnixLabels] | Return the effective group id under which the process runs. |
getegid [Unix] | Return the effective group id under which the process runs. |
getenv [UnixLabels] | Return the value associated to a variable in the process environment. |
getenv [Unix] | Return the value associated to a variable in the process environment, unless the process has special privileges. |
getenv [Sys] | Return the value associated to a variable in the process environment. |
getenv_opt [Sys] | Return the value associated to a variable in the process
environment or |
geteuid [UnixLabels] | Return the effective user id under which the process runs. |
geteuid [Unix] | Return the effective user id under which the process runs. |
getgid [UnixLabels] | Return the group id of the user executing the process. |
getgid [Unix] | Return the group id of the user executing the process. |
getgrgid [UnixLabels] | Find an entry in |
getgrgid [Unix] | Find an entry in |
getgrnam [UnixLabels] | Find an entry in |
getgrnam [Unix] | Find an entry in |
getgroups [UnixLabels] | Return the list of groups to which the user executing the process belongs. |
getgroups [Unix] | Return the list of groups to which the user executing the process belongs. |
gethostbyaddr [UnixLabels] | Find an entry in |
gethostbyaddr [Unix] | Find an entry in |
gethostbyname [UnixLabels] | Find an entry in |
gethostbyname [Unix] | Find an entry in |
gethostname [UnixLabels] | Return the name of the local host. |
gethostname [Unix] | Return the name of the local host. |
getitimer [UnixLabels] | Return the current status of the given interval timer. |
getitimer [Unix] | Return the current status of the given interval timer. |
getlogin [UnixLabels] | Return the login name of the user executing the process. |
getlogin [Unix] | Return the login name of the user executing the process. |
getnameinfo [UnixLabels] |
|
getnameinfo [Unix] |
|
getpeername [UnixLabels] | Return the address of the host connected to the given socket. |
getpeername [Unix] | Return the address of the host connected to the given socket. |
getpid [UnixLabels] | Return the pid of the process. |
getpid [Unix] | Return the pid of the process. |
getppid [UnixLabels] | Return the pid of the parent process. |
getppid [Unix] | Return the pid of the parent process. |
getprotobyname [UnixLabels] | Find an entry in |
getprotobyname [Unix] | Find an entry in |
getprotobynumber [UnixLabels] | Find an entry in |
getprotobynumber [Unix] | Find an entry in |
getpwnam [UnixLabels] | Find an entry in |
getpwnam [Unix] | Find an entry in |
getpwuid [UnixLabels] | Find an entry in |
getpwuid [Unix] | Find an entry in |
getservbyname [UnixLabels] | Find an entry in |
getservbyname [Unix] | Find an entry in |
getservbyport [UnixLabels] | Find an entry in |
getservbyport [Unix] | Find an entry in |
getsockname [UnixLabels] | Return the address of the given socket. |
getsockname [Unix] | Return the address of the given socket. |
getsockopt [UnixLabels] | Return the current status of a boolean-valued option in the given socket. |
getsockopt [Unix] | Return the current status of a boolean-valued option in the given socket. |
getsockopt_error [UnixLabels] | Return the error condition associated with the given socket, and clear it. |
getsockopt_error [Unix] | Return the error condition associated with the given socket, and clear it. |
getsockopt_float [UnixLabels] | Same as |
getsockopt_float [Unix] | Same as |
getsockopt_int [UnixLabels] | Same as |
getsockopt_int [Unix] | Same as |
getsockopt_optint [UnixLabels] | Same as |
getsockopt_optint [Unix] | Same as |
gettimeofday [UnixLabels] | Same as |
gettimeofday [Unix] | Same as |
getuid [UnixLabels] | Return the user id of the user executing the process. |
getuid [Unix] | Return the user id of the user executing the process. |
global_replace [Str] |
|
global_substitute [Str] |
|
gmtime [UnixLabels] | Convert a time in seconds, as returned by |
gmtime [Unix] | Convert a time in seconds, as returned by |
green [Graphics] | |
group_beginning [Str] |
|
group_end [Str] |
|
guard [Event] |
|
H | |
handle_unix_error [UnixLabels] |
|
handle_unix_error [Unix] |
|
has_symlink [UnixLabels] | Returns |
has_symlink [Unix] | Returns |
hash [Uchar] |
|
hash [MoreLabels.Hashtbl] | |
hash [Hashtbl.SeededHashedType] | A seeded hashing function on keys. |
hash [Hashtbl.HashedType] | A hashing function on keys. |
hash [Hashtbl] |
|
hash [Float] | The hash function for floating-point numbers. |
hash_param [MoreLabels.Hashtbl] | |
hash_param [Hashtbl] |
|
hd [ListLabels] | Return the first element of the given list. |
hd [List] | Return the first element of the given list. |
header_size [Marshal] | The bytes representing a marshaled value are composed of a fixed-size header and a variable-sized data part, whose size can be determined from the header. |
huge_fallback_count [Gc] | Return the number of times we tried to map huge pages and had to fall back to small pages. |
hypot [Pervasives] | |
hypot [Float] |
|
I | |
i [Complex] | The complex number |
id [Thread] | Return the identifier of the given thread. |
id [Oo] | Return an integer identifying this object, unique for the current execution of the program. |
ifprintf [Printf] | Same as |
ifprintf [Format] | Same as |
ignore [Pervasives] | |
ikfprintf [Printf] | Same as |
ikfprintf [Format] | Same as |
in_channel_length [Stdlib.LargeFile] | |
in_channel_length [Pervasives] | |
in_channel_of_descr [UnixLabels] | Create an input channel reading from the given descriptor. |
in_channel_of_descr [Unix] | Create an input channel reading from the given descriptor. |
incr [Pervasives] | |
index [String] |
|
index [StringLabels] |
|
index [BytesLabels] |
|
index [Bytes] |
|
index_from [String] |
|
index_from [StringLabels] |
|
index_from [BytesLabels] |
|
index_from [Bytes] |
|
index_from_opt [String] |
|
index_from_opt [StringLabels] |
|
index_from_opt [BytesLabels] |
|
index_from_opt [Bytes] |
|
index_opt [String] |
|
index_opt [StringLabels] |
|
index_opt [BytesLabels] |
|
index_opt [Bytes] |
|
inet6_addr_any [UnixLabels] | A special IPv6 address, for use only with |
inet6_addr_any [Unix] | A special IPv6 address, for use only with |
inet6_addr_loopback [UnixLabels] | A special IPv6 address representing the host machine ( |
inet6_addr_loopback [Unix] | A special IPv6 address representing the host machine ( |
inet_addr_any [UnixLabels] | A special IPv4 address, for use only with |
inet_addr_any [Unix] | A special IPv4 address, for use only with |
inet_addr_loopback [UnixLabels] | A special IPv4 address representing the host machine ( |
inet_addr_loopback [Unix] | A special IPv4 address representing the host machine ( |
inet_addr_of_string [UnixLabels] | Conversion from the printable representation of an Internet address to its internal representation. |
inet_addr_of_string [Unix] | Conversion from the printable representation of an Internet address to its internal representation. |
infinity [Pervasives] | |
infinity [Float] | Positive infinity. |
infix_tag [Obj] | |
inherits [CamlinternalOO] | |
init [String] |
|
init [StringLabels] |
|
init [Random] | Initialize the generator, using the argument as a seed. |
init [ListLabels] |
|
init [List] |
|
init [Dynlink] | |
init [BytesLabels] |
|
init [Bytes] |
|
init [ArrayLabels] |
|
init [Array] |
|
init_class [CamlinternalOO] | |
init_mod [CamlinternalMod] | |
initgroups [UnixLabels] |
|
initgroups [Unix] |
|
input [Pervasives] | |
input [Digest] | Read a digest from the given input channel. |
input_binary_int [Pervasives] | |
input_byte [Pervasives] | |
input_char [Pervasives] | |
input_line [Pervasives] | |
input_value [Pervasives] | |
int [Random.State] | |
int [Random] |
|
int [Bigarray] | See |
int16_signed [Bigarray] | See |
int16_unsigned [Bigarray] | See |
int32 [Random.State] | |
int32 [Random] |
|
int32 [Bigarray] | See |
int64 [Random.State] | |
int64 [Random] |
|
int64 [Bigarray] | See |
int8_signed [Bigarray] | See |
int8_unsigned [Bigarray] | See |
int_of_char [Pervasives] | |
int_of_float [Pervasives] | |
int_of_string [Pervasives] | |
int_of_string_opt [Pervasives] | |
int_size [Sys] | Size of |
int_tag [Obj] | |
inter [Set.S] | Set intersection. |
inter [MoreLabels.Set.S] | |
interactive [Sys] | This reference is initially set to |
inv [Complex] | Multiplicative inverse ( |
invalid_arg [Pervasives] | |
is_block [Obj] | |
is_char [Uchar] |
|
is_directory [Sys] | Returns |
is_empty [Stack] | Return |
is_empty [Set.S] | Test whether a set is empty or not. |
is_empty [Queue] | Return |
is_empty [MoreLabels.Set.S] | |
is_empty [MoreLabels.Map.S] | |
is_empty [Map.S] | Test whether a map is empty or not. |
is_error [Result] |
|
is_implicit [Filename] | Return |
is_in_char_set [CamlinternalFormat] | |
is_inline [Printexc.Slot] |
|
is_int [Obj] | |
is_native [Dynlink] |
|
is_none [Option] |
|
is_ok [Result] |
|
is_raise [Printexc.Slot] |
|
is_randomized [MoreLabels.Hashtbl] | |
is_randomized [Hashtbl] | return if the tables are currently created in randomized mode by default |
is_relative [Filename] | Return |
is_some [Option] |
|
is_val [Lazy] |
|
is_valid [Uchar] |
|
isatty [UnixLabels] | Return |
isatty [Unix] | Return |
iter [Weak.S] |
|
iter [String] |
|
iter [Stream] |
|
iter [StringLabels] |
|
iter [Stack] |
|
iter [Set.S] |
|
iter [Seq] | Iterate on the sequence, calling the (imperative) function on every element. |
iter [Result] |
|
iter [Queue] |
|
iter [Option] |
|
iter [MoreLabels.Set.S] | |
iter [MoreLabels.Map.S] | |
iter [MoreLabels.Hashtbl.SeededS] | |
iter [MoreLabels.Hashtbl.S] | |
iter [MoreLabels.Hashtbl] | |
iter [Map.S] |
|
iter [ListLabels] |
|
iter [List] |
|
iter [Hashtbl.SeededS] | |
iter [Hashtbl.S] | |
iter [Hashtbl] |
|
iter [BytesLabels] |
|
iter [Bytes] |
|
iter [ArrayLabels] |
|
iter [Array] |
|
iter2 [ListLabels] |
|
iter2 [List] |
|
iter2 [ArrayLabels] |
|
iter2 [Array] |
|
iter_error [Result] |
|
iteri [String] | Same as |
iteri [StringLabels] | Same as |
iteri [ListLabels] | Same as |
iteri [List] | Same as |
iteri [BytesLabels] | Same as |
iteri [Bytes] | Same as |
iteri [ArrayLabels] | Same as |
iteri [Array] | Same as |
J | |
join [Thread] |
|
join [Result] |
|
join [Option] |
|
junk [Stream] | Remove the first element of the stream, possibly unfreezing it before. |
K | |
kasprintf [Format] | Same as |
kbprintf [Printf] | Same as |
kdprintf [Format] | Same as |
key_pressed [Graphics] | Return |
kfprintf [Printf] | Same as |
kfprintf [Format] | Same as |
kfscanf [Scanf] | |
kill [UnixLabels] |
|
kill [Unix] |
|
kill [Thread] | Terminate prematurely the thread whose handle is given. |
kind [Bigarray.Array3] | Return the kind of the given big array. |
kind [Bigarray.Array2] | Return the kind of the given big array. |
kind [Bigarray.Array1] | Return the kind of the given big array. |
kind [Bigarray.Array0] | Return the kind of the given big array. |
kind [Bigarray.Genarray] | Return the kind of the given big array. |
kind_size_in_bytes [Bigarray] |
|
kprintf [Printf] | A deprecated synonym for |
kprintf [Format] | |
kscanf [Scanf] | Same as |
ksprintf [Printf] | Same as |
ksprintf [Format] | Same as |
ksscanf [Scanf] | Same as |
L | |
last_chars [Str] |
|
last_non_constant_constructor_tag [Obj] | |
layout [Bigarray.Array3] | Return the layout of the given big array. |
layout [Bigarray.Array2] | Return the layout of the given big array. |
layout [Bigarray.Array1] | Return the layout of the given big array. |
layout [Bigarray.Array0] | Return the layout of the given big array. |
layout [Bigarray.Genarray] | Return the layout of the given big array. |
lazy_from_fun [Lazy] | |
lazy_from_val [Lazy] | |
lazy_is_val [Lazy] | |
lazy_tag [Obj] | |
ldexp [Pervasives] | |
ldexp [Float] |
|
length [Weak] |
|
length [String] | Return the length (number of characters) of the given string. |
length [StringLabels] | Return the length (number of characters) of the given string. |
length [Stack] | Return the number of elements in a stack. |
length [Queue] | Return the number of elements in a queue. |
length [Obj.Ephemeron] | return the number of keys |
length [MoreLabels.Hashtbl.SeededS] | |
length [MoreLabels.Hashtbl.S] | |
length [MoreLabels.Hashtbl] | |
length [ListLabels] | Return the length (number of elements) of the given list. |
length [List] | Return the length (number of elements) of the given list. |
length [Hashtbl.SeededS] | |
length [Hashtbl.S] | |
length [Hashtbl] |
|
length [Float.Array] | |
length [BytesLabels] | Return the length (number of bytes) of the argument. |
length [Bytes] | Return the length (number of bytes) of the argument. |
length [Buffer] | Return the number of characters currently contained in the buffer. |
length [ArrayLabels] | Return the length (number of elements) of the given array. |
length [Array] | Return the length (number of elements) of the given array. |
lexeme [Lexing] |
|
lexeme_char [Lexing] |
|
lexeme_end [Lexing] |
|
lexeme_end_p [Lexing] | Like |
lexeme_start [Lexing] |
|
lexeme_start_p [Lexing] | Like |
lineto [Graphics] | Draw a line with endpoints the current point and the given point, and move the current point to the given point. |
link [UnixLabels] |
|
link [Unix] |
|
listen [UnixLabels] | Set up a socket for receiving connection requests. |
listen [Unix] | Set up a socket for receiving connection requests. |
lnot [Pervasives] | |
loadfile [Dynlink] | In bytecode: load the given bytecode object file ( |
loadfile_private [Dynlink] | Same as |
localtime [UnixLabels] | Convert a time in seconds, as returned by |
localtime [Unix] | Convert a time in seconds, as returned by |
location [Printexc.Slot] |
|
lock [Mutex] | Lock the given mutex. |
lockf [UnixLabels] |
|
lockf [Unix] |
|
log [Pervasives] | |
log [Float] | Natural logarithm. |
log [Complex] | Natural logarithm (in base |
log10 [Pervasives] | |
log10 [Float] | Base 10 logarithm. |
log1p [Pervasives] | |
log1p [Float] |
|
logand [Nativeint] | Bitwise logical and. |
logand [Int64] | Bitwise logical and. |
logand [Int32] | Bitwise logical and. |
lognot [Nativeint] | Bitwise logical negation. |
lognot [Int64] | Bitwise logical negation. |
lognot [Int32] | Bitwise logical negation. |
logor [Nativeint] | Bitwise logical or. |
logor [Int64] | Bitwise logical or. |
logor [Int32] | Bitwise logical or. |
logxor [Nativeint] | Bitwise logical exclusive or. |
logxor [Int64] | Bitwise logical exclusive or. |
logxor [Int32] | Bitwise logical exclusive or. |
lookup_tables [CamlinternalOO] | |
loop_at_exit [Graphics] | Loop before exiting the program, the list given as argument is the list of handlers and the events on which these handlers are called. |
lowercase [String] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
lowercase [StringLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
lowercase [Char] | Convert the given character to its equivalent lowercase character, using the ISO Latin-1 (8859-1) character set. |
lowercase [BytesLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
lowercase [Bytes] | Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
lowercase_ascii [String] | Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set. |
lowercase_ascii [StringLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set. |
lowercase_ascii [Char] | Convert the given character to its equivalent lowercase character, using the US-ASCII character set. |
lowercase_ascii [BytesLabels] | Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set. |
lowercase_ascii [Bytes] | Return a copy of the argument, with all uppercase letters translated to lowercase, using the US-ASCII character set. |
lseek [UnixLabels.LargeFile] | |
lseek [UnixLabels] | Set the current position for a file descriptor, and return the resulting offset (from the beginning of the file). |
lseek [Unix.LargeFile] | See |
lseek [Unix] | Set the current position for a file descriptor, and return the resulting offset (from the beginning of the file). |
lstat [UnixLabels.LargeFile] | |
lstat [UnixLabels] | Same as |
lstat [Unix.LargeFile] | |
lstat [Unix] | Same as |
M | |
magenta [Graphics] | |
magic [Obj] | |
major [Gc] | Do a minor collection and finish the current major collection cycle. |
major_slice [Gc] |
|
make [String] |
|
make [StringLabels] |
|
make [Random.State] | Create a new state and initialize it with the given seed. |
make [BytesLabels] |
|
make [Bytes] |
|
make [ArrayLabels] |
|
make [Array] |
|
make_class [CamlinternalOO] | |
make_class_store [CamlinternalOO] | |
make_float [ArrayLabels] | |
make_float [Array] | |
make_formatter [Format] |
|
make_image [Graphics] | Convert the given color matrix to an image. |
make_iprintf [CamlinternalFormat] | |
make_lexer [Genlex] | Construct the lexer function. |
make_matrix [ArrayLabels] |
|
make_matrix [Array] |
|
make_printf [CamlinternalFormat] | |
make_self_init [Random.State] | Create a new state and initialize it with a system-dependent low-entropy seed. |
make_symbolic_output_buffer [Format] |
|
map [String] |
|
map [StringLabels] |
|
map [Set.S] |
|
map [Seq] |
|
map [Result] |
|
map [Option] |
|
map [MoreLabels.Set.S] | |
map [MoreLabels.Map.S] | |
map [Map.S] |
|
map [ListLabels] |
|
map [List] |
|
map [BytesLabels] |
|
map [Bytes] |
|
map [ArrayLabels] |
|
map [Array] |
|
map2 [ListLabels] |
|
map2 [List] |
|
map2 [ArrayLabels] |
|
map2 [Array] |
|
map_error [Result] |
|
map_file [UnixLabels] | Memory mapping of a file as a big array. |
map_file [Unix] | Memory mapping of a file as a big array. |
mapi [String] |
|
mapi [StringLabels] |
|
mapi [MoreLabels.Map.S] | |
mapi [Map.S] | Same as |
mapi [ListLabels] | Same as |
mapi [List] | Same as |
mapi [BytesLabels] |
|
mapi [Bytes] |
|
mapi [ArrayLabels] | Same as |
mapi [Array] | Same as |
marshal [Obj] | |
match_beginning [Str] |
|
match_end [Str] |
|
matched_group [Str] |
|
matched_string [Str] |
|
max [Uchar] |
|
max [Pervasives] | |
max_array_length [Sys] | Maximum length of a normal array. |
max_binding [MoreLabels.Map.S] | |
max_binding [Map.S] | Same as |
max_binding_opt [MoreLabels.Map.S] | |
max_binding_opt [Map.S] | Same as |
max_elt [Set.S] | Same as |
max_elt [MoreLabels.Set.S] | |
max_elt_opt [Set.S] | Same as |
max_elt_opt [MoreLabels.Set.S] | |
max_float [Pervasives] | |
max_float [Float] | The largest positive finite value of type |
max_int [Pervasives] | |
max_int [Nativeint] | The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform. |
max_int [Int64] | The greatest representable 64-bit integer, 263 - 1. |
max_int [Int32] | The greatest representable 32-bit integer, 231 - 1. |
max_string_length [Sys] | Maximum length of strings and byte sequences. |
mem [Weak.S] |
|
mem [Set.S] |
|
mem [MoreLabels.Set.S] | |
mem [MoreLabels.Map.S] | |
mem [MoreLabels.Hashtbl.SeededS] | |
mem [MoreLabels.Hashtbl.S] | |
mem [MoreLabels.Hashtbl] | |
mem [Map.S] |
|
mem [ListLabels] |
|
mem [List] |
|
mem [Hashtbl.SeededS] | |
mem [Hashtbl.S] | |
mem [Hashtbl] |
|
mem [ArrayLabels] |
|
mem [Array] |
|
mem_assoc [ListLabels] | Same as |
mem_assoc [List] | Same as |
mem_assq [ListLabels] | Same as |
mem_assq [List] | Same as |
memq [ListLabels] | Same as |
memq [List] | Same as |
memq [ArrayLabels] | Same as |
memq [Array] | Same as |
merge [Weak.S] |
|
merge [MoreLabels.Map.S] | |
merge [Map.S] |
|
merge [ListLabels] | Merge two lists:
Assuming that |
merge [List] | Merge two lists:
Assuming that |
min [Uchar] |
|
min [Pervasives] | |
min_binding [MoreLabels.Map.S] | |
min_binding [Map.S] | Return the smallest binding of the given map
(with respect to the |
min_binding_opt [MoreLabels.Map.S] | |
min_binding_opt [Map.S] | Return the smallest binding of the given map
(with respect to the |
min_elt [Set.S] | Return the smallest element of the given set
(with respect to the |
min_elt [MoreLabels.Set.S] | |
min_elt_opt [Set.S] | Return the smallest element of the given set
(with respect to the |
min_elt_opt [MoreLabels.Set.S] | |
min_float [Pervasives] | |
min_float [Float] | The smallest positive, non-zero, non-denormalized value of type |
min_int [Pervasives] | |
min_int [Nativeint] | The smallest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform. |
min_int [Int64] | The smallest representable 64-bit integer, -263. |
min_int [Int32] | The smallest representable 32-bit integer, -231. |
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. |
mkdir [UnixLabels] | Create a directory with the given permissions. |
mkdir [Unix] | Create a directory with the given permissions (see |
mkfifo [UnixLabels] | Create a named pipe with the given permissions. |
mkfifo [Unix] | Create a named pipe with the given permissions (see |
mktime [UnixLabels] | Convert a date and time, specified by the |
mktime [Unix] | Convert a date and time, specified by the |
mod_float [Pervasives] | |
modf [Pervasives] | |
modf [Float] |
|
mouse_pos [Graphics] | Return the position of the mouse cursor, relative to the graphics window. |
moveto [Graphics] | Position the current point. |
mul [Nativeint] | Multiplication. |
mul [Int64] | Multiplication. |
mul [Int32] | Multiplication. |
mul [Float] | Floating-point multiplication. |
mul [Complex] | Multiplication |
N | |
name_of_input [Scanf.Scanning] |
|
nan [Pervasives] | |
nan [Float] | A special floating-point value denoting the result of an
undefined operation such as |
narrow [CamlinternalOO] | |
nativeint [Random.State] | |
nativeint [Random] |
|
nativeint [Bigarray] | See |
neg [Nativeint] | Unary negation. |
neg [Int64] | Unary negation. |
neg [Int32] | Unary negation. |
neg [Float] | Unary negation. |
neg [Complex] | Unary negation. |
neg_infinity [Pervasives] | |
neg_infinity [Float] | Negative infinity. |
new_block [Obj] | |
new_channel [Event] | Return a new channel. |
new_line [Lexing] | Update the |
new_method [CamlinternalOO] | |
new_methods_variables [CamlinternalOO] | |
new_variable [CamlinternalOO] | |
next [Stream] | Return the first element of the stream and remove it from the stream. |
nice [UnixLabels] | Change the process priority. |
nice [Unix] | Change the process priority. |
no_scan_tag [Obj] | |
none [Option] |
|
norm [Complex] | Norm: given |
norm2 [Complex] | Norm squared: given |
not [Pervasives] | |
npeek [Stream] |
|
nth [ListLabels] | Return the |
nth [List] | Return the |
nth [Buffer] | Get the n-th character of the buffer. |
nth_dim [Bigarray.Genarray] |
|
nth_opt [ListLabels] | Return the |
nth_opt [List] | Return the |
num_dims [Bigarray.Genarray] | Return the number of dimensions of the given big array. |
O | |
obj [Obj] | |
object_tag [Obj] | |
ocaml_version [Sys] |
|
of_array [Bigarray.Array3] | Build a three-dimensional big array initialized from the given array of arrays of arrays. |
of_array [Bigarray.Array2] | Build a two-dimensional big array initialized from the given array of arrays. |
of_array [Bigarray.Array1] | Build a one-dimensional big array initialized from the given array. |
of_bytes [Stream] | Return the stream of the characters of the bytes parameter. |
of_channel [Stream] | Return the stream of the characters read from the input channel. |
of_char [Uchar] |
|
of_float [Nativeint] | Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0). |
of_float [Int64] | Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0). |
of_float [Int32] | Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0). |
of_int [Uchar] |
|
of_int [Nativeint] | Convert the given integer (type |
of_int [Int64] | Convert the given integer (type |
of_int [Int32] | Convert the given integer (type |
of_int [Float] | Convert an integer to floating-point. |
of_int32 [Nativeint] | Convert the given 32-bit integer (type |
of_int32 [Int64] | Convert the given 32-bit integer (type |
of_list [Stream] | Return the stream holding the elements of the list in the same order. |
of_list [Set.S] |
|
of_list [MoreLabels.Set.S] | |
of_list [ArrayLabels] |
|
of_list [Array] |
|
of_nativeint [Int64] | Convert the given native integer (type |
of_seq [String] | Create a string from the generator |
of_seq [StringLabels] | Create a string from the generator |
of_seq [Stack] | Create a stack from the iterator |
of_seq [Set.S] | Build a set from the given bindings |
of_seq [Queue] | Create an array from the generator |
of_seq [MoreLabels.Set.S] | |
of_seq [MoreLabels.Map.S] | |
of_seq [MoreLabels.Hashtbl.SeededS] | |
of_seq [MoreLabels.Hashtbl.S] | |
of_seq [MoreLabels.Hashtbl] | |
of_seq [Map.S] | Build a map from the given bindings |
of_seq [ListLabels] | Create a list from the iterator |
of_seq [List] | Create a list from the iterator |
of_seq [Hashtbl.SeededS] | |
of_seq [Hashtbl.S] | |
of_seq [Hashtbl] | Build a table from the given bindings. |
of_seq [BytesLabels] | Create a string from the generator |
of_seq [Bytes] | Create a string from the generator |
of_seq [Buffer] | Create a buffer from the generator |
of_seq [ArrayLabels] | Create an array from the generator |
of_seq [Array] | Create an array from the generator |
of_string [Stream] | Return the stream of the characters of the string parameter. |
of_string [Nativeint] | Convert the given string to a native integer. |
of_string [Int64] | Convert the given string to a 64-bit integer. |
of_string [Int32] | Convert the given string to a 32-bit integer. |
of_string [Float] | Convert the given string to a float. |
of_string [BytesLabels] | Return a new byte sequence that contains the same bytes as the given string. |
of_string [Bytes] | Return a new byte sequence that contains the same bytes as the given string. |
of_string_opt [Nativeint] | Same as |
of_string_opt [Int64] | Same as |
of_string_opt [Int32] | Same as |
of_string_opt [Float] | Same as |
of_value [Bigarray.Array0] | Build a zero-dimensional big array initialized from the given value. |
ok [Result] |
|
one [Nativeint] | The native integer 1. |
one [Int64] | The 64-bit integer 1. |
one [Int32] | The 32-bit integer 1. |
one [Complex] | The complex number |
opaque_identity [Sys] | For the purposes of optimization, |
open_box [Format] |
|
open_box_of_string [CamlinternalFormat] | |
open_connection [UnixLabels] | Connect to a server at the given address. |
open_connection [Unix] | Connect to a server at the given address. |
open_connection [ThreadUnix] | |
open_graph [Graphics] | Show the graphics window or switch the screen to graphic mode. |
open_hbox [Format] |
|
open_hovbox [Format] |
|
open_hvbox [Format] |
|
open_in [Scanf.Scanning] |
|
open_in [Pervasives] | |
open_in_bin [Scanf.Scanning] |
|
open_in_bin [Pervasives] | |
open_in_gen [Pervasives] | |
open_out [Pervasives] | |
open_out_bin [Pervasives] | |
open_out_gen [Pervasives] | |
open_process [UnixLabels] | Same as |
open_process [Unix] | Same as |
open_process [ThreadUnix] | |
open_process_args [UnixLabels] | Same as |
open_process_args [Unix] | Same as |
open_process_args_full [UnixLabels] | Similar to |
open_process_args_full [Unix] | Similar to |
open_process_args_in [UnixLabels] | High-level pipe and process management. |
open_process_args_in [Unix] | High-level pipe and process management. |
open_process_args_out [UnixLabels] | Same as |
open_process_args_out [Unix] | Same as |
open_process_full [UnixLabels] | Similar to |
open_process_full [Unix] | Similar to |
open_process_in [UnixLabels] | High-level pipe and process management. |
open_process_in [Unix] | High-level pipe and process management. |
open_process_in [ThreadUnix] | |
open_process_out [UnixLabels] | Same as |
open_process_out [Unix] | Same as |
open_process_out [ThreadUnix] | |
open_stag [Format] |
|
open_subwindow [GraphicsX11] | Create a sub-window of the current OCaml graphics window and return its identifier. |
open_tag [Format] | |
open_tbox [Format] |
|
open_temp_file [Filename] | Same as |
open_vbox [Format] |
|
opendir [UnixLabels] | Open a descriptor on a directory |
opendir [Unix] | Open a descriptor on a directory |
openfile [UnixLabels] | Open the named file with the given flags. |
openfile [Unix] | Open the named file with the given flags. |
os_type [Sys] | Operating system currently executing the OCaml program. |
out_channel_length [Stdlib.LargeFile] | |
out_channel_length [Pervasives] | |
out_channel_of_descr [UnixLabels] | Create an output channel writing on the given descriptor. |
out_channel_of_descr [Unix] | Create an output channel writing on the given descriptor. |
out_of_heap_tag [Obj] | |
output [Pervasives] | |
output [Digest] | Write a digest on the given output channel. |
output_acc [CamlinternalFormat] | |
output_binary_int [Pervasives] | |
output_buffer [Buffer] |
|
output_byte [Pervasives] | |
output_bytes [Pervasives] | |
output_char [Pervasives] | |
output_string [Pervasives] | |
output_substring [Pervasives] | |
output_value [Pervasives] | |
over_max_boxes [Format] | Tests if the maximum number of pretty-printing boxes allowed have already been opened. |
P | |
param_format_of_ignored_format [CamlinternalFormat] | |
params [CamlinternalOO] | |
parent_dir_name [Filename] | The conventional name for the parent of the current directory (e.g. |
parse [Arg] |
|
parse_and_expand_argv_dynamic [Arg] | Same as |
parse_argv [Arg] |
|
parse_argv_dynamic [Arg] | Same as |
parse_dynamic [Arg] | Same as |
parse_expand [Arg] | Same as |
partition [Set.S] |
|
partition [MoreLabels.Set.S] | |
partition [MoreLabels.Map.S] | |
partition [Map.S] |
|
partition [ListLabels] |
|
partition [List] |
|
pause [UnixLabels] | Wait until a non-ignored, non-blocked signal is delivered. |
pause [Unix] | Wait until a non-ignored, non-blocked signal is delivered. |
peek [Stream] | Return |
peek [Queue] |
|
peek_opt [Queue] |
|
pi [Float] | The constant pi. |
pipe [UnixLabels] | Create a pipe. |
pipe [Unix] | Create a pipe. |
pipe [ThreadUnix] | |
plot [Graphics] | Plot the given point with the current drawing color. |
plots [Graphics] | Plot the given points with the current drawing color. |
point_color [Graphics] | Return the color of the given point in the backing store (see "Double buffering" below). |
polar [Complex] |
|
poll [Event] | Non-blocking version of |
pop [Stack] |
|
pop [Queue] |
|
pop_opt [Stack] |
|
pos_in [Stdlib.LargeFile] | |
pos_in [Pervasives] | |
pos_out [Stdlib.LargeFile] | |
pos_out [Pervasives] | |
pow [Float] | Exponentiation. |
pow [Complex] | Power function. |
pp_close_box [Format] | |
pp_close_stag [Format] | |
pp_close_tag [Format] | |
pp_close_tbox [Format] | |
pp_force_newline [Format] | |
pp_get_all_formatter_output_functions [Format] | |
pp_get_ellipsis_text [Format] | |
pp_get_formatter_out_functions [Format] | |
pp_get_formatter_output_functions [Format] | |
pp_get_formatter_stag_functions [Format] | |
pp_get_formatter_tag_functions [Format] | |
pp_get_margin [Format] | |
pp_get_mark_tags [Format] | |
pp_get_max_boxes [Format] | |
pp_get_max_indent [Format] | |
pp_get_print_tags [Format] | |
pp_open_box [Format] | |
pp_open_hbox [Format] | |
pp_open_hovbox [Format] | |
pp_open_hvbox [Format] | |
pp_open_stag [Format] | |
pp_open_tag [Format] | |
pp_open_tbox [Format] | |
pp_open_vbox [Format] | |
pp_over_max_boxes [Format] | |
pp_print_as [Format] | |
pp_print_bool [Format] | |
pp_print_break [Format] | |
pp_print_char [Format] | |
pp_print_cut [Format] | |
pp_print_float [Format] | |
pp_print_flush [Format] | |
pp_print_if_newline [Format] | |
pp_print_int [Format] | |
pp_print_list [Format] |
|
pp_print_newline [Format] | |
pp_print_option [Format] |
|
pp_print_result [Format] |
|
pp_print_space [Format] | |
pp_print_string [Format] | |
pp_print_tab [Format] | |
pp_print_tbreak [Format] | |
pp_print_text [Format] |
|
pp_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_margin [Format] | |
pp_set_mark_tags [Format] | |
pp_set_max_boxes [Format] | |
pp_set_max_indent [Format] | |
pp_set_print_tags [Format] | |
pp_set_tab [Format] | |
pp_set_tags [Format] | |
pred [Uchar] |
|
pred [Pervasives] | |
pred [Nativeint] | Predecessor. |
pred [Int64] | Predecessor. |
pred [Int32] | Predecessor. |
prerr_bytes [Pervasives] | |
prerr_char [Pervasives] | |
prerr_endline [Pervasives] | |
prerr_float [Pervasives] | |
prerr_int [Pervasives] | |
prerr_newline [Pervasives] | |
prerr_string [Pervasives] | |
print [Printexc] |
|
print_as [Format] |
|
print_backtrace [Printexc] |
|
print_bool [Format] | Print a boolean in the current pretty-printing box. |
print_break [Format] |
|
print_bytes [Pervasives] | |
print_char [Pervasives] | |
print_char [Format] | Print a character in the current pretty-printing box. |
print_cut [Format] |
|
print_endline [Pervasives] | |
print_float [Pervasives] | |
print_float [Format] | Print a floating point number in the current pretty-printing box. |
print_flush [Format] | End of pretty-printing: resets the pretty-printer to initial state. |
print_if_newline [Format] | Execute the next formatting command if the preceding line has just been split. |
print_int [Pervasives] | |
print_int [Format] | Print an integer in the current pretty-printing box. |
print_newline [Pervasives] | |
print_newline [Format] | End of pretty-printing: resets the pretty-printer to initial state. |
print_raw_backtrace [Printexc] | Print a raw backtrace in the same format
|
print_space [Format] |
|
print_stat [Gc] | Print the current values of the memory management counters (in human-readable form) into the channel argument. |
print_string [Pervasives] | |
print_string [Format] |
|
print_tab [Format] |
|
print_tbreak [Format] |
|
printf [Printf] | Same as |
printf [Format] | Same as |
process_full_pid [Unix] | Return the pid of a process opened via |
process_in_pid [Unix] | Return the pid of a process opened via |
process_out_pid [Unix] | Return the pid of a process opened via |
process_pid [Unix] | Return the pid of a process opened via |
prohibit [Dynlink] |
|
public_method_label [CamlinternalOO] | |
push [Stack] |
|
push [Queue] |
|
putenv [UnixLabels] |
|
putenv [Unix] |
|
Q | |
quick_stat [Gc] | Same as |
quote [Str] |
|
quote [Filename] | Return a quoted version of a file name, suitable for use as one argument in a command line, escaping all meta-characters. |
R | |
raise [Pervasives] | |
raise_notrace [Pervasives] | |
raise_with_backtrace [Printexc] | Reraise the exception using the given raw_backtrace for the origin of the exception |
randomize [MoreLabels.Hashtbl] | |
randomize [Hashtbl] | After a call to |
raw_backtrace_length [Printexc] |
|
raw_backtrace_to_string [Printexc] | Return a string from a raw backtrace, in the same format
|
rcontains_from [String] |
|
rcontains_from [StringLabels] |
|
rcontains_from [BytesLabels] |
|
rcontains_from [Bytes] |
|
reachable_words [Obj] | Computes the total size (in words, including the headers) of all heap blocks accessible from the argument. |
read [UnixLabels] |
|
read [Unix] |
|
read [ThreadUnix] | |
read_arg [Arg] |
|
read_arg0 [Arg] | Identical to |
read_float [Pervasives] | |
read_float_opt [Pervasives] | |
read_int [Pervasives] | |
read_int_opt [Pervasives] | |
read_key [Graphics] | Wait for a key to be pressed, and return the corresponding character. |
read_line [Pervasives] | |
readdir [UnixLabels] | Return the next entry in a directory. |
readdir [Unix] | Return the next entry in a directory. |
readdir [Sys] | Return the names of all files present in the given directory. |
readlink [UnixLabels] | Read the contents of a link. |
readlink [Unix] | Read the contents of a symbolic link. |
really_input [Pervasives] | |
really_input_string [Pervasives] | |
recast [CamlinternalFormat] | |
receive [Event] |
|
record_backtrace [Printexc] |
|
recv [UnixLabels] | Receive data from a connected socket. |
recv [Unix] | Receive data from a connected socket. |
recv [ThreadUnix] | |
recvfrom [UnixLabels] | Receive data from an unconnected socket. |
recvfrom [Unix] | Receive data from an unconnected socket. |
recvfrom [ThreadUnix] | |
red [Graphics] | |
ref [Pervasives] | |
regexp [Str] | Compile a regular expression. |
regexp_case_fold [Str] | Same as |
regexp_string [Str] |
|
regexp_string_case_fold [Str] |
|
register [Callback] |
|
register_exception [Callback] |
|
register_printer [Printexc] |
|
rem [Nativeint] | Integer remainder. |
rem [Int64] | Integer remainder. |
rem [Int32] | Integer remainder. |
rem [Float] |
|
remember_mode [Graphics] | Set remember mode on or off. |
remove [Weak.S] |
|
remove [Sys] | Remove the given file name from the file system. |
remove [Set.S] |
|
remove [MoreLabels.Set.S] | |
remove [MoreLabels.Map.S] | |
remove [MoreLabels.Hashtbl.SeededS] | |
remove [MoreLabels.Hashtbl.S] | |
remove [MoreLabels.Hashtbl] | |
remove [Map.S] |
|
remove [Hashtbl.SeededS] | |
remove [Hashtbl.S] | |
remove [Hashtbl] |
|
remove_assoc [ListLabels] |
|
remove_assoc [List] |
|
remove_assq [ListLabels] | Same as |
remove_assq [List] | Same as |
remove_extension [Filename] | Return the given file name without its extension, as defined
in |
rename [UnixLabels] |
|
rename [Unix] |
|
rename [Sys] | Rename a file. |
rep [Uchar] |
|
replace [MoreLabels.Hashtbl.SeededS] | |
replace [MoreLabels.Hashtbl.S] | |
replace [MoreLabels.Hashtbl] | |
replace [Hashtbl.SeededS] | |
replace [Hashtbl.S] | |
replace [Hashtbl] |
|
replace_first [Str] | Same as |
replace_matched [Str] |
|
replace_seq [MoreLabels.Hashtbl.SeededS] | |
replace_seq [MoreLabels.Hashtbl.S] | |
replace_seq [MoreLabels.Hashtbl] | |
replace_seq [Hashtbl.SeededS] | |
replace_seq [Hashtbl.S] | |
replace_seq [Hashtbl] | Add the given bindings to the table, using |
repr [Obj] | |
reset [MoreLabels.Hashtbl.SeededS] | |
reset [MoreLabels.Hashtbl.S] | |
reset [MoreLabels.Hashtbl] | |
reset [Hashtbl.SeededS] | |
reset [Hashtbl.S] | |
reset [Hashtbl] | Empty a hash table and shrink the size of the bucket table to its initial size. |
reset [Buffer] | Empty the buffer and deallocate the internal byte sequence holding the
buffer contents, replacing it with the initial internal byte sequence
of length |
reshape [Bigarray] |
|
reshape_0 [Bigarray] | Specialized version of |
reshape_1 [Bigarray] | Specialized version of |
reshape_2 [Bigarray] | Specialized version of |
reshape_3 [Bigarray] | Specialized version of |
resize_window [Graphics] | Resize and erase the graphics window. |
return [Seq] | The singleton sequence containing only the given element. |
rev [ListLabels] | List reversal. |
rev [List] | List reversal. |
rev_append [ListLabels] |
|
rev_append [List] |
|
rev_char_set [CamlinternalFormat] | |
rev_map [ListLabels] | |
rev_map [List] | |
rev_map2 [ListLabels] | |
rev_map2 [List] | |
rewinddir [UnixLabels] | Reposition the descriptor to the beginning of the directory |
rewinddir [Unix] | Reposition the descriptor to the beginning of the directory |
rgb [Graphics] |
|
rhs_end [Parsing] | See |
rhs_end_pos [Parsing] | Same as |
rhs_start [Parsing] | Same as |
rhs_start_pos [Parsing] | Same as |
rindex [String] |
|
rindex [StringLabels] |
|
rindex [BytesLabels] |
|
rindex [Bytes] |
|
rindex_from [String] |
|
rindex_from [StringLabels] |
|
rindex_from [BytesLabels] |
|
rindex_from [Bytes] |
|
rindex_from_opt [String] |
|
rindex_from_opt [StringLabels] |
|
rindex_from_opt [BytesLabels] |
|
rindex_from_opt [Bytes] |
|
rindex_opt [String] |
|
rindex_opt [StringLabels] |
|
rindex_opt [BytesLabels] |
|
rindex_opt [Bytes] |
|
rlineto [Graphics] | Draw a line with endpoints the current point and the current point translated of the given vector, and move the current point to this point. |
rmdir [UnixLabels] | Remove an empty directory. |
rmdir [Unix] | Remove an empty directory. |
rmoveto [Graphics] |
|
run_initializers [CamlinternalOO] | |
run_initializers_opt [CamlinternalOO] | |
runtime_parameters [Sys] | Return the value of the runtime parameters, in the same format
as the contents of the |
runtime_variant [Sys] | Return the name of the runtime variant the program is running on. |
runtime_warnings_enabled [Sys] | Return whether runtime warnings are currently enabled. |
S | |
save_and_close [Spacetime.Series] |
|
save_event [Spacetime.Series] |
|
save_event_for_automatic_snapshots [Spacetime] | Like |
scanf [Scanf] | Same as |
search_backward [Str] |
|
search_forward [Str] |
|
seeded_hash [MoreLabels.Hashtbl] | |
seeded_hash [Hashtbl] | A variant of |
seeded_hash_param [MoreLabels.Hashtbl] | |
seeded_hash_param [Hashtbl] | A variant of |
seek_in [Stdlib.LargeFile] | |
seek_in [Pervasives] | |
seek_out [Stdlib.LargeFile] | |
seek_out [Pervasives] | |
select [UnixLabels] | Wait until some input/output operations become possible on some channels. |
select [Unix] | Wait until some input/output operations become possible on some channels. |
select [ThreadUnix] | |
select [Thread] | Suspend the execution of the calling thread until input/output becomes possible on the given Unix file descriptors. |
select [Event] | 'Synchronize' on an alternative of events. |
self [Thread] | Return the thread currently executing. |
self_init [Random] | Initialize the generator with a random seed chosen in a system-dependent way. |
send [UnixLabels] | Send data over a connected socket. |
send [Unix] | Send data over a connected socket. |
send [ThreadUnix] | |
send [Event] |
|
send [CamlinternalOO] | |
send_substring [UnixLabels] | Same as |
send_substring [Unix] | Same as |
send_substring [ThreadUnix] | |
sendcache [CamlinternalOO] | |
sendself [CamlinternalOO] | |
sendto [UnixLabels] | Send data over an unconnected socket. |
sendto [Unix] | Send data over an unconnected socket. |
sendto [ThreadUnix] | |
sendto_substring [UnixLabels] | Same as |
sendto_substring [Unix] | Same as |
sendto_substring [ThreadUnix] | |
set [Weak] |
|
set [String] |
|
set [StringLabels] |
|
set [Gc] |
|
set [Float.Array] | |
set [BytesLabels] |
|
set [Bytes] |
|
set [Bigarray.Array3] |
|
set [Bigarray.Array2] |
|
set [Bigarray.Array1] |
|
set [Bigarray.Array0] |
|
set [Bigarray.Genarray] | Assign an element of a generic big array. |
set [ArrayLabels] |
|
set [Array] |
|
set_all_formatter_output_functions [Format] | |
set_binary_mode_in [Pervasives] | |
set_binary_mode_out [Pervasives] | |
set_close_on_exec [UnixLabels] | Set the ``close-on-exec'' flag on the given descriptor. |
set_close_on_exec [Unix] | Set the ``close-on-exec'' flag on the given descriptor. |
set_color [Graphics] | Set the current drawing color. |
set_data [Obj.Ephemeron] | Same as |
set_data [Ephemeron.Kn] | Same as |
set_data [Ephemeron.K2] | Same as |
set_data [Ephemeron.K1] |
|
set_double_field [Obj] | |
set_ellipsis_text [Format] | Set the text of the ellipsis printed when too many pretty-printing boxes
are open (a single dot, |
set_field [Obj] | When using flambda: |
set_font [Graphics] | Set the font used for drawing text. |
set_formatter_out_channel [Format] | Redirect the standard pretty-printer output to the given channel. |
set_formatter_out_functions [Format] |
|
set_formatter_output_functions [Format] |
|
set_formatter_stag_functions [Format] |
|
set_formatter_tag_functions [Format] | |
set_key [Obj.Ephemeron] | Same as |
set_key [Ephemeron.Kn] | Same as |
set_key [Ephemeron.K1] |
|
set_key1 [Ephemeron.K2] | Same as |
set_key2 [Ephemeron.K2] | Same as |
set_line_width [Graphics] | Set the width of points and lines drawn with the functions above. |
set_margin [Format] |
|
set_mark_tags [Format] |
|
set_max_boxes [Format] |
|
set_max_indent [Format] |
|
set_method [CamlinternalOO] | |
set_methods [CamlinternalOO] | |
set_nonblock [UnixLabels] | Set the ``non-blocking'' flag on the given descriptor. |
set_nonblock [Unix] | Set the ``non-blocking'' flag on the given descriptor. |
set_print_tags [Format] |
|
set_signal [Sys] | Same as |
set_state [Random] | Set the state of the generator used by the basic functions. |
set_tab [Format] | Sets a tabulation marker at current insertion point. |
set_tag [Obj] | |
set_tags [Format] |
|
set_temp_dir_name [Filename] | Change the temporary directory returned by |
set_text_size [Graphics] | Set the character size used for drawing text. |
set_trace [Parsing] | Control debugging support for |
set_uncaught_exception_handler [Printexc] |
|
set_window_title [Graphics] | Set the title of the graphics window. |
setgid [UnixLabels] | Set the real group id and effective group id for the process. |
setgid [Unix] | Set the real group id and effective group id for the process. |
setgroups [UnixLabels] |
|
setgroups [Unix] |
|
setitimer [UnixLabels] |
|
setitimer [Unix] |
|
setsid [UnixLabels] | Put the calling process in a new session and detach it from its controlling terminal. |
setsid [Unix] | Put the calling process in a new session and detach it from its controlling terminal. |
setsockopt [UnixLabels] | Set or clear a boolean-valued option in the given socket. |
setsockopt [Unix] | Set or clear a boolean-valued option in the given socket. |
setsockopt_float [UnixLabels] | Same as |
setsockopt_float [Unix] | Same as |
setsockopt_int [UnixLabels] | Same as |
setsockopt_int [Unix] | Same as |
setsockopt_optint [UnixLabels] | Same as |
setsockopt_optint [Unix] | Same as |
setuid [UnixLabels] | Set the real user id and effective user id for the process. |
setuid [Unix] | Set the real user id and effective user id for the process. |
shift_left [Nativeint] |
|
shift_left [Int64] |
|
shift_left [Int32] |
|
shift_right [Nativeint] |
|
shift_right [Int64] |
|
shift_right [Int32] |
|
shift_right_logical [Nativeint] |
|
shift_right_logical [Int64] |
|
shift_right_logical [Int32] |
|
shutdown [UnixLabels] | Shutdown a socket connection. |
shutdown [Unix] | Shutdown a socket connection. |
shutdown_connection [UnixLabels] | ``Shut down'' a connection established with |
shutdown_connection [Unix] | ``Shut down'' a connection established with |
sigabrt [Sys] | Abnormal termination |
sigalrm [Sys] | Timeout |
sigbus [Sys] | Bus error |
sigchld [Sys] | Child process terminated |
sigcont [Sys] | Continue |
sigfpe [Sys] | Arithmetic exception |
sighup [Sys] | Hangup on controlling terminal |
sigill [Sys] | Invalid hardware instruction |
sigint [Sys] | Interactive interrupt (ctrl-C) |
sigkill [Sys] | Termination (cannot be ignored) |
sigmask [Thread] |
|
signal [Sys] | Set the behavior of the system on receipt of a given signal. |
signal [Condition] |
|
sigpending [UnixLabels] | Return the set of blocked signals that are currently pending. |
sigpending [Unix] | Return the set of blocked signals that are currently pending. |
sigpipe [Sys] | Broken pipe |
sigpoll [Sys] | Pollable event |
sigprocmask [UnixLabels] |
|
sigprocmask [Unix] |
|
sigprof [Sys] | Profiling interrupt |
sigquit [Sys] | Interactive termination |
sigsegv [Sys] | Invalid memory reference |
sigstop [Sys] | Stop |
sigsuspend [UnixLabels] |
|
sigsuspend [Unix] |
|
sigsys [Sys] | Bad argument to routine |
sigterm [Sys] | Termination |
sigtrap [Sys] | Trace/breakpoint trap |
sigtstp [Sys] | Interactive stop |
sigttin [Sys] | Terminal read from background process |
sigttou [Sys] | Terminal write from background process |
sigurg [Sys] | Urgent condition on socket |
sigusr1 [Sys] | Application-defined signal 1 |
sigusr2 [Sys] | Application-defined signal 2 |
sigvtalrm [Sys] | Timeout in virtual time |
sigxcpu [Sys] | Timeout in cpu time |
sigxfsz [Sys] | File size limit exceeded |
sin [Pervasives] | |
sin [Float] | Sine. |
single_write [UnixLabels] | Same as |
single_write [Unix] | Same as |
single_write_substring [UnixLabels] | Same as |
single_write_substring [Unix] | Same as |
singleton [Set.S] |
|
singleton [MoreLabels.Set.S] | |
singleton [MoreLabels.Map.S] | |
singleton [Map.S] |
|
sinh [Pervasives] | |
sinh [Float] | Hyperbolic sine. |
size [Obj] | |
size [Nativeint] | The size in bits of a native integer. |
size_in_bytes [Bigarray.Array3] |
|
size_in_bytes [Bigarray.Array2] |
|
size_in_bytes [Bigarray.Array1] |
|
size_in_bytes [Bigarray.Array0] |
|
size_in_bytes [Bigarray.Genarray] |
|
size_x [Graphics] | See |
size_y [Graphics] | Return the size of the graphics window. |
sleep [UnixLabels] | Stop execution for the given number of seconds. |
sleep [Unix] | Stop execution for the given number of seconds. |
sleep [ThreadUnix] | |
sleepf [Unix] | Stop execution for the given number of seconds. |
slice [Bigarray.Array1] | Extract a scalar (zero-dimensional slice) of the given one-dimensional big array. |
slice_left [Bigarray.Array2] | Extract a row (one-dimensional slice) of the given two-dimensional big array. |
slice_left [Bigarray.Genarray] | Extract a sub-array of lower dimension from the given big array by fixing one or several of the first (left-most) coordinates. |
slice_left_1 [Bigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional big array by fixing the first two coordinates. |
slice_left_2 [Bigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional big array by fixing the first coordinate. |
slice_right [Bigarray.Array2] | Extract a column (one-dimensional slice) of the given two-dimensional big array. |
slice_right [Bigarray.Genarray] | Extract a sub-array of lower dimension from the given big array by fixing one or several of the last (right-most) coordinates. |
slice_right_1 [Bigarray.Array3] | Extract a one-dimensional slice of the given three-dimensional big array by fixing the last two coordinates. |
slice_right_2 [Bigarray.Array3] | Extract a two-dimensional slice of the given three-dimensional big array by fixing the last coordinate. |
snd [Pervasives] | |
socket [UnixLabels] | Create a new socket in the given domain, and with the given kind. |
socket [Unix] | Create a new socket in the given domain, and with the given kind. |
socket [ThreadUnix] | |
socketpair [UnixLabels] | Create a pair of unnamed sockets, connected together. |
socketpair [Unix] | Create a pair of unnamed sockets, connected together. |
some [Option] |
|
sort [ListLabels] | Sort a list in increasing order according to a comparison function. |
sort [List] | Sort a list in increasing order according to a comparison function. |
sort [ArrayLabels] | Sort an array in increasing order according to a comparison function. |
sort [Array] | Sort an array in increasing order according to a comparison function. |
sort_uniq [ListLabels] | Same as |
sort_uniq [List] | Same as |
sound [Graphics] |
|
split [Str] |
|
split [Set.S] |
|
split [MoreLabels.Set.S] | |
split [MoreLabels.Map.S] | |
split [Map.S] |
|
split [ListLabels] | Transform a list of pairs into a pair of lists:
|
split [List] | Transform a list of pairs into a pair of lists:
|
split_delim [Str] | Same as |
split_on_char [String] |
|
split_on_char [StringLabels] |
|
sprintf [Printf] | Same as |
sprintf [Format] | Same as |
sqrt [Pervasives] | |
sqrt [Float] | Square root. |
sqrt [Complex] | Square root. |
sscanf [Scanf] | Same as |
sscanf_format [Scanf] | Same as |
stable_sort [ListLabels] | Same as |
stable_sort [List] | Same as |
stable_sort [ArrayLabels] | Same as |
stable_sort [Array] | Same as |
stat [UnixLabels.LargeFile] | |
stat [UnixLabels] | Return the information for the named file. |
stat [Unix.LargeFile] | |
stat [Unix] | Return the information for the named file. |
stat [Gc] | Return the current values of the memory management counters in a
|
stats [Weak.S] | Return statistics on the table. |
stats [MoreLabels.Hashtbl.SeededS] | |
stats [MoreLabels.Hashtbl.S] | |
stats [MoreLabels.Hashtbl] | |
stats [Hashtbl.SeededS] | |
stats [Hashtbl.S] | |
stats [Hashtbl] |
|
stats [CamlinternalOO] | |
stats_alive [Ephemeron.SeededS] | same as |
stats_alive [Ephemeron.S] | same as |
std_formatter [Format] | The standard formatter to write to standard output. |
stdbuf [Format] | The string buffer in which |
stderr [UnixLabels] | File descriptor for standard error. |
stderr [Unix] | File descriptor for standard error. |
stderr [Pervasives] | |
stdib [Scanf.Scanning] | A deprecated alias for |
stdin [UnixLabels] | File descriptor for standard input. |
stdin [Unix] | File descriptor for standard input. |
stdin [Scanf.Scanning] | The standard input notion for the |
stdin [Pervasives] | |
stdout [UnixLabels] | File descriptor for standard output. |
stdout [Unix] | File descriptor for standard output. |
stdout [Pervasives] | |
str_formatter [Format] | A formatter to output to the |
string [Digest] | Return the digest of the given string. |
string_after [Str] |
|
string_before [Str] |
|
string_match [Str] |
|
string_of_bool [Pervasives] | |
string_of_float [Pervasives] | |
string_of_fmt [CamlinternalFormat] | |
string_of_fmtty [CamlinternalFormat] | |
string_of_format [Pervasives] | |
string_of_formatting_gen [CamlinternalFormat] | |
string_of_formatting_lit [CamlinternalFormat] | |
string_of_inet_addr [UnixLabels] | Return the printable representation of the given Internet address. |
string_of_inet_addr [Unix] | Return the printable representation of the given Internet address. |
string_of_int [Pervasives] | |
string_partial_match [Str] | Similar to |
string_tag [Obj] | |
strput_acc [CamlinternalFormat] | |
sub [String] |
|
sub [StringLabels] |
|
sub [Nativeint] | Subtraction. |
sub [Int64] | Subtraction. |
sub [Int32] | Subtraction. |
sub [Float] | Floating-point subtraction. |
sub [Complex] | Subtraction |
sub [BytesLabels] |
|
sub [Bytes] |
|
sub [Buffer] |
|
sub [Bigarray.Array1] | Extract a sub-array of the given one-dimensional big array. |
sub [ArrayLabels] |
|
sub [Array] |
|
sub_left [Bigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional big array by restricting the first dimension. |
sub_left [Bigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional big array by restricting the first dimension. |
sub_left [Bigarray.Genarray] | Extract a sub-array of the given big array by restricting the first (left-most) dimension. |
sub_right [Bigarray.Array3] | Extract a three-dimensional sub-array of the given three-dimensional big array by restricting the second dimension. |
sub_right [Bigarray.Array2] | Extract a two-dimensional sub-array of the given two-dimensional big array by restricting the second dimension. |
sub_right [Bigarray.Genarray] | Extract a sub-array of the given big array by restricting the last (right-most) dimension. |
sub_string [BytesLabels] | Same as |
sub_string [Bytes] | Same as |
subbytes [Digest] |
|
subset [Set.S] |
|
subset [MoreLabels.Set.S] | |
substitute_first [Str] | Same as |
substring [Digest] |
|
succ [Uchar] |
|
succ [Pervasives] | |
succ [Nativeint] | Successor. |
succ [Int64] | Successor. |
succ [Int32] | Successor. |
symbol_end [Parsing] | See |
symbol_end_pos [Parsing] | Same as |
symbol_start [Parsing] |
|
symbol_start_pos [Parsing] | Same as |
symlink [UnixLabels] |
|
symlink [Unix] |
|
symm [CamlinternalFormat] | |
sync [Event] | 'Synchronize' on an event: offer all the communication possibilities specified in the event to the outside world, and block until one of the communications succeed. |
synchronize [Graphics] | Synchronize the backing store and the on-screen window, by copying the contents of the backing store onto the graphics window. |
system [UnixLabels] | Execute the given command, wait until it terminates, and return its termination status. |
system [Unix] | Execute the given command, wait until it terminates, and return its termination status. |
system [ThreadUnix] | |
T | |
tag [Obj] | |
take [Spacetime.Snapshot] |
|
take [Queue] |
|
take_opt [Queue] |
|
tan [Pervasives] | |
tan [Float] | Tangent. |
tanh [Pervasives] | |
tanh [Float] | Hyperbolic tangent. |
tcdrain [UnixLabels] | Waits until all output written on the given file descriptor has been transmitted. |
tcdrain [Unix] | Waits until all output written on the given file descriptor has been transmitted. |
tcflow [UnixLabels] | Suspend or restart reception or transmission of data on
the given file descriptor, depending on the second argument:
|
tcflow [Unix] | Suspend or restart reception or transmission of data on
the given file descriptor, depending on the second argument:
|
tcflush [UnixLabels] | Discard data written on the given file descriptor but not yet
transmitted, or data received but not yet read, depending on the
second argument: |
tcflush [Unix] | Discard data written on the given file descriptor but not yet
transmitted, or data received but not yet read, depending on the
second argument: |
tcgetattr [UnixLabels] | Return the status of the terminal referred to by the given file descriptor. |
tcgetattr [Unix] | Return the status of the terminal referred to by the given file descriptor. |
tcsendbreak [UnixLabels] | Send a break condition on the given file descriptor. |
tcsendbreak [Unix] | Send a break condition on the given file descriptor. |
tcsetattr [UnixLabels] | Set the status of the terminal referred to by the given file descriptor. |
tcsetattr [Unix] | Set the status of the terminal referred to by the given file descriptor. |
temp_dir_name [Filename] | The name of the initial temporary directory:
Under Unix, the value of the |
temp_file [Filename] |
|
text_size [Graphics] | Return the dimensions of the given text, if it were drawn with the current font and size. |
time [UnixLabels] | Return the current time since 00:00:00 GMT, Jan. |
time [Unix] | Return the current time since 00:00:00 GMT, Jan. |
time [Sys] | Return the processor time, in seconds, used by the program since the beginning of execution. |
timed_read [ThreadUnix] | |
timed_write [ThreadUnix] | Behave as |
timed_write_substring [ThreadUnix] | |
times [UnixLabels] | Return the execution times of the process. |
times [Unix] | Return the execution times of the process. |
tl [ListLabels] | Return the given list without its first element. |
tl [List] | Return the given list without its first element. |
to_buffer [Marshal] |
|
to_bytes [Marshal] |
|
to_bytes [Buffer] | Return a copy of the current contents of the buffer. |
to_channel [Marshal] |
|
to_char [Uchar] |
|
to_float [Nativeint] | Convert the given native integer to a floating-point number. |
to_float [Int64] | Convert the given 64-bit integer to a floating-point number. |
to_float [Int32] | Convert the given 32-bit integer to a floating-point number. |
to_hex [Digest] | Return the printable hexadecimal representation of the given digest. |
to_int [Uchar] |
|
to_int [Nativeint] | Convert the given native integer (type |
to_int [Int64] | Convert the given 64-bit integer (type |
to_int [Int32] | Convert the given 32-bit integer (type |
to_int [Float] | Truncate the given floating-point number to an integer. |
to_int32 [Nativeint] | Convert the given native integer to a
32-bit integer (type |
to_int32 [Int64] | Convert the given 64-bit integer (type |
to_list [Result] |
|
to_list [Option] |
|
to_list [ArrayLabels] |
|
to_list [Array] |
|
to_nativeint [Int64] | Convert the given 64-bit integer (type |
to_option [Result] |
|
to_result [Option] |
|
to_seq [String] | Iterate on the string, in increasing index order. |
to_seq [StringLabels] | Iterate on the string, in increasing index order. |
to_seq [Stack] | Iterate on the stack, top to bottom. |
to_seq [Set.S] | Iterate on the whole set, in ascending order |
to_seq [Result] |
|
to_seq [Queue] | Iterate on the queue, in front-to-back order. |
to_seq [Option] |
|
to_seq [MoreLabels.Set.S] | |
to_seq [MoreLabels.Map.S] | |
to_seq [MoreLabels.Hashtbl.SeededS] | |
to_seq [MoreLabels.Hashtbl.S] | |
to_seq [MoreLabels.Hashtbl] | |
to_seq [Map.S] | Iterate on the whole map, in ascending order |
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, in unspecified order. |
to_seq [BytesLabels] | Iterate on the string, in increasing index order. |
to_seq [Bytes] | Iterate on the string, in increasing index order. |
to_seq [Buffer] | Iterate on the buffer, in increasing order. |
to_seq [ArrayLabels] | Iterate on the array, in increasing order |
to_seq [Array] | Iterate on the array, in increasing order. |
to_seq_from [Set.S] |
|
to_seq_from [MoreLabels.Set.S] | |
to_seq_from [MoreLabels.Map.S] | |
to_seq_from [Map.S] |
|
to_seq_keys [MoreLabels.Hashtbl.SeededS] | |
to_seq_keys [MoreLabels.Hashtbl.S] | |
to_seq_keys [MoreLabels.Hashtbl] | |
to_seq_keys [Hashtbl.SeededS] | |
to_seq_keys [Hashtbl.S] | |
to_seq_keys [Hashtbl] | Iterate on 'as, in ascending order |
to_seq_values [MoreLabels.Hashtbl.SeededS] | |
to_seq_values [MoreLabels.Hashtbl.S] | |
to_seq_values [MoreLabels.Hashtbl] | |
to_seq_values [Hashtbl.SeededS] | |
to_seq_values [Hashtbl.S] | |
to_seq_values [Hashtbl] | Iterate on values, in ascending order of their corresponding 'a |
to_seqi [String] | Iterate on the string, in increasing order, yielding indices along chars |
to_seqi [StringLabels] | Iterate on the string, in increasing order, yielding indices along chars |
to_seqi [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 [Printexc] |
|
to_string [Nativeint] | Return the string representation of its argument, in decimal. |
to_string [Marshal] | Same as |
to_string [Int64] | Return the string representation of its argument, in decimal. |
to_string [Int32] | Return the string representation of its argument, in signed decimal. |
to_string [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. |
top [Stack] |
|
top [Queue] |
|
top_opt [Stack] |
|
total_size [Marshal] | See |
trans [CamlinternalFormat] | |
transfer [Queue] |
|
transp [Graphics] | In matrices of colors, this color represent a 'transparent' point: when drawing the corresponding image, all pixels on the screen corresponding to a transparent pixel in the image will not be modified, while other points will be set to the color of the corresponding point in the image. |
trim [String] | Return a copy of the argument, without leading and trailing whitespace. |
trim [StringLabels] | Return a copy of the argument, without leading and trailing whitespace. |
trim [BytesLabels] | Return a copy of the argument, without leading and trailing whitespace. |
trim [Bytes] | Return a copy of the argument, without leading and trailing whitespace. |
truncate [UnixLabels.LargeFile] | |
truncate [UnixLabels] | Truncates the named file to the given size. |
truncate [Unix.LargeFile] | See |
truncate [Unix] | Truncates the named file to the given size. |
truncate [Pervasives] | |
truncate [Obj] | |
truncate [Buffer] |
|
try_lock [Mutex] | Same as |
type_format [CamlinternalFormat] | |
U | |
umask [UnixLabels] | Set the process's file mode creation mask, and return the previous mask. |
umask [Unix] | Set the process's file mode creation mask, and return the previous mask. |
unaligned_tag [Obj] | |
uncapitalize [String] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.. |
uncapitalize [StringLabels] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.. |
uncapitalize [BytesLabels] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.. |
uncapitalize [Bytes] | Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.. |
uncapitalize_ascii [String] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set. |
uncapitalize_ascii [StringLabels] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set. |
uncapitalize_ascii [BytesLabels] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set. |
uncapitalize_ascii [Bytes] | Return a copy of the argument, with the first character set to lowercase, using the US-ASCII character set. |
unescaped [Scanf] |
|
union [Set.S] | Set union. |
union [MoreLabels.Set.S] | |
union [MoreLabels.Map.S] | |
union [Map.S] |
|
unix [Sys] | True if |
unlink [UnixLabels] | Removes the named file |
unlink [Unix] | Removes the named file. |
unlock [Mutex] | Unlock the given mutex. |
unmarshal [Obj] | |
unsafe_environment [Unix] | Return the process environment, as an array of strings with the format ``variable=value''. |
unsafe_get [Float.Array] | |
unsafe_get [Bigarray.Array3] | Like |
unsafe_get [Bigarray.Array2] | Like |
unsafe_get [Bigarray.Array1] | Like |
unsafe_getenv [UnixLabels] | Return the value associated to a variable in the process environment. |
unsafe_getenv [Unix] | Return the value associated to a variable in the process environment. |
unsafe_of_string [Bytes] | Unsafely convert a shared string to a byte sequence that should not be mutated. |
unsafe_set [Float.Array] | |
unsafe_set [Bigarray.Array3] | Like |
unsafe_set [Bigarray.Array2] | Like |
unsafe_set [Bigarray.Array1] | Like |
unsafe_to_string [Bytes] | Unsafely convert a byte sequence into a string. |
unset_data [Obj.Ephemeron] | Same as |
unset_data [Ephemeron.Kn] | Same as |
unset_data [Ephemeron.K2] | Same as |
unset_data [Ephemeron.K1] |
|
unset_key [Obj.Ephemeron] | Same as |
unset_key [Ephemeron.Kn] | Same as |
unset_key [Ephemeron.K1] |
|
unset_key1 [Ephemeron.K2] | Same as |
unset_key2 [Ephemeron.K2] | Same as |
update [MoreLabels.Map.S] | |
update [Map.S] |
|
update_mod [CamlinternalMod] | |
uppercase [String] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
uppercase [StringLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
uppercase [Char] | Convert the given character to its equivalent uppercase character, using the ISO Latin-1 (8859-1) character set. |
uppercase [BytesLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
uppercase [Bytes] | Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set. |
uppercase_ascii [String] | Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set. |
uppercase_ascii [StringLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set. |
uppercase_ascii [Char] | Convert the given character to its equivalent uppercase character, using the US-ASCII character set. |
uppercase_ascii [BytesLabels] | Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set. |
uppercase_ascii [Bytes] | Return a copy of the argument, with all lowercase letters translated to uppercase, using the US-ASCII character set. |
usage [Arg] |
|
usage_string [Arg] | Returns the message that would have been printed by |
utimes [UnixLabels] | Set the last access time (second arg) and last modification time (third arg) for a file. |
utimes [Unix] | Set the last access time (second arg) and last modification time (third arg) for a file. |
V | |
valid_float_lexem [Pervasives] | |
value [Result] |
|
value [Option] |
|
W | |
wait [UnixLabels] | Wait until one of the children processes die, and return its pid and termination status. |
wait [Unix] | Wait until one of the children processes die, and return its pid and termination status. |
wait [ThreadUnix] | |
wait [Condition] |
|
wait_next_event [Graphics] | Wait until one of the events specified in the given event list occurs, and return the status of the mouse and keyboard at that time. |
wait_pid [Thread] |
|
wait_read [Thread] | See |
wait_signal [Thread] |
|
wait_timed_read [Thread] | |
wait_timed_write [Thread] | Suspend the execution of the calling thread until at least
one character or EOF is available for reading ( |
wait_write [Thread] | This function does nothing in this implementation. |
waitpid [UnixLabels] | Same as |
waitpid [Unix] | Same as |
waitpid [ThreadUnix] | |
white [Graphics] | |
widen [CamlinternalOO] | |
win32 [Sys] | True if |
window_id [GraphicsX11] | Return the unique identifier of the OCaml graphics window. |
with_positions [Lexing] | Tell whether the lexer buffer keeps track of position fields
|
word_size [Sys] | Size of one word on the machine currently executing the OCaml program, in bits: 32 or 64. |
wrap [Event] |
|
wrap_abort [Event] |
|
write [UnixLabels] |
|
write [Unix] |
|
write [ThreadUnix] | |
write_arg [Arg] |
|
write_arg0 [Arg] | Identical to |
write_substring [UnixLabels] | Same as |
write_substring [Unix] | Same as |
write_substring [ThreadUnix] | |
Y | |
yellow [Graphics] | |
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 [Complex] | The complex number |