| ! [Pervasives] | !r returns the current contents of reference r.
|
| != [Pervasives] |
Negation of
Pervasives.==.
|
| & [Pervasives] |
Deprecated !
|
| && [Pervasives] |
The boolean ``and''.
|
| * [Pervasives.*] |
Floating-point multiplication
|
| * [Pervasives] |
Integer multiplication.
|
| ** [Pervasives] |
Exponentiation
|
| **/ [Num] |
Same as
Num.power_num.
|
| */ [Num] |
Same as
Num.mult_num.
|
| + [Pervasives.+] |
Floating-point addition
|
| + [Pervasives] |
Integer addition.
|
| +/ [Num] |
Same as
Num.add_num.
|
| - [Pervasives.-] |
Floating-point subtraction
|
| - [Pervasives] |
Integer subtraction.
|
| -/ [Num] |
Same as
Num.sub_num.
|
| / [Pervasives./] |
Floating-point division.
|
| / [Pervasives] |
Integer division.
|
| // [Num] |
Same as
Num.div_num.
|
| := [Pervasives] | r := a stores the value of a in reference r.
|
| < [Pervasives] |
See
Pervasives.>=.
|
| [Num] | |
| <= [Pervasives] |
See
Pervasives.>=.
|
| <=/ [Num] | |
| <> [Pervasives] |
Negation of
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] |
See
Pervasives.>=.
|
| >/ [Num] | |
| >= [Pervasives] |
Structural ordering functions.
|
| >=/ [Num] | |
| @ [Pervasives] |
List concatenation.
|
| ^ [Pervasives] |
String concatenation.
|
| || [Pervasives] |
See
Pervasives.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] |
See
Pervasives.atan2.
|
| 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_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_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] |
See
Num.approx_num_exp.
|
| 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] |
See
Pervasives.atan2.
|
| 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] |
See
Pervasives.atan2.
|
| 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] |
See
Graphics.foreground.
|
| 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_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] | |
| 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.
|
| 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] |
See
Pervasives.floor.
|
| ceiling_num [Num] | ceiling_num n returns the smallest integer bigger or equal to n.
|
| channel [Digest] | Digest.channel ic len reads len characters from channel ic
and returns their digest.
|
| 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 nth 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 [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] |
Close 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 channels opened by
UnixLabels.open_process_full,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_full [Unix] |
Close channels opened by
Unix.open_process_full,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_in [UnixLabels] |
Close channels opened by
UnixLabels.open_process_in,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_in [Unix] |
Close channels opened by
Unix.open_process_in,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_out [UnixLabels] |
Close channels opened by
UnixLabels.open_process_out,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_out [Unix] |
Close channels opened by
Unix.open_process_out,
wait for the associated command to terminate,
and return its termination status.
|
| close_subwindow [GraphicsX11] |
Close the sub-window having the given identifier.
|
| close_tbox [Format] |
Close 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 [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 [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_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.
|
| 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.
|
| 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 [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 [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] |
See
Pervasives.atan2.
|
| cosh [Pervasives] |
See
Pervasives.tanh.
|
| count [Stream] |
Return the current count of the stream elements, i.
|
| counters [Gc] |
Return
(minor_words, promoted_words, major_words).
|
| 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] |
Deprecated !
|
| create [Array] |
Deprecated !
|
| create_alarm [Gc] | create_alarm f will arrange for f to be called at the end of each
major GC cycle.
|
| 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] |
Deprecated !
|
| create_matrix [Array] |
Deprecated !
|
| 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.
|
| current [Arg] |
Position (in
Sys.argv) of the argument being processed.
|
| current_dir_name [Filename] |
The conventional name for the current directory (e.
|
| 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.
|
| cyan [Graphics] | |
D | |
| data_size [Marshal] |
See
Marshal.header_size.
|
| 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.
|
| dirname [Filename] |
See
Filename.dirname.
|
| display_mode [Graphics] |
Set display mode on or off.
|
| div [Nativeint] |
Integer division.
|
| div [Int64] |
Integer division.
|
| div [Int32] |
Integer 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] |
See
Graphics.draw_string.
|
| 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] |
Same as
Printf.fprintf, but output on stderr.
|
| 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.
|
| 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] |
Same as
ListLabels.exists, but for a two-argument predicate.
|
| exists2 [List] |
Same as
List.exists, but for a two-argument predicate.
|
| exit [Thread] |
Terminate prematurely the currently executing thread.
|
| exit [Pervasives] |
Flush all pending writes on
Pervasives.stdout and
Pervasives.stderr,
and 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.
|
F | |
| failwith [Pervasives] |
Raise exception
Failure with the given string.
|
| 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] | Gc.finalise f v registers f as a finalisation function for v.
|
| 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 [StdLabels.List] | |
| find_all [MoreLabels.Hashtbl.S] | |
| find_all [MoreLabels.Hashtbl] | |
| find_all [ListLabels] | find_all is another name for ListLabels.filter.
|
| find_all [List] | find_all is another name for List.filter.
|
| find_all [Hashtbl.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] |
See
Dbm.nextkey.
|
| flatten [StdLabels.List] | |
| flatten [ListLabels] |
Flatten a list of lists.
|
| flatten [List] |
Flatten a list of lists.
|
| float [Random] | Random.float bound returns a random floating-point number
between 0 (inclusive) and bound (exclusive).
|
| float [Pervasives] |
Same as
Pervasives.float_of_int.
|
| float32 [Bigarray] |
See
Bigarray.char.
|
| float64 [Bigarray] |
See
Bigarray.char.
|
| 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 reset the corresponding buffer.
|
| fold [Set.S] | fold f s a computes (f xN ... (f x2 (f x1 a))...),
where x1 ... xN are the elements of s.
|
| 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] |
Same as
ListLabels.for_all, but for a two-argument predicate.
|
| for_all2 [List] |
Same as
List.for_all, but for a two-argument predicate.
|
| force [Lazy] | Lazy.force x computes the suspension x and returns its result.
|
| force_newline [Format] |
Force a newline in the current box.
|
| 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] | |
| 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 [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 [Lexing] |
Create a lexer buffer with the given function as its reading method.
|
| 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.
|
| fst [Pervasives] |
Return the first component of a pair.
|
| fstat [UnixLabels] |
Return the information for the file associated with the given
descriptor.
|
| fstat [Unix] |
Return the informations for the file associated with the given
descriptor.
|
| ftruncate [UnixLabels] |
Truncates the file corresponding to the given descriptor
to the given size.
|
| ftruncate [Unix] |
Truncates the file corresponding to the given descriptor
to the given size.
|
| full_init [Random] |
Same as
Random.init but takes more data as seed.
|
| full_major [Gc] |
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 nth 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
Gc.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 nth 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_image [Graphics] |
Capture the contents of a rectangle on the screen as an image.
|
| get_margin [Format] |
Return the position of the right margin.
|
| get_max_boxes [Format] |
Return the maximum number of boxes allowed before ellipsis.
|
| get_max_indent [Format] |
Return the value of the maximum indentation limit (in characters).
|
| get_normalize_ratio [Arith_status] | |
| get_normalize_ratio_when_printing [Arith_status] | |
| get_state [Random] |
Returns the current state of the generator.
|
| 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] |
Same as
UnixLabels.getsockopt for a socket option whose value is a floating-point number.
|
| getsockopt_float [Unix] |
Same as
Unix.getsockopt for a socket option whose value is a floating-point number.
|
| getsockopt_int [UnixLabels] |
Same as
UnixLabels.getsockopt for an integer-valued socket option.
|
| getsockopt_int [Unix] |
Same as
Unix.getsockopt for an integer-valued socket option.
|
| getsockopt_optint [UnixLabels] |
Same as
UnixLabels.getsockopt for a socket option whose value is an int option.
|
| getsockopt_optint [Unix] |
Same as
Unix.getsockopt for a socket option whose value is an int option.
|
| gettimeofday [UnixLabels] |
Same as
UnixLabels.time, but with resolution better than 1 second.
|
| gettimeofday [Unix] |
Same as
Unix.time, but with resolution better than 1 second.
|
| getuid [UnixLabels] |
Return the user id of the user executing the process.
|
| getuid [Unix] |
Return the user id of the user executing the process.
|
| global_replace [Str] | global_replace regexp templ s returns a string identical to s,
except that all substrings of s that match regexp have been
replaced by templ.
|
| global_substitute [Str] | global_substitute regexp subst s returns a string identical
to s, except that all substrings of s that match regexp
have been replaced by the result of function subst.
|
| gmtime [UnixLabels] |
Convert a time in seconds, as returned by
UnixLabels.time, into a date and
a time.
|
| gmtime [Unix] |
Convert a time in seconds, as returned by
Unix.time, into a date and
a time.
|
| 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 nth 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 nth 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, returning a non-negative
integer.
|
| 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 | |
| id [Thread] |
Return the identifier of the given thread.
|
| ignore [Pervasives] |
Discard the value of its argument and return
().
|
| 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.
|
| input [Pervasives] |
Read up to
len characters from the given channel,
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] |
Same as
Pervasives.input_char, but return the 8-bit integer representing
the character.
|
| 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] |
See
Bigarray.char.
|
| int16_signed [Bigarray] |
See
Bigarray.char.
|
| int16_unsigned [Bigarray] |
See
Bigarray.char.
|
| int32 [Bigarray] |
See
Bigarray.char.
|
| int64 [Bigarray] |
See
Bigarray.char.
|
| int8_signed [Bigarray] |
See
Bigarray.char.
|
| int8_unsigned [Bigarray] |
See
Bigarray.char.
|
| 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 interseection.
|
| 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.
|
| invalid_arg [Pervasives] |
Raise exception
Invalid_argument with the given string.
|
| is_block [Obj] | |
| is_empty [Set.S] |
Test whether a set is empty or not.
|
| 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.
|
| 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.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.
|
L | |
| land [Pervasives] |
Bitwise logical and.
|
| last_chars [Str] | last_chars s n returns the last n characters of s.
|
| 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.
|
| 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] |
Set the current position for a file descriptor
|
| 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] |
Same as
UnixLabels.stat, but in case the file is a symbolic link,
return the information for the link itself.
|
| 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] |
Finish the current major collection cycle.
|
| 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_beginning() returns the position of the first character
of the substring that was matched by Str.string_match,
Str.search_forward or Str.search_backward.
|
| 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_group n s returns the substring of s that was matched
by the nth group \(...\) of the regular expression during
the latest Str.string_match, Str.search_forward or
Str.search_backward.
|
| matched_string [Str] | matched_string s returns the substring of s that was matched
by the latest Str.string_match, Str.search_forward or
Str.search_backward.
|
| 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 [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 [Sort] |
Merge two lists according to the given predicate.
|
| 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.
|
| 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.
|
| nat_of_num [Num] | |
| nativeint [Bigarray] |
See
Bigarray.char.
|
| neg [Nativeint] |
Unary negation.
|
| neg [Int64] |
Unary negation.
|
| neg [Int32] |
Unary negation.
|
| neg_infinity [Pervasives] |
Negative infinity.
|
| new_block [Obj] | |
| new_channel [Event] |
Return a new channel.
|
| 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] | |
| 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] | |
| 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.
|
| 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] |
See
Unix.open_process_in.
|
| open_process [ThreadUnix] | |
| open_process_full [UnixLabels] |
Similar to
UnixLabels.open_process, but the second argument specifies
the environment passed to the command.
|
| open_process_full [Unix] |
Similar to
Unix.open_process, but the second argument specifies
the environment passed to the command.
|
| open_process_in [UnixLabels] |
High-level pipe and process management.
|
| open_process_in [Unix] |
High-level pipe and process management.
|
| open_process_in [ThreadUnix] | |
| open_process_out [UnixLabels] | |
| open_process_out [Unix] |
See
Unix.open_process_in.
|
| open_process_out [ThreadUnix] | |
| open_subwindow [GraphicsX11] |
Create a sub-window of the current Caml graphics window
and return its identifier.
|
| open_tbox [Format] |
Open a tabulation box.
|
| 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] |
The boolean ``or''.
|
| os_type [Sys] |
Operating system currently executing the Caml program.
|
| 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] |
Write
len characters from string buf, starting at offset
pos, to the given output channel.
|
| 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] |
Test 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.
|
| parent_dir_name [Filename] |
The conventional name for the parent of the current directory
(e.
|
| parse [Arg] | Arg.parse speclist anonfun usage_msg parses 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).
|
| 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.
|
| pos_in [Pervasives] |
Return the current reading position for the given channel.
|
| pos_out [Pervasives] |
Return the current writing position for the given channel.
|
| 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_tbox [Format] | |
| pp_force_newline [Format] | |
| pp_get_all_formatter_output_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_ellipsis_text [Format] | |
| pp_get_formatter_output_functions [Format] | |
| pp_get_margin [Format] | |
| pp_get_max_boxes [Format] | |
| pp_get_max_indent [Format] | |
| pp_open_box [Format] | |
| pp_open_hbox [Format] | |
| pp_open_hovbox [Format] | |
| pp_open_hvbox [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_margin [Format] | |
| pp_set_max_boxes [Format] | |
| pp_set_max_indent [Format] | |
| pp_set_tab [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] |
Print a boolean in the current box.
|
| print_break [Format] |
Insert a break hint in a pretty-printing box.
|
| print_char [Pervasives] |
Print a character on standard output.
|
| print_char [Format] |
Print 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] |
Print a floating point number in the current box.
|
| print_flush [Format] |
Flush the pretty printer: all opened boxes are closed,
and all pending text is displayed.
|
| print_if_newline [Format] |
Execute 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] |
Print 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] |
Same as
Printf.fprintf, but output on stdout.
|
| printf [Format] |
Same as
fprintf above, but output on std_formatter.
|
| push [Stack] | push x s adds the element x at the top of stack s.
|
| 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 any 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] |
Read
len characters from the given channel, 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 an unconnected 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 [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] |
Same as
ListLabels.remove_assq, but uses physical equality instead
of structural equality to compare keys.
|
| remove_assq [List] |
Same as
List.remove_assoc, but uses physical equality instead
of structural equality to compare keys.
|
| 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] | List.rev_map f l gives the same result as
ListLabels.rev (ListLabels.map f l), but is tail-recursive and
more efficient.
|
| rev_map [List] | |
| rev_map2 [StdLabels.List] | |
| rev_map2 [ListLabels] | List.rev_map2 f l gives the same result as
ListLabels.rev (ListLabels.map2 f l), but is tail-recursive and
more efficient.
|
| rev_map2 [List] | |
| rewinddir [UnixLabels] |
Reposition the descriptor to the beginning of the directory
|
| rewinddir [Unix] |
Reposition the descriptor to the beginning of the directory
|
| rgb [Graphics] | rgb r g b returns the integer encoding the color with red
component r, green component g, and blue component b.
|
| rhs_end [Parsing] |
See
Parsing.rhs_start.
|
| rhs_start [Parsing] |
Same as
Parsing.symbol_start and Parsing.symbol_end, but return the
position of the string matching the nth 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.
|
S | |
| search_backward [Str] |
Same as
Str.search_forward, but the search proceeds towards the
beginning of the string.
|
| search_forward [Str] | search_forward r s start searchs the string s for a substring
matching the regular expression r.
|
| seek_in [Pervasives] | seek_in chan pos sets the current reading position to pos
for channel chan.
|
| 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 an unconnected socket.
|
| send [ThreadUnix] | |
| send [Event] | send ch v returns the event consisting in sending the value v
over the channel ch.
|
| 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 nth cell of ar to be a
(full) pointer to el; Weak.set ar n None sets the nth
cell of ar to empty.
|
| set [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 [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_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_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_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_signal [Sys] |
Same as
Sys.signal but return value is ignored.
|
| set_state [Random] |
Resets the state of the generator to some previous state returned by
Random.get_state.
|
| set_tab [Format] |
Set a tabulation mark at the current insertion point.
|
| 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] |
Same as
UnixLabels.setsockopt for a socket option whose value is a floating-point number.
|
| setsockopt_float [Unix] |
Same as
Unix.setsockopt for a socket option whose value is a floating-point number.
|
| setsockopt_int [UnixLabels] |
Same as
UnixLabels.setsockopt for an integer-valued socket option.
|
| setsockopt_int [Unix] |
Same as
Unix.setsockopt for an integer-valued socket option.
|
| setsockopt_optint [UnixLabels] |
Same as
UnixLabels.setsockopt for a socket option whose value is an int option.
|
| setsockopt_optint [Unix] |
Same as
Unix.setsockopt for a socket option whose value is an int option.
|
| setuid [UnixLabels] |
Set the real user id and effective user id for the process.
|
| setuid [Unix] |
Set the real user id and effective user id for the process.
|
| shift_left [Nativeint] | Nativeint.shift_left x y shifts x to the left by y bits.
|
| shift_left [Int64] | Int64.shift_left x y shifts x to the left by y bits.
|
| shift_left [Int32] | Int32.shift_left x y shifts x to the left by y bits.
|
| shift_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.
|
| 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] |
See
Pervasives.atan2.
|
| singleton [Set.S] | singleton x returns the one-element set containing only x.
|
| singleton [MoreLabels.Set.S] | |
| sinh [Pervasives] |
See
Pervasives.tanh.
|
| size [Obj] | |
| size [Nativeint] |
The size in bits of a native integer.
|
| size_x [Graphics] |
See
Graphics.size_y.
|
| 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,
return a string containing the result of formatting the arguments.
|
| sqrt [Pervasives] |
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
|
| stable_sort [StdLabels.List] | |
| stable_sort [StdLabels.Array] | |
| stable_sort [ListLabels] |
Same as
ListLabels.sort, but the sorting algorithm is stable.
|
| stable_sort [List] |
Same as
List.sort, but the sorting algorithm is stable.
|
| 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 and
not guaranteed to use a fixed amount of heap memory.
|
| stat [UnixLabels] |
Return the information for the named file.
|
| stat [Unix] |
Return the informations for the named file.
|
| stat [Gc] |
Return the current values of the memory management counters in a
stat record.
|
| 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 [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] |
See
Parsing.symbol_start.
|
| 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] |
See
Pervasives.atan2.
|
| 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
read and 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_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.
|
| total_size [Marshal] |
See
Marshal.header_size.
|
| 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] |
Truncates the named file to the given size.
|
| truncate [Unix] |
Truncates the named file to the given size.
|
| truncate [Pervasives] |
Same as
Pervasives.int_of_float.
|
| 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] |
See
Thread.wait_write.
|
| 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] |
Same as
UnixLabels.wait, but waits for the process whose pid is given.
|
| waitpid [Unix] |
Same as
Unix.wait, but waits for the process whose pid is given.
|
| waitpid [ThreadUnix] | |
| white [Graphics] | |
| 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_big_int [Big_int] |
The big integer
0.
|