| (!) [Pervasives] | !r returns the current contents of reference r.
|
| (!=) [Pervasives] |
Negation of
(==).
|
| (&&) [Pervasives] |
The boolean ``and''.
|
| (&) [Pervasives] | |
| (*) [Pervasives] |
Integer multiplication.
|
| (**) [Pervasives] |
Exponentiation
|
| (**/) [Num] |
Same as
Num.power_num.
|
| (*.) [Pervasives] |
Floating-point multiplication
|
| (*/) [Num] |
Same as
Num.mult_num.
|
| (+) [Pervasives] |
Integer addition.
|
| (+.) [Pervasives] |
Floating-point addition
|
| (+/) [Num] |
Same as
Num.add_num.
|
| (-) [Pervasives] |
Integer subtraction.
|
| (-.) [Pervasives] |
Floating-point subtraction
|
| (-/) [Num] |
Same as
Num.sub_num.
|
| (/) [Pervasives] |
Integer division.
|
| (/.) [Pervasives] |
Floating-point division.
|
| (//) [Num] |
Same as
Num.div_num.
|
| (:=) [Pervasives] | r := a stores the value of a in reference r.
|
| (<) [Pervasives] |
See
(>=).
|
| () [Num] | |
| (<=) [Pervasives] |
See
(>=).
|
| (<=/) [Num] | |
| (<>) [Pervasives] |
Negation of
(=).
|
| (<>/) [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
(>=).
|
| (>/) [Num] | |
| (>=) [Pervasives] |
Structural ordering functions.
|
| (>=/) [Num] | |
| (@) [Pervasives] |
List concatenation.
|
| (^) [Pervasives] |
String concatenation.
|
| (^^) [Pervasives] | f1 ^^ f2 catenates formats f1 and f2.
|
| (||) [Pervasives] |
The boolean ``or''.
|
| (~-) [Pervasives] |
Unary negation.
|
| (~-.) [Pervasives] |
Unary negation.
|
A | |
| abs [Pervasives] |
Return the absolute value of the argument.
|
| abs [Nativeint] |
Return the absolute value of its argument.
|
| abs [Int64] |
Return the absolute value of its argument.
|
| abs [Int32] |
Return the absolute value of its argument.
|
| abs_big_int [Big_int] |
Absolute value.
|
| abs_float [Pervasives] |
Return the absolute value of the argument.
|
| abs_num [Num] |
Absolute value.
|
| abstract_tag [Obj] | |
| accept [UnixLabels] |
Accept connections on the given socket.
|
| accept [Unix] |
Accept connections on the given socket.
|
| accept [ThreadUnix] | |
| access [UnixLabels] |
Check that the process has the given permissions over the named
file.
|
| access [Unix] |
Check that the process has the given permissions over the named
file.
|
| acos [Pervasives] |
See
atan2.
|
| add [Weak.S] | add t x adds x to t.
|
| add [Set.S] | add x s returns a set containing all elements of s,
plus x.
|
| add [Queue] | add x q adds the element x at the end of the queue q.
|
| add [Nativeint] |
Addition.
|
| add [MoreLabels.Set.S] | |
| add [MoreLabels.Map.S] | |
| add [MoreLabels.Hashtbl.S] | |
| add [MoreLabels.Hashtbl] | |
| add [Map.S] | add x y m returns a map containing the same bindings as
m, plus a binding of x to y.
|
| add [Int64] |
Addition.
|
| add [Int32] |
Addition.
|
| add [Hashtbl.S] | |
| add [Hashtbl] | Hashtbl.add tbl x y adds a binding of x to y in table tbl.
|
| add [Dbm] | add db key data inserts the pair (key, data) in
the database db.
|
| add [Complex] |
Addition
|
| add_available_units [Dynlink] |
Same as
Dynlink.add_interfaces, but instead of searching .cmi files
to find the unit interfaces, uses the interface digests given
for each unit.
|
| add_big_int [Big_int] |
Addition.
|
| add_buffer [Buffer] | add_buffer b1 b2 appends the current contents of buffer b2
at the end of buffer b1.
|
| add_channel [Buffer] | add_channel b ic n reads exactly n character from the
input channel ic and stores them at the end of buffer b.
|
| add_char [Buffer] | add_char b c appends the character c at the end of the buffer b.
|
| add_initializer [CamlinternalOO] | |
| add_int_big_int [Big_int] |
Addition of a small integer to a big integer.
|
| add_interfaces [Dynlink] | add_interfaces units path grants dynamically-linked object
files access to the compilation units named in list units.
|
| add_num [Num] |
Addition
|
| add_string [Buffer] | add_string b s appends the string s at the end of the buffer b.
|
| add_substitute [Buffer] | add_substitute b f s appends the string pattern s at the end
of the buffer b with substitution.
|
| add_substring [Buffer] | add_substring b s ofs len takes len characters from offset
ofs in string s and appends them at the end of 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.
|
| align [Arg] |
Align the documentation strings by inserting spaces at the first
space, according to the length of the keyword.
|
| allocated_bytes [Gc] |
Return the total number of bytes allocated since the program was
started.
|
| allow_only [Dynlink] | allow_only units restricts the compilation units that dynamically-linked
units can reference: it only allows references to the units named in
list units.
|
| allow_unsafe_modules [Dynlink] |
Govern whether unsafe object files are allowed to be
dynamically linked.
|
| always [Event] | always v returns an event that is always ready for
synchronization.
|
| app_const [CamlinternalOO] | |
| app_const_const [CamlinternalOO] | |
| app_const_env [CamlinternalOO] | |
| app_const_meth [CamlinternalOO] | |
| app_const_var [CamlinternalOO] | |
| app_env [CamlinternalOO] | |
| app_env_const [CamlinternalOO] | |
| app_meth [CamlinternalOO] | |
| app_meth_const [CamlinternalOO] | |
| app_var [CamlinternalOO] | |
| app_var_const [CamlinternalOO] | |
| 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.
|
| arg [Complex] |
Argument.
|
| argv [Sys] |
The command line arguments given to the process.
|
| arith_status [Arith_status] |
Print the current status of the arithmetic flags.
|
| array [Sort] |
Sort an array in increasing order according to an
ordering predicate.
|
| array1_of_genarray [Bigarray] |
Return the one-dimensional big array corresponding to the given
generic big array.
|
| array2_of_genarray [Bigarray] |
Return the two-dimensional big array corresponding to the given
generic big array.
|
| array3_of_genarray [Bigarray] |
Return the three-dimensional big array corresponding to the given
generic big array.
|
| asin [Pervasives] |
See
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
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.
|
| beginning_of_input [Scanf.Scanning] | Scanning.beginning_of_input scanbuf tests the beginning of input
condition of the given buffer.
|
| 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.State] | |
| bits [Random] |
Return 30 random bits in a nonnegative integer.
|
| bits_of_float [Int64] |
Return the internal representation of the given float according
to the IEEE 754 floating-point ``double format'' bit layout.
|
| bits_of_float [Int32] |
Return the internal representation of the given float according
to the IEEE 754 floating-point ``single format'' bit layout.
|
| black [Graphics] | |
| blit [Weak] | Weak.blit ar1 off1 ar2 off2 len copies len weak pointers
from ar1 (starting at off1) to ar2 (starting at off2).
|
| blit [StringLabels] | String.blit src srcoff dst dstoff len copies len characters
from string src, starting at character number srcoff, to
string dst, starting at character number dstoff.
|
| blit [String] | String.blit src srcoff dst dstoff len copies len characters
from string src, starting at character number srcoff, to
string dst, starting at character number dstoff.
|
| blit [StdLabels.String] | |
| blit [StdLabels.Array] | |
| blit [Bigarray.Array3] |
Copy the first big array to the second big array.
|
| blit [Bigarray.Array2] |
Copy the first big array to the second big array.
|
| blit [Bigarray.Array1] |
Copy the first big array to the second big array.
|
| blit [Bigarray.Genarray] |
Copy all elements of a big array in another big array.
|
| blit [ArrayLabels] | Array.blit v1 o1 v2 o2 len copies len elements
from array v1, starting at element number o1, to array v2,
starting at element number o2.
|
| blit [Array] | Array.blit v1 o1 v2 o2 len copies len elements
from array v1, starting at element number o1, to array v2,
starting at element number o2.
|
| blit_image [Graphics] | blit_image img x y copies screen pixels into the image img,
modifying img in-place.
|
| blue [Graphics] | |
| bool [Random.State] |
These functions are the same as the basic functions, except that they
use (and update) the given PRNG state instead of the default one.
|
| bool [Random] | Random.bool () returns true or false with probability 0.5 each.
|
| bool_of_string [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.
|
| bscanf [Scanf] | bscanf ib format f reads tokens from the scanning buffer ib according
to the format string format, converts these tokens to values, and
applies the function f to these values.
|
| button_down [Graphics] |
Return
true if the mouse button is pressed, false otherwise.
|
C | |
| c_layout [Bigarray] | |
| capitalize [StringLabels] |
Return a copy of the argument, with the first letter set to uppercase.
|
| capitalize [String] |
Return a copy of the argument, with the first character 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
floor.
|
| ceiling_num [Num] | ceiling_num n returns the smallest integer bigger or equal to n.
|
| channel [Digest] |
If
len is nonnegative, Digest.channel ic len reads len
characters from channel ic and returns their digest, or raises
End_of_file if end-of-file is reached before len characters
are read.
|
| char [Bigarray] |
As shown by the types of the values above,
big arrays of kind
float32_elt and float64_elt are
accessed using the Caml type float.
|
| char_of_int [Pervasives] |
Return the character with the given ASCII code.
|
| chdir [UnixLabels] |
Change the process working directory.
|
| chdir [Unix] |
Change the process working directory.
|
| chdir [Sys] |
Change the current working directory of the process.
|
| check [Weak] | Weak.check ar n returns true if the 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 [Weak.S] |
Remove all elements from the table.
|
| clear [Stack] |
Discard all elements from a stack.
|
| clear [Queue] |
Discard all elements from a queue.
|
| clear [MoreLabels.Hashtbl.S] | |
| clear [MoreLabels.Hashtbl] | |
| clear [Hashtbl.S] | |
| clear [Hashtbl] |
Empty a hash table.
|
| clear [Buffer] |
Empty the buffer.
|
| clear_available_units [Dynlink] |
Empty the list of compilation units accessible to dynamically-linked
programs.
|
| clear_close_on_exec [UnixLabels] |
Clear the ``close-on-exec'' flag on the given descriptor.
|
| clear_close_on_exec [Unix] |
Clear the ``close-on-exec'' flag on the given descriptor.
|
| clear_graph [Graphics] |
Erase the graphics window.
|
| clear_nonblock [UnixLabels] |
Clear the ``non-blocking'' flag on the given descriptor.
|
| clear_nonblock [Unix] |
Clear the ``non-blocking'' flag on the given descriptor.
|
| clear_parser [Parsing] |
Empty the parser stack.
|
| close [UnixLabels] |
Close a file descriptor.
|
| close [Unix] |
Close a file descriptor.
|
| close [Dbm] |
Close the given descriptor.
|
| closeTk [Tk] |
Quit the main loop and close all open windows.
|
| close_box [Format] |
Closes the most recently opened pretty-printing box.
|
| close_graph [Graphics] |
Delete the graphics window or switch the screen back to text mode.
|
| close_in [Pervasives] |
Close the given channel.
|
| close_in_noerr [Pervasives] |
Same as
close_in, but ignore all errors.
|
| close_out [Pervasives] |
Close the given channel, flushing all buffered write operations.
|
| close_out_noerr [Pervasives] |
Same as
close_out, but ignore all errors.
|
| close_process [UnixLabels] |
Close channels opened by
UnixLabels.open_process,
wait for the associated command to terminate,
and return its termination status.
|
| close_process [Unix] |
Close channels opened by
Unix.open_process,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_full [UnixLabels] |
Close channels opened by
UnixLabels.open_process_full,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_full [Unix] |
Close channels opened by
Unix.open_process_full,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_in [UnixLabels] |
Close channels opened by
UnixLabels.open_process_in,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_in [Unix] |
Close channels opened by
Unix.open_process_in,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_out [UnixLabels] |
Close channels opened by
UnixLabels.open_process_out,
wait for the associated command to terminate,
and return its termination status.
|
| close_process_out [Unix] |
Close channels opened by
Unix.open_process_out,
wait for the associated command to terminate,
and return its termination status.
|
| close_subwindow [GraphicsX11] |
Close the sub-window having the given identifier.
|
| close_tag [Format] | close_tag () closes the most recently opened tag t.
|
| close_tbox [Format] |
Closes the most recently opened tabulation box.
|
| closedir [UnixLabels] |
Close a directory descriptor.
|
| closedir [Unix] |
Close a directory descriptor.
|
| closure_tag [Obj] | |
| code [Char] |
Return the ASCII code of the argument.
|
| combine [StdLabels.List] | |
| combine [ListLabels] |
Transform a pair of lists into a list of pairs:
combine [a1; ...; an] [b1; ...; bn] is
[(a1,b1); ...; (an,bn)].
|
| combine [List] |
Transform a pair of lists into a list of pairs:
combine [a1; ...; an] [b1; ...; bn] is
[(a1,b1); ...; (an,bn)].
|
| command [Sys] |
Execute the given shell command and return its exit code.
|
| compact [Gc] |
Perform a full major collection and compact the heap.
|
| compare [StringLabels] |
The comparison function for strings, with the same specification as
compare.
|
| compare [String] |
The comparison function for strings, with the same specification as
compare.
|
| compare [StdLabels.String] | |
| compare [Set.S] |
Total ordering between sets.
|
| compare [Pervasives] | compare x y returns 0 if x is equal to y,
a negative integer if x is less than y, and a positive integer
if x is greater than y.
|
| compare [Nativeint] |
The comparison function for native integers, with the same specification as
compare.
|
| compare [Set.OrderedType] |
A total ordering function over the set elements.
|
| compare [MoreLabels.Set.S] | |
| compare [MoreLabels.Map.S] | |
| compare [Map.OrderedType] |
A total ordering function over the keys.
|
| compare [Map.S] |
Total ordering between maps.
|
| compare [Int64] |
The comparison function for 64-bit integers, with the same specification as
compare.
|
| compare [Int32] |
The comparison function for 32-bit integers, with the same specification as
compare.
|
| compare [Char] |
The comparison function for characters, with the same specification as
compare.
|
| compare_big_int [Big_int] | compare_big_int a b returns 0 if a and b are equal,
1 if a is greater than b, and -1 if a is smaller
than b.
|
| compare_num [Num] |
Return
-1, 0 or 1 if the first argument is less than,
equal to, or greater than the second argument.
|
| complex32 [Bigarray] |
See
Bigarray.char.
|
| complex64 [Bigarray] |
See
Bigarray.char.
|
| concat [StringLabels] | String.concat sep sl concatenates the list of strings sl,
inserting the separator string sep between each.
|
| concat [String] | String.concat sep sl concatenates the list of strings sl,
inserting the separator string sep between each.
|
| concat [StdLabels.String] | |
| concat [StdLabels.List] | |
| concat [StdLabels.Array] | |
| concat [ListLabels] |
Concatenate a list of lists.
|
| concat [List] |
Concatenate a list of lists.
|
| concat [Filename] | concat dir file returns a file name that designates file
file in directory dir.
|
| concat [ArrayLabels] |
Same as
Array.append, but concatenates a list of arrays.
|
| concat [Array] |
Same as
Array.append, but concatenates a list of arrays.
|
| conj [Complex] |
Conjugate: given the complex
x + i.y, returns x - i.y.
|
| connect [UnixLabels] |
Connect a socket to an address.
|
| connect [Unix] |
Connect a socket to an address.
|
| connect [ThreadUnix] | |
| contains [StringLabels] | String.contains s c tests if character c
appears in the string s.
|
| contains [String] | String.contains s c tests if character c
appears in the string s.
|
| contains [StdLabels.String] | |
| contains_from [StringLabels] | String.contains_from s start c tests if character c
appears in the substring of s starting from start to the end
of s.
|
| contains_from [String] | String.contains_from s start c tests if character c
appears in the substring of s starting from start to the end
of s.
|
| contains_from [StdLabels.String] | |
| contents [Buffer] |
Return a copy of the current contents of the buffer.
|
| copy [StringLabels] |
Return a copy of the given string.
|
| copy [String] |
Return a copy of the given string.
|
| copy [StdLabels.String] | |
| copy [StdLabels.Array] | |
| copy [Stack] |
Return a copy of the given stack.
|
| copy [Random.State] |
Return a copy of the given state.
|
| copy [Queue] |
Return a copy of the given queue.
|
| copy [Oo] | Oo.copy o returns a copy of object o, that is a fresh
object with the same methods and instance variables as o
|
| copy [MoreLabels.Hashtbl.S] | |
| copy [MoreLabels.Hashtbl] | |
| copy [Hashtbl.S] | |
| copy [Hashtbl] |
Return a copy of the given hashtable.
|
| copy [CamlinternalOO] | |
| copy [ArrayLabels] | Array.copy a returns a copy of a, that is, a fresh array
containing the same elements as a.
|
| copy [Array] | Array.copy a returns a copy of a, that is, a fresh array
containing the same elements as a.
|
| cos [Pervasives] |
See
atan2.
|
| cosh [Pervasives] |
See
tanh.
|
| count [Weak.S] |
Count the number of elements in the table.
|
| count [Stream] |
Return the current count of the stream elements, i.e.
|
| counters [Gc] |
Return
(minor_words, promoted_words, major_words).
|
| create [Weak.S] | create n creates a new empty weak hash table, of initial
size n.
|
| create [Weak] | Weak.create n returns a new weak array of length n.
|
| create [Thread] | Thread.create funct arg creates a new thread of control,
in which the function application funct arg
is executed concurrently with the other threads of the program.
|
| create [StringLabels] | String.create n returns a fresh string of length n.
|
| create [String] | String.create n returns a fresh string of length n.
|
| create [StdLabels.String] | |
| create [StdLabels.Array] | |
| create [Stack] |
Return a new stack, initially empty.
|
| create [Queue] |
Return a new queue, initially empty.
|
| create [Mutex] |
Return a new mutex.
|
| create [MoreLabels.Hashtbl.S] | |
| create [MoreLabels.Hashtbl] | |
| create [Hashtbl.S] | |
| create [Hashtbl] | Hashtbl.create n creates a new, empty hash table, with
initial size n.
|
| create [Condition] |
Return a new condition variable.
|
| create [Buffer] | create n returns a fresh buffer, initially empty.
|
| create [Bigarray.Array3] | Array3.create kind layout dim1 dim2 dim3 returns a new bigarray of
three dimension, whose size is dim1 in the first dimension,
dim2 in the second dimension, and dim3 in the third.
|
| create [Bigarray.Array2] | Array2.create kind layout dim1 dim2 returns a new bigarray of
two dimension, whose size is dim1 in the first dimension
and dim2 in the second dimension.
|
| create [Bigarray.Array1] | Array1.create kind layout dim returns a new bigarray of
one dimension, whose size is dim.
|
| create [Bigarray.Genarray] | Genarray.create kind layout dimensions returns a new big array
whose element kind is determined by the parameter kind (one of
float32, float64, int8_signed, etc) and whose layout is
determined by the parameter layout (one of c_layout or
fortran_layout).
|
| create [ArrayLabels] | |
| create [Array] | |
| create_alarm [Gc] | create_alarm f will arrange for f to be called at the end of each
major GC cycle, starting with the current cycle or the next one.
|
| create_image [Graphics] | create_image w h returns a new image w pixels wide and h
pixels tall, to be used in conjunction with blit_image.
|
| create_matrix [StdLabels.Array] | |
| create_matrix [ArrayLabels] | |
| create_matrix [Array] | |
| create_object [CamlinternalOO] | |
| create_object_and_run_initializers [CamlinternalOO] | |
| create_object_opt [CamlinternalOO] | |
| create_process [UnixLabels] | create_process prog args new_stdin new_stdout new_stderr
forks a new process that executes the program
in file prog, with arguments args.
|
| create_process [Unix] | create_process prog args new_stdin new_stdout new_stderr
forks a new process that executes the program
in file prog, with arguments args.
|
| create_process_env [UnixLabels] | create_process_env prog args env new_stdin new_stdout new_stderr
works as UnixLabels.create_process, except that the extra argument
env specifies the environment passed to the program.
|
| create_process_env [Unix] | create_process_env prog args env new_stdin new_stdout new_stderr
works as Unix.create_process, except that the extra argument
env specifies the environment passed to the program.
|
| create_table [CamlinternalOO] | |
| current [Arg] |
Position (in
Sys.argv) of the argument being processed.
|
| current_dir_name [Filename] |
The conventional name for the current directory (e.g.
|
| current_point [Graphics] |
Return the position of the current point.
|
| current_x [Graphics] |
Return the abscissa of the current point.
|
| current_y [Graphics] |
Return the ordinate of the current point.
|
| curveto [Graphics] | curveto b c d draws a cubic Bezier curve starting from
the current point to point d, with control points b and
c, and moves the current point to d.
|
| custom_tag [Obj] | |
| cyan [Graphics] | |
D | |
| data_size [Marshal] |
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.
|
| default_available_units [Dynlink] |
Reset the set of units that can be referenced from dynamically-linked
code to its default value, that is, all units composing the currently
running program.
|
| delay [Thread] | delay d suspends the execution of the calling thread for
d seconds.
|
| delete_alarm [Gc] | delete_alarm a will stop the calls to the function associated
to a.
|
| descr_of_in_channel [UnixLabels] |
Return the descriptor corresponding to an input channel.
|
| descr_of_in_channel [Unix] |
Return the descriptor corresponding to an input channel.
|
| descr_of_out_channel [UnixLabels] |
Return the descriptor corresponding to an output channel.
|
| descr_of_out_channel [Unix] |
Return the descriptor corresponding to an output channel.
|
| destroy [Tk] |
Destroy an individual widget.
|
| diff [Set.S] |
Set difference.
|
| diff [MoreLabels.Set.S] | |
| dim [Bigarray.Array1] |
Return the size (dimension) of the given one-dimensional
big array.
|
| dim1 [Bigarray.Array3] |
Return the first dimension of the given three-dimensional big array.
|
| dim1 [Bigarray.Array2] |
Return the first dimension of the given two-dimensional big array.
|
| dim2 [Bigarray.Array3] |
Return the second dimension of the given three-dimensional big array.
|
| dim2 [Bigarray.Array2] |
Return the second dimension of the given two-dimensional big array.
|
| dim3 [Bigarray.Array3] |
Return the third dimension of the given three-dimensional big array.
|
| dims [Bigarray.Genarray] | Genarray.dims a returns all dimensions of the big array a,
as an array of integers of length Genarray.num_dims a.
|
| dirname [Filename] |
See
Filename.basename.
|
| display_mode [Graphics] |
Set display mode on or off.
|
| div [Nativeint] |
Integer division.
|
| div [Int64] |
Integer division.
|
| div [Int32] |
Integer division.
|
| div [Complex] |
Division
|
| div_big_int [Big_int] |
Euclidean quotient of two big integers.
|
| div_num [Num] |
Division
|
| domain_of_sockaddr [UnixLabels] |
Return the socket domain adequate for the given socket address.
|
| domain_of_sockaddr [Unix] |
Return the socket domain adequate for the given socket address.
|
| double_array_tag [Obj] | |
| double_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.
|
| dummy_pos [Lexing] |
A value of type
position, guaranteed to be different from any
valid position.
|
| dummy_table [CamlinternalOO] | |
| dump_image [Graphics] |
Convert an image to a color matrix.
|
| dup [UnixLabels] |
Return a new file descriptor referencing the same file as
the given descriptor.
|
| dup [Unix] |
Return a new file descriptor referencing the same file as
the given descriptor.
|
| dup [Obj] | |
| dup2 [UnixLabels] | dup2 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.
|
| end_of_input [Scanf.Scanning] | Scanning.end_of_input scanbuf tests the end of input condition
of the given buffer.
|
| 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 [MoreLabels.Map.S] | |
| equal [Map.S] | equal cmp m1 m2 tests whether the maps m1 and m2 are
equal, that is, contain equal keys and associate them with
equal data.
|
| equal [Hashtbl.HashedType] |
The equality predicate used to compare keys.
|
| err_formatter [Format] |
A formatter to use with formatting functions below for
output to standard error.
|
| error_message [UnixLabels] |
Return a string describing the given error code.
|
| error_message [Unix] |
Return a string describing the given error code.
|
| error_message [Dynlink] |
Convert an error description to a printable message.
|
| escaped [StringLabels] |
Return a copy of the argument, with special characters
represented by escape sequences, following the lexical
conventions of Objective Caml.
|
| escaped [String] |
Return a copy of the argument, with special characters
represented by escape sequences, following the lexical
conventions of Objective Caml.
|
| escaped [StdLabels.String] | |
| escaped [Char] |
Return a string representing the given character,
with special characters escaped following the lexical conventions
of Objective Caml.
|
| establish_server [UnixLabels] |
Establish a server on the given address.
|
| establish_server [Unix] |
Establish a server on the given address.
|
| executable_name [Sys] |
The name of the file containing the executable currently running.
|
| execv [UnixLabels] | execv prog args execute the program in file prog, with
the arguments args, and the current process environment.
|
| execv [Unix] | execv prog args execute the program in file prog, with
the arguments args, and the current process environment.
|
| execv [ThreadUnix] | |
| execve [UnixLabels] |
Same as
UnixLabels.execv, except that the third argument provides the
environment to the program executed.
|
| execve [Unix] |
Same as
Unix.execv, except that the third argument provides the
environment to the program executed.
|
| execve [ThreadUnix] | |
| execvp [UnixLabels] |
Same as
UnixLabels.execv respectively, except that
the program is searched in the path.
|
| execvp [Unix] |
Same as
Unix.execv respectively, except that
the program is searched in the path.
|
| execvp [ThreadUnix] | |
| execvpe [UnixLabels] |
Same as
UnixLabels.execvp respectively, except that
the program is searched in the path.
|
| execvpe [Unix] |
Same as
Unix.execvp respectively, except that
the program is searched in the path.
|
| exists [StdLabels.List] | |
| exists [Set.S] | exists p s checks if at least one element of
the set satisfies the predicate p.
|
| exists [MoreLabels.Set.S] | |
| exists [ListLabels] | exists p [a1; ...; an] checks if at least one element of
the list satisfies the predicate p.
|
| exists [List] | exists p [a1; ...; an] checks if at least one element of
the list satisfies the predicate p.
|
| exists2 [StdLabels.List] | |
| exists2 [ListLabels] |
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] |
Terminate the process, returning the given status code
to the operating system: usually 0 to indicate no errors,
and a small positive integer to indicate failure.
|
| exp [Pervasives] |
Exponential.
|
| exp [Complex] |
Exponentiation.
|
F | |
| failwith [Pervasives] |
Raise exception
Failure with the given string.
|
| fast_sort [StdLabels.List] | |
| fast_sort [StdLabels.Array] | |
| fast_sort [ListLabels] |
Same as
List.sort or List.stable_sort, whichever is faster
on typical input.
|
| fast_sort [List] |
Same as
List.sort or List.stable_sort, whichever is faster
on typical input.
|
| fast_sort [ArrayLabels] |
Same as
Array.sort or Array.stable_sort, whichever is faster
on typical input.
|
| fast_sort [Array] |
Same as
Array.sort or Array.stable_sort, whichever is faster
on typical input.
|
| fchmod [UnixLabels] |
Change the permissions of an opened file.
|
| fchmod [Unix] |
Change the permissions of an opened file.
|
| fchown [UnixLabels] |
Change the owner uid and owner gid of an opened file.
|
| fchown [Unix] |
Change the owner uid and owner gid of an opened file.
|
| field [Obj] | |
| file [Digest] |
Return the digest of the file whose name is given.
|
| file_exists [Sys] |
Test if a file with the given name exists.
|
| fill [Weak] | Weak.fill ar ofs len el sets to el all pointers of ar from
ofs to ofs + len - 1.
|
| fill [StringLabels] | String.fill s start len c modifies string s in place,
replacing the characters number start to start + len - 1
by c.
|
| fill [String] | String.fill s start len c modifies string s in place,
replacing the characters number start to start + len - 1
by c.
|
| fill [StdLabels.String] | |
| fill [StdLabels.Array] | |
| fill [Bigarray.Array3] |
Fill the given big array with the given value.
|
| fill [Bigarray.Array2] |
Fill the given big array with the given value.
|
| fill [Bigarray.Array1] |
Fill the given big array with the given value.
|
| fill [Bigarray.Genarray] |
Set all elements of a big array to a given value.
|
| fill [ArrayLabels] | Array.fill a ofs len x modifies the array a in place,
storing x in elements number ofs to ofs + len - 1.
|
| fill [Array] | Array.fill a ofs len x modifies the array a in place,
storing x in elements number ofs to ofs + len - 1.
|
| fill_arc [Graphics] |
Fill an elliptical pie slice with the current color.
|
| fill_circle [Graphics] |
Fill a circle with the current color.
|
| fill_ellipse [Graphics] |
Fill an ellipse with the current color.
|
| fill_poly [Graphics] |
Fill the given polygon with the current color.
|
| fill_rect [Graphics] | fill_rect x y w h fills the rectangle with lower left corner
at x,y, width w and height h, with the current color.
|
| filter [StdLabels.List] | |
| filter [Set.S] | filter p s returns the set of all elements in s
that satisfy predicate p.
|
| filter [MoreLabels.Set.S] | |
| filter [ListLabels] | filter p l returns all the elements of the list l
that satisfy the predicate p.
|
| filter [List] | filter p l returns all the elements of the list l
that satisfy the predicate p.
|
| final_tag [Obj] | |
| finalise [Gc] | finalise f v registers f as a finalisation function for v.
|
| finalise_release [Gc] |
A finalisation function may call
finalise_release to tell the
GC that it can launch the next finalisation function without waiting
for the current one to return.
|
| find [Weak.S] | find t x returns an instance of x found in t.
|
| find [StdLabels.List] | |
| find [MoreLabels.Map.S] | |
| find [MoreLabels.Hashtbl.S] | |
| find [MoreLabels.Hashtbl] | |
| find [Map.S] | find x m returns the current binding of x in m,
or raises Not_found if no such binding exists.
|
| find [ListLabels] | find p l returns the first element of the list l
that satisfies the predicate p.
|
| find [List] | find p l returns the first element of the list l
that satisfies the predicate p.
|
| find [Hashtbl.S] | |
| find [Hashtbl] | Hashtbl.find tbl x returns the current binding of x in tbl,
or raises Not_found if no such binding exists.
|
| find [Dbm] | find db key returns the data associated with the given
key in the database opened for the descriptor db.
|
| find_all [Weak.S] | find_all t x returns a list of all the instances of x
found in t.
|
| find_all [StdLabels.List] | |
| find_all [MoreLabels.Hashtbl.S] | |
| find_all [MoreLabels.Hashtbl] | |
| find_all [ListLabels] | find_all 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] |
Same as
concat.
|
| float [Random.State] | |
| float [Random] | Random.float bound returns a random floating-point number
between 0 (inclusive) and bound (exclusive).
|
| float [Pervasives] |
Same as
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_bits [Int32] |
Return the floating-point number whose internal representation,
according to the IEEE 754 floating-point ``single format'' bit layout,
is the given
int32.
|
| float_of_int [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 open output channels; ignore errors.
|
| flush_input [Lexing] |
Discard the contents of the buffer and reset the current
position to 0.
|
| flush_str_formatter [Format] |
Returns the material printed with
str_formatter, flushes
the formatter and resets the corresponding buffer.
|
| fold [Weak.S] | fold f t init computes (f d1 (... (f dN init))) where
d1 ... dN are the elements of t in some unspecified order.
|
| fold [Set.S] | fold f s a computes (f xN ... (f x2 (f x1 a))...),
where x1 ... xN are the elements of s, in increasing order.
|
| fold [Queue] | fold f accu q is equivalent to List.fold_left f accu l,
where l is the list of q's elements.
|
| fold [MoreLabels.Set.S] | |
| fold [MoreLabels.Map.S] | |
| fold [MoreLabels.Hashtbl.S] | |
| fold [MoreLabels.Hashtbl] | |
| fold [Map.S] | fold f m a computes (f kN dN ... (f k1 d1 a)...),
where k1 ... kN are the keys of all bindings in m
(in increasing order), 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.
|