|
(!) [Pervasives] |
!r returns the current contents of reference r .
|
(!=) [Pervasives] |
|
(&&) [Pervasives] |
The boolean ``and''.
|
(&) [Pervasives] |
|
(*) [Pervasives] |
Integer multiplication.
|
(**) [Pervasives] |
Exponentiation
|
(**/) [Num] |
|
(*.) [Pervasives] |
Floating-point multiplication
|
(*/) [Num] |
|
(+) [Pervasives] |
Integer addition.
|
(+.) [Pervasives] |
Floating-point addition
|
(+/) [Num] |
|
(-) [Pervasives] |
Integer subtraction.
|
(-.) [Pervasives] |
Floating-point subtraction
|
(-/) [Num] |
|
(/) [Pervasives] |
Integer division.
|
(/.) [Pervasives] |
Floating-point division.
|
(//) [Num] |
|
(:=) [Pervasives] |
r := a stores the value of a in reference r .
|
(<) [Pervasives] |
|
() [Num] |
|
(<=) [Pervasives] |
|
(<=/) [Num] |
|
(<>) [Pervasives] |
|
(<>/) [Num] |
|
(=) [Pervasives] |
e1 = e2 tests for structural equality of e1 and e2 .
|
(=/) [Num] |
|
(==) [Pervasives] |
e1 == e2 tests for physical equality of e1 and e2 .
|
(>) [Pervasives] |
|
(>/) [Num] |
|
(>=) [Pervasives] |
Structural ordering functions.
|
(>=/) [Num] |
|
(@) [Pervasives] |
List concatenation.
|
(^) [Pervasives] |
String concatenation.
|
(||) [Pervasives] |
The boolean ``or''.
|
(~-) [Pervasives] |
Unary negation.
|
(~-.) [Pervasives] |
Unary negation.
|
A |
abs [Pervasives] |
Return the absolute value of the argument.
|
abs [Nativeint] |
Return the absolute value of its argument.
|
abs [Int64] |
Return the absolute value of its argument.
|
abs [Int32] |
Return the absolute value of its argument.
|
abs_big_int [Big_int] |
Absolute value.
|
abs_float [Pervasives] |
Return the absolute value of the argument.
|
abs_num [Num] |
Absolute value.
|
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] |
|
add [Weak.S] |
add t x adds x to t .
|
add [Set.S] |
add x s returns a set containing all elements of s ,
plus x .
|
add [Queue] |
add x q adds the element x at the end of the queue q .
|
add [Nativeint] |
Addition.
|
add [MoreLabels.Set.S] |
|
add [MoreLabels.Map.S] |
|
add [MoreLabels.Hashtbl.S] |
|
add [MoreLabels.Hashtbl] |
|
add [Map.S] |
add x y m returns a map containing the same bindings as
m , plus a binding of x to y .
|
add [Int64] |
Addition.
|
add [Int32] |
Addition.
|
add [Hashtbl.S] |
|
add [Hashtbl] |
Hashtbl.add tbl x y adds a binding of x to y in table tbl .
|
add [Dbm] |
add db key data inserts the pair (key , data ) in
the database db .
|
add [Complex] |
Addition
|
add_available_units [Dynlink] |
Same as Dynlink.add_interfaces , but instead of searching .cmi files
to find the unit interfaces, uses the interface digests given
for each unit.
|
add_big_int [Big_int] |
Addition.
|
add_buffer [Buffer] |
add_buffer b1 b2 appends the current contents of buffer b2
at the end of buffer b1 .
|
add_channel [Buffer] |
add_channel b ic n reads exactly n character from the
input channel ic and stores them at the end of buffer b .
|
add_char [Buffer] |
add_char b c appends the character c at the end of the buffer b .
|
add_initializer [CamlinternalOO] |
|
add_int_big_int [Big_int] |
Addition of a small integer to a big integer.
|
add_interfaces [Dynlink] |
add_interfaces units path grants dynamically-linked object
files access to the compilation units named in list units .
|
add_num [Num] |
Addition
|
add_string [Buffer] |
add_string b s appends the string s at the end of the buffer b .
|
add_substring [Buffer] |
add_substring b s ofs len takes len characters from offset
ofs in string s and appends them at the end of the buffer b .
|
alarm [UnixLabels] |
Schedule a SIGALRM signal after the given number of seconds.
|
alarm [Unix] |
Schedule a SIGALRM signal after the given number of seconds.
|
allocated_bytes [Gc] |
Return the total number of bytes allocated since the program was
started.
|
allow_unsafe_modules [Dynlink] |
Govern whether unsafe object files are allowed to be
dynamically linked.
|
always [Event] |
always v returns an event that is always ready for
synchronization.
|
append [StdLabels.List] |
|
append [StdLabels.Array] |
|
append [ListLabels] |
Catenate two lists.
|
append [List] |
Catenate two lists.
|
append [ArrayLabels] |
Array.append v1 v2 returns a fresh array containing the
concatenation of the arrays v1 and v2 .
|
append [Array] |
Array.append v1 v2 returns a fresh array containing the
concatenation of the arrays v1 and v2 .
|
appname_get [Tk] |
|
appname_set [Tk] |
Get or set the application name.
|
approx_num_exp [Num] |
Approximate a number by a decimal.
|
approx_num_fix [Num] |
|
arg [Complex] |
Argument.
|
argv [Sys] |
The command line arguments given to the process.
|
arith_status [Arith_status] |
Print the current status of the arithmetic flags.
|
array [Sort] |
Sort an array in increasing order according to an
ordering predicate.
|
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] |
|
asr [Pervasives] |
n asr m shifts n to the right by m bits.
|
assoc [StdLabels.List] |
|
assoc [ListLabels] |
assoc a l returns the value associated with key a in the list of
pairs l .
|
assoc [List] |
assoc a l returns the value associated with key a in the list of
pairs l .
|
assq [StdLabels.List] |
|
assq [ListLabels] |
Same as ListLabels.assoc , but uses physical equality instead of structural
equality to compare keys.
|
assq [List] |
Same as List.assoc , but uses physical equality instead of structural
equality to compare keys.
|
at_exit [Pervasives] |
Register the given function to be called at program
termination time.
|
atan [Pervasives] |
|
atan2 [Pervasives] |
The usual trigonometric functions.
|
auto_synchronize [Graphics] |
By default, drawing takes place both on the window displayed
on screen, and in a memory area (the ``backing store'').
|
B |
background [Graphics] |
|
basename [Filename] |
Split a file name into directory name / base file name.
|
big_int_of_int [Big_int] |
Convert a small integer to a big integer.
|
big_int_of_num [Num] |
|
big_int_of_string [Big_int] |
Convert a string to a big integer, in decimal.
|
bind [UnixLabels] |
Bind a socket to an address.
|
bind [Unix] |
Bind a socket to an address.
|
bind [Tk] |
Bind a succession of events on a widget to an action .
|
bind_class [Tk] |
Same thing for all widgets of a given class.
|
bind_tag [Tk] |
Same thing for all widgets having a given tag
|
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.
|
black [Graphics] |
|
blit [Weak] |
Weak.blit ar1 off1 ar2 off2 len copies len weak pointers
from ar1 (starting at off1 ) to ar2 (starting at off2 ).
|
blit [StringLabels] |
String.blit src srcoff dst dstoff len copies len characters
from string src , starting at character number srcoff , to
string dst , starting at character number dstoff .
|
blit [String] |
String.blit src srcoff dst dstoff len copies len characters
from string src , starting at character number srcoff , to
string dst , starting at character number dstoff .
|
blit [StdLabels.String] |
|
blit [StdLabels.Array] |
|
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.Genarray] |
Copy all elements of a big array in another big array.
|
blit [ArrayLabels] |
Array.blit v1 o1 v2 o2 len copies len elements
from array v1 , starting at element number o1 , to array v2 ,
starting at element number o2 .
|
blit [Array] |
Array.blit v1 o1 v2 o2 len copies len elements
from array v1 , starting at element number o1 , to array v2 ,
starting at element number o2 .
|
blit_image [Graphics] |
blit_image img x y copies screen pixels into the image img ,
modifying img in-place.
|
blue [Graphics] |
|
bool [Random] |
Random.bool () returns true or false with probability 0.5 each.
|
bool_of_string [Pervasives] |
Convert the given string to a boolean.
|
bounded_full_split [Str] |
Same as Str.bounded_split_delim , but returns
the delimiters as well as the substrings contained between
delimiters.
|
bounded_split [Str] |
Same as Str.split , but splits into at most n substrings,
where n is the extra integer parameter.
|
bounded_split_delim [Str] |
Same as Str.bounded_split , but occurrences of the
delimiter at the beginning and at the end of the string are
recognized and returned as empty strings in the result.
|
bprintf [Printf] |
Same as Printf.fprintf , but instead of printing on an output channel,
append the formatted arguments to the given extensible buffer
(see module Buffer ).
|
bprintf [Format] |
Same as sprintf above, but instead of printing on a string,
writes into the given extensible buffer.
|
break [Tk] |
Used inside a bound action, do not call other actions
after this one.
|
broadcast [Condition] |
broadcast c restarts all processes waiting on the
condition variable c .
|
bscanf [Scanf] |
bscanf ib format f reads tokens from the scanning buffer ib according
to the format string format , converts these tokens to values, and
applies the function f to these values.
|
button_down [Graphics] |
Return true if the mouse button is pressed, false otherwise.
|
C |
c_layout [Bigarray] |
|
capitalize [StringLabels] |
Return a copy of the argument, with the first letter set to uppercase.
|
capitalize [String] |
Return a copy of the argument, with the first letter set to uppercase.
|
capitalize [StdLabels.String] |
|
cardinal [Set.S] |
Return the number of elements of a set.
|
cardinal [MoreLabels.Set.S] |
|
catch [Printexc] |
Printexc.catch fn x is similar to Printexc.print , but
aborts the program with exit code 2 after printing the
uncaught exception.
|
catch_break [Sys] |
catch_break governs whether interactive interrupt (ctrl-C)
terminates the program or raises the Break exception.
|
ceil [Pervasives] |
|
ceiling_num [Num] |
ceiling_num n returns the smallest integer bigger or equal to n .
|
channel [Digest] |
If len is nonnegative, Digest.channel ic len reads len
characters from channel ic and returns their digest, or raises
End_of_file if end-of-file is reached before len characters
are read.
|
char [Bigarray] |
As shown by the types of the values above,
big arrays of kind float32_elt and float64_elt are
accessed using the Caml type float .
|
char_of_int [Pervasives] |
Return the character with the given ASCII code.
|
chdir [UnixLabels] |
Change the process working directory.
|
chdir [Unix] |
Change the process working directory.
|
chdir [Sys] |
Change the current working directory of the process.
|
check [Weak] |
Weak.check ar n returns true if the n th cell of ar is
full, false if it is empty.
|
check_suffix [Filename] |
check_suffix name suff returns true if the filename name
ends with the suffix suff .
|
chmod [UnixLabels] |
Change the permissions of the named file.
|
chmod [Unix] |
Change the permissions of the named file.
|
choose [Set.S] |
Return one element of the given set, or raise Not_found if
the set is empty.
|
choose [MoreLabels.Set.S] |
|
choose [Event] |
choose evl returns the event that is the alternative of
all the events in the list evl .
|
chop_extension [Filename] |
Return the given file name without its extension.
|
chop_suffix [Filename] |
chop_suffix name suff removes the suffix suff from
the filename name .
|
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] |
Return the class of the given floating-point number:
normal, subnormal, zero, infinite, or not a number.
|
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.S] |
|
clear [MoreLabels.Hashtbl] |
|
clear [Hashtbl.S] |
|
clear [Hashtbl] |
Empty a hash table.
|
clear [Buffer] |
Empty the buffer.
|
clear_available_units [Dynlink] |
Clear the list of compilation units accessible to dynamically-linked programs.
|
clear_close_on_exec [UnixLabels] |
Clear the ``close-on-exec'' flag on the given descriptor.
|
clear_close_on_exec [Unix] |
Clear the ``close-on-exec'' flag on the given descriptor.
|
clear_graph [Graphics] |
Erase the graphics window.
|
clear_nonblock [UnixLabels] |
Clear the ``non-blocking'' flag on the given descriptor.
|
clear_nonblock [Unix] |
Clear the ``non-blocking'' flag on the given descriptor.
|
clear_parser [Parsing] |
Empty the parser stack.
|
close [UnixLabels] |
Close a file descriptor.
|
close [Unix] |
Close a file descriptor.
|
close [Dbm] |
Close the given descriptor.
|
closeTk [Tk] |
Quit the main loop and close all open windows.
|
close_box [Format] |
Closes the most recently opened pretty-printing box.
|
close_graph [Graphics] |
Delete the graphics window or switch the screen back to text mode.
|
close_in [Pervasives] |
Close the given channel.
|
close_out [Pervasives] |
Close the given channel, flushing all buffered write operations.
|
close_process [UnixLabels] |
Close channels opened by UnixLabels.open_process ,
wait for the associated command to terminate,
and return its termination status.
|
close_process [Unix] |
Close channels opened by Unix.open_process ,
wait for the associated command to terminate,
and return its termination status.
|
close_process_full [UnixLabels] |
|
close_process_full [Unix] |
Close channels opened by Unix.open_process_full ,
wait for the associated command to terminate,
and return its termination status.
|
close_process_in [UnixLabels] |
Close channels opened by UnixLabels.open_process_in ,
wait for the associated command to terminate,
and return its termination status.
|
close_process_in [Unix] |
Close channels opened by Unix.open_process_in ,
wait for the associated command to terminate,
and return its termination status.
|
close_process_out [UnixLabels] |
|
close_process_out [Unix] |
Close channels opened by Unix.open_process_out ,
wait for the associated command to terminate,
and return its termination status.
|
close_subwindow [GraphicsX11] |
Close the sub-window having the given identifier.
|
close_tag [Format] |
close_tag () closes the most recently opened tag t .
|
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 [StdLabels.List] |
|
combine [ListLabels] |
Transform a pair of lists into a list of pairs:
combine [a1; ...; an] [b1; ...; bn] is
[(a1,b1); ...; (an,bn)] .
|
combine [List] |
Transform a pair of lists into a list of pairs:
combine [a1; ...; an] [b1; ...; bn] is
[(a1,b1); ...; (an,bn)] .
|
command [Sys] |
Execute the given shell command and return its exit code.
|
compact [Gc] |
Perform a full major collection and compact the heap.
|
compare [String] |
|
compare [Set.S] |
Total ordering between sets.
|
compare [Pervasives] |
compare x y returns 0 if x=y , a negative integer if
x<y , and a positive integer if x>y .
|
compare [Nativeint] |
The comparison function for native integers, with the same specification as
Pervasives.compare .
|
compare [Set.OrderedType] |
A total ordering function over the set elements.
|
compare [MoreLabels.Set.S] |
|
compare [Map.OrderedType] |
A total ordering function over the keys.
|
compare [Int64] |
The comparison function for 64-bit integers, with the same specification as
Pervasives.compare .
|
compare [Int32] |
The comparison function for 32-bit integers, with the same specification as
Pervasives.compare .
|
compare [Char] |
The comparison function for characters, with the same specification as
Pervasives.compare .
|
compare_big_int [Big_int] |
compare_big_int a b returns 0 if a and b are equal,
1 if a is greater than b , and -1 if a is smaller
than b .
|
compare_num [Num] |
Return -1 , 0 or 1 if the first argument is less than,
equal to, or greater than the second argument.
|
complex32 [Bigarray] |
|
complex64 [Bigarray] |
|
concat [StringLabels] |
String.concat sep sl concatenates the list of strings sl ,
inserting the separator string sep between each.
|
concat [String] |
String.concat sep sl concatenates the list of strings sl ,
inserting the separator string sep between each.
|
concat [StdLabels.String] |
|
concat [StdLabels.List] |
|
concat [StdLabels.Array] |
|
concat [ListLabels] |
Concatenate a list of lists.
|
concat [List] |
Concatenate a list of lists.
|
concat [Filename] |
concat dir file returns a file name that designates file
file in directory dir .
|
concat [ArrayLabels] |
Same as Array.append , but concatenates a list of arrays.
|
concat [Array] |
Same as Array.append , but concatenates a list of arrays.
|
conj [Complex] |
Conjugate: given the complex x + i.y , returns x - i.y .
|
connect [UnixLabels] |
Connect a socket to an address.
|
connect [Unix] |
Connect a socket to an address.
|
connect [ThreadUnix] |
|
contains [StringLabels] |
String.contains s c tests if character c
appears in the string s .
|
contains [String] |
String.contains s c tests if character c
appears in the string s .
|
contains [StdLabels.String] |
|
contains_from [StringLabels] |
String.contains_from s start c tests if character c
appears in the substring of s starting from start to the end
of s .
|
contains_from [String] |
String.contains_from s start c tests if character c
appears in the substring of s starting from start to the end
of s .
|
contains_from [StdLabels.String] |
|
contents [Buffer] |
Return a copy of the current contents of the buffer.
|
copy [StringLabels] |
Return a copy of the given string.
|
copy [String] |
Return a copy of the given string.
|
copy [StdLabels.String] |
|
copy [StdLabels.Array] |
|
copy [Stack] |
Return a copy of the given stack.
|
copy [Queue] |
Return a copy of the given queue.
|
copy [Oo] |
Oo.copy o returns a copy of object o , that is a fresh
object with the same methods and instance variables as o
|
copy [MoreLabels.Hashtbl.S] |
|
copy [MoreLabels.Hashtbl] |
|
copy [Hashtbl.S] |
|
copy [Hashtbl] |
Return a copy of the given hashtable.
|
copy [CamlinternalOO] |
|
copy [ArrayLabels] |
Array.copy a returns a copy of a , that is, a fresh array
containing the same elements as a .
|
copy [Array] |
Array.copy a returns a copy of a , that is, a fresh array
containing the same elements as a .
|
cos [Pervasives] |
|
cosh [Pervasives] |
|
count [Weak.S] |
Count the number of elements in the table.
|
count [Stream] |
Return the current count of the stream elements, i.e.
|
counters [Gc] |
Return (minor_words, promoted_words, major_words) .
|
create [Weak.S] |
create n creates a new empty weak hash table, of initial
size n .
|
create [Weak] |
Weak.create n returns a new weak array of length n .
|
create [Thread] |
Thread.create funct arg creates a new thread of control,
in which the function application funct arg
is executed concurrently with the other threads of the program.
|
create [StringLabels] |
String.create n returns a fresh string of length n .
|
create [String] |
String.create n returns a fresh string of length n .
|
create [StdLabels.String] |
|
create [StdLabels.Array] |
|
create [Stack] |
Return a new stack, initially empty.
|
create [Queue] |
Return a new queue, initially empty.
|
create [Mutex] |
Return a new mutex.
|
create [MoreLabels.Hashtbl.S] |
|
create [MoreLabels.Hashtbl] |
|
create [Hashtbl.S] |
|
create [Hashtbl] |
Hashtbl.create n creates a new, empty hash table, with
initial size n .
|
create [Condition] |
Return a new condition variable.
|
create [Buffer] |
create n returns a fresh buffer, initially empty.
|
create [Bigarray.Array3] |
Array3.create kind layout dim1 dim2 dim3 returns a new bigarray of
three dimension, whose size is dim1 in the first dimension,
dim2 in the second dimension, and dim3 in the third.
|
create [Bigarray.Array2] |
Array2.create kind layout dim1 dim2 returns a new bigarray of
two dimension, whose size is dim1 in the first dimension
and dim2 in the second dimension.
|
create [Bigarray.Array1] |
Array1.create kind layout dim returns a new bigarray of
one dimension, whose size is dim .
|
create [Bigarray.Genarray] |
Genarray.create kind layout dimensions returns a new big array
whose element kind is determined by the parameter kind (one of
float32 , float64 , int8_signed , etc) and whose layout is
determined by the parameter layout (one of c_layout or
fortran_layout ).
|
create [ArrayLabels] |
|
create [Array] |
|
create_alarm [Gc] |
create_alarm f will arrange for f to be called at the end of each
major GC cycle, starting with the current cycle or the next one.
|
create_image [Graphics] |
create_image w h returns a new image w pixels wide and h
pixels tall, to be used in conjunction with blit_image .
|
create_matrix [StdLabels.Array] |
|
create_matrix [ArrayLabels] |
|
create_matrix [Array] |
|
create_object [CamlinternalOO] |
|
create_object_and_run_initializers [CamlinternalOO] |
|
create_object_opt [CamlinternalOO] |
|
create_process [UnixLabels] |
create_process prog args new_stdin new_stdout new_stderr
forks a new process that executes the program
in file prog , with arguments args .
|
create_process [Unix] |
create_process prog args new_stdin new_stdout new_stderr
forks a new process that executes the program
in file prog , with arguments args .
|
create_process_env [UnixLabels] |
create_process_env prog args env new_stdin new_stdout new_stderr
works as UnixLabels.create_process , except that the extra argument
env specifies the environment passed to the program.
|
create_process_env [Unix] |
create_process_env prog args env new_stdin new_stdout new_stderr
works as Unix.create_process , except that the extra argument
env specifies the environment passed to the program.
|
create_table [CamlinternalOO] |
|
current [Arg] |
Position (in Sys.argv ) of the argument being processed.
|
current_dir_name [Filename] |
The conventional name for the current directory (e.g.
|
current_point [Graphics] |
Return the position of the current point.
|
current_x [Graphics] |
Return the abscissa of the current point.
|
current_y [Graphics] |
Return the ordinate of the current point.
|
curveto [Graphics] |
curveto b c d draws a cubic Bezier curve starting from
the current point to point d , with control points b and
c , and moves the current point to d .
|
custom_tag [Obj] |
|
cyan [Graphics] |
|
D |
data_size [Marshal] |
|
decr [Pervasives] |
Decrement the integer contained in the given reference.
|
decr_num [Num] |
decr r is r:=!r-1 , where r is a reference to a number.
|
delay [Thread] |
delay d suspends the execution of the calling thread for
d seconds.
|
delete_alarm [Gc] |
delete_alarm a will stop the calls to the function associated
to a .
|
descr_of_in_channel [UnixLabels] |
Return the descriptor corresponding to an input channel.
|
descr_of_in_channel [Unix] |
Return the descriptor corresponding to an input channel.
|
descr_of_out_channel [UnixLabels] |
Return the descriptor corresponding to an output channel.
|
descr_of_out_channel [Unix] |
Return the descriptor corresponding to an output channel.
|
destroy [Tk] |
Destroy an individual widget.
|
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] |
Genarray.dims a returns all dimensions of the big array a ,
as an array of integers of length Genarray.num_dims a .
|
dirname [Filename] |
|
display_mode [Graphics] |
Set display mode on or off.
|
div [Nativeint] |
Integer division.
|
div [Int64] |
Integer division.
|
div [Int32] |
Integer division.
|
div [Complex] |
Division
|
div_big_int [Big_int] |
Euclidean quotient of two big integers.
|
div_num [Num] |
Division
|
double_array_tag [Obj] |
|
double_tag [Obj] |
|
draw_arc [Graphics] |
draw_arc x y rx ry a1 a2 draws an elliptical arc with center
x,y , horizontal radius rx , vertical radius ry , from angle
a1 to angle a2 (in degrees).
|
draw_char [Graphics] |
|
draw_circle [Graphics] |
draw_circle x y r draws a circle with center x,y and
radius r .
|
draw_ellipse [Graphics] |
draw_ellipse x y rx ry draws an ellipse with center
x,y , horizontal radius rx and vertical radius ry .
|
draw_image [Graphics] |
Draw the given image with lower left corner at the given point.
|
draw_poly [Graphics] |
draw_poly polygon draws the given polygon.
|
draw_poly_line [Graphics] |
draw_poly_line points draws the line that joins the
points given by the array argument.
|
draw_rect [Graphics] |
draw_rect x y w h draws the rectangle with lower left corner
at x,y , width w and height h .
|
draw_segments [Graphics] |
draw_segments segments draws the segments given in the array
argument.
|
draw_string [Graphics] |
Draw a character or a character string with lower left corner
at current position.
|
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 fd1 fd2 duplicates fd1 to fd2 , closing fd2 if already
opened.
|
dup2 [Unix] |
dup2 fd1 fd2 duplicates fd1 to fd2 , closing fd2 if already
opened.
|
E |
elements [Set.S] |
Return the list of all elements of the given set.
|
elements [MoreLabels.Set.S] |
|
empty [Stream] |
Return () if the stream is empty, else raise Stream.Failure .
|
empty [Set.S] |
The empty set.
|
empty [MoreLabels.Set.S] |
|
empty [MoreLabels.Map.S] |
|
empty [Map.S] |
The empty map.
|
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] |
|
eprintf [Format] |
Same as fprintf above, but output on err_formatter .
|
epsilon_float [Pervasives] |
The smallest positive float x such that 1.0 +. x <> 1.0 .
|
eq_big_int [Big_int] |
|
eq_num [Num] |
|
equal [Set.S] |
equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
equal [MoreLabels.Set.S] |
|
equal [Hashtbl.HashedType] |
The equality predicate used to compare keys.
|
err_formatter [Format] |
A formatter to use with formatting functions below for
output to standard error.
|
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 [StringLabels] |
Return a copy of the argument, with special characters
represented by escape sequences, following the lexical
conventions of Objective Caml.
|
escaped [String] |
Return a copy of the argument, with special characters
represented by escape sequences, following the lexical
conventions of Objective Caml.
|
escaped [StdLabels.String] |
|
escaped [Char] |
Return a string representing the given character,
with special characters escaped following the lexical conventions
of Objective Caml.
|
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 prog args execute the program in file prog , with
the arguments args , and the current process environment.
|
execv [Unix] |
execv prog args execute the program in file prog , with
the arguments args , and the current process environment.
|
execv [ThreadUnix] |
|
execve [UnixLabels] |
Same as UnixLabels.execv , except that the third argument provides the
environment to the program executed.
|
execve [Unix] |
Same as Unix.execv , except that the third argument provides the
environment to the program executed.
|
execve [ThreadUnix] |
|
execvp [UnixLabels] |
Same as UnixLabels.execv respectively, except that
the program is searched in the path.
|
execvp [Unix] |
Same as Unix.execv respectively, except that
the program is searched in the path.
|
execvp [ThreadUnix] |
|
execvpe [UnixLabels] |
Same as UnixLabels.execvp respectively, except that
the program is searched in the path.
|
execvpe [Unix] |
Same as Unix.execvp respectively, except that
the program is searched in the path.
|
exists [StdLabels.List] |
|
exists [Set.S] |
exists p s checks if at least one element of
the set satisfies the predicate p .
|
exists [MoreLabels.Set.S] |
|
exists [ListLabels] |
exists p [a1; ...; an] checks if at least one element of
the list satisfies the predicate p .
|
exists [List] |
exists p [a1; ...; an] checks if at least one element of
the list satisfies the predicate p .
|
exists2 [StdLabels.List] |
|
exists2 [ListLabels] |
|
exists2 [List] |
|
exit [Thread] |
Terminate prematurely the currently executing thread.
|
exit [Pervasives] |
Terminate the process, returning the given status code
to the operating system: usually 0 to indicate no errors,
and a small positive integer to indicate failure.
|
exp [Pervasives] |
Exponential.
|
exp [Complex] |
Exponentiation.
|
F |
failwith [Pervasives] |
Raise exception Failure with the given string.
|
fast_sort [ListLabels] |
|
fast_sort [List] |
|
fast_sort [ArrayLabels] |
|
fast_sort [Array] |
|
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] |
Weak.fill ar ofs len el sets to el all pointers of ar from
ofs to ofs + len - 1 .
|
fill [StringLabels] |
String.fill s start len c modifies string s in place,
replacing the characters number start to start + len - 1
by c .
|
fill [String] |
String.fill s start len c modifies string s in place,
replacing the characters number start to start + len - 1
by c .
|
fill [StdLabels.String] |
|
fill [StdLabels.Array] |
|
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.Genarray] |
Set all elements of a big array to a given value.
|
fill [ArrayLabels] |
Array.fill a ofs len x modifies the array a in place,
storing x in elements number ofs to ofs + len - 1 .
|
fill [Array] |
Array.fill a ofs len x modifies the array a in place,
storing x in elements number ofs to ofs + len - 1 .
|
fill_arc [Graphics] |
Fill an elliptical pie slice with the current color.
|
fill_circle [Graphics] |
Fill a circle with the current color.
|
fill_ellipse [Graphics] |
Fill an ellipse with the current color.
|
fill_poly [Graphics] |
Fill the given polygon with the current color.
|
fill_rect [Graphics] |
fill_rect x y w h fills the rectangle with lower left corner
at x,y , width w and height h , with the current color.
|
filter [StdLabels.List] |
|
filter [Set.S] |
filter p s returns the set of all elements in s
that satisfy predicate p .
|
filter [MoreLabels.Set.S] |
|
filter [ListLabels] |
filter p l returns all the elements of the list l
that satisfy the predicate p .
|
filter [List] |
filter p l returns all the elements of the list l
that satisfy the predicate p .
|
final_tag [Obj] |
|
finalise [Gc] |
finalise f v registers f as a finalisation function for v .
|
find [Weak.S] |
find t x returns an instance of x found in t .
|
find [StdLabels.List] |
|
find [MoreLabels.Map.S] |
|
find [MoreLabels.Hashtbl.S] |
|
find [MoreLabels.Hashtbl] |
|
find [Map.S] |
find x m returns the current binding of x in m ,
or raises Not_found if no such binding exists.
|
find [ListLabels] |
find p l returns the first element of the list l
that satisfies the predicate p .
|
find [List] |
find p l returns the first element of the list l
that satisfies the predicate p .
|
find [Hashtbl.S] |
|
find [Hashtbl] |
Hashtbl.find tbl x returns the current binding of x in tbl ,
or raises Not_found if no such binding exists.
|
find [Dbm] |
find db key returns the data associated with the given
key in the database opened for the descriptor db .
|
find_all [Weak.S] |
find_all t x returns a list of all the instances of x
found in t .
|
find_all [StdLabels.List] |
|
find_all [MoreLabels.Hashtbl.S] |
|
find_all [MoreLabels.Hashtbl] |
|
find_all [ListLabels] |
|
find_all [List] |
|
find_all [Hashtbl.S] |
|
find_all [Hashtbl] |
Hashtbl.find_all tbl x returns the list of all data
associated with x in tbl .
|
first_chars [Str] |
first_chars s n returns the first n characters of s .
|
firstkey [Dbm] |
|
flatten [StdLabels.List] |
|
flatten [ListLabels] |
Flatten a list of lists.
|
flatten [List] |
Same as concat .
|
float [Random] |
Random.float bound returns a random floating-point number
between 0 (inclusive) and bound (exclusive).
|
float [Pervasives] |
|
float32 [Bigarray] |
|
float64 [Bigarray] |
|
float_of_big_int [Big_int] |
Returns a floating-point number approximating the
given big integer.
|
float_of_bits [Int64] |
Return the floating-point number whose internal representation,
according to the IEEE 754 floating-point ``double format'' bit layout,
is the given int64 .
|
float_of_int [Pervasives] |
Convert an integer to floating-point.
|
float_of_num [Num] |
|
float_of_string [Pervasives] |
Convert the given string to a float.
|
floor [Pervasives] |
Round the given float to an integer value.
|
floor_num [Num] |
floor_num n returns the largest integer smaller or equal to n .
|
flush [Pervasives] |
Flush the buffer associated with the given output channel,
performing all pending writes on that channel.
|
flush_all [Pervasives] |
Flush all opened output channels.
|
flush_str_formatter [Format] |
Returns the material printed with str_formatter , flushes
the formatter and resets the corresponding buffer.
|
fold [Weak.S] |
fold f t init computes (f d1 (... (f dN init))) where
d1 ... dN are the elements of t in some unspecified order.
|
fold [Set.S] |
fold f s a computes (f xN ... (f x2 (f x1 a))...) ,
where x1 ... xN are the elements of s .
|
fold [Queue] |
fold f accu q is equivalent to List.fold_left f accu l ,
where l is the list of q 's elements.
|
fold [MoreLabels.Set.S] |
|
fold [MoreLabels.Map.S] |
|
fold [MoreLabels.Hashtbl.S] |
|
fold [MoreLabels.Hashtbl] |
|
fold [Map.S] |
fold f m a computes (f kN dN ... (f k1 d1 a)...) ,
where k1 ... kN are the keys of all bindings in m ,
and d1 ... dN are the associated data.
|
fold [Hashtbl.S] |
|
fold [Hashtbl] |
Hashtbl.fold f tbl init computes
(f kN dN ... (f k1 d1 init)...) ,
where k1 ... kN are the keys of all bindings in tbl ,
and d1 ... dN are the associated values.
|
fold_left [StdLabels.List] |
|
fold_left [StdLabels.Array] |
|
fold_left [ListLabels] |
List.fold_left f a [b1; ...; bn] is
f (... (f (f a b1) b2) ...) bn .
|
fold_left [List] |
List.fold_left f a [b1; ...; bn] is
f (... (f (f a b1) b2) ...) bn .
|
fold_left [ArrayLabels] |
Array.fold_left f x a computes
f (... (f (f x a.(0)) a.(1)) ...) a.(n-1) ,
where n is the length of the array a .
|
fold_left [Array] |
Array.fold_left f x a computes
f (... (f (f x a.(0)) a.(1)) ...) a.(n-1) ,
where n is the length of the array a .
|
fold_left2 [StdLabels.List] |
|
fold_left2 [ListLabels] |
List.fold_left2 f a [b1; ...; bn] [c1; ...; cn] is
f (... (f (f a b1 c1) b2 c2) ...) bn cn .
|
fold_left2 [List] |
List.fold_left2 f a [b1; ...; bn] [c1; ...; cn] is
f (... (f (f a b1 c1) b2 c2) ...) bn cn .
|
fold_right [StdLabels.List] |
|
fold_right [StdLabels.Array] |
|
fold_right [ListLabels] |
List.fold_right f [a1; ...; an] b is
f a1 (f a2 (... (f an b) ...)) .
|
fold_right [List] |
List.fold_right f [a1; ...; an] b is
f a1 (f a2 (... (f an b) ...)) .
|
fold_right [ArrayLabels] |
Array.fold_right f a x computes
f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...)) ,
where n is the length of the array a .
|
fold_right [Array] |
Array.fold_right f a x computes
f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...)) ,
where n is the length of the array a .
|
fold_right2 [StdLabels.List] |
|
fold_right2 [ListLabels] |
List.fold_right2 f [a1; ...; an] [b1; ...; bn] c is
f a1 b1 (f a2 b2 (... (f an bn c) ...)) .
|
fold_right2 [List] |
List.fold_right2 f [a1; ...; an] [b1; ...; bn] c is
f a1 b1 (f a2 b2 (... (f an bn c) ...)) .
|
for_all [StdLabels.List] |
|
for_all [Set.S] |
for_all p s checks if all elements of the set
satisfy the predicate p .
|
for_all [MoreLabels.Set.S] |
|
for_all [ListLabels] |
for_all p [a1; ...; an] checks if all elements of the list
satisfy the predicate p .
|
for_all [List] |
for_all p [a1; ...; an] checks if all elements of the list
satisfy the predicate p .
|
for_all2 [StdLabels.List] |
|
for_all2 [ListLabels] |
|
for_all2 [List] |
|
force [Lazy] |
force x forces the suspension x and returns its result.
|
force_newline [Format] |
Forces a newline in the current box.
|
force_val [Lazy] |
force_val x forces the suspension x and returns its
result.
|
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 [Nativeint] |
Nativeint.format fmt n return the string representation of the
native integer n in the format specified by fmt .
|
format [Int64] |
Int64.format fmt n return the string representation of the
64-bit integer n in the format specified by fmt .
|
format [Int32] |
Int32.format fmt n return the string representation of the
32-bit integer n in the format specified by fmt .
|
formatter_of_buffer [Format] |
formatter_of_buffer b returns a new formatter writing to
buffer b .
|
formatter_of_out_channel [Format] |
formatter_of_out_channel oc returns a new formatter that
writes to the corresponding channel oc .
|
fortran_layout [Bigarray] |
|
forward_tag [Obj] |
|
fprintf [Printf] |
fprintf outchan format arg1 ... argN formats the arguments
arg1 to argN according to the format string format ,
and outputs the resulting string on the channel outchan .
|
fprintf [Format] |
fprintf ff format arg1 ... argN formats the arguments
arg1 to argN according to the format string format ,
and outputs the resulting string on the formatter ff .
|
frexp [Pervasives] |
frexp f returns the pair of the significant
and the exponent of f .
|
from [Stream] |
Stream.from f returns a stream built from the function f .
|
from_channel [Scanf.Scanning] |
Scanning.from_channel inchan returns a scanning buffer which reads
from the input channel inchan , at the current reading position.
|
from_channel [Marshal] |
Marshal.from_channel chan reads from channel chan the
byte representation of a structured value, as produced by
one of the Marshal.to_* functions, and reconstructs and
returns the corresponding value.
|
from_channel [Lexing] |
Create a lexer buffer on the given input channel.
|
from_function [Scanf.Scanning] |
Scanning.from_function f returns a scanning buffer with
the given function as its reading method.
|
from_function [Lexing] |
Create a lexer buffer with the given function as its reading method.
|
from_string [Scanf.Scanning] |
Scanning.from_string s returns a scanning buffer which reads
from the given string.
|
from_string [Marshal] |
Marshal.from_string buff ofs unmarshals a structured value
like Marshal.from_channel does, except that the byte
representation is not read from a channel, but taken from
the string buff , starting at position ofs .
|
from_string [Lexing] |
Create a lexer buffer which reads from
the given string.
|
fscanf [Scanf] |
|
fst [Pervasives] |
Return the first component of a pair.
|
fstat [UnixLabels.LargeFile] |
|
fstat [UnixLabels] |
Return the information for the file associated with the given
descriptor.
|
fstat [Unix.LargeFile] |
|
fstat [Unix] |
Return the informations for the file associated with the given
descriptor.
|
ftruncate [UnixLabels.LargeFile] |
|
ftruncate [UnixLabels] |
Truncates the file corresponding to the given descriptor
to the given size.
|
ftruncate [Unix.LargeFile] |
|
ftruncate [Unix] |
Truncates the file corresponding to the given descriptor
to the given size.
|
full_init [Random] |
|
full_major [Gc] |
Do a minor collection, finish the current major collection cycle,
and perform a complete new cycle.
|
full_split [Str] |
Same as Str.split_delim , but returns
the delimiters as well as the substrings contained between
delimiters.
|
G |
gcd_big_int [Big_int] |
Greatest common divisor of two big integers.
|
ge_big_int [Big_int] |
|
ge_num [Num] |
|
genarray_of_array1 [Bigarray] |
Return the generic big array corresponding to the given one-dimensional big array.
|
genarray_of_array2 [Bigarray] |
Return the generic big array corresponding to the given two-dimensional big array.
|
genarray_of_array3 [Bigarray] |
Return the generic big array corresponding to the given three-dimensional big array.
|
get [Weak] |
Weak.get ar n returns None if the n th cell of ar is
empty, Some x (where x is the value) if it is full.
|
get [StringLabels] |
String.get s n returns character number n in string s .
|
get [String] |
String.get s n returns character number n in string s .
|
get [StdLabels.String] |
|
get [StdLabels.Array] |
|
get [Gc] |
Return the current values of the GC parameters in a control record.
|
get [Bigarray.Array3] |
Array3.get a x y z , also written a.{x,y,z} ,
returns the element of a at coordinates (x , y , z ).
|
get [Bigarray.Array2] |
Array2.get a x y , also written a.{x,y} ,
returns the element of a at coordinates (x , y ).
|
get [Bigarray.Array1] |
Array1.get a x , or alternatively a.{x} ,
returns the element of a at index x .
|
get [Bigarray.Genarray] |
Read an element of a generic big array.
|
get [ArrayLabels] |
Array.get a n returns the element number n of array a .
|
get [Array] |
Array.get a n returns the element number n of array a .
|
get_all_formatter_output_functions [Format] |
Return the current output functions of the pretty-printer,
including line breaking and indentation functions.
|
get_approx_printing [Arith_status] |
|
get_copy [Weak] |
Weak.get_copy ar n returns None if the n th cell of ar is
empty, Some x (where x is a (shallow) copy of the value) if
it is full.
|
get_ellipsis_text [Format] |
Return the text of the ellipsis.
|
get_error_when_null_denominator [Arith_status] |
|
get_floating_precision [Arith_status] |
|
get_formatter_output_functions [Format] |
Return the current output functions of the pretty-printer.
|
get_formatter_tag_functions [Format] |
Return the current tag functions of the pretty-printer.
|
get_image [Graphics] |
Capture the contents of a rectangle on the screen as an image.
|
get_margin [Format] |
Returns the position of the right margin.
|
get_mark_tags [Format] |
Return the current status of tag printing and marking.
|
get_max_boxes [Format] |
Returns the maximum number of boxes allowed before ellipsis.
|
get_max_indent [Format] |
Return the value of the maximum indentation limit (in characters).
|
get_method [CamlinternalOO] |
|
get_method_label [CamlinternalOO] |
|
get_normalize_ratio [Arith_status] |
|
get_normalize_ratio_when_printing [Arith_status] |
|
get_print_tags [Format] |
|
get_state [Random] |
Returns the current state of the generator.
|
get_variable [CamlinternalOO] |
|
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.
|
getenv [Sys] |
Return the value associated to a variable in the process
environment.
|
geteuid [UnixLabels] |
Return the effective user id under which the process runs.
|
geteuid [Unix] |
Return the effective user id under which the process runs.
|
getgid [UnixLabels] |
Return the group id of the user executing the process.
|
getgid [Unix] |
Return the group id of the user executing the process.
|
getgrgid [UnixLabels] |
Find an entry in group with the given group id, or raise
Not_found .
|
getgrgid [Unix] |
Find an entry in group with the given group id, or raise
Not_found .
|
getgrnam [UnixLabels] |
Find an entry in group with the given name, or raise
Not_found .
|
getgrnam [Unix] |
Find an entry in group with the given name, or raise
Not_found .
|
getgroups [UnixLabels] |
Return the list of groups to which the user executing the process
belongs.
|
getgroups [Unix] |
Return the list of groups to which the user executing the process
belongs.
|
gethostbyaddr [UnixLabels] |
Find an entry in hosts with the given address, or raise
Not_found .
|
gethostbyaddr [Unix] |
Find an entry in hosts with the given address, or raise
Not_found .
|
gethostbyname [UnixLabels] |
Find an entry in hosts with the given name, or raise
Not_found .
|
gethostbyname [Unix] |
Find an entry in hosts with the given name, or raise
Not_found .
|
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.
|
getpeername [UnixLabels] |
Return the address of the host connected to the given socket.
|
getpeername [Unix] |
Return the address of the host connected to the given socket.
|
getpid [UnixLabels] |
Return the pid of the process.
|
getpid [Unix] |
Return the pid of the process.
|
getppid [UnixLabels] |
Return the pid of the parent process.
|
getppid [Unix] |
Return the pid of the parent process.
|
getprotobyname [UnixLabels] |
Find an entry in protocols with the given name, or raise
Not_found .
|
getprotobyname [Unix] |
Find an entry in protocols with the given name, or raise
Not_found .
|
getprotobynumber [UnixLabels] |
Find an entry in protocols with the given protocol number,
or raise Not_found .
|
getprotobynumber [Unix] |
Find an entry in protocols with the given protocol number,
or raise Not_found .
|
getpwnam [UnixLabels] |
Find an entry in passwd with the given name, or raise
Not_found .
|
getpwnam [Unix] |
Find an entry in passwd with the given name, or raise
Not_found .
|
getpwuid [UnixLabels] |
Find an entry in passwd with the given user id, or raise
Not_found .
|
getpwuid [Unix] |
Find an entry in passwd with the given user id, or raise
Not_found .
|
getservbyname [UnixLabels] |
Find an entry in services with the given name, or raise
Not_found .
|
getservbyname [Unix] |
Find an entry in services with the given name, or raise
Not_found .
|
getservbyport [UnixLabels] |
Find an entry in services with the given service number,
or raise Not_found .
|
getservbyport [Unix] |
Find an entry in services with the given service number,
or raise Not_found .
|
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_float [UnixLabels] |
|
getsockopt_float [Unix] |
Same as Unix.getsockopt for a socket option whose value is a floating-point number.
|
getsockopt_int [UnixLabels] |
|
getsockopt_int [Unix] |
|
getsockopt_optint [UnixLabels] |
|
getsockopt_optint [Unix] |
|
gettimeofday [UnixLabels] |
|
gettimeofday [Unix] |
Same as Unix.time , but with resolution better than 1 second.
|
getuid [UnixLabels] |
Return the user id of the user executing the process.
|
getuid [Unix] |
Return the user id of the user executing the process.
|
global_replace [Str] |
global_replace regexp templ s returns a string identical to s ,
except that all substrings of s that match regexp have been
replaced by templ .
|
global_substitute [Str] |
global_substitute regexp subst s returns a string identical
to s , except that all substrings of s that match regexp
have been replaced by the result of function subst .
|
gmtime [UnixLabels] |
Convert a time in seconds, as returned by UnixLabels.time , into a date and
a time.
|
gmtime [Unix] |
Convert a time in seconds, as returned by Unix.time , into a date and
a time.
|
green [Graphics] |
|
grid [Tk] |
Pack a widget inside its parent, using the grid layout engine.
|
group_beginning [Str] |
group_beginning n returns the position of the first character
of the substring that was matched by the n th group of
the regular expression.
|
group_end [Str] |
group_end n returns
the position of the character following the last character of
substring that was matched by the n th group of the regular expression.
|
gt_big_int [Big_int] |
Usual boolean comparisons between two big integers.
|
gt_num [Num] |
|
guard [Event] |
guard fn returns the event that, when synchronized, computes
fn() and behaves as the resulting event.
|
H |
handle_unix_error [UnixLabels] |
handle_unix_error f x applies f to x and returns the result.
|
handle_unix_error [Unix] |
handle_unix_error f x applies f to x and returns the result.
|
hash [MoreLabels.Hashtbl] |
|
hash [Hashtbl.HashedType] |
A hashing function on keys.
|
hash [Hashtbl] |
Hashtbl.hash x associates a positive integer to any value of
any type.
|
hash_param [MoreLabels.Hashtbl] |
|
hash_param [Hashtbl] |
Hashtbl.hash_param n m x computes a hash value for x , with the
same properties as for hash .
|
hd [StdLabels.List] |
|
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.
|
I |
i [Complex] |
The complex number i .
|
id [Thread] |
Return the identifier of the given thread.
|
id [Oo] |
Return an integer identifying this object, unique for
the current execution of the program.
|
ignore [Pervasives] |
Discard the value of its argument and return () .
|
in_channel_length [Pervasives.LargeFile] |
|
in_channel_length [Pervasives] |
Return the total length (number of characters) of the
given channel.
|
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] |
Increment the integer contained in the given reference.
|
incr_num [Num] |
incr r is r:=!r+1 , where r is a reference to a number.
|
index [StringLabels] |
String.index s c returns the position of the leftmost
occurrence of character c in string s .
|
index [String] |
String.index s c returns the position of the leftmost
occurrence of character c in string s .
|
index [StdLabels.String] |
|
index_from [StringLabels] |
Same as StringLabels.index , but start
searching at the character position given as second argument.
|
index_from [String] |
Same as String.index , but start
searching at the character position given as second argument.
|
index_from [StdLabels.String] |
|
inet_addr_any [UnixLabels] |
A special Internet address, for use only with bind , representing
all the Internet addresses that the host machine possesses.
|
inet_addr_any [Unix] |
A special Internet address, for use only with bind , representing
all the Internet addresses that the host machine possesses.
|
inet_addr_of_string [UnixLabels] |
Conversions between string with the format XXX.YYY.ZZZ.TTT
and Internet addresses.
|
inet_addr_of_string [Unix] |
Conversions between string with the format XXX.YYY.ZZZ.TTT
and Internet addresses.
|
infinity [Pervasives] |
Positive infinity.
|
infix_tag [Obj] |
|
init [StdLabels.Array] |
|
init [Random] |
Initialize the generator, using the argument as a seed.
|
init [Dynlink] |
Initialize the library.
|
init [ArrayLabels] |
Array.init n f returns a fresh array of length n ,
with element number i initialized to the result of f i .
|
init [Array] |
Array.init n f returns a fresh array of length n ,
with element number i initialized to the result of f i .
|
init_class [CamlinternalOO] |
|
input [Pervasives] |
input ic buf pos len reads up to len characters from
the given channel ic , storing them in string buf , starting at
character number pos .
|
input [Digest] |
Read a digest from the given input channel.
|
input_binary_int [Pervasives] |
Read an integer encoded in binary format from the given input
channel.
|
input_byte [Pervasives] |
|
input_char [Pervasives] |
Read one character from the given input channel.
|
input_line [Pervasives] |
Read characters from the given input channel, until a
newline character is encountered.
|
input_value [Pervasives] |
Read the representation of a structured value, as produced
by Pervasives.output_value , and return the corresponding value.
|
int [Random] |
Random.int bound returns a random integer between 0 (inclusive)
and bound (exclusive).
|
int [Bigarray] |
|
int16_signed [Bigarray] |
|
int16_unsigned [Bigarray] |
|
int32 [Bigarray] |
|
int64 [Bigarray] |
|
int8_signed [Bigarray] |
|
int8_unsigned [Bigarray] |
|
int_of_big_int [Big_int] |
Convert a big integer to a small integer (type int ).
|
int_of_char [Pervasives] |
Return the ASCII code of the argument.
|
int_of_float [Pervasives] |
Truncate the given floating-point number to an integer.
|
int_of_num [Num] |
|
int_of_string [Pervasives] |
Convert the given string to an integer.
|
integer_num [Num] |
integer_num n returns the integer closest to n .
|
inter [Set.S] |
Set intersection.
|
inter [MoreLabels.Set.S] |
|
interactive [Sys] |
This reference is initially set to false in standalone
programs and to true if the code is being executed under
the interactive toplevel system ocaml .
|
inv [Complex] |
Multiplicative inverse (1/z ).
|
invalid_arg [Pervasives] |
Raise exception Invalid_argument with the given string.
|
is_block [Obj] |
|
is_empty [Stack] |
Return true if the given stack is empty, false otherwise.
|
is_empty [Set.S] |
Test whether a set is empty or not.
|
is_empty [Queue] |
Return true if the given queue is empty, false otherwise.
|
is_empty [MoreLabels.Set.S] |
|
is_implicit [Filename] |
Return true if the file name is relative and does not start
with an explicit reference to the current directory (./ or
../ in Unix), false if it starts with an explicit reference
to the root directory or the current directory.
|
is_int [Obj] |
|
is_int_big_int [Big_int] |
Test whether the given big integer is small enough to
be representable as a small integer (type int )
without loss of precision.
|
is_integer_num [Num] |
Test if a number is an integer
|
is_relative [Filename] |
Return true if the file name is relative to the current
directory, false if it is absolute (i.e.
|
iter [Weak.S] |
iter f t calls f on each element of t , in some unspecified
order.
|
iter [StringLabels] |
String.iter f s applies function f in turn to all
the characters of s .
|
iter [String] |
String.iter f s applies function f in turn to all
the characters of s .
|
iter [Stream] |
Stream.iter f s scans the whole stream s, applying function f
in turn to each stream element encountered.
|
iter [StdLabels.String] |
|
iter [StdLabels.List] |
|
iter [StdLabels.Array] |
|
iter [Stack] |
iter f s applies f in turn to all elements of s ,
from the element at the top of the stack to the element at the
bottom of the stack.
|
iter [Set.S] |
iter f s applies f in turn to all elements of s .
|
iter [Queue] |
iter f q applies f in turn to all elements of q ,
from the least recently entered to the most recently entered.
|
iter [MoreLabels.Set.S] |
|
iter [MoreLabels.Map.S] |
|
iter [MoreLabels.Hashtbl.S] |
|
iter [MoreLabels.Hashtbl] |
|
iter [Map.S] |
iter f m applies f to all bindings in map m .
|
iter [ListLabels] |
List.iter f [a1; ...; an] applies function f in turn to
a1; ...; an .
|
iter [List] |
List.iter f [a1; ...; an] applies function f in turn to
a1; ...; an .
|
iter [Hashtbl.S] |
|
iter [Hashtbl] |
Hashtbl.iter f tbl applies f to all bindings in table tbl .
|
iter [Dbm] |
iter f db applies f to each (key , data ) pair in
the database db .
|
iter [ArrayLabels] |
Array.iter f a applies function f in turn to all
the elements of a .
|
iter [Array] |
Array.iter f a applies function f in turn to all
the elements of a .
|
iter2 [StdLabels.List] |
|
iter2 [ListLabels] |
List.iter2 f [a1; ...; an] [b1; ...; bn] calls in turn
f a1 b1; ...; f an bn .
|
iter2 [List] |
List.iter2 f [a1; ...; an] [b1; ...; bn] calls in turn
f a1 b1; ...; f an bn .
|
iteri [StdLabels.Array] |
|
iteri [ArrayLabels] |
Same as ArrayLabels.iter , but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
|
iteri [Array] |
Same as Array.iter , but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
|
J |
join [Thread] |
join th suspends the execution of the calling thread
until the thread th has terminated.
|
junk [Stream] |
Remove the first element of the stream, possibly unfreezing
it before.
|
K |
key_pressed [Graphics] |
Return true if a keypress is available; that is, if read_key
would not block.
|
kill [UnixLabels] |
kill pid sig sends signal number sig to the process
with id pid .
|
kill [Unix] |
kill pid sig sends signal number sig to the process
with id pid .
|
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.Genarray] |
Return the kind of the given big array.
|
kprintf [Printf] |
kprintf k format arguments is the same as sprintf format arguments ,
except that the resulting string is passed as argument to k ; the
result of k is then returned as the result of kprintf .
|
kprintf [Format] |
Same as sprintf above, but instead of returning the string,
passes it to the first argument.
|
kscanf [Scanf] |
Same as Scanf.bscanf , but takes an additional function argument
ef that is called in case of error: if the scanning process or
some conversion fails, the scanning function aborts and applies the
error handling function ef to the scanning buffer and the
exception that aborted evaluation.
|
L |
land [Pervasives] |
Bitwise logical and.
|
last_chars [Str] |
last_chars s n returns the last n characters of s .
|
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.Genarray] |
Return the layout of the given big array.
|
lazy_from_fun [Lazy] |
lazy_from_fun f is the same as lazy (f ()) but slightly more
efficient.
|
lazy_from_val [Lazy] |
lazy_from_val v returns an already-forced suspension of v
This is for special purposes only and should not be confused with
lazy (v) .
|
lazy_is_val [Lazy] |
lazy_is_val x returns true if x has already been forced and
did not raise an exception.
|
lazy_tag [Obj] |
|
ldexp [Pervasives] |
ldexp x n returns x *. 2 ** n .
|
le_big_int [Big_int] |
|
le_num [Num] |
|
length [Weak] |
Weak.length ar returns the length (number of elements) of
ar .
|
length [StringLabels] |
Return the length (number of characters) of the given string.
|
length [String] |
Return the length (number of characters) of the given string.
|
length [StdLabels.String] |
|
length [StdLabels.List] |
|
length [StdLabels.Array] |
|
length [Stack] |
Return the number of elements in a stack.
|
length [Queue] |
Return the number of elements in a queue.
|
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 [Buffer] |
Return the number of characters currently contained in the buffer.
|
length [ArrayLabels] |
Return the length (number of elements) of the given array.
|
length [Array] |
Return the length (number of elements) of the given array.
|
lexeme [Lexing] |
Lexing.lexeme lexbuf returns the string matched by
the regular expression.
|
lexeme_char [Lexing] |
Lexing.lexeme_char lexbuf i returns character number i in
the matched string.
|
lexeme_end [Lexing] |
Lexing.lexeme_end lexbuf returns the position in the input stream
of the character following the last character of the matched
string.
|
lexeme_start [Lexing] |
Lexing.lexeme_start lexbuf returns the position in the
input stream of the first character of the matched string.
|
lineto [Graphics] |
Draw a line with endpoints the current point and the given point,
and move the current point to the given point.
|
link [UnixLabels] |
link source dest creates a hard link named dest to the file
named new .
|
link [Unix] |
link source dest creates a hard link named dest to the file
named source .
|
list [Sort] |
Sort a list in increasing order according to an ordering predicate.
|
listen [UnixLabels] |
Set up a socket for receiving connection requests.
|
listen [Unix] |
Set up a socket for receiving connection requests.
|
lnot [Pervasives] |
Bitwise logical negation.
|
loadfile [Dynlink] |
Load the given bytecode object file and link it.
|
loadfile_private [Dynlink] |
Same as loadfile , except that the module loaded is not
made available to other modules dynamically loaded afterwards.
|
localtime [UnixLabels] |
Convert a time in seconds, as returned by UnixLabels.time , into a date and
a time.
|
localtime [Unix] |
Convert a time in seconds, as returned by Unix.time , into a date and
a time.
|
lock [Mutex] |
Lock the given mutex.
|
lockf [UnixLabels] |
lockf fd cmd size puts a lock on a region of the file opened
as fd .
|
lockf [Unix] |
lockf fd cmd size puts a lock on a region of the file opened
as fd .
|
log [Pervasives] |
Natural logarithm.
|
log [Complex] |
Natural logarithm (in base e ).
|
log10 [Pervasives] |
Base 10 logarithm.
|
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.
|
lor [Pervasives] |
Bitwise logical or.
|
lower_window [Tk] |
Raise or lower the window associated to a widget.
|
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 [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 [StdLabels.String] |
|
lowercase [Char] |
Convert the given character to its equivalent lowercase character.
|
lseek [UnixLabels.LargeFile] |
|
lseek [UnixLabels] |
Set the current position for a file descriptor
|
lseek [Unix.LargeFile] |
|
lseek [Unix] |
Set the current position for a file descriptor
|
lsl [Pervasives] |
n lsl m shifts n to the left by m bits.
|
lsr [Pervasives] |
n lsr m shifts n to the right by m bits.
|
lstat [UnixLabels.LargeFile] |
|
lstat [UnixLabels] |
Same as UnixLabels.stat , but in case the file is a symbolic link,
return the information for the link itself.
|
lstat [Unix.LargeFile] |
|
lstat [Unix] |
Same as Unix.stat , but in case the file is a symbolic link,
return the informations for the link itself.
|
lt_big_int [Big_int] |
|
lt_num [Num] |
|
lxor [Pervasives] |
Bitwise logical exclusive or.
|
M |
magenta [Graphics] |
|
magic [Obj] |
|
mainLoop [Tk] |
Start the main event loop
|
major [Gc] |
Do a minor collection and finish the current major collection cycle.
|
major_slice [Gc] |
Do a minor collection and a slice of major collection.
|
make [StringLabels] |
String.make n c returns a fresh string of length n ,
filled with the character c .
|
make [String] |
String.make n c returns a fresh string of length n ,
filled with the character c .
|
make [StdLabels.String] |
|
make [StdLabels.Array] |
|
make [ArrayLabels] |
Array.make n x returns a fresh array of length n ,
initialized with x .
|
make [Array] |
Array.make n x returns a fresh array of length n ,
initialized with x .
|
make_formatter [Format] |
make_formatter out flush returns a new formatter that
writes according to the output function out , and the flushing
function flush .
|
make_image [Graphics] |
Convert the given color matrix to an image.
|
make_lexer [Genlex] |
Construct the lexer function.
|
make_matrix [StdLabels.Array] |
|
make_matrix [ArrayLabels] |
Array.make_matrix dimx dimy e returns a two-dimensional array
(an array of arrays) with first dimension dimx and
second dimension dimy .
|
make_matrix [Array] |
Array.make_matrix dimx dimy e returns a two-dimensional array
(an array of arrays) with first dimension dimx and
second dimension dimy .
|
map [StdLabels.List] |
|
map [StdLabels.Array] |
|
map [MoreLabels.Map.S] |
|
map [Map.S] |
map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
|
map [ListLabels] |
List.map f [a1; ...; an] applies function f to a1, ..., an ,
and builds the list [f a1; ...; f an]
with the results returned by f .
|
map [List] |
List.map f [a1; ...; an] applies function f to a1, ..., an ,
and builds the list [f a1; ...; f an]
with the results returned by f .
|
map [ArrayLabels] |
Array.map f a applies function f to all the elements of a ,
and builds an array with the results returned by f :
[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |] .
|
map [Array] |
Array.map f a applies function f to all the elements of a ,
and builds an array with the results returned by f :
[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |] .
|
map2 [StdLabels.List] |
|
map2 [ListLabels] |
List.map2 f [a1; ...; an] [b1; ...; bn] is
[f a1 b1; ...; f an bn] .
|
map2 [List] |
List.map2 f [a1; ...; an] [b1; ...; bn] is
[f a1 b1; ...; f an bn] .
|
map_file [Bigarray.Array3] |
Memory mapping of a file as a three-dimensional big array.
|
map_file [Bigarray.Array2] |
Memory mapping of a file as a two-dimensional big array.
|
map_file [Bigarray.Array1] |
Memory mapping of a file as a one-dimensional big array.
|
map_file [Bigarray.Genarray] |
Memory mapping of a file as a big array.
|
mapi [StdLabels.Array] |
|
mapi [MoreLabels.Map.S] |
|
mapi [Map.S] |
Same as Map.S.map , but the function receives as arguments both the
key and the associated value for each binding of the map.
|
mapi [ArrayLabels] |
Same as ArrayLabels.map , but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
|
mapi [Array] |
Same as Array.map , but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
|
marshal [Obj] |
|
match_beginning [Str] |
|
match_end [Str] |
match_end() returns the position of the character following the
last character of the substring that was matched by string_match ,
search_forward or search_backward .
|
matched_group [Str] |
|
matched_string [Str] |
|
max [Pervasives] |
Return the greater of the two arguments.
|
max_array_length [Sys] |
Maximum length of an array.
|
max_big_int [Big_int] |
Return the greater of its two arguments.
|
max_elt [Set.S] |
Same as Set.S.min_elt , but returns the largest element of the
given set.
|
max_elt [MoreLabels.Set.S] |
|
max_float [Pervasives] |
The largest positive finite value of type float .
|
max_int [Pervasives] |
The greatest representable integer.
|
max_int [Nativeint] |
The greatest representable native integer,
either 231 - 1 on a 32-bit platform,
or 263 - 1 on a 64-bit platform.
|
max_int [Int64] |
The greatest representable 64-bit integer, 263 - 1.
|
max_int [Int32] |
The greatest representable 32-bit integer, 231 - 1.
|
max_num [Num] |
Return the greater of the two arguments.
|
max_string_length [Sys] |
Maximum length of a string.
|
mem [Weak.S] |
mem t x returns true if there is at least one instance
of x in t , false otherwise.
|
mem [StdLabels.List] |
|
mem [Set.S] |
mem x s tests whether x belongs to the set s .
|
mem [MoreLabels.Set.S] |
|
mem [MoreLabels.Map.S] |
|
mem [MoreLabels.Hashtbl.S] |
|
mem [MoreLabels.Hashtbl] |
|
mem [Map.S] |
mem x m returns true if m contains a binding for x ,
and false otherwise.
|
mem [ListLabels] |
mem a l is true if and only if a is equal
to an element of l .
|
mem [List] |
mem a l is true if and only if a is equal
to an element of l .
|
mem [Hashtbl.S] |
|
mem [Hashtbl] |
Hashtbl.mem tbl x checks if x is bound in tbl .
|
mem_assoc [StdLabels.List] |
|
mem_assoc [ListLabels] |
Same as ListLabels.assoc , but simply return true if a binding exists,
and false if no bindings exist for the given key.
|
mem_assoc [List] |
Same as List.assoc , but simply return true if a binding exists,
and false if no bindings exist for the given key.
|
mem_assq [StdLabels.List] |
|
mem_assq [ListLabels] |
Same as ListLabels.mem_assoc , but uses physical equality instead of
structural equality to compare keys.
|
mem_assq [List] |
Same as List.mem_assoc , but uses physical equality instead of
structural equality to compare keys.
|
memq [StdLabels.List] |
|
memq [ListLabels] |
Same as ListLabels.mem , but uses physical equality instead of structural
equality to compare list elements.
|
memq [List] |
Same as List.mem , but uses physical equality instead of structural
equality to compare list elements.
|
merge [Weak.S] |
merge t x returns an instance of x found in t if any,
or else adds x to t and return x .
|
merge [Sort] |
Merge two lists according to the given predicate.
|
merge [ListLabels] |
Merge two lists:
Assuming that l1 and l2 are sorted according to the
comparison function cmp , merge cmp l1 l2 will return a
sorted list containting all the elements of l1 and l2 .
|
merge [List] |
Merge two lists:
Assuming that l1 and l2 are sorted according to the
comparison function cmp , merge cmp l1 l2 will return a
sorted list containting all the elements of l1 and l2 .
|
min [Pervasives] |
Return the smaller of the two arguments.
|
min_big_int [Big_int] |
Return the smaller of its two arguments.
|
min_elt [Set.S] |
Return the smallest element of the given set
(with respect to the Ord.compare ordering), or raise
Not_found if the set is empty.
|
min_elt [MoreLabels.Set.S] |
|
min_float [Pervasives] |
The smallest positive, non-zero, non-denormalized value of type float .
|
min_int [Pervasives] |
The smallest representable integer.
|
min_int [Nativeint] |
The greatest representable native integer,
either -231 on a 32-bit platform,
or -263 on a 64-bit platform.
|
min_int [Int64] |
The smallest representable 64-bit integer, -263.
|
min_int [Int32] |
The smallest representable 32-bit integer, -231.
|
min_num [Num] |
Return the smaller of the two arguments.
|
minor [Gc] |
Trigger a minor collection.
|
minus_big_int [Big_int] |
Unary negation.
|
minus_num [Num] |
Unary negation.
|
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.
|
mkfifo [UnixLabels] |
Create a named pipe with the given permissions.
|
mkfifo [Unix] |
Create a named pipe with the given permissions.
|
mktime [UnixLabels] |
Convert a date and time, specified by the tm argument, into
a time in seconds, as returned by UnixLabels.time .
|
mktime [Unix] |
Convert a date and time, specified by the tm argument, into
a time in seconds, as returned by Unix.time .
|
mod [Pervasives] |
Integer remainder.
|
mod_big_int [Big_int] |
Euclidean modulus of two big integers.
|
mod_float [Pervasives] |
mod_float a b returns the remainder of a with respect to
b .
|
mod_num [Num] |
Euclidean division: remainder.
|
modf [Pervasives] |
modf f returns the pair of the fractional and integral
part of f .
|
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 [Complex] |
Multiplication
|
mult_big_int [Big_int] |
Multiplication of two big integers.
|
mult_int_big_int [Big_int] |
Multiplication of a big integer by a small integer
|
mult_num [Num] |
Multiplication
|
N |
nan [Pervasives] |
A special floating-point value denoting the result of an
undefined operation such as 0.0 /. 0.0 .
|
narrow [CamlinternalOO] |
|
nat_of_num [Num] |
|
nativeint [Bigarray] |
|
neg [Nativeint] |
Unary negation.
|
neg [Int64] |
Unary negation.
|
neg [Int32] |
Unary negation.
|
neg [Complex] |
Unary negation.
|
neg_infinity [Pervasives] |
Negative infinity.
|
new_block [Obj] |
|
new_channel [Event] |
Return a new channel.
|
new_method [CamlinternalOO] |
|
new_variable [CamlinternalOO] |
|
next [Stream] |
Return the first element of the stream and remove it from the
stream.
|
nextkey [Dbm] |
Enumerate all keys in the given database, in an unspecified order.
|
nice [UnixLabels] |
Change the process priority.
|
nice [Unix] |
Change the process priority.
|
no_scan_tag [Obj] |
|
norm [Complex] |
Norm: given x + i.y , returns sqrt(x^2 + y^2) .
|
norm2 [Complex] |
Norm squared: given x + i.y , returns x^2 + y^2 .
|
not [Pervasives] |
The boolean negation.
|
npeek [Stream] |
npeek n returns the list of the n first elements of
the stream, or all its remaining elements if less than n
elements are available.
|
nth [StdLabels.List] |
|
nth [ListLabels] |
Return the n-th element of the given list.
|
nth [List] |
Return the n-th element of the given list.
|
nth_dim [Bigarray.Genarray] |
Genarray.nth_dim a n returns the n -th dimension of the
big array a .
|
num_digits_big_int [Big_int] |
Return the number of machine words used to store the
given big integer.
|
num_dims [Bigarray.Genarray] |
Return the number of dimensions of the given big array.
|
num_of_big_int [Num] |
|
num_of_int [Num] |
|
num_of_nat [Num] |
|
num_of_ratio [Num] |
|
num_of_string [Num] |
Convert a string to a number.
|
O |
obj [Obj] |
|
object_tag [Obj] |
|
ocaml_version [Sys] |
ocaml_version is the version of Objective Caml.
|
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_channel [Stream] |
Return the stream of the characters read from the input channel.
|
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 [Nativeint] |
Convert the given integer (type int ) to a native integer
(type nativeint ).
|
of_int [Int64] |
Convert the given integer (type int ) to a 64-bit integer (type int64 ).
|
of_int [Int32] |
Convert the given integer (type int ) to a 32-bit integer (type int32 ).
|
of_int32 [Nativeint] |
Convert the given 32-bit integer (type int32 )
to a native integer.
|
of_int32 [Int64] |
Convert the given 32-bit integer (type int32 )
to a 64-bit integer (type int64 ).
|
of_list [Stream] |
Return the stream holding the elements of the list in the same
order.
|
of_list [StdLabels.Array] |
|
of_list [ArrayLabels] |
Array.of_list l returns a fresh array containing the elements
of l .
|
of_list [Array] |
Array.of_list l returns a fresh array containing the elements
of l .
|
of_nativeint [Int64] |
Convert the given native integer (type nativeint )
to a 64-bit integer (type int64 ).
|
of_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.
|
one [Nativeint] |
The native integer 1.
|
one [Int64] |
The 64-bit integer 1.
|
one [Int32] |
The 32-bit integer 1.
|
one [Complex] |
The complex number 1 .
|
openTk [Tk] |
Initialize LablTk and open a toplevel window.
|
open_box [Format] |
open_box d opens a new pretty-printing box
with offset d .
|
open_connection [UnixLabels] |
Connect to a server at the given address.
|
open_connection [Unix] |
Connect to a server at the given address.
|
open_connection [ThreadUnix] |
|
open_graph [Graphics] |
Show the graphics window or switch the screen to graphic mode.
|
open_hbox [Format] |
open_hbox () opens a new pretty-printing box.
|
open_hovbox [Format] |
open_hovbox d opens a new pretty-printing box
with offset d .
|
open_hvbox [Format] |
open_hvbox d opens a new pretty-printing box
with offset d .
|
open_in [Pervasives] |
Open the named file for reading, and return a new input channel
on that file, positionned at the beginning of the file.
|
open_in_bin [Pervasives] |
Same as Pervasives.open_in , but the file is opened in binary mode,
so that no translation takes place during reads.
|
open_in_gen [Pervasives] |
Open the named file for reading, as above.
|
open_out [Pervasives] |
Open the named file for writing, and return a new output channel
on that file, positionned at the beginning of the file.
|
open_out_bin [Pervasives] |
Same as Pervasives.open_out , but the file is opened in binary mode,
so that no translation takes place during writes.
|
open_out_gen [Pervasives] |
Open the named file for writing, as above.
|
open_process [UnixLabels] |
|
open_process [Unix] |
Same as Unix.open_process_out , but redirects both the standard input
and standard output of the command to pipes connected to the two
returned channels.
|
open_process [ThreadUnix] |
|
open_process_full [UnixLabels] |
|
open_process_full [Unix] |
Similar to Unix.open_process , but the second argument specifies
the environment passed to the command.
|
open_process_in [UnixLabels] |
High-level pipe and process management.
|
open_process_in [Unix] |
High-level pipe and process management.
|
open_process_in [ThreadUnix] |
|
open_process_out [UnixLabels] |
|
open_process_out [Unix] |
|
open_process_out [ThreadUnix] |
|
open_subwindow [GraphicsX11] |
Create a sub-window of the current Caml graphics window
and return its identifier.
|
open_tag [Format] |
open_tag t opens the tag named t ; the print_open_tag
function of the formatter is called with t as argument;
the tag marker mark_open_tag t will be flushed into the output
device of the formatter.
|
open_tbox [Format] |
Opens a tabulation box.
|
open_temp_file [Filename] |
Same as Filename.temp_file , but returns both the name of a fresh
temporary file, and an output channel opened (atomically) on
this file.
|
open_vbox [Format] |
open_vbox d opens a new pretty-printing box
with offset d .
|
opendbm [Dbm] |
Open a descriptor on an NDBM database.
|
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.
|
or [Pervasives] |
|
os_type [Sys] |
Operating system currently executing the Caml program.
|
out_channel_length [Pervasives.LargeFile] |
|
out_channel_length [Pervasives] |
Return the total length (number of characters) of the
given channel.
|
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.
|
output [Pervasives] |
output oc buf pos len writes len characters from string buf ,
starting at offset pos , to the given output channel oc .
|
output [Digest] |
Write a digest on the given output channel.
|
output_binary_int [Pervasives] |
Write one integer in binary format on the given output channel.
|
output_buffer [Buffer] |
output_buffer oc b writes the current contents of buffer b
on the output channel oc .
|
output_byte [Pervasives] |
Write one 8-bit integer (as the single character with that code)
on the given output channel.
|
output_char [Pervasives] |
Write the character on the given output channel.
|
output_string [Pervasives] |
Write the string on the given output channel.
|
output_value [Pervasives] |
Write the representation of a structured value of any type
to a channel.
|
over_max_boxes [Format] |
Tests if the maximum number of boxes allowed have already been opened.
|
P |
pack [Tk] |
Pack a widget inside its parent,
using the standard layout engine.
|
params [CamlinternalOO] |
|
parent_dir_name [Filename] |
The conventional name for the parent of the current directory
(e.g.
|
parse [Arg] |
Arg.parse speclist anonfun usage_msg parses the command line.
|
parse_argv [Arg] |
Arg.parse_argv args speclist anonfun usage_msg parses array args as
if it were the command line.
|
partition [StdLabels.List] |
|
partition [Set.S] |
partition p s returns a pair of sets (s1, s2) , where
s1 is the set of all the elements of s that satisfy the
predicate p , and s2 is the set of all the elements of
s that do not satisfy p .
|
partition [MoreLabels.Set.S] |
|
partition [ListLabels] |
partition p l returns a pair of lists (l1, l2) , where
l1 is the list of all the elements of l that
satisfy the predicate p , and l2 is the list of all the
elements of l that do not satisfy p .
|
partition [List] |
partition p l returns a pair of lists (l1, l2) , where
l1 is the list of all the elements of l that
satisfy the predicate p , and l2 is the list of all the
elements of l that do not satisfy p .
|
pause [UnixLabels] |
Wait until a non-ignored, non-blocked signal is delivered.
|
pause [Unix] |
Wait until a non-ignored, non-blocked signal is delivered.
|
peek [Stream] |
Return Some of "the first element" of the stream, or None if
the stream is empty.
|
peek [Queue] |
peek q returns the first element in queue q , without removing
it from the queue, or raises Empty if the queue is empty.
|
pipe [UnixLabels] |
Create a pipe.
|
pipe [Unix] |
Create a pipe.
|
pipe [ThreadUnix] |
|
pixels [Tk] |
Converts various on-screen units to pixels,
respective to the default display.
|
place [Tk] |
Pack a widget inside its parent, at absolute coordinates.
|
plot [Graphics] |
Plot the given point with the current drawing color.
|
plots [Graphics] |
Plot the given points with the current drawing color.
|
point_color [Graphics] |
Return the color of the given point in the backing store
(see "Double buffering" below).
|
polar [Complex] |
polar norm arg returns the complex having norm norm
and argument arg .
|
poll [Event] |
Non-blocking version of Event.sync : offer all the communication
possibilities specified in the event to the outside world,
and if one can take place immediately, perform it and return
Some r where r is the result value of that communication.
|
pop [Stack] |
pop s removes and returns the topmost element in stack s ,
or raises Empty if the stack is empty.
|
pop [Queue] |
pop is a synonym for take .
|
pos_in [Pervasives.LargeFile] |
|
pos_in [Pervasives] |
Return the current reading position for the given channel.
|
pos_out [Pervasives.LargeFile] |
|
pos_out [Pervasives] |
Return the current writing position for the given channel.
|
pow [Complex] |
Power function.
|
power_big_int_positive_big_int [Big_int] |
Exponentiation functions.
|
power_big_int_positive_int [Big_int] |
|
power_int_positive_big_int [Big_int] |
|
power_int_positive_int [Big_int] |
|
power_num [Num] |
Exponentiation
|
pp_close_box [Format] |
|
pp_close_tag [Format] |
|
pp_close_tbox [Format] |
|
pp_force_newline [Format] |
|
pp_get_all_formatter_output_functions [Format] |
|
pp_get_ellipsis_text [Format] |
|
pp_get_formatter_output_functions [Format] |
|
pp_get_formatter_tag_functions [Format] |
These functions are the basic ones: usual functions
operating on the standard formatter are defined via partial
evaluation of these primitives.
|
pp_get_margin [Format] |
|
pp_get_mark_tags [Format] |
|
pp_get_max_boxes [Format] |
|
pp_get_max_indent [Format] |
|
pp_get_print_tags [Format] |
|
pp_open_box [Format] |
|
pp_open_hbox [Format] |
|
pp_open_hovbox [Format] |
|
pp_open_hvbox [Format] |
|
pp_open_tag [Format] |
|
pp_open_tbox [Format] |
|
pp_open_vbox [Format] |
|
pp_over_max_boxes [Format] |
|
pp_print_as [Format] |
|
pp_print_bool [Format] |
|
pp_print_break [Format] |
|
pp_print_char [Format] |
|
pp_print_cut [Format] |
|
pp_print_float [Format] |
|
pp_print_flush [Format] |
|
pp_print_if_newline [Format] |
|
pp_print_int [Format] |
|
pp_print_newline [Format] |
|
pp_print_space [Format] |
|
pp_print_string [Format] |
|
pp_print_tab [Format] |
|
pp_print_tbreak [Format] |
|
pp_set_all_formatter_output_functions [Format] |
|
pp_set_ellipsis_text [Format] |
|
pp_set_formatter_out_channel [Format] |
|
pp_set_formatter_output_functions [Format] |
|
pp_set_formatter_tag_functions [Format] |
|
pp_set_margin [Format] |
|
pp_set_mark_tags [Format] |
|
pp_set_max_boxes [Format] |
|
pp_set_max_indent [Format] |
|
pp_set_print_tags [Format] |
|
pp_set_tab [Format] |
|
pp_set_tags [Format] |
|
pred [Pervasives] |
pred x is x-1 .
|
pred [Nativeint] |
Predecessor.
|
pred [Int64] |
Predecessor.
|
pred [Int32] |
Predecessor.
|
pred_big_int [Big_int] |
Predecessor (subtract 1).
|
pred_num [Num] |
pred n is n-1
|
prerr_char [Pervasives] |
Print a character on standard error.
|
prerr_endline [Pervasives] |
Print a string, followed by a newline character on standard error
and flush standard error.
|
prerr_float [Pervasives] |
Print a floating-point number, in decimal, on standard error.
|
prerr_int [Pervasives] |
Print an integer, in decimal, on standard error.
|
prerr_newline [Pervasives] |
Print a newline character on standard error, and flush
standard error.
|
prerr_string [Pervasives] |
Print a string on standard error.
|
print [Printexc] |
Printexc.print fn x applies fn to x and returns the result.
|
print_as [Format] |
print_as len str prints str in the
current box.
|
print_bool [Format] |
Prints a boolean in the current box.
|
print_break [Format] |
Inserts a break hint in a pretty-printing box.
|
print_char [Pervasives] |
Print a character on standard output.
|
print_char [Format] |
Prints a character in the current box.
|
print_cut [Format] |
print_cut () is used to mark a good break position.
|
print_endline [Pervasives] |
Print a string, followed by a newline character, on
standard output.
|
print_float [Pervasives] |
Print a floating-point number, in decimal, on standard output.
|
print_float [Format] |
Prints a floating point number in the current box.
|
print_flush [Format] |
Flushes the pretty printer: all opened boxes are closed,
and all pending text is displayed.
|
print_if_newline [Format] |
Executes the next formatting command if the preceding line
has just been split.
|
print_int [Pervasives] |
Print an integer, in decimal, on standard output.
|
print_int [Format] |
Prints an integer in the current box.
|
print_newline [Pervasives] |
Print a newline character on standard output, and flush
standard output.
|
print_newline [Format] |
Equivalent to print_flush followed by a new line.
|
print_space [Format] |
print_space () is used to separate items (typically to print
a space between two words).
|
print_stat [Gc] |
Print the current values of the memory management counters (in
human-readable form) into the channel argument.
|
print_string [Pervasives] |
Print a string on standard output.
|
print_string [Format] |
print_string str prints str in the current box.
|
print_tab [Format] |
print_tab () is equivalent to print_tbreak (0,0) .
|
print_tbreak [Format] |
Break hint in a tabulation box.
|
printf [Printf] |
|
printf [Format] |
Same as fprintf above, but output on std_formatter .
|
public_method_label [CamlinternalOO] |
|
push [Stack] |
push x s adds the element x at the top of stack s .
|
push [Queue] |
push is a synonym for add .
|
putenv [UnixLabels] |
Unix.putenv name value sets the value associated to a
variable in the process environment.
|
putenv [Unix] |
Unix.putenv name value sets the value associated to a
variable in the process environment.
|
Q |
quo_num [Num] |
Euclidean division: quotient.
|
quomod_big_int [Big_int] |
Euclidean division of two big integers.
|
quote [Str] |
Str.quote s returns a regexp string that matches exactly
s and nothing else.
|
quote [Filename] |
Return a quoted version of a file name, suitable for use as
one argument in a shell command line, escaping all shell
meta-characters.
|
R |
raise [Pervasives] |
Raise the given exception value
|
raise_window [Tk] |
|
ratio_of_num [Num] |
|
rcontains_from [StringLabels] |
String.rcontains_from s stop c tests if character c
appears in the substring of s starting from the beginning
of s to index stop .
|
rcontains_from [String] |
String.rcontains_from s stop c tests if character c
appears in the substring of s starting from the beginning
of s to index stop .
|
rcontains_from [StdLabels.String] |
|
read [UnixLabels] |
read fd buff ofs len reads len characters from descriptor
fd , storing them in string buff , starting at position ofs
in string buff .
|
read [Unix] |
read fd buff ofs len reads len characters from descriptor
fd , storing them in string buff , starting at position ofs
in string buff .
|
read [ThreadUnix] |
|
read_float [Pervasives] |
Flush standard output, then read one line from standard input
and convert it to a floating-point number.
|
read_int [Pervasives] |
Flush standard output, then read one line from standard input
and convert it to an integer.
|
read_key [Graphics] |
Wait for a key to be pressed, and return the corresponding
character.
|
read_line [Pervasives] |
Flush standard output, then read characters from standard input
until a newline character is encountered.
|
readdir [UnixLabels] |
Return the next entry in a directory.
|
readdir [Unix] |
Return the next entry in a directory.
|
readlink [UnixLabels] |
Read the contents of a link.
|
readlink [Unix] |
Read the contents of a link.
|
really_input [Pervasives] |
really_input ic buf pos len reads len characters from channel ic ,
storing them in string buf , starting at character number pos .
|
receive [Event] |
receive ch returns the event consisting in receiving a value
from the channel ch .
|
recv [UnixLabels] |
Receive data from an unconnected socket.
|
recv [Unix] |
Receive data from a connected socket.
|
recv [ThreadUnix] |
|
recvfrom [UnixLabels] |
Receive data from an unconnected socket.
|
recvfrom [Unix] |
Receive data from an unconnected socket.
|
recvfrom [ThreadUnix] |
|
red [Graphics] |
|
ref [Pervasives] |
Return a fresh reference containing the given value.
|
regexp [Str] |
Compile a regular expression.
|
regexp_case_fold [Str] |
Same as regexp , but the compiled expression will match text
in a case-insensitive way: uppercase and lowercase letters will
be considered equivalent.
|
regexp_string [Str] |
Str.regexp_string s returns a regular expression
that matches exactly s and nothing else.
|
regexp_string_case_fold [Str] |
Str.regexp_string_case_fold is similar to Str.regexp_string ,
but the regexp matches in a case-insensitive way.
|
register [Callback] |
Callback.register n v registers the value v under
the name n .
|
register_exception [Callback] |
Callback.register_exception n exn registers the
exception contained in the exception value exn
under the name n .
|
rem [Nativeint] |
Integer remainder.
|
rem [Int64] |
Integer remainder.
|
rem [Int32] |
Integer remainder.
|
remember_mode [Graphics] |
Set remember mode on or off.
|
remove [Weak.S] |
remove t x removes from t one instance of x .
|
remove [Sys] |
Remove the given file name from the file system.
|
remove [Set.S] |
remove x s returns a set containing all elements of s ,
except x .
|
remove [MoreLabels.Set.S] |
|
remove [MoreLabels.Map.S] |
|
remove [MoreLabels.Hashtbl.S] |
|
remove [MoreLabels.Hashtbl] |
|
remove [Map.S] |
remove x m returns a map containing the same bindings as
m , except for x which is unbound in the returned map.
|
remove [Hashtbl.S] |
|
remove [Hashtbl] |
Hashtbl.remove tbl x removes the current binding of x in tbl ,
restoring the previous binding if it exists.
|
remove [Dbm] |
remove db key data removes the data associated with key
in db .
|
remove_assoc [StdLabels.List] |
|
remove_assoc [ListLabels] |
remove_assoc a l returns the list of
pairs l without the first pair with key a , if any.
|
remove_assoc [List] |
remove_assoc a l returns the list of
pairs l without the first pair with key a , if any.
|
remove_assq [StdLabels.List] |
|
remove_assq [ListLabels] |
|
remove_assq [List] |
Same as List.remove_assoc , but uses physical equality instead
of structural equality to compare keys.
|
rename [UnixLabels] |
rename old new changes the name of a file from old to new .
|
rename [Unix] |
rename old new changes the name of a file from old to new .
|
rename [Sys] |
Rename a file.
|
replace [MoreLabels.Hashtbl.S] |
|
replace [MoreLabels.Hashtbl] |
|
replace [Hashtbl.S] |
|
replace [Hashtbl] |
Hashtbl.replace tbl x y replaces the current binding of x
in tbl by a binding of x to y .
|
replace [Dbm] |
replace db key data inserts the pair (key , data ) in
the database db .
|
replace_first [Str] |
Same as Str.global_replace , except that only the first substring
matching the regular expression is replaced.
|
replace_matched [Str] |
replace_matched repl s returns the replacement text repl
in which \1 , \2 , etc.
|
repr [Obj] |
|
reset [Buffer] |
Empty the buffer and deallocate the internal string holding the
buffer contents, replacing it with the initial internal string
of length n that was allocated by Buffer.create n .
|
reshape [Bigarray] |
reshape b [|d1;...;dN|] converts the big array b to a
N -dimensional array of dimensions d1 ...
|
reshape_1 [Bigarray] |
Specialized version of Bigarray.reshape for reshaping to one-dimensional arrays.
|
reshape_2 [Bigarray] |
Specialized version of Bigarray.reshape for reshaping to two-dimensional arrays.
|
reshape_3 [Bigarray] |
Specialized version of Bigarray.reshape for reshaping to three-dimensional arrays.
|
rev [StdLabels.List] |
|
rev [ListLabels] |
List reversal.
|
rev [List] |
List reversal.
|
rev_append [StdLabels.List] |
|
rev_append [ListLabels] |
List.rev_append l1 l2 reverses l1 and concatenates it to l2 .
|
rev_append [List] |
List.rev_append l1 l2 reverses l1 and concatenates it to l2 .
|
rev_map [StdLabels.List] |
|
rev_map [ListLabels] |
|
rev_map [List] |
List.rev_map f l gives the same result as
List.rev ( List.map f l) , but is tail-recursive and
more efficient.
|
rev_map2 [StdLabels.List] |
|
rev_map2 [ListLabels] |
|
rev_map2 [List] |
List.rev_map2 f l gives the same result as
List.rev ( List.map2 f l) , but is tail-recursive and
more efficient.
|
rewinddir [UnixLabels] |
Reposition the descriptor to the beginning of the directory
|
rewinddir [Unix] |
Reposition the descriptor to the beginning of the directory
|
rgb [Graphics] |
rgb r g b returns the integer encoding the color with red
component r , green component g , and blue component b .
|
rhs_end [Parsing] |
|
rhs_start [Parsing] |
Same as Parsing.symbol_start and Parsing.symbol_end , but return the
position of the string matching the n th item on the
right-hand side of the rule, where n is the integer parameter
to lhs_start and lhs_end .
|
rindex [StringLabels] |
String.rindex s c returns the position of the rightmost
occurrence of character c in string s .
|
rindex [String] |
String.rindex s c returns the position of the rightmost
occurrence of character c in string s .
|
rindex [StdLabels.String] |
|
rindex_from [StringLabels] |
Same as StringLabels.rindex , but start
searching at the character position given as second argument.
|
rindex_from [String] |
Same as String.rindex , but start
searching at the character position given as second argument.
|
rindex_from [StdLabels.String] |
|
rlineto [Graphics] |
Draw a line with endpoints the current point and the
current point translated of the given vector,
and move the current point to this point.
|
rmdir [UnixLabels] |
Remove an empty directory.
|
rmdir [Unix] |
Remove an empty directory.
|
rmoveto [Graphics] |
rmoveto dx dy translates the current point by the given vector.
|
round_num [Num] |
round_num n returns the integer closest to n .
|
run_initializers [CamlinternalOO] |
|
run_initializers_opt [CamlinternalOO] |
|
S |
scanf [Scanf] |
Same as Scanf.bscanf , but inputs from stdin
(the standard input channel).
|
search_backward [Str] |
|
search_forward [Str] |
search_forward r s start searchs the string s for a substring
matching the regular expression r .
|
seek_in [Pervasives.LargeFile] |
|
seek_in [Pervasives] |
seek_in chan pos sets the current reading position to pos
for channel chan .
|
seek_out [Pervasives.LargeFile] |
|
seek_out [Pervasives] |
seek_out chan pos sets the current writing position to pos
for channel chan .
|
select [UnixLabels] |
Wait until some input/output operations become possible on
some channels.
|
select [Unix] |
Wait until some input/output operations become possible on
some channels.
|
select [ThreadUnix] |
|
select [Thread] |
Suspend the execution of the calling thead 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 more-or-less random seed chosen
in a system-dependent way.
|
send [UnixLabels] |
Send data over an unconnected socket.
|
send [Unix] |
Send data over a connected socket.
|
send [ThreadUnix] |
|
send [Event] |
send ch v returns the event consisting in sending the value v
over the channel ch .
|
send [CamlinternalOO] |
|
sendto [UnixLabels] |
Send data over an unconnected socket.
|
sendto [Unix] |
Send data over an unconnected socket.
|
sendto [ThreadUnix] |
|
set [Weak] |
Weak.set ar n (Some el) sets the n th cell of ar to be a
(full) pointer to el ; Weak.set ar n None sets the n th
cell of ar to empty.
|
set [StringLabels] |
String.set s n c modifies string s in place,
replacing the character number n by c .
|
set [String] |
String.set s n c modifies string s in place,
replacing the character number n by c .
|
set [StdLabels.String] |
|
set [StdLabels.Array] |
|
set [Gc] |
set r changes the GC parameters according to the control record r .
|
set [Bigarray.Array3] |
Array3.set a x y v , or alternatively a.{x,y,z} <- v ,
stores the value v at coordinates (x , y , z ) in a .
|
set [Bigarray.Array2] |
Array2.set a x y v , or alternatively a.{x,y} <- v ,
stores the value v at coordinates (x , y ) in a .
|
set [Bigarray.Array1] |
Array1.set a x v , also written a.{x} <- v ,
stores the value v at index x in a .
|
set [Bigarray.Genarray] |
Assign an element of a generic big array.
|
set [ArrayLabels] |
Array.set a n x modifies array a in place, replacing
element number n with x .
|
set [Array] |
Array.set a n x modifies array a in place, replacing
element number n with x .
|
set_all_formatter_output_functions [Format] |
set_all_formatter_output_functions out flush outnewline outspace
redirects the pretty-printer output to the functions out and
flush as described in set_formatter_output_functions .
|
set_approx_printing [Arith_status] |
Get or set the flag approx_printing .
|
set_binary_mode_in [Pervasives] |
set_binary_mode_in ic true sets the channel ic to binary
mode: no translations take place during input.
|
set_binary_mode_out [Pervasives] |
set_binary_mode_out oc true sets the channel oc to binary
mode: no translations take place during output.
|
set_close_on_exec [UnixLabels] |
Set the ``close-on-exec'' flag on the given descriptor.
|
set_close_on_exec [Unix] |
Set the ``close-on-exec'' flag on the given descriptor.
|
set_color [Graphics] |
Set the current drawing color.
|
set_ellipsis_text [Format] |
Set the text of the ellipsis printed when too many boxes
are opened (a single dot, . , by default).
|
set_error_when_null_denominator [Arith_status] |
Get or set the flag null_denominator .
|
set_field [Obj] |
|
set_floating_precision [Arith_status] |
Get or set the parameter floating_precision .
|
set_font [Graphics] |
Set the font used for drawing text.
|
set_formatter_out_channel [Format] |
Redirect the pretty-printer output to the given channel.
|
set_formatter_output_functions [Format] |
set_formatter_output_functions out flush redirects the
pretty-printer output to the functions out and flush .
|
set_formatter_tag_functions [Format] |
|
set_line_width [Graphics] |
Set the width of points and lines drawn with the functions above.
|
set_margin [Format] |
set_margin d sets the value of the right margin
to d (in characters): this value is used to detect line
overflows that leads to split lines.
|
set_mark_tags [Format] |
set_print_tags b turns on or off the printing of tags, while
set_mark_tags b turns on or off the output of tag markers.
|
set_max_boxes [Format] |
set_max_boxes max sets the maximum number
of boxes simultaneously opened.
|
set_max_indent [Format] |
set_max_indent d sets the value of the maximum
indentation limit to d (in characters):
once this limit is reached, boxes are rejected to the left,
if they do not fit on the current line.
|
set_method [CamlinternalOO] |
|
set_nonblock [UnixLabels] |
Set the ``non-blocking'' flag on the given descriptor.
|
set_nonblock [Unix] |
Set the ``non-blocking'' flag on the given descriptor.
|
set_normalize_ratio [Arith_status] |
Get or set the flag normalize_ratio .
|
set_normalize_ratio_when_printing [Arith_status] |
Get or set the flag normalize_ratio_when_printing .
|
set_print_tags [Format] |
|
set_signal [Sys] |
|
set_state [Random] |
Resets the state of the generator to some previous state returned by
Random.get_state .
|
set_tab [Format] |
Sets a tabulation mark at the current insertion point.
|
set_tag [Obj] |
|
set_tags [Format] |
set_tags b turns on or off the treatment of tags (default is on).
|
set_text_size [Graphics] |
Set the character size used for drawing text.
|
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.
|
setitimer [UnixLabels] |
setitimer t s sets the interval timer t and returns
its previous status.
|
setitimer [Unix] |
setitimer t s sets the interval timer t and returns
its previous status.
|
setsid [UnixLabels] |
Put the calling process in a new session and detach it from
its controlling terminal.
|
setsid [Unix] |
Put the calling process in a new session and detach it from
its controlling terminal.
|
setsockopt [UnixLabels] |
Set or clear a boolean-valued option in the given socket.
|
setsockopt [Unix] |
Set or clear a boolean-valued option in the given socket.
|
setsockopt_float [UnixLabels] |
|
setsockopt_float [Unix] |
Same as Unix.setsockopt for a socket option whose value is a floating-point number.
|
setsockopt_int [UnixLabels] |
|
setsockopt_int [Unix] |
|
setsockopt_optint [UnixLabels] |
|
setsockopt_optint [Unix] |
|
setuid [UnixLabels] |
Set the real user id and effective user id for the process.
|
setuid [Unix] |
Set the real user id and effective user id for the process.
|
shift_left [Nativeint] |
Nativeint.shift_left x y shifts x to the left by y bits.
|
shift_left [Int64] |
Int64.shift_left x y shifts x to the left by y bits.
|
shift_left [Int32] |
Int32.shift_left x y shifts x to the left by y bits.
|
shift_right [Nativeint] |
Nativeint.shift_right x y shifts x to the right by y bits.
|
shift_right [Int64] |
Int64.shift_right x y shifts x to the right by y bits.
|
shift_right [Int32] |
Int32.shift_right x y shifts x to the right by y bits.
|
shift_right_logical [Nativeint] |
Nativeint.shift_right_logical x y shifts x to the right
by y bits.
|
shift_right_logical [Int64] |
Int64.shift_right_logical x y shifts x to the right by y bits.
|
shift_right_logical [Int32] |
Int32.shift_right_logical x y shifts x to the right by y bits.
|
show_buckets [CamlinternalOO] |
|
shutdown [UnixLabels] |
Shutdown a socket connection.
|
shutdown [Unix] |
Shutdown a socket connection.
|
shutdown_connection [UnixLabels] |
``Shut down'' a connection established with UnixLabels.open_connection ;
that is, transmit an end-of-file condition to the server reading
on the other side of the connection.
|
shutdown_connection [Unix] |
``Shut down'' a connection established with Unix.open_connection ;
that is, transmit an end-of-file condition to the server reading
on the other side of the connection.
|
sigabrt [Sys] |
Abnormal termination
|
sigalrm [Sys] |
Timeout
|
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)
|
sign_big_int [Big_int] |
Return 0 if the given big integer is zero,
1 if it is positive, and -1 if it is negative.
|
sign_num [Num] |
Return -1 , 0 or 1 according to the sign of the argument.
|
signal [Sys] |
Set the behavior of the system on receipt of a given signal.
|
signal [Condition] |
signal c restarts one of the processes waiting on the
condition variable c .
|
sigpending [UnixLabels] |
Return the set of blocked signals that are currently pending.
|
sigpending [Unix] |
Return the set of blocked signals that are currently pending.
|
sigpipe [Sys] |
Broken pipe
|
sigprocmask [UnixLabels] |
sigprocmask cmd sigs changes the set of blocked signals.
|
sigprocmask [Unix] |
sigprocmask cmd sigs changes the set of blocked signals.
|
sigprof [Sys] |
Profiling interrupt
|
sigquit [Sys] |
Interactive termination
|
sigsegv [Sys] |
Invalid memory reference
|
sigstop [Sys] |
Stop
|
sigsuspend [UnixLabels] |
sigsuspend sigs atomically sets the blocked signals to sig
and waits for a non-ignored, non-blocked signal to be delivered.
|
sigsuspend [Unix] |
sigsuspend sigs atomically sets the blocked signals to sig
and waits for a non-ignored, non-blocked signal to be delivered.
|
sigterm [Sys] |
Termination
|
sigtstp [Sys] |
Interactive stop
|
sigttin [Sys] |
Terminal read from background process
|
sigttou [Sys] |
Terminal write from background process
|
sigusr1 [Sys] |
Application-defined signal 1
|
sigusr2 [Sys] |
Application-defined signal 2
|
sigvtalrm [Sys] |
Timeout in virtual time
|
sin [Pervasives] |
|
singleton [Set.S] |
singleton x returns the one-element set containing only x .
|
singleton [MoreLabels.Set.S] |
|
sinh [Pervasives] |
|
size [Obj] |
|
size [Nativeint] |
The size in bits of a native integer.
|
size_x [Graphics] |
|
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] |
|
slice_left [Bigarray.Array2] |
Extract a row (one-dimensional slice) of the given two-dimensional
big array.
|
slice_left [Bigarray.Genarray] |
Extract a sub-array of lower dimension from the given big array
by fixing one or several of the first (left-most) coordinates.
|
slice_left_1 [Bigarray.Array3] |
Extract a one-dimensional slice of the given three-dimensional
big array by fixing the first two coordinates.
|
slice_left_2 [Bigarray.Array3] |
Extract a two-dimensional slice of the given three-dimensional
big array by fixing the first coordinate.
|
slice_right [Bigarray.Array2] |
Extract a column (one-dimensional slice) of the given
two-dimensional big array.
|
slice_right [Bigarray.Genarray] |
Extract a sub-array of lower dimension from the given big array
by fixing one or several of the last (right-most) coordinates.
|
slice_right_1 [Bigarray.Array3] |
Extract a one-dimensional slice of the given three-dimensional
big array by fixing the last two coordinates.
|
slice_right_2 [Bigarray.Array3] |
Extract a two-dimensional slice of the given
three-dimensional big array by fixing the last coordinate.
|
snd [Pervasives] |
Return the second component of a pair.
|
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.
|
sort [StdLabels.List] |
|
sort [StdLabels.Array] |
|
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.
|
sound [Graphics] |
sound freq dur plays a sound at frequency freq (in hertz)
for a duration dur (in milliseconds).
|
split [Str] |
split r s splits s into substrings, taking as delimiters
the substrings that match r , and returns the list of substrings.
|
split [StdLabels.List] |
|
split [ListLabels] |
Transform a list of pairs into a pair of lists:
split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]) .
|
split [List] |
Transform a list of pairs into a pair of lists:
split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]) .
|
split_delim [Str] |
Same as Str.split but occurrences of the
delimiter at the beginning and at the end of the string are
recognized and returned as empty strings in the result.
|
sprintf [Printf] |
Same as Printf.fprintf , but instead of printing on an output channel,
return a string containing the result of formatting
the arguments.
|
sprintf [Format] |
Same as printf above, but instead of printing on a formatter,
returns a string containing the result of formatting the arguments.
|
sqrt [Pervasives] |
Square root
|
sqrt [Complex] |
Square root.
|
sqrt_big_int [Big_int] |
sqrt_big_int a returns the integer square root of a ,
that is, the largest big integer r such that r * r <= a .
|
square_big_int [Big_int] |
Return the square of the given big integer
|
square_num [Num] |
Squaring
|
sscanf [Scanf] |
|
stable_sort [StdLabels.List] |
|
stable_sort [StdLabels.Array] |
|
stable_sort [ListLabels] |
|
stable_sort [List] |
Same as List.sort , but the sorting algorithm is guaranteed to
be stable (i.e.
|
stable_sort [ArrayLabels] |
Same as ArrayLabels.sort , but the sorting algorithm is stable and
not guaranteed to use a fixed amount of heap memory.
|
stable_sort [Array] |
Same as Array.sort , but the sorting algorithm is stable (i.e.
|
stat [UnixLabels.LargeFile] |
|
stat [UnixLabels] |
Return the information for the named file.
|
stat [Unix.LargeFile] |
|
stat [Unix] |
Return the informations for the named file.
|
stat [Gc] |
Return the current values of the memory management counters in a
stat record.
|
stats [Weak.S] |
Return statistics on the table.
|
stats [CamlinternalOO] |
|
std_formatter [Format] |
The standard formatter used by the formatting functions
above.
|
stdbuf [Format] |
The string buffer in which str_formatter writes.
|
stderr [UnixLabels] |
File descriptor for standard standard error.
|
stderr [Unix] |
File descriptor for standard standard error.
|
stderr [Pervasives] |
The standard error ouput for the process.
|
stdin [UnixLabels] |
File descriptor for standard input.
|
stdin [Unix] |
File descriptor for standard input.
|
stdin [Pervasives] |
The standard input for the process.
|
stdout [UnixLabels] |
File descriptor for standard output.
|
stdout [Unix] |
File descriptor for standard output.
|
stdout [Pervasives] |
The standard output for the process.
|
str_formatter [Format] |
A formatter to use with formatting functions below for
output to the stdbuf string buffer.
|
string [Digest] |
Return the digest of the given string.
|
string_after [Str] |
string_after s n returns the substring of all characters of s
that follow position n (including the character at
position n ).
|
string_before [Str] |
string_before s n returns the substring of all characters of s
that precede position n (excluding the character at
position n ).
|
string_match [Str] |
string_match r s start tests whether the characters in s
starting at position start match the regular expression r .
|
string_of_big_int [Big_int] |
Return the string representation of the given big integer,
in decimal (base 10).
|
string_of_bool [Pervasives] |
Return the string representation of a boolean.
|
string_of_float [Pervasives] |
Return the string representation of a floating-point number.
|
string_of_inet_addr [UnixLabels] |
|
string_of_inet_addr [Unix] |
|
string_of_int [Pervasives] |
Return the string representation of an integer, in decimal.
|
string_of_num [Num] |
Convert a number to a string, using fractional notation.
|
string_partial_match [Str] |
Similar to Str.string_match , but succeeds whenever the argument
string is a prefix of a string that matches.
|
string_tag [Obj] |
|
sub [StringLabels] |
String.sub s start len returns a fresh string of length len ,
containing the characters number start to start + len - 1
of string s .
|
sub [String] |
String.sub s start len returns a fresh string of length len ,
containing the characters number start to start + len - 1
of string s .
|
sub [StdLabels.String] |
|
sub [StdLabels.Array] |
|
sub [Nativeint] |
Subtraction.
|
sub [Int64] |
Subtraction.
|
sub [Int32] |
Subtraction.
|
sub [Complex] |
Subtraction
|
sub [Bigarray.Array1] |
Extract a sub-array of the given one-dimensional big array.
|
sub [ArrayLabels] |
Array.sub a start len returns a fresh array of length len ,
containing the elements number start to start + len - 1
of array a .
|
sub [Array] |
Array.sub a start len returns a fresh array of length len ,
containing the elements number start to start + len - 1
of array a .
|
sub_big_int [Big_int] |
Subtraction.
|
sub_left [Bigarray.Array3] |
Extract a three-dimensional sub-array of the given
three-dimensional big array by restricting the first dimension.
|
sub_left [Bigarray.Array2] |
Extract a two-dimensional sub-array of the given two-dimensional
big array by restricting the first dimension.
|
sub_left [Bigarray.Genarray] |
Extract a sub-array of the given big array by restricting the
first (left-most) dimension.
|
sub_num [Num] |
Subtraction
|
sub_right [Bigarray.Array3] |
Extract a three-dimensional sub-array of the given
three-dimensional big array by restricting the second dimension.
|
sub_right [Bigarray.Array2] |
Extract a two-dimensional sub-array of the given two-dimensional
big array by restricting the second dimension.
|
sub_right [Bigarray.Genarray] |
Extract a sub-array of the given big array by restricting the
last (right-most) dimension.
|
subset [Set.S] |
subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
|
subset [MoreLabels.Set.S] |
|
substitute_first [Str] |
Same as Str.global_substitute , except that only the first substring
matching the regular expression is replaced.
|
substring [Digest] |
Digest.substring s ofs len returns the digest of the substring
of s starting at character number ofs and containing len
characters.
|
succ [Pervasives] |
succ x is x+1 .
|
succ [Nativeint] |
Successor.
|
succ [Int64] |
Successor.
|
succ [Int32] |
Successor.
|
succ_big_int [Big_int] |
Successor (add 1).
|
succ_num [Num] |
succ n is n+1
|
symbol_end [Parsing] |
|
symbol_start [Parsing] |
symbol_start and Parsing.symbol_end are to be called in the action part
of a grammar rule only.
|
symlink [UnixLabels] |
symlink source dest creates the file dest as a symbolic link
to the file source .
|
symlink [Unix] |
symlink source dest creates the file dest as a symbolic link
to the file source .
|
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 [Queue] |
take q removes and returns the first element in queue q ,
or raises Empty if the queue is empty.
|
tan [Pervasives] |
|
tanh [Pervasives] |
The usual hyperbolic trigonometric functions.
|
tcdrain [UnixLabels] |
Waits until all output written on the given file descriptor
has been transmitted.
|
tcdrain [Unix] |
Waits until all output written on the given file descriptor
has been transmitted.
|
tcflow [UnixLabels] |
Suspend or restart reception or transmission of data on
the given file descriptor, depending on the second argument:
TCOOFF suspends output, TCOON restarts output,
TCIOFF transmits a STOP character to suspend input,
and TCION transmits a START character to restart input.
|
tcflow [Unix] |
Suspend or restart reception or transmission of data on
the given file descriptor, depending on the second argument:
TCOOFF suspends output, TCOON restarts output,
TCIOFF transmits a STOP character to suspend input,
and TCION transmits a START character to restart input.
|
tcflush [UnixLabels] |
Discard data written on the given file descriptor but not yet
transmitted, or data received but not yet read, depending on the
second argument: TCIFLUSH flushes data received but not read,
TCOFLUSH flushes data written but not transmitted, and
TCIOFLUSH flushes both.
|
tcflush [Unix] |
Discard data written on the given file descriptor but not yet
transmitted, or data received but not yet read, depending on the
second argument: TCIFLUSH flushes data received but not read,
TCOFLUSH flushes data written but not transmitted, and
TCIOFLUSH flushes both.
|
tcgetattr [UnixLabels] |
Return the status of the terminal referred to by the given
file descriptor.
|
tcgetattr [Unix] |
Return the status of the terminal referred to by the given
file descriptor.
|
tcsendbreak [UnixLabels] |
Send a break condition on the given file descriptor.
|
tcsendbreak [Unix] |
Send a break condition on the given file descriptor.
|
tcsetattr [UnixLabels] |
Set the status of the terminal referred to by the given
file descriptor.
|
tcsetattr [Unix] |
Set the status of the terminal referred to by the given
file descriptor.
|
temp_file [Filename] |
temp_file prefix suffix returns the name of a
fresh temporary file in the temporary directory.
|
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 ThreadUnix.read and ThreadUnix.write , except that
Unix_error(ETIMEDOUT,_,_) is raised if no data is
available for reading or ready for writing after d seconds.
|
times [UnixLabels] |
Return the execution times of the process.
|
times [Unix] |
Return the execution times of the process.
|
tl [StdLabels.List] |
|
tl [ListLabels] |
Return the given list without its first element.
|
tl [List] |
Return the given list without its first element.
|
to_buffer [Marshal] |
Marshal.to_buffer buff ofs len v flags marshals the value v ,
storing its byte representation in the string buff ,
starting at character number ofs , and writing at most
len characters.
|
to_channel [Marshal] |
Marshal.to_channel chan v flags writes the representation
of v on channel chan .
|
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 [Nativeint] |
Convert the given native integer (type nativeint ) to an
integer (type int ).
|
to_int [Int64] |
Convert the given 64-bit integer (type int64 ) to an
integer (type int ).
|
to_int [Int32] |
Convert the given 32-bit integer (type int32 ) to an
integer (type int ).
|
to_int32 [Nativeint] |
Convert the given native integer to a
32-bit integer (type int32 ).
|
to_int32 [Int64] |
Convert the given 64-bit integer (type int64 ) to a
32-bit integer (type int32 ).
|
to_list [StdLabels.Array] |
|
to_list [ArrayLabels] |
Array.to_list a returns the list of all the elements of a .
|
to_list [Array] |
Array.to_list a returns the list of all the elements of a .
|
to_nativeint [Int64] |
Convert the given 64-bit integer (type int64 ) to a
native integer.
|
to_string [Printexc] |
Printexc.to_string e returns a string representation of
the exception e .
|
to_string [Nativeint] |
Return the string representation of its argument, in decimal.
|
to_string [Marshal] |
Marshal.to_string v flags returns a string containing
the representation of v as a sequence of bytes.
|
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.
|
top [Stack] |
top s returns the topmost element in stack s ,
or raises Empty if the stack is empty.
|
top [Queue] |
top is a synonym for peek .
|
total_size [Marshal] |
|
transfer [Queue] |
transfer q1 q2 adds all of q1 's elements at the end of
the queue q2 , then clears q1 .
|
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.
|
truncate [UnixLabels.LargeFile] |
|
truncate [UnixLabels] |
Truncates the named file to the given size.
|
truncate [Unix.LargeFile] |
|
truncate [Unix] |
Truncates the named file to the given size.
|
truncate [Pervasives] |
|
truncate [Obj] |
|
try_lock [Mutex] |
Same as Mutex.lock , but does not suspend the calling thread if
the mutex is already locked: just return false immediately
in that case.
|
U |
umask [UnixLabels] |
Set the process creation mask, and return the previous mask.
|
umask [Unix] |
Set the process creation mask, and return the previous mask.
|
uncapitalize [StringLabels] |
Return a copy of the argument, with the first letter set to lowercase.
|
uncapitalize [String] |
Return a copy of the argument, with the first letter set to lowercase.
|
uncapitalize [StdLabels.String] |
|
union [Set.S] |
Set union.
|
union [MoreLabels.Set.S] |
|
unit_big_int [Big_int] |
The big integer 1 .
|
unlink [UnixLabels] |
Removes the named file
|
unlink [Unix] |
Removes the named file
|
unlock [Mutex] |
Unlock the given mutex.
|
unmarshal [Obj] |
|
unsafe_blit [StdLabels.String] |
|
unsafe_fill [StdLabels.String] |
|
unsafe_get [StdLabels.String] |
|
unsafe_get [StdLabels.Array] |
|
unsafe_set [StdLabels.String] |
|
unsafe_set [StdLabels.Array] |
|
update [Tk] |
Synchronize display with internal state.
|
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 [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 [StdLabels.String] |
|
uppercase [Char] |
Convert the given character to its equivalent uppercase character.
|
usage [Arg] |
Arg.usage speclist usage_msg prints an error message including
the list of valid options.
|
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.
|
W |
wait [UnixLabels] |
Wait until one of the children processes die, and return its pid
and termination status.
|
wait [Unix] |
Wait until one of the children processes die, and return its pid
and termination status.
|
wait [ThreadUnix] |
|
wait [Condition] |
wait c m atomically unlocks the mutex m and suspends the
calling process on the condition variable c .
|
wait_next_event [Graphics] |
Wait until one of the events specified in the given event list
occurs, and return the status of the mouse and keyboard at
that time.
|
wait_pid [Thread] |
wait_pid p suspends the execution of the calling thread
until the process specified by the process identifier p
terminates.
|
wait_read [Thread] |
|
wait_signal [Thread] |
wait_signal sigs suspends the execution of the calling thread
until the process receives one of the signals specified in the
list sigs .
|
wait_timed_read [Thread] |
|
wait_timed_write [Thread] |
Suspend the execution of the calling thread until at least
one character is available for reading (wait_read ) or
one character can be written without blocking (wait_write )
on the given Unix file descriptor.
|
wait_write [Thread] |
This function does nothing in this implementation.
|
waitpid [UnixLabels] |
|
waitpid [Unix] |
Same as Unix.wait , but waits for the process whose pid is given.
|
waitpid [ThreadUnix] |
|
white [Graphics] |
|
widen [CamlinternalOO] |
|
window_id [GraphicsX11] |
Return the unique identifier of the Caml graphics window.
|
word_size [Sys] |
Size of one word on the machine currently executing the Caml
program, in bits: 32 or 64.
|
wrap [Event] |
wrap ev fn returns the event that performs the same communications
as ev , then applies the post-processing function fn
on the return value.
|
wrap_abort [Event] |
wrap_abort ev fn returns the event that performs
the same communications as ev , but if it is not selected
the function fn is called after the synchronization.
|
write [UnixLabels] |
write fd buff ofs len writes len characters to descriptor
fd , taking them from string buff , starting at position ofs
in string buff .
|
write [Unix] |
write fd buff ofs len writes len characters to descriptor
fd , taking them from string buff , starting at position ofs
in string buff .
|
write [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 0 .
|
zero_big_int [Big_int] |
The big integer 0 .
|