| ( * ) [Pervasives] | 
Integer multiplication.
 
 | 
| ( ** ) [Pervasives] | 
Exponentiation.
 
 | 
| ( **/ ) [Num] | 
Same as  
Num.power_num.
 | 
| ( *. ) [Pervasives] | 
Floating-point multiplication
 
 | 
| ( */ ) [Num] | 
Same as  
Num.mult_num.
 | 
| (!) [Pervasives] | !r returns the current contents of reference r.
 | 
| (!=) [Pervasives] | 
Negation of  
Pervasives.(==).
 | 
| (!@) [JavaPervasives] | 
Synonym for  
JavaString.of_string.
 | 
| (&&) [Pervasives] | 
The boolean 'and'.
 
 | 
| (&) [Pervasives] | |
| (+) [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  
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] | 
Application operator:  
g @@ f @@ x is exactly equivalent to
 g (f (x)).
 | 
| (^) [Pervasives] | 
String concatenation.
 
 | 
| (^^) [Pervasives] | f1 ^^ f2 catenates format strings f1 and f2.
 | 
| (^^^) [JavaPervasives] | 
Concatenation of Java strings.
 
 | 
| (asr) [Pervasives] | n asr m shifts n to the right by m bits.
 | 
| (land) [Pervasives] | 
Bitwise logical and.
 
 | 
| (lor) [Pervasives] | 
Bitwise logical or.
 
 | 
| (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.
 | 
| (lxor) [Pervasives] | 
Bitwise logical exclusive or.
 
 | 
| (mod) [Pervasives] | 
Integer remainder.
 
 | 
| (or) [Pervasives] | |
| (|.) [JavaPervasives] | 
Akin to  
Pervasives.(@@), with a different priority allowing to
    chain calls with parameters:
    
 | 
| (|>) [Pervasives] | 
Reverse-application operator:  
x |> f |> g is exactly equivalent
 to g (f (x)).
 | 
| (||) [Pervasives] | 
The boolean 'or'.
 
 | 
| (~+) [Pervasives] | 
Unary addition.
 
 | 
| (~+.) [Pervasives] | 
Unary addition.
 
 | 
| (~-) [Pervasives] | 
Unary negation.
 
 | 
| (~-.) [Pervasives] | 
Unary negation.
 
 | 
A  | |
| abort_policy [RejectedExecutionHandler] | 
Reject computation; see
    java.util.concurrent.ThreadPoolExecutor.AbortPolicy.
 
 | 
| 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] | abs_float f returns the absolute value of f.
 | 
| abs_num [Num] | 
Absolute value.
 
 | 
| abstract_tag [Obj] | |
| accept [Unix] | 
Accept connections on the given socket.
 
 | 
| access [Unix] | 
Check that the process has the given permissions over the named
   file.
 
 | 
| acos [Pervasives] | 
Arc cosine.
 
 | 
| acquire [Semaphore] | acquire s p acquires p permits from semaphore s, blocking until
    they are available; see
    acquire(...).
 | 
| acquire_uninterruptibly [Semaphore] | acquire_uninterruptibly s p is similar to acquire s p, except
    that waiting thread cannot be interrupted; see
    acquireUninterruptibly(...).
 | 
| active_count [ThreadGroup] | 
Returns the number of active threads in this group (including
    children groups); see activeCount(...).
 
 | 
| active_group_count [ThreadGroup] | 
Returns the number of active groups in this group (including children
    groups); see activeGroupCount(...).
 
 | 
| adapt_filename [Dynlink] | 
In bytecode, the identity function.
 
 | 
| add [Weak.S] | add t x adds x to t.
 | 
| add [Set.S] | add x s returns a set containing all elements of s,
       plus x.
 | 
| add [Queue] | add x q adds the element x at the end of the queue q.
 | 
| add [Nativeint] | 
Addition.
 
 | 
| add [MoreLabels.Set.S] | |
| add [MoreLabels.Map.S] | |
| add [MoreLabels.Hashtbl.SeededS] | |
| 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 [JavaCalendar] | add cal f delta returns a new instance that is equal to cal, with
    the field f modified by adding delta; see
    add(...).
 | 
| add [Int64] | 
Addition.
 
 | 
| add [Int32] | 
Addition.
 
 | 
| add [Hashtbl.SeededS] | |
| add [Hashtbl.S] | |
| add [Hashtbl] | Hashtbl.add tbl x y adds a binding of x to y in table tbl.
 | 
| add [Complex] | 
Addition
 
 | 
| add_and_get [AtomicInt64Array] | add_and_get a i d atomically adds d to the value at index i,
    and returns the new value.
 | 
| add_and_get [AtomicInt64] | add_and_get a d atomically adds d to the current value, and returns the new value.
 | 
| add_and_get [AtomicInt32Array] | add_and_get a i d atomically adds d to the value at index i,
    and returns the new value.
 | 
| add_and_get [AtomicInt32] | add_and_get a d atomically adds d to the current value, and returns the new value.
 | 
| 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_nat [Nat] | |
| add_num [Num] | 
Addition
 
 | 
| add_offset [Obj] | |
| 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.
 | 
| after [JavaDate] | |
| after [JavaCalendar] | |
| 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.
 
 | 
| and_big_int [Big_int] | 
Bitwise logical 'and'.
 
 | 
| append [StdLabels.List] | |
| append [StdLabels.Array] | |
| append [ParallelArray.S] | |
| append [ParallelArray] | 
Synonym for  
Array.append.
 | 
| append [ListLabels] | 
Catenate two lists.
 
 | 
| append [List] | 
Catenate two lists.
 
 | 
| append [JavaShortArray] | append a1 a2 returns the concatenation of a1 and a2.
 | 
| append [JavaLongArray] | append a1 a2 returns the concatenation of a1 and a2.
 | 
| append [JavaIntArray] | append a1 a2 returns the concatenation of a1 and a2.
 | 
| append [JavaFloatArray] | append a1 a2 returns the concatenation of a1 and a2.
 | 
| append [JavaDoubleArray] | append a1 a2 returns the concatenation of a1 and a2.
 | 
| append [JavaCharArray] | append a1 a2 returns the concatenation of a1 and a2.
 | 
| append [JavaByteArray] | append a1 a2 returns the concatenation of a1 and a2.
 | 
| append [JavaBooleanArray] | append a1 a2 returns the concatenation of a1 and a2.
 | 
| append [JavaArraySignature.T] | |
| 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.
 | 
| append_boolean [JavaStringBuilder] | 
Appends the passed boolean to the passed builder; see
    append(...).
 
 | 
| append_char [JavaStringBuilder] | 
Appends the passed character to the passed builder; see
    append(...).
 
 | 
| append_code_point [JavaStringBuilder] | 
Appends the passed code point to the passed builder; see
    appendCodePoint(...).
 
 | 
| append_double [JavaStringBuilder] | 
Appends the passed double to the passed builder; see
    append(...).
 
 | 
| append_float [JavaStringBuilder] | 
Appends the passed float to the passed builder; see
    append(...).
 
 | 
| append_int [JavaStringBuilder] | 
Appends the passed integer to the passed builder; see
    append(...).
 
 | 
| append_long [JavaStringBuilder] | 
Appends the passed long to the passed builder; see
    append(...).
 
 | 
| append_string [JavaStringBuilder] | 
Appends the passed string to the passed builder; see
    append(...).
 
 | 
| applet_info [JavaApplet.Graphics] | 
The value to be returned by the getAppletInfo(...) method.
 
 | 
| applet_info [JavaApplet.Swing] | 
The value to be returned by the getAppletInfo(...) method.
 
 | 
| applet_info [JavaApplet.AWT] | 
The value to be returned by the getAppletInfo(...) method.
 
 | 
| approx_num_exp [Num] | 
Approximate a number by a decimal.
 
 | 
| approx_num_fix [Num] | 
See  
Num.approx_num_exp.
 | 
| approx_printing_flag [Arith_flags] | |
| 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.
 
 | 
| arrive [Phaser] | 
Records that a party has arrived to the phaser without waiting for
    others, returns the phase number (negative if the phaser is
    terminated); see arrive(...).
 
 | 
| arrive_and_await_advance [Phaser] | 
Records that a party has arrived to the phaser and waits for others,
    returns the phase number (negative if the phaser is terminated); see
    arriveAndAwaitAdvance(...).
 
 | 
| arrive_and_deregister [Phaser] | 
Records that a party has arrived to the phaser without waiting for
    others, deregisters a party, returns the phase number (negative if
    the phaser is terminated); see
    arriveAndDeregister(...).
 
 | 
| asin [Pervasives] | 
Arc sine.
 
 | 
| asprintf [JavaStringFormat] | 
This function can be passed to  
Format.bprintf to print a Java
    string through a "%a" conversion specification.
 | 
| asprintf [Format] | 
Same as  
printf above, but instead of printing on a formatter,
   returns a string containing the result of formatting the arguments.
 | 
| 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] | 
Arc tangent.
 
 | 
| atan2 [Pervasives] | atan2 y x returns the arc tangent of y /. x.
 | 
| attempt_mark [AtomicMarkableReference] | attempt_mark a e m sets the mark to m if the current value is
    e.
 | 
| attempt_stamp [AtomicStampedReference] | attempt_stamp a e s sets the stamp to s if the current value is
    e.
 | 
| attribute_added [JavaServlet.HTTPSessionAttributeListener] | 
Called to notify that a new session attribute has been added to a
      session; see
      attributeAdded(...).
 
 | 
| attribute_added [JavaServlet.ServletContextAttributeListener] | 
Called to notify that a new attribute was added to the context; see
      attributeAdded(...).
 
 | 
| attribute_removed [JavaServlet.HTTPSessionAttributeListener] | 
Called to notify that a session attribute has been removed from a
      session; see
      attributeRemoved(...).
 
 | 
| attribute_removed [JavaServlet.ServletContextAttributeListener] | 
Called to notify that an attribute was removed from the context; see
      attributeRemoved(...).
 
 | 
| attribute_replaced [JavaServlet.HTTPSessionAttributeListener] | 
Called to notify that a session attribute has been replaced in a
      session; see
      attributeReplaced(...).
 
 | 
| attribute_replaced [JavaServlet.ServletContextAttributeListener] | 
Called to notify that an attribute was replaced in the context; see
      attributeReplaced(...).
 
 | 
| auto_synchronize [Graphics] | 
By default, drawing takes place both on the window displayed
   on screen, and in a memory area (the 'backing store').
 
 | 
| available_permits [Semaphore] | 
Returns the number of available permits for the semaphore; see
    availablePermits(...).
 
 | 
| available_processors [JavaRuntime] | 
Returns the number of (logical) available processors; see
    availableProcessors(...).
 
 | 
| await [CyclicBarrier] | 
Waits until all threads have reached the barrier; see
    await(...).
 
 | 
| await [CountDownLatch] | 
Waits until the coutdown reaches zero, without countingdown; see
    await(...).
 
 | 
| await [Condition] | 
Waits until either the condition is signal, or the current thread is
    interrupted; see
    await(...).
 
 | 
| await_advance [Phaser] | 
Waits for the phase number of the phaser to reach the passed value; see
    awaitAdvance(...).
 
 | 
| await_advance_interruptibly [Phaser] | 
Similar to  
Phaser.await_advance except that the thread can be interrupted; see
    awaitAdvanceInterruptibly(...).
 | 
| await_advance_interruptibly_time [Phaser] | await_advance_interruptibly_time p pn t u is similar to
    await_advance_interruptibly p pn, except that the current
    thread will at most wait for t (time value whose unit is u); see
    awaitAdvanceInterruptibly(...).
 | 
| await_nanos [Condition] | await_nanos c n is similar to await c, except that the current
    thread will at most wait for n nanoseconds.
 | 
| await_termination [ThreadPoolExecutor] | 
Waits for pool termination, waiting at most wait for  
t (time value
    whose unit is u); see awaitTermination(...).
 | 
| await_termination [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.await_termination.
 | 
| await_termination [ForkJoinPool] | 
Waits for pool termination, waiting at most wait for  
t (time value
    whose unit is u); see
    awaitTermination(...).
 | 
| await_time [CyclicBarrier] | await_time b t u is similar to await b, except that the current
    thread will at most wait for t (time value whose unit is u); see
    await(...).
 | 
| await_time [CountDownLatch] | await_time c t u is similar to await c, except that the current
    thread will at most wait for t (time value whose unit is u); see
    await(...).
 | 
| await_time [Condition] | await_time c t u is similar to await c, except that the current
    thread will at most wait for t (time value whose unit is u).
 | 
| await_uninterruptibly [Condition] | 
Similar to  
await except that the thread cannot be interrupted; see
    awaitUninterruptibly(...).
 | 
| await_until [Condition] | await_until c d waits until the date d is reached.
 | 
B  | |
| background [Graphics] | 
See  
Graphics.foreground.
 | 
| backtrace_status [Printexc] | Printexc.backtrace_status() returns true if exception
    backtraces are currently recorded, false if not.
 | 
| basename [Filename] | 
Split a file name into directory name / base file name.
 
 | 
| before [JavaDate] | |
| before [JavaCalendar] | |
| beginning_of_input [Scanf.Scanning] | Scanning.beginning_of_input ic tests the beginning of input condition of
    the given formatted input channel.
 | 
| big_endian [Sys] | 
Whether the machine currently executing the Caml program is big-endian.
 
 | 
| big_int_of_int [Big_int] | 
Convert a small integer to a big integer.
 
 | 
| big_int_of_int32 [Big_int] | 
Convert a 32-bit integer to a big integer.
 
 | 
| big_int_of_int64 [Big_int] | 
Convert a 64-bit integer to a big integer.
 
 | 
| big_int_of_nativeint [Big_int] | 
Convert a native 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.
 
 | 
| biggest_int [Int_misc] | |
| bind [Unix] | 
Bind a socket to an address.
 
 | 
| bindings [MoreLabels.Map.S] | |
| bindings [Map.S] | 
Return the list of all bindings of the given map.
 
 | 
| bits [Random.State] | |
| bits [Random] | 
Return 30 random bits in a nonnegative integer.
 
 | 
| bits_of_float [Int64] | 
Return the internal representation of the given float according
   to the IEEE 754 floating-point 'double format' bit layout.
 
 | 
| bits_of_float [Int32] | 
Return the internal representation of the given float according
   to the IEEE 754 floating-point 'single format' bit layout.
 
 | 
| black [Graphics] | |
| blit [Weak] | 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 [ParallelArray.S] | |
| blit [ParallelArray] | 
Synonym for  
Array.blit.
 | 
| blit [JavaShortArray] | blit src srcofs dst dstofs len copies len elements from src at
    offset srcofs to dst at offset dstofs.
 | 
| blit [JavaReferenceArray] | blit src srcofs dst dstofs len copies len elements from src at
    offset srcofs to dst at offset dstofs.
 | 
| blit [JavaLongArray] | blit src srcofs dst dstofs len copies len elements from src at
    offset srcofs to dst at offset dstofs.
 | 
| blit [JavaIntArray] | blit src srcofs dst dstofs len copies len elements from src at
    offset srcofs to dst at offset dstofs.
 | 
| blit [JavaFloatArray] | blit src srcofs dst dstofs len copies len elements from src at
    offset srcofs to dst at offset dstofs.
 | 
| blit [JavaDoubleArray] | blit src srcofs dst dstofs len copies len elements from src at
    offset srcofs to dst at offset dstofs.
 | 
| blit [JavaCharArray] | blit src srcofs dst dstofs len copies len elements from src at
    offset srcofs to dst at offset dstofs.
 | 
| blit [JavaByteArray] | blit src srcofs dst dstofs len copies len elements from src at
    offset srcofs to dst at offset dstofs.
 | 
| blit [JavaBooleanArray] | blit src srcofs dst dstofs len copies len elements from src at
    offset srcofs to dst at offset dstofs.
 | 
| blit [JavaArraySignature.T] | |
| blit [Buffer] | Buffer.blit src srcoff dst dstoff len copies len characters from
   the current contents of the buffer src, starting at offset srcoff
   to string dst, starting at character dstoff.
 | 
| 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.
 | 
| blit_nat [Nat] | |
| 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.
 
 | 
| boolean_value [JavaBoolean] | 
Returns the wrapped value.
 
 | 
| 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 [JavaStringPrintf] | 
This function can be passed to  
Printf.bprintf to print a Java
    string through a "%a" conversion specification.
 | 
| bprintf [Format] | 
A deprecated and error prone function.
 
 | 
| bscanf [Scanf] | bscanf ic fmt r1 ... rN f reads arguments for the function f, from the
    formatted input channel ic, according to the format string fmt, and
    applies f to these values.
 | 
| bscanf_format [Scanf] | bscanf_format ic fmt f reads a format string token from the formatted
    input channel ic, according to the given format string fmt, and
    applies f to the resulting format string value.
 | 
| bulk_register [Phaser] | |
| button_down [Graphics] | 
Return  
true if the mouse button is pressed, false otherwise.
 | 
| byte_value [JavaShort] | 
Returns the wrapped value, as a byte.
 
 | 
| byte_value [JavaLong] | 
Returns the wrapped value, as a byte.
 
 | 
| byte_value [JavaInt] | 
Returns the wrapped value, as a byte.
 
 | 
| byte_value [JavaFloat] | 
Returns the wrapped value, as a byte.
 
 | 
| byte_value [JavaDouble] | 
Returns the wrapped value, as a byte.
 
 | 
| byte_value [JavaByte] | 
Returns the wrapped value, as a byte.
 
 | 
C  | |
| c_layout [Bigarray] | |
| call [Java] | call desc param1 ... paramn calls and returns the result of method
    desc called with parameters param1 ... paramn, where param1 is
    the instance to call method upon if the method is not static.
 | 
| caller_runs_policy [RejectedExecutionHandler] | 
Run the computation in the calling thread; see
    java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy.
 
 | 
| canada [JavaLocale] | |
| canada_french [JavaLocale] | |
| cancel [ScheduledFuture] | 
Same as  
Future.cancel.
 | 
| cancel [Future] | cancel f i attemps to cancel future f, i indicating whether to
    interrupt the computation if already started.
 | 
| capacity [JavaStringBuilder] | 
Returns the capacity of the passed builder; see
    capacity(...).
 
 | 
| capitalize [StringLabels] | 
Return a copy of the argument, with the first character set to uppercase.
 
 | 
| capitalize [String] | 
Return a copy of the argument, with the first character set to uppercase.
 
 | 
| capitalize [StdLabels.String] | |
| capitalize [JavaString.OCaml] | 
Similar to  
String.capitalize.
 | 
| cardinal [Set.S] | 
Return the number of elements of a set.
 
 | 
| cardinal [MoreLabels.Set.S] | |
| cardinal [MoreLabels.Map.S] | |
| cardinal [Map.S] | 
Return the number of bindings of a map.
 
 | 
| cast [JavaObject] | |
| cast [Java] | cast desc x casts x, so that it can be used as an instance of
    desc.
 | 
| 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] | 
Round above to an integer value.
 
 | 
| ceiling_num [Num] | ceiling_num n returns the smallest integer bigger or equal to n.
 | 
| chain [Java] | 
Similar to  
Java.call, returns the instance the method was called upon.
 | 
| 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 OCaml type float.
 | 
| char_at [JavaStringBuilder] | 
Returns the character at the passed index in the passed builder; see
    charAt(...).
 
 | 
| char_at [JavaString] | 
Returns the character at the passed index; see
    charAt(...).
 
 | 
| char_of_int [Pervasives] | 
Return the character with the given ASCII code.
 
 | 
| char_value [JavaChar] | 
Returns the wrapped value.
 
 | 
| 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.
 | 
| china [JavaLocale] | |
| chinese [JavaLocale] | |
| 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 [MoreLabels.Map.S] | |
| choose [Map.S] | 
Return one binding of the given map, or raise  
Not_found if
       the map is empty.
 | 
| 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 [Unix] | 
Change the owner uid and owner gid of the named file.
 
 | 
| chr [Char] | 
Return the character with the given ASCII code.
 
 | 
| chroot [Unix] | 
Change the process root directory.
 
 | 
| chunk_size [ParallelArray.OptionalParameters] | 
The size of chunks for parallel computations.
 
 | 
| 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.SeededS] | |
| clear [MoreLabels.Hashtbl.S] | |
| clear [MoreLabels.Hashtbl] | |
| clear [JavaCalendar] | |
| clear [Hashtbl.SeededS] | |
| clear [Hashtbl.S] | |
| clear [Hashtbl] | 
Empty a hash table.
 
 | 
| clear [Buffer] | 
Empty the buffer.
 
 | 
| clear_all [JavaCalendar] | clear_all cal returns a new instance that is equal to cal, with
    the all fields cleared; see
    clear(...).
 | 
| clear_available_units [Dynlink] | 
Empty the list of compilation units accessible to dynamically-linked
    programs.
 
 | 
| clear_close_on_exec [Unix] | 
Clear the ``close-on-exec'' flag on the given descriptor.
 
 | 
| clear_graph [Graphics] | 
Erase the graphics window.
 
 | 
| clear_nonblock [Unix] | 
Clear the ``non-blocking'' flag on the given descriptor.
 
 | 
| clear_parser [Parsing] | 
Empty the parser stack.
 
 | 
| clear_property [JavaSystem] | clear_property name removes the system property named name,
    returning its previous value if any; see
    clearProperty(...).
 | 
| close [Unix] | 
Close a file descriptor.
 
 | 
| 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 [Scanf.Scanning] | 
Closes the  
Pervasives.in_channel associated with the given
  Scanning.in_channel formatted input channel.
 | 
| close_in [Pervasives] | 
Close the given channel.
 
 | 
| close_in [JavaIOStreams] | 
Closes the passed stream.
 
 | 
| close_in_noerr [Pervasives] | 
Same as  
close_in, but ignore all errors.
 | 
| close_in_noerr [JavaIOStreams] | 
Closes the passed stream, discarding any error.
 
 | 
| close_out [Pervasives] | 
Close the given channel, flushing all buffered write operations.
 
 | 
| close_out [JavaIOStreams] | 
Closes the passed stream.
 
 | 
| close_out_noerr [Pervasives] | 
Same as  
close_out, but ignore all errors.
 | 
| close_out_noerr [JavaIOStreams] | 
Closes the passed stream, discarding any error.
 
 | 
| 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 [Unix] | 
Close channels opened by  
Unix.open_process_full,
   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 [Unix] | 
Close channels opened by  
Unix.open_process_out,
   wait for the associated command to terminate,
   and return its termination status.
 | 
| close_tag [Format] | close_tag () closes the most recently opened tag t.
 | 
| close_tbox [Format] | 
Closes the most recently opened tabulation box.
 
 | 
| closedir [Unix] | 
Close a directory descriptor.
 
 | 
| closure_tag [Obj] | |
| code [Char] | 
Return the ASCII code of the argument.
 
 | 
| code_point_at [JavaStringBuilder] | 
Returns the code point at the passed index in the passed builder; see
    codePointAt(...).
 
 | 
| combine [StdLabels.List] | |
| combine [MapReduce.Computation] | 
combine operation, turning two values into one for a given key.
 
 | 
| 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
     
Pervasives.compare.
 | 
| compare [String] | 
The comparison function for strings, with the same specification as
     
Pervasives.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
     
Pervasives.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 [JavaString.OCaml] | 
Similar to  
String.compare.
 | 
| compare [JavaShort] | 
Compares the passed values.
 
 | 
| compare [JavaLong] | 
Compares the passed values.
 
 | 
| compare [JavaInt] | 
Compares the passed values.
 
 | 
| compare [JavaFloat] | 
Compares the passed values.
 
 | 
| compare [JavaDouble] | 
Compares the passed values.
 
 | 
| compare [JavaChar] | 
Compares the passed values.
 
 | 
| compare [JavaByte] | 
Compares the passed values.
 
 | 
| compare [JavaBoolean] | 
Compares the passed values.
 
 | 
| compare [Int64] | 
The comparison function for 64-bit integers, with the same specification as
     
Pervasives.compare.
 | 
| compare [Int32] | 
The comparison function for 32-bit integers, with the same specification as
     
Pervasives.compare.
 | 
| compare [Digest] | 
The comparison function for 16-character digest, with the same
    specification as  
Pervasives.compare and the implementation
    shared with String.compare.
 | 
| compare [Char] | 
The comparison function for characters, with the same specification as
     
Pervasives.compare.
 | 
| compare_and_set [AtomicStampedReference] | compare_and_set a er ur es us atomically sets the value of a to
    ur and stamp to us if the current value is er and the current
    stamp is es.
 | 
| compare_and_set [AtomicReferenceArray] | compare_and_set a i e u atomically sets the value of a at index
    i to u if the current value is e.
 | 
| compare_and_set [AtomicReference] | compare_and_set a e u atomically sets the value of a to u if
    the current value is e.
 | 
| compare_and_set [AtomicMarkableReference] | compare_and_set a er ur em um atomically sets the value of a to
    ur and mark to um if the current value is er and the current
    mark is em.
 | 
| compare_and_set [AtomicInt64Array] | compare_and_set a i e u atomically sets the value of a at index
    i to u if the current value is e.
 | 
| compare_and_set [AtomicInt64] | compare_and_set a e u atomically sets the value of a to u if
    the current value is e.
 | 
| compare_and_set [AtomicInt32Array] | compare_and_set a i e u atomically sets the value of a at index
    i to u if the current value is e.
 | 
| compare_and_set [AtomicInt32] | compare_and_set a e u atomically sets the value of a to u if
    the current value is e.
 | 
| compare_and_set [AtomicBool] | compare_and_set a e u atomically sets the value of a to u if
    the current value is e.
 | 
| 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_digits_nat [Nat] | |
| compare_ignore_case [JavaString.OCaml] | 
Similar to  
String.compare, but ignoring case when comparing
      strings.
 | 
| compare_int [Int_misc] | |
| compare_keys [MapReduce.Computation] | 
Ordering over keys.
 
 | 
| compare_nat [Nat] | |
| compare_num [Num] | 
Return  
-1, 0 or 1 if the first argument is less than,
   equal to, or greater than the second argument.
 | 
| compare_to [JavaString] | 
Compares the passed strings; see
    compareTo(...).
 
 | 
| compare_to [JavaShort] | 
Compares the passed values.
 
 | 
| compare_to [JavaLong] | 
Compares the passed values.
 
 | 
| compare_to [JavaInt] | 
Compares the passed values.
 
 | 
| compare_to [JavaFloat] | 
Compares the passed values.
 
 | 
| compare_to [JavaDouble] | 
Compares the passed values.
 
 | 
| compare_to [JavaDate] | 
Compares the passed dates; see
    compareTo(...).
 
 | 
| compare_to [JavaChar] | 
Compares the passed values.
 
 | 
| compare_to [JavaCalendar] | 
Compares the passed calendars; see
    compareTo(...).
 
 | 
| compare_to [JavaByte] | 
Compares the passed values.
 
 | 
| compare_to [JavaBoolean] | 
Compares the passed values.
 
 | 
| compare_to_ignore_case [JavaString] | 
Similar to  
JavaString.compare_to, but ignoring case when comparing strings;
    see compareToIgnoreCase(...).
 | 
| complement_nat [Nat] | |
| complex32 [Bigarray] | 
See  
Bigarray.char.
 | 
| complex64 [Bigarray] | 
See  
Bigarray.char.
 | 
| compute [MapReduce.S] | 
Iterates over the passed stream using pool threads to execute
      map operations over the various input values, and applies
      combine operation over values having identical keys as soon as
      they are available.
 
 | 
| 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 [ParallelArray.S] | |
| concat [ParallelArray] | 
Synonym for  
Array.concat.
 | 
| concat [ListLabels] | 
Concatenate a list of lists.
 
 | 
| concat [List] | 
Concatenate a list of lists.
 
 | 
| concat [JavaString.OCaml] | 
Similar to  
String.concat.
 | 
| concat [JavaShortArray] | concat l returns the concatenation of arrays in l.
 | 
| concat [JavaLongArray] | concat l returns the concatenation of arrays in l.
 | 
| concat [JavaIntArray] | concat l returns the concatenation of arrays in l.
 | 
| concat [JavaFloatArray] | concat l returns the concatenation of arrays in l.
 | 
| concat [JavaDoubleArray] | concat l returns the concatenation of arrays in l.
 | 
| concat [JavaCharArray] | concat l returns the concatenation of arrays in l.
 | 
| concat [JavaByteArray] | concat l returns the concatenation of arrays in l.
 | 
| concat [JavaBooleanArray] | concat l returns the concatenation of arrays in l.
 | 
| concat [JavaArraySignature.T] | |
| 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 [Unix] | 
Connect a socket to an address.
 
 | 
| 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 [JavaString.OCaml] | 
Similar to  
String.contains.
 | 
| 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 s after position start.
 | 
| contains_from [StdLabels.String] | |
| contains_from [JavaString.OCaml] | 
Similar to  
String.contains_from.
 | 
| contents [Buffer] | 
Return a copy of the current contents of the buffer.
 
 | 
| context_destroyed [JavaServlet.ServletContextListener] | 
Called to notify that the servlet context will shutdown; see
      contextDestroyed(...).
 
 | 
| context_initialized [JavaServlet.ServletContextListener] | 
Called to notify that the application initialization is starting; see
      contextInitialized(...).
 
 | 
| convert [TimeUnit] | |
| 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 [ParallelArray.S] | |
| copy [ParallelArray] | 
Synonym for  
Array.copy.
 | 
| copy [Oo] | Oo.copy o returns a copy of object o, that is a fresh
   object with the same methods and instance variables as o.
 | 
| copy [MoreLabels.Hashtbl.SeededS] | |
| copy [MoreLabels.Hashtbl.S] | |
| copy [MoreLabels.Hashtbl] | |
| copy [JavaString.OCaml] | 
Similar to  
String.copy, equivalent to the identity function.
 | 
| copy [JavaShortArray] | copy a returns a copy of a.
 | 
| copy [JavaLongArray] | copy a returns a copy of a.
 | 
| copy [JavaIntArray] | copy a returns a copy of a.
 | 
| copy [JavaFloatArray] | copy a returns a copy of a.
 | 
| copy [JavaDoubleArray] | copy a returns a copy of a.
 | 
| copy [JavaCharArray] | copy a returns a copy of a.
 | 
| copy [JavaByteArray] | copy a returns a copy of a.
 | 
| copy [JavaBooleanArray] | copy a returns a copy of a.
 | 
| copy [JavaArraySignature.T] | |
| copy [Hashtbl.SeededS] | |
| 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.
 | 
| copy_nat [Nat] | |
| copysign [Pervasives] | copysign x y returns a float whose absolute value is that of x
  and whose sign is that of y.
 | 
| cos [Pervasives] | 
Cosine.
 
 | 
| cosh [Pervasives] | 
Hyperbolic cosine.
 
 | 
| count [Weak.S] | 
Count the number of elements in the table.
 
 | 
| count [Stream] | 
Return the current count of the stream elements, i.e.
 
 | 
| count_down [CountDownLatch] | 
Decrements the count, and then waits for the countdown to reach
    zero; see countDown(...).
 
 | 
| 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 [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 [ParallelArray.S] | |
| create [ParallelArray] | 
Synonym for  
Array.create.
 | 
| create [MoreLabels.Hashtbl.SeededS] | |
| create [MoreLabels.Hashtbl.S] | |
| create [MoreLabels.Hashtbl] | |
| create [Hashtbl.SeededS] | |
| create [Hashtbl.S] | |
| create [Hashtbl] | Hashtbl.create n creates a new, empty hash table, with
   initial size n.
 | 
| create [Buffer] | create n returns a fresh buffer, initially empty.
 | 
| create [Bigarray.Array3] | Array3.create kind layout dim1 dim2 dim3 returns a new bigarray of
     three 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 [ParallelArray.S] | |
| create_matrix [ParallelArray] | 
Synonym for  
Array.create_matrix.
 | 
| create_matrix [ArrayLabels] | |
| create_matrix [Array] | |
| create_nat [Nat] | |
| create_object [CamlinternalOO] | |
| create_object_and_run_initializers [CamlinternalOO] | |
| create_object_opt [CamlinternalOO] | |
| 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 [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_thread [Thread] | 
Returns the thread that is currently executing; see
    currentThread(...).
 
 | 
| current_thread_local [JavaRandom] | 
Returns the instance of java.util.concurrent.ThreadLocalRandom
    for the current thread.
 
 | 
| current_time_millis [JavaSystem] | 
Returns the number of milliseconds since January 1, 1970 UTC at
    midnight; see currentTimeMillis(...).
 
 | 
| 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] | |
| cygwin [Sys] | 
True if  
Sys.os_type = "Cygwin".
 | 
D  | |
| data_size [Marshal] | 
See  
Marshal.header_size.
 | 
| days [TimeUnit] | 
Time unit for days.
 
 | 
| decode [JavaShort] | 
Converts the passed string into a short wrapper; see
    decode(...).
 
 | 
| decode [JavaLong] | 
Converts the passed string into a long wrapper; see
    decode(...).
 
 | 
| decode [JavaInt] | 
Converts the passed string into a integer wrapper; see
    decode(...).
 
 | 
| decode [JavaByte] | 
Converts the passed string into a byte wrapper; see
    decode(...).
 
 | 
| decr [Pervasives] | 
Decrement the integer contained in the given reference.
 
 | 
| decr_nat [Nat] | |
| decr_num [Num] | decr r is r:=!r-1, where r is a reference to a number.
 | 
| decrement_and_get [AtomicInt64Array] | 
Atomically decrements the value at passed index, and returns the new
    value.
 
 | 
| decrement_and_get [AtomicInt64] | 
Atomically decrements the current value, and returns the new value.
 
 | 
| decrement_and_get [AtomicInt32Array] | 
Atomically decrements the value at passed index, and returns the new
    value.
 
 | 
| decrement_and_get [AtomicInt32] | 
Atomically decrements the current value, and returns the new value.
 
 | 
| 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.
 
 | 
| default_pool [ParallelArray] | 
The default pool used for parallel computations, initialized with the
    number of available (logical) processors.
 
 | 
| delete [JavaStringBuilder] | delete sb start end deletes the characters from index start
    (inclusive) to index end (exclusive) from builder sb; see
    delete(...).
 | 
| delete_alarm [Gc] | delete_alarm a will stop the calls to the function associated
   to a.
 | 
| delete_char_at [JavaStringBuilder] | |
| descr_of_in_channel [Unix] | 
Return the descriptor corresponding to an input channel.
 
 | 
| descr_of_out_channel [Unix] | 
Return the descriptor corresponding to an output channel.
 
 | 
| destroy [ThreadGroup] | 
Destroys the passed group and all its children groups; see
    destroy(...).
 
 | 
| destroy [JavaServlet.HTTP] | 
Called by the servlet container when the servlet is being taken out
      of service.
 
 | 
| destroy [JavaServlet.Generic] | 
Called by the servlet container when the servlet is being taken out
      of service.
 
 | 
| destroy [JavaServlet.Default_HTTP] | |
| destroy [JavaServlet.Default_Generic] | |
| destroy [JavaApplet.Graphics] | 
The implementation of the destroy(...) method.
 
 | 
| destroy [JavaApplet.Swing] | 
The implementation of the destroy(...) method.
 
 | 
| destroy [JavaApplet.AWT] | 
The implementation of the destroy(...) method.
 
 | 
| 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.
 | 
| dir_sep [Filename] | 
The directory separator (e.g.
 
 | 
| dirname [Filename] | 
See  
Filename.basename.
 | 
| discard_oldest_policy [RejectedExecutionHandler] | 
Discard the oldest unstarted computation; see
    java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy.
 
 | 
| discard_policy [RejectedExecutionHandler] | 
Discard the submitted computation; see
    java.util.concurrent.ThreadPoolExecutor.DiscardPolicy.
 
 | 
| 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_digit_nat [Nat] | |
| div_nat [Nat] | |
| div_num [Num] | 
Division
 
 | 
| do_delete [JavaServlet.HTTP] | do_delete v inst req resp handles the DELETE request req
      through the servlet instance inst (associated to value v).
 | 
| do_delete [JavaServlet.Default_HTTP] | |
| do_get [JavaServlet.HTTP] | do_get v inst req resp handles the GET request req through
      the servlet instance inst (associated to value v).
 | 
| do_get [JavaServlet.Default_HTTP] | |
| do_head [JavaServlet.HTTP] | do_head v inst req resp handles the HEAD request req
      through the servlet instance inst (associated to value v).
 | 
| do_head [JavaServlet.Default_HTTP] | |
| do_options [JavaServlet.HTTP] | do_options v inst req resp handles the OPTIONS request req
      through the servlet instance inst (associated to value v).
 | 
| do_post [JavaServlet.HTTP] | do_post v inst req resp handles the POST request req
      through the servlet instance inst (associated to value v).
 | 
| do_post [JavaServlet.Default_HTTP] | |
| do_put [JavaServlet.HTTP] | do_put v inst req resp handles the PUT request req through
      the servlet instance inst (associated to value v).
 | 
| do_put [JavaServlet.Default_HTTP] | |
| do_trace [JavaServlet.HTTP] | do_trace v inst req resp handles the TRACE request req
      through the servlet instance inst (associated to value v).
 | 
| do_trace [JavaServlet.Default_HTTP] | |
| domain_of_sockaddr [Unix] | 
Return the socket domain adequate for the given socket address.
 
 | 
| double_array_tag [Obj] | |
| double_field [Obj] | |
| double_tag [Obj] | |
| double_value [JavaShort] | 
Returns the wrapped value, as a double.
 
 | 
| double_value [JavaLong] | 
Returns the wrapped value, as a double.
 
 | 
| double_value [JavaInt] | 
Returns the wrapped value, as a double.
 
 | 
| double_value [JavaFloat] | 
Returns the wrapped value, as a double.
 
 | 
| double_value [JavaDouble] | 
Returns the wrapped value, as a double.
 
 | 
| double_value [JavaByte] | 
Returns the wrapped value, as a double.
 
 | 
| drain_permits [Semaphore] | 
Acquires and returns all available permits from the semaphore,
    returning immediately; see
    drainPermits(...).
 
 | 
| 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_class [CamlinternalOO] | |
| 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 [Unix] | 
Return a new file descriptor referencing the same file as
   the given descriptor.
 
 | 
| dup [Obj] | |
| 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 ic tests the end-of-input condition of the given
    formatted input channel.
 | 
| ends_with [JavaString] | |
| english [JavaLocale] | |
| ensure_capacity [JavaStringBuilder] | 
Ensures that the passed builder is at least equal to the passed
    value; see ensureCapacity(...).
 
 | 
| enumerate_groups [ThreadGroup] | 
Enumerates (recursively by default) the groups in the group by
    storing them in the passed array, and returning the number of
    actually stored groups; see
    enumerate(...).
 
 | 
| enumerate_threads [ThreadGroup] | 
Enumerates (recursively by default) the threads in the group by
    storing them in the passed array, and returning the number of
    actually stored threads; see
    enumerate(...).
 
 | 
| 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 [JavaStringPrintf] | 
This function can be passed to  
Printf.eprintf to print a Java
    string through a "%a" conversion specification.
 | 
| eprintf [JavaStringFormat] | 
This function can be passed to  
Format.eprintf to print a Java
    string through a "%a" conversion specification.
 | 
| eprintf [Format] | 
Same as  
fprintf above, but output on err_formatter.
 | 
| epsilon_float [Pervasives] | 
The difference between  
1.0 and the smallest exactly representable
    floating-point number greater than 1.0.
 | 
| eq_big_int [Big_int] | |
| eq_nat [Nat] | |
| 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 [Java] | equal x y returns true if x and y designate the very same
    reference.
 | 
| equal [Hashtbl.SeededHashedType] | 
The equality predicate used to compare keys.
 
 | 
| equal [Hashtbl.HashedType] | 
The equality predicate used to compare keys.
 
 | 
| equals [JavaString] | 
Tests whether the passed strings are equal; see
    equals(...).
 
 | 
| equals [JavaShortArray] | |
| equals [JavaReferenceArray] | |
| equals [JavaObject] | |
| equals [JavaLongArray] | |
| equals [JavaIntArray] | |
| equals [JavaFloatArray] | |
| equals [JavaDoubleArray] | |
| equals [JavaCharArray] | |
| equals [JavaByteArray] | |
| equals [JavaBooleanArray] | |
| equals [JavaArraySignature.T] | |
| equals_ignore_case [JavaString] | 
Similar to  
JavaString.equals, but ignoring case when comparing strings; see
    equalsIgnoreCase(...).
 | 
| err_formatter [Format] | 
A formatter to use with formatting functions below for
   output to standard error.
 
 | 
| error_message [Unix] | 
Return a string describing the given error code.
 
 | 
| error_message [Dynlink] | 
Convert an error description to a printable message.
 
 | 
| error_when_null_denominator_flag [Arith_flags] | |
| escaped [StringLabels] | 
Return a copy of the argument, with special characters
   represented by escape sequences, following the lexical
   conventions of OCaml.
 
 | 
| escaped [String] | 
Return a copy of the argument, with special characters
   represented by escape sequences, following the lexical
   conventions of OCaml.
 
 | 
| escaped [StdLabels.String] | |
| escaped [JavaString.OCaml] | 
Similar to  
String.escaped.
 | 
| escaped [Char] | 
Return a string representing the given character,
   with special characters escaped following the lexical conventions
   of OCaml.
 
 | 
| establish_server [Unix] | 
Establish a server on the given address.
 
 | 
| exchange [Exchanger] | 
Waits for another thread to arrive at the same exchange point, and
    then swaps the values provided by the two threads; see
    exchange(...).
 
 | 
| exchange_time [Exchanger] | exchange_time e x t u is similar to exchange e x, except that the
    current thread will at most wait for t (time value whose unit is
    u); see
    exchange(...).
 | 
| exec [Java] | 
Similar to  
Java.call, but ignores the result if any.
 | 
| executable_name [Sys] | 
The name of the file containing the executable currently running.
 
 | 
| execv [Unix] | execv prog args execute the program in file prog, with
   the arguments args, and the current process environment.
 | 
| execve [Unix] | 
Same as  
Unix.execv, except that the third argument provides the
   environment to the program executed.
 | 
| execvp [Unix] | 
Same as  
Unix.execv, except that
   the program is searched in the path.
 | 
| execvpe [Unix] | 
Same as  
Unix.execve, except that
   the program is searched in the path.
 | 
| exists [StdLabels.List] | |
| exists [Set.S] | exists p s checks if at least one element of
       the set satisfies the predicate p.
 | 
| exists [ParallelArray.S] | |
| exists [ParallelArray] | exists ~pool ~chunk_size f a returns true iff there is an element
    e of a such that f e = true.
 | 
| exists [MoreLabels.Set.S] | |
| exists [MoreLabels.Map.S] | |
| exists [Map.S] | exists p m checks if at least one binding of the map
        satisfy the predicate p.
 | 
| 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 [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.
 
 | 
| expm1 [Pervasives] | expm1 x computes exp x -. 1.0, giving numerically-accurate results
    even if x is close to 0.0.
 | 
| extract_big_int [Big_int] | extract_big_int bi ofs n returns a nonnegative number
            corresponding to bits ofs to ofs + n - 1 of the
            binary representation of bi.
 | 
F  | |
| failwith [Pervasives] | 
Raise exception  
Failure with the given string.
 | 
| false_ [JavaBoolean] | 
The constant for the wrapper around the  
false value.
 | 
| fast_sort [StdLabels.List] | |
| fast_sort [StdLabels.Array] | |
| fast_sort [ParallelArray.S] | |
| fast_sort [ParallelArray] | 
Synonym for  
ParallelArray.sort.
 | 
| 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 [Unix] | 
Change the permissions 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 len characters by c, starting at start.
 | 
| fill [StdLabels.String] | |
| fill [StdLabels.Array] | |
| fill [ParallelArray.S] | |
| fill [ParallelArray] | 
Synonym for  
Array.fill.
 | 
| fill [JavaShortArray] | fill a ofs len x sets len elements of a to x, starting at
    offset ofs.
 | 
| fill [JavaLongArray] | fill a ofs len x sets len elements of a to x, starting at
    offset ofs.
 | 
| fill [JavaIntArray] | fill a ofs len x sets len elements of a to x, starting at
    offset ofs.
 | 
| fill [JavaFloatArray] | fill a ofs len x sets len elements of a to x, starting at
    offset ofs.
 | 
| fill [JavaDoubleArray] | fill a ofs len x sets len elements of a to x, starting at
    offset ofs.
 | 
| fill [JavaCharArray] | fill a ofs len x sets len elements of a to x, starting at
    offset ofs.
 | 
| fill [JavaByteArray] | fill a ofs len x sets len elements of a to x, starting at
    offset ofs.
 | 
| fill [JavaBooleanArray] | fill a ofs len x sets len elements of a to x, starting at
    offset ofs.
 | 
| fill [JavaArraySignature.T] | |
| 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 [MoreLabels.Map.S] | |
| filter [Map.S] | filter p m returns the map with all the bindings in m
        that satisfy predicate p.
 | 
| 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 [Set.S] | find x s returns the element of s equal to x (according
        to Ord.compare), or raise Not_found if no such element
        exists.
 | 
| find [ParallelArray.S] | |
| find [ParallelArray] | find ~pool ~chunk_size f a returns an element e of a such that
    f e = true, raising Not_found if there is no such element in a.
 | 
| find [MoreLabels.Set.S] | |
| find [MoreLabels.Map.S] | |
| find [MoreLabels.Hashtbl.SeededS] | |
| 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.SeededS] | |
| find [Hashtbl.S] | |
| find [Hashtbl] | Hashtbl.find tbl x returns the current binding of x in tbl,
   or raises Not_found if no such binding exists.
 | 
| find_all [Weak.S] | find_all t x returns a list of all the instances of x
        found in t.
 | 
| find_all [StdLabels.List] | |
| find_all [ParallelArray.S] | |
| find_all [ParallelArray] | find_all ~pool ~chunk_size f a returns all the elements of a that
    return true when applied to f, preserving the order of the
    elements in a.
 | 
| find_all [MoreLabels.Hashtbl.SeededS] | |
| 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.SeededS] | |
| find_all [Hashtbl.S] | |
| find_all [Hashtbl] | Hashtbl.find_all tbl x returns the list of all data
   associated with x in tbl.
 | 
| find_index [ParallelArray.S] | |
| find_index [ParallelArray] | 
Similar to  
ParallelArray.find, except that the index is returned.
 | 
| first_chars [Str] | first_chars s n returns the first n characters of s.
 | 
| flatten [StdLabels.List] | |
| flatten [ListLabels] | 
Same as  
concat.
 | 
| flatten [List] | 
Same as  
concat.
 | 
| float [Random.State] | |
| float [Random] | Random.float bound returns a random floating-point number
   between 0 and bound (inclusive).
 | 
| 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_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_nat [Nat] | |
| float_of_num [Num] | |
| float_of_string [Pervasives] | 
Convert the given string to a float.
 
 | 
| float_value [JavaShort] | 
Returns the wrapped value, as a float.
 
 | 
| float_value [JavaLong] | 
Returns the wrapped value, as a float.
 
 | 
| float_value [JavaInt] | 
Returns the wrapped value, as a float.
 
 | 
| float_value [JavaFloat] | 
Returns the wrapped value, as a float.
 
 | 
| float_value [JavaDouble] | 
Returns the wrapped value, as a float.
 
 | 
| float_value [JavaByte] | 
Returns the wrapped value, as a float.
 
 | 
| floating_precision [Arith_flags] | |
| floor [Pervasives] | 
Round below 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.SeededS] | |
| 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 [Java] | fold desc f z it computes (f ... ((f z it0) it1) ... itn) where
    iti values are successively returned by it, and casted to desc
    before they are passed to f.
 | 
| fold [Hashtbl.SeededS] | |
| fold [Hashtbl.S] | |
| fold [Hashtbl] | Hashtbl.fold f tbl init computes
   (f kN dN ... (f k1 d1 init)...),
   where k1 ... kN are the keys of all bindings in tbl,
   and d1 ... dN are the associated values.
 | 
| fold_left [StdLabels.List] | |
| fold_left [StdLabels.Array] | |
| fold_left [ParallelArray.S] | |
| fold_left [ParallelArray] | 
Similar to  
Array.fold_left, except that computations are done in
    parallel; pool indicates the thread pool to use (defaulting to
    default_pool), while chunk_size indicates the size of each chunk
    to be allocated to a thread.
 | 
| 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 [JavaShortArray] | fold_left f z a returns f (... (f (f z a_0) a_1)) where a_i is
    the element of a at index i.
 | 
| fold_left [JavaReferenceArray] | fold_left f z a returns f (... (f (f z a_0) a_1)) where a_i is
    the element of a at index i.
 | 
| fold_left [JavaLongArray] | fold_left f z a returns f (... (f (f z a_0) a_1)) where a_i is
    the element of a at index i.
 | 
| fold_left [JavaIntArray] | fold_left f z a returns f (... (f (f z a_0) a_1)) where a_i is
    the element of a at index i.
 | 
| fold_left [JavaFloatArray] | fold_left f z a returns f (... (f (f z a_0) a_1)) where a_i is
    the element of a at index i.
 | 
| fold_left [JavaDoubleArray] | fold_left f z a returns f (... (f (f z a_0) a_1)) where a_i is
    the element of a at index i.
 | 
| fold_left [JavaCharArray] | fold_left f z a returns f (... (f (f z a_0) a_1)) where a_i is
    the element of a at index i.
 | 
| fold_left [JavaByteArray] | fold_left f z a returns f (... (f (f z a_0) a_1)) where a_i is
    the element of a at index i.
 | 
| fold_left [JavaBooleanArray] | fold_left f z a returns f (... (f (f z a_0) a_1)) where a_i is
    the element of a at index i.
 | 
| fold_left [JavaArraySignature.T] | |
| 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 [ParallelArray.S] | |
| fold_right [ParallelArray] | 
Similar to  
Array.fold_right, except that computations are done in
    parallel; pool indicates the thread pool to use (defaulting to
    default_pool), while chunk_size indicates the size of each chunk
    to be allocated to a thread.
 | 
| 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 [JavaShortArray] | fold_right f a z returns f a_0 (f a_1 (f ... z)) where a_i is
    the element of a at index i.
 | 
| fold_right [JavaReferenceArray] | fold_right f a z returns f a_0 (f a_1 (f ... z)) where a_i is
    the element of a at index i.
 | 
| fold_right [JavaLongArray] | fold_right f a z returns f a_0 (f a_1 (f ... z)) where a_i is
    the element of a at index i.
 | 
| fold_right [JavaIntArray] | fold_right f a z returns f a_0 (f a_1 (f ... z)) where a_i is
    the element of a at index i.
 | 
| fold_right [JavaFloatArray] | fold_right f a z returns f a_0 (f a_1 (f ... z)) where a_i is
    the element of a at index i.
 | 
| fold_right [JavaDoubleArray] | fold_right f a z returns f a_0 (f a_1 (f ... z)) where a_i is
    the element of a at index i.
 | 
| fold_right [JavaCharArray] | fold_right f a z returns f a_0 (f a_1 (f ... z)) where a_i is
    the element of a at index i.
 | 
| fold_right [JavaByteArray] | fold_right f a z returns f a_0 (f a_1 (f ... z)) where a_i is
    the element of a at index i.
 | 
| fold_right [JavaBooleanArray] | fold_right f a z returns f a_0 (f a_1 (f ... z)) where a_i is
    the element of a at index i.
 | 
| fold_right [JavaArraySignature.T] | |
| 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 [ParallelArray.S] | |
| for_all [ParallelArray] | for_all ~pool ~chunk_size f a returns true iff there is no element
    e of a such that f e = false.
 | 
| for_all [MoreLabels.Set.S] | |
| for_all [MoreLabels.Map.S] | |
| for_all [Map.S] | for_all p m checks if all the bindings of the map
        satisfy the predicate p.
 | 
| 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] | force x forces the suspension x and returns its result.
 | 
| force [CamlinternalLazy] | |
| force_lazy_block [CamlinternalLazy] | |
| force_newline [Format] | 
Forces a newline in the current box.
 
 | 
| force_termination [Phaser] | 
Forces termination of the phaser, includind children phasers; see
    forceTermination(...).
 
 | 
| force_val [Lazy] | force_val x forces the suspension x and returns its
    result.
 | 
| force_val [CamlinternalLazy] | |
| force_val_lazy_block [CamlinternalLazy] | |
| foreground [Graphics] | 
Default background and foreground colors (usually, either black
   foreground on a white background or white foreground on a
   black background).
 
 | 
| fork [Unix] | 
Fork a new process.
 
 | 
| format_from_string [Scanf] | format_from_string s fmt converts a string argument to a format string,
    according to the given format string fmt.
 | 
| format_of_string [Pervasives] | format_of_string s returns a format string read from the string
    literal s.
 | 
| formatter_of_buffer [Format] | formatter_of_buffer b returns a new formatter writing to
   buffer b.
 | 
| formatter_of_out_channel [Format] | formatter_of_out_channel oc returns a new formatter that
   writes to the corresponding channel oc.
 | 
| fortran_layout [Bigarray] | |
| forward_tag [Obj] | |
| fprintf [Printf] | fprintf outchan format arg1 ... argN formats the arguments
   arg1 to argN according to the format string format, and
   outputs the resulting string on the channel outchan.
 | 
| fprintf [JavaStringPrintf] | 
This function can be passed to  
Printf.fprintf to print a Java
    string through a "%a" conversion specification.
 | 
| fprintf [JavaStringFormat] | 
This function can be passed to  
Format.fprintf to print a Java
    string through a "%a" conversion specification.
 | 
| fprintf [Format] | |
| france [JavaLocale] | |
| free_memory [JavaRuntime] | 
Returns the amount of free memory in the JVM (in bytes); see
    freeMemory(...).
 
 | 
| french [JavaLocale] | |
| frexp [Pervasives] | frexp f returns the pair of the significant
   and the exponent of f.
 | 
| from [Stream] | Stream.from f returns a stream built from the function f.
 | 
| from_channel [Scanf.Scanning] | Scanning.from_channel ic returns a formatted input channel which reads
    from the regular input channel ic argument, starting at the current
    reading position.
 | 
| from_channel [Marshal] | Marshal.from_channel chan reads from channel chan the
   byte representation of a structured value, as produced by
   one of the Marshal.to_* functions, and reconstructs and
   returns the corresponding value.
 | 
| from_channel [Lexing] | 
Create a lexer buffer on the given input channel.
 
 | 
| from_file [Scanf.Scanning] | 
An alias for  
open_in above.
 | 
| from_file_bin [Scanf.Scanning] | 
An alias for  
open_in_bin above.
 | 
| from_fun [Lazy] | from_fun f is the same as lazy (f ()) but slightly more efficient.
 | 
| from_function [Scanf.Scanning] | Scanning.from_function f returns a formatted input channel with the
    given function as its reading method.
 | 
| from_function [Lexing] | 
Create a lexer buffer with the given function as its reading method.
 
 | 
| from_hex [Digest] | 
Convert a hexadecimal representation back into the corresponding digest.
 
 | 
| from_string [Scanf.Scanning] | Scanning.from_string s returns a formatted input channel which reads
    from the given string.
 | 
| from_string [Marshal] | Marshal.from_string buff ofs unmarshals a structured value
   like Marshal.from_channel does, except that the byte
   representation is not read from a channel, but taken from
   the string buff, starting at position ofs.
 | 
| from_string [Lexing] | 
Create a lexer buffer which reads from
   the given string.
 
 | 
| from_val [Lazy] | from_val v returns an already-forced suspension of v.
 | 
| fscanf [Scanf] | 
Same as  
Scanf.bscanf, but reads from the given regular input channel.
 | 
| fst [Pervasives] | 
Return the first component of a pair.
 
 | 
| fstat [Unix.LargeFile] | |
| fstat [Unix] | 
Return the information for the file associated with the given
   descriptor.
 
 | 
| ftruncate [Unix.LargeFile] | |
| 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] | 
Do a minor collection, finish the current major collection cycle,
   and perform a complete new cycle.
 
 | 
| full_split [Str] | 
Same as  
Str.split_delim, but returns
   the delimiters as well as the substrings contained between
   delimiters.
 | 
G  | |
| gc [JavaSystem] | 
Runs the garbage collector; see gc(...).
 
 | 
| gcd_big_int [Big_int] | 
Greatest common divisor of two big integers.
 
 | 
| gcd_int [Int_misc] | |
| gcd_nat [Nat] | |
| ge_big_int [Big_int] | |
| ge_nat [Nat] | |
| 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.
 
 | 
| german [JavaLocale] | |
| germany [JavaLocale] | |
| 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 [ThreadLocal] | 
Returns the value of the thread-local variable for the current
    thread; see get(...).
 
 | 
| 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 [ScheduledFuture] | 
Same as  
Future.get.
 | 
| get [ParallelArray.S] | |
| get [ParallelArray] | 
Synonym for  
Array.get.
 | 
| get [JavaString.OCaml] | 
Similar to  
String.get.
 | 
| get [JavaShortArray] | get a i returns the element at index i in a.
 | 
| get [JavaReferenceArray] | get a i returns the element at index i in a.
 | 
| get [JavaLongArray] | get a i returns the element at index i in a.
 | 
| get [JavaIntArray] | get a i returns the element at index i in a.
 | 
| get [JavaFloatArray] | get a i returns the element at index i in a.
 | 
| get [JavaDoubleArray] | get a i returns the element at index i in a.
 | 
| get [JavaCharArray] | get a i returns the element at index i in a.
 | 
| get [JavaCalendar] | |
| get [JavaByteArray] | get a i returns the element at index i in a.
 | 
| get [JavaBooleanArray] | get a i returns the element at index i in a.
 | 
| get [JavaArraySignature.T] | |
| get [JavaArray] | get a i returns the element at index i in a.
 | 
| get [Java] | get desc obj retrieves the value of field desc for instance
    obj.
 | 
| get [Gc] | 
Return the current values of the GC parameters in a  
control record.
 | 
| get [Future] | 
Waits for the computation to complete, and returns its result; see
    get(...).
 
 | 
| 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 [AtomicStampedReference] | 
Returns the current value and stamp.
 
 | 
| get [AtomicReferenceArray] | 
Returns the value at passed index.
 
 | 
| get [AtomicReference] | 
Returns the current value.
 
 | 
| get [AtomicMarkableReference] | 
Returns the current value and mark.
 
 | 
| get [AtomicInt64Array] | 
Returns the value at passed index.
 
 | 
| get [AtomicInt64] | 
Returns the current value.
 
 | 
| get [AtomicInt32Array] | 
Returns the value at passed index.
 
 | 
| get [AtomicInt32] | 
Returns the current value.
 
 | 
| get [AtomicBool] | 
Returns the current value.
 
 | 
| 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_active_count [ThreadPoolExecutor] | 
Returns an estimate of the number of active threads in the pool; see
    getActiveCount(...).
 
 | 
| get_active_count [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.get_active_count.
 | 
| get_active_thread_count [ForkJoinPool] | 
Returns an estimate of the number of active threads in the pool; see
    getActiveThreadCount(...).
 
 | 
| get_all_formatter_output_functions [Format] | 
Deprecated.
 
 | 
| get_and_add [AtomicInt64Array] | get_and_add a i d atomically adds d to the value at index i,
    and returns the previous value.
 | 
| get_and_add [AtomicInt64] | get_and_add a d atomically adds d to the current value, and returns the previous value.
 | 
| get_and_add [AtomicInt32Array] | get_and_add a i d atomically adds d to the value at index i,
    and returns the previous value.
 | 
| get_and_add [AtomicInt32] | get_and_add a d atomically adds d to the current value, and returns the previous value.
 | 
| get_and_decrement [AtomicInt64Array] | 
Atomically decrements the value at passed index, and returns the
    previous value.
 
 | 
| get_and_decrement [AtomicInt64] | 
Atomically decrements the current value, and returns the previous value.
 
 | 
| get_and_decrement [AtomicInt32Array] | 
Atomically decrements the value at passed index, and returns the
    previous value.
 
 | 
| get_and_decrement [AtomicInt32] | 
Atomically decrements the current value, and returns the previous value.
 
 | 
| get_and_increment [AtomicInt64Array] | 
Atomically increments the value at passed index, and returns the
    previous value.
 
 | 
| get_and_increment [AtomicInt64] | 
Atomically increments the current value, and returns the previous value.
 
 | 
| get_and_increment [AtomicInt32Array] | 
Atomically increments the value at passed index, and returns the
    previous value.
 
 | 
| get_and_increment [AtomicInt32] | 
Atomically increments the current value, and returns the previous value.
 
 | 
| get_and_set [AtomicReferenceArray] | get_and_set a i x atomically sets the value of a at index i to
    x, and returns the previous value.
 | 
| get_and_set [AtomicReference] | get_and_set a x atomically sets the value of a to x, and
    returns the previous value.
 | 
| get_and_set [AtomicInt64Array] | get_and_set a i x atomically sets the value of a at index i to
    x, and returns the previous value.
 | 
| get_and_set [AtomicInt64] | get_and_set a x atomically sets the value of a to x, and
    returns the previous value.
 | 
| get_and_set [AtomicInt32Array] | get_and_set a i x atomically sets the value of a at index i to
    x, and returns the previous value.
 | 
| get_and_set [AtomicInt32] | get_and_set a x atomically sets the value of a to x, and
    returns the previous value.
 | 
| get_and_set [AtomicBool] | get_and_set a x atomically sets the value of a to x, and
    returns the previous value.
 | 
| get_approx_printing [Arith_status] | |
| get_arrived_parties [Phaser] | 
Returns the number of registered parties that have arrived to the
    phaser; see getArrivedParties(...).
 
 | 
| get_async_mode [ForkJoinPool] | 
Returns the asynchronous mode of the pool; see
    getAsyncMode(...).
 
 | 
| get_available_ids [JavaTimeZone] | 
Returns the list of all time zone identifiers.
 
 | 
| get_available_locales [JavaLocale] | 
Returns the list of all available locales.
 
 | 
| get_backtrace [Printexc] | Printexc.get_backtrace () returns a string containing the
    same exception backtrace that Printexc.print_backtrace would
    print.
 | 
| get_callstack [Printexc] | |
| get_cause [JavaThrowable] | 
Returns the case; see getCause(...).
 
 | 
| get_cause [JavaException] | 
Returns the case; see getCause(...).
 
 | 
| get_cause [JavaError] | 
Returns the case; see getCause(...).
 
 | 
| get_class [JavaObject] | |
| get_class [Java] | get_class desc returns the instance of java.lang.Class
    representing the passed type descriptor.
 | 
| get_completed_task_count [ThreadPoolExecutor] | 
Returns an estimate of the number of completed computations in the
    pool; see getCompletedTaskCount(...).
 
 | 
| get_completed_task_count [ScheduledThreadPoolExecutor] | |
| get_continue_existing_periodic_tasks_after_shutdown_policy [ScheduledThreadPoolExecutor] | 
Tests whether periodic tasks should continue execution after
    shutdown; see
    getContinueExistingPeriodicTasksAfterShutdownPolicy(...).
 
 | 
| 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_core_pool_size [ThreadPoolExecutor] | 
Returns the core size of the pool; see
    getCorePoolSize(...).
 
 | 
| get_core_pool_size [ScheduledThreadPoolExecutor] | |
| get_count [CountDownLatch] | 
Returns the current count; see
    getCount(...).
 
 | 
| get_country [JavaLocale] | 
Returns the country of the passed locale; see
    getCountry(...).
 
 | 
| get_default [JavaTimeZone] | 
Returns the default time zone.
 
 | 
| get_default [JavaLocale] | 
Returns the default locale.
 
 | 
| get_delay [ScheduledFuture] | 
Returns the remaining delay for the computation, in the passed time
    unit; see getDelay(...).
 
 | 
| get_display_country [JavaLocale] | 
Returns the country of the passed locale; see
    getDisplayCountry(...).
 
 | 
| get_display_language [JavaLocale] | 
Returns the language of the passed locale; see
    getDisplayLanguage(...).
 
 | 
| get_display_name [JavaTimeZone] | 
Returns the name for the passed time zone, as a long string; see
    getDisplayName(...).
 
 | 
| get_display_name [JavaLocale] | 
Returns the name of the passed locale; see
    getDisplayName(...).
 
 | 
| get_display_script [JavaLocale] | 
Returns the script of the passed locale; see
    getDisplayScript(...).
 
 | 
| get_display_variant [JavaLocale] | 
Returns the variant of the passed locale; see
    getDisplayVariant(...).
 
 | 
| get_ellipsis_text [Format] | 
Return the text of the ellipsis.
 
 | 
| get_env [JavaSystem] | get_env name returns the value of the environment variable named
    name if defined, null otherwise; see
    getenv(...).
 | 
| get_error_when_null_denominator [Arith_status] | |
| get_execute_existing_delayed_tasks_after_shutdown_policy [ScheduledThreadPoolExecutor] | 
Tests whether delayed tasks should continue execution after
    shutdown; see
    getExecuteExistingDelayedTasksAfterShutdownPolicy(...).
 
 | 
| get_floating_precision [Arith_status] | |
| get_formatter_out_functions [Format] | 
Return the current output functions of the pretty-printer,
   including line breaking and indentation functions.
 
 | 
| get_formatter_output_functions [Format] | 
Return the current output functions of the pretty-printer.
 
 | 
| get_formatter_tag_functions [Format] | 
Return the current tag functions of the pretty-printer.
 
 | 
| get_id [Thread] | 
Returns the thread identifier.
 
 | 
| get_id [JavaTimeZone] | 
Returns the identifier for the passed time zone; see
    getID(...).
 
 | 
| get_image [Graphics] | 
Capture the contents of a rectangle on the screen as an image.
 
 | 
| get_iso3_country [JavaLocale] | 
Returns the country of the passed locale; see
    getISO3Country(...).
 
 | 
| get_iso3_language [JavaLocale] | 
Returns the language of the passed locale; see
    getISO3Language(...).
 
 | 
| get_keep_alive_time [ThreadPoolExecutor] | 
Returns the keep alive time for thread outside of the core; see
    getKeepAliveTime(...).
 
 | 
| get_keep_alive_time [ScheduledThreadPoolExecutor] | |
| get_language [JavaLocale] | 
Returns the language of the passed locale; see
    getLanguage(...).
 
 | 
| get_largest_pool_size [ThreadPoolExecutor] | 
Returns the largest size reached by the pool; see
    getLargestPoolSize(...).
 
 | 
| get_largest_pool_size [ScheduledThreadPoolExecutor] | |
| get_last_modified [JavaServlet.HTTP] | get_last_modified v inst req handles the request req through
      the servlet instance inst (associated to value v), returning
      the time the underlying information was last modified (in
      milliseconds since 1970-01-01), or a negative value if the time
      is unknown.
 | 
| get_last_modified [JavaServlet.Default_HTTP] | |
| get_margin [Format] | 
Returns the position of the right margin.
 
 | 
| get_mark_tags [Format] | 
Return the current status of tags printing and tags marking.
 
 | 
| get_max_boxes [Format] | 
Returns the maximum number of boxes allowed before ellipsis.
 
 | 
| get_max_indent [Format] | 
Return the value of the maximum indentation limit (in characters).
 
 | 
| get_max_priority [ThreadGroup] | 
Returns the maximum priority of the group; see
    getMaxPriority(...).
 
 | 
| get_maximum_pool_size [ThreadPoolExecutor] | 
Returns the maximum size of the pool; see
    getMaximumPoolSize(...).
 
 | 
| get_maximum_pool_size [ScheduledThreadPoolExecutor] | |
| get_message [JavaThrowable] | 
Returns the message; see getMessage(...).
 
 | 
| get_message [JavaException] | 
Returns the message; see getMessage(...).
 
 | 
| get_message [JavaError] | 
Returns the message; see getMessage(...).
 
 | 
| get_method [CamlinternalOO] | |
| get_method_label [CamlinternalOO] | |
| get_method_labels [CamlinternalOO] | |
| get_name [ThreadGroup] | 
Returns the name of the group; see
    getName(...).
 
 | 
| get_name [Thread] | 
Returns the name of the thread; see
    getName(...).
 
 | 
| get_normalize_ratio [Arith_status] | |
| get_normalize_ratio_when_printing [Arith_status] | |
| get_number_waiting [CyclicBarrier] | 
Returns the number of threads currently waiting on the barrier; see
    getNumberWaiting(...).
 
 | 
| get_parallelism [ForkJoinPool] | 
Returns the parallelism of the pool; see
    getParallelism(...).
 
 | 
| get_parent [ThreadGroup] | 
Returns the parent of the group,  
null if no such group exists; see
    getParent(...).
 | 
| get_parent [Phaser] | 
Returns the parent of the phaser; see
    getParent(...).
 
 | 
| get_parties [CyclicBarrier] | 
Returns the number of threads to be waited on the barrier; see
    getParties(...).
 
 | 
| get_phase [Phaser] | 
Returns the phase number; see
    getPhase(...).
 
 | 
| get_pool_size [ThreadPoolExecutor] | 
Returns an estimate of the current pool size; see
    getPoolSize(...).
 
 | 
| get_pool_size [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.get_pool_size.
 | 
| get_pool_size [ForkJoinPool] | 
Returns the number of threads that have started and not terminated in
    the pool; see
    getPoolSize(...).
 
 | 
| get_print_tags [Format] | |
| get_priority [Thread] | 
Returns the priority of the thread; see
    getPriority(...).
 
 | 
| get_property [JavaSystem] | get_property name returns the value of the system property named
    name if defined, null otherwise; see
    getProperty(...).
 | 
| get_property [JavaProperties] | get_property props key returns the value of the property whose key
    is key in props if found, None otherwise; see
    getProperty(...).
 | 
| get_property_default [JavaSystem] | get_property_default name default returns the value of the system
    property named name if defined, default otherwise; see
    getProperty(...).
 | 
| get_property_default [JavaProperties] | get_property_default props key def returns the value of the
    property whose key is key in props if found, def otherwise; see
    getProperty(...).
 | 
| get_public_method [CamlinternalOO] | |
| get_queue_length [Semaphore] | 
Returns an estimate of the number of threads waiting on the semaphore
    to acquire permits; see
    getQueueLength(...).
 
 | 
| get_queued_submission_count [ForkJoinPool] | 
Returns an estimate of the number of tasks submitted (but unstarted)
    to the pool; see
    getQueuedSubmissionCount(...).
 
 | 
| get_queued_task_count [ForkJoinPool] | 
Returns an estimate of the number of tasks currently queued in the
    pool; see
    getQueuedTaskCount(...).
 
 | 
| get_raw_backtrace [Printexc] | |
| get_reference [AtomicStampedReference] | 
Returns the current value.
 
 | 
| get_reference [AtomicMarkableReference] | 
Returns the current value.
 
 | 
| get_registered_parties [Phaser] | 
Returns the number of registered parties; see
    getRegisteredParties(...).
 
 | 
| get_rejected_execution_handler [ThreadPoolExecutor] | 
Returns the policy for blocked computations; see
    getRejectedExecutionHandler(...).
 
 | 
| get_rejected_execution_handler [ScheduledThreadPoolExecutor] | |
| get_remove_on_cancel_policy [ScheduledThreadPoolExecutor] | 
Tests whether tasks should be removed when cancelled; see
    getRemoveOnCancelPolicy(...).
 
 | 
| get_root [Phaser] | 
Returns the root that can be reached from the phaser by recursively
    visiting parents.
 
 | 
| get_running_thread_count [ForkJoinPool] | 
Returns an estimate of the number of threads in the pool; see
    getRunningThreadCount(...).
 
 | 
| get_runtime [JavaRuntime] | 
Returns the runtime for the current Java application; see
    getRuntime(...).
 
 | 
| get_script [JavaLocale] | 
Returns the script of the passed locale; see
    getScript(...).
 
 | 
| get_stack_trace [JavaThrowable] | 
Returns the stack trace; see getStackTrace(...).
 
 | 
| get_stack_trace [JavaException] | 
Returns the stack trace; see getStackTrace(...).
 
 | 
| get_stack_trace [JavaError] | 
Returns the stack trace; see getStackTrace(...).
 
 | 
| get_stamp [AtomicStampedReference] | 
Returns the current stamp.
 
 | 
| get_state [Thread] | 
Returns the state of the thread; see
    getState(...).
 
 | 
| get_state [Random] | 
Return the current state of the generator used by the basic functions.
 
 | 
| get_steal_count [ForkJoinPool] | 
Returns an estimate of the number of tasks stolen from one thread by
    another one in the pool; see
    getStealCount(...).
 
 | 
| get_task_count [ThreadPoolExecutor] | 
Returns an estimate of number of task that have been submitted for
    execution; see getTaskCount(...).
 
 | 
| get_task_count [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.get_task_count.
 | 
| get_temp_dir_name [Filename] | 
The name of the temporary directory:
    Under Unix, the value of the  
TMPDIR environment variable, or "/tmp"
    if the variable is not set.
 | 
| get_thread_group [Thread] | 
Returns the group of the thread,  
None if the thread has terminated
    its execution; see getThreadGroup(...).
 | 
| get_time [ScheduledFuture] | 
Same as  
Future.get_time.
 | 
| get_time [JavaDate] | get_time date returns the time of the passed date, as the number of
    milliseconds since 1970-01-01 00:00:00; see
    getTime(...).
 | 
| get_time [JavaCalendar] | get_time cal returns the time of the passed calendar, as the number
    of milliseconds since 1970-01-01 00:00:00; see
    getTimeInMillis(...).
 | 
| get_time [Future] | get_time f t u is similar to get f, except that the current
    thread will at most wait for t (time value whose unit is u); see
    get(...).
 | 
| get_time_zone [JavaCalendar] | 
Returns the time zone for the passed calendar; see
    getTimeZone(...).
 
 | 
| get_unarrived_parties [Phaser] | 
Returns the number of registered parties that have not yet arrived to
    the phaser; see
    getUnarrivedParties(...).
 
 | 
| get_variable [CamlinternalOO] | |
| get_variables [CamlinternalOO] | |
| get_variant [JavaLocale] | 
Returns the variant of the passed locale; see
    getVariant(...).
 
 | 
| getaddrinfo [Unix] | getaddrinfo host service opts returns a list of Unix.addr_info
    records describing socket parameters and addresses suitable for
    communicating with the given host and service.
 | 
| getcwd [Unix] | 
Return the name of the current working directory.
 
 | 
| getcwd [Sys] | 
Return the current working directory of the process.
 
 | 
| getegid [Unix] | 
Return the effective group id under which the process runs.
 
 | 
| 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 [Unix] | 
Return the effective user id under which the process runs.
 
 | 
| getgid [Unix] | 
Return the group id of the user executing the process.
 
 | 
| getgrgid [Unix] | 
Find an entry in  
group with the given group id, or raise
   Not_found.
 | 
| getgrnam [Unix] | 
Find an entry in  
group with the given name, or raise
   Not_found.
 | 
| getgroups [Unix] | 
Return the list of groups to which the user executing the process
   belongs.
 
 | 
| gethostbyaddr [Unix] | 
Find an entry in  
hosts with the given address, or raise
   Not_found.
 | 
| gethostbyname [Unix] | 
Find an entry in  
hosts with the given name, or raise
   Not_found.
 | 
| gethostname [Unix] | 
Return the name of the local host.
 
 | 
| getitimer [Unix] | 
Return the current status of the given interval timer.
 
 | 
| getlogin [Unix] | 
Return the login name of the user executing the process.
 
 | 
| getnameinfo [Unix] | getnameinfo addr opts returns the host name and service name
    corresponding to the socket address addr.
 | 
| getpeername [Unix] | 
Return the address of the host connected to the given socket.
 
 | 
| getpid [Unix] | 
Return the pid of the process.
 
 | 
| getppid [Unix] | 
Return the pid of the parent process.
 
 | 
| getprotobyname [Unix] | 
Find an entry in  
protocols with the given name, or raise
   Not_found.
 | 
| getprotobynumber [Unix] | 
Find an entry in  
protocols with the given protocol number,
   or raise Not_found.
 | 
| getpwnam [Unix] | 
Find an entry in  
passwd with the given name, or raise
   Not_found.
 | 
| getpwuid [Unix] | 
Find an entry in  
passwd with the given user id, or raise
   Not_found.
 | 
| getservbyname [Unix] | 
Find an entry in  
services with the given name, or raise
   Not_found.
 | 
| getservbyport [Unix] | 
Find an entry in  
services with the given service number,
   or raise Not_found.
 | 
| getsockname [Unix] | 
Return the address of the given socket.
 
 | 
| getsockopt [Unix] | 
Return the current status of a boolean-valued option
   in the given socket.
 
 | 
| getsockopt_error [Unix] | 
Return the error condition associated with the given socket,
    and clear it.
 
 | 
| getsockopt_float [Unix] | 
Same as  
Unix.getsockopt for a socket option whose value is a
   floating-point number.
 | 
| getsockopt_int [Unix] | 
Same as  
Unix.getsockopt for an integer-valued socket option.
 | 
| getsockopt_optint [Unix] | 
Same as  
Unix.getsockopt for a socket option whose value is an
   int option.
 | 
| gettimeofday [Unix] | 
Same as  
Unix.time, but with resolution better than 1 second.
 | 
| 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 [Unix] | 
Convert a time in seconds, as returned by  
Unix.time, into a date and
   a time.
 | 
| green [Graphics] | |
| group_beginning [Str] | group_beginning n returns the position of the first character
   of the substring that was matched by the nth group of
   the regular expression that was matched by the last call to a
   matching or searching function (see Str.matched_string for details).
 | 
| group_end [Str] | group_end n returns
   the position of the character following the last character of
   substring that was matched by the nth group of the regular
   expression that was matched by the last call to a matching or
   searching function (see Str.matched_string for details).
 | 
| gt_big_int [Big_int] | 
Usual boolean comparisons between two big integers.
 
 | 
| gt_nat [Nat] | |
| gt_num [Num] | |
H  | |
| handle_unix_error [Unix] | handle_unix_error f x applies f to x and returns the result.
 | 
| has_queued_submissions [ForkJoinPool] | 
Tests whether there are submitted but unstarted tasks in the pool; see
    hasQueuedSubmissions(...).
 
 | 
| has_queued_threads [Semaphore] | 
Tests whether there are threads waiting on the semaphore to acquire
    permits; see
    hasQueuedThreads(...).
 
 | 
| hash [MoreLabels.Hashtbl] | |
| hash [Hashtbl.SeededHashedType] | 
A seeded hashing function on keys.
 
 | 
| hash [Hashtbl.HashedType] | 
A hashing function on keys.
 
 | 
| hash [Hashtbl] | Hashtbl.hash x associates a nonnegative integer to any value of
   any type.
 | 
| hash_code [JavaShortArray] | |
| hash_code [JavaReferenceArray] | |
| hash_code [JavaObject] | |
| hash_code [JavaLongArray] | |
| hash_code [JavaIntArray] | |
| hash_code [JavaFloatArray] | |
| hash_code [JavaDoubleArray] | |
| hash_code [JavaCharArray] | |
| hash_code [JavaByteArray] | |
| hash_code [JavaBooleanArray] | |
| hash_code [JavaArraySignature.T] | |
| hash_param [MoreLabels.Hashtbl] | |
| hash_param [Hashtbl] | Hashtbl.hash_param meaningful total 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.
 
 | 
| hours [TimeUnit] | 
Time unit for hours.
 
 | 
| hypot [Pervasives] | hypot x y returns sqrt(x *. x + y *. y), that is, the length
  of the hypotenuse of a right-angled triangle with sides of length
  x and y, or, equivalently, the distance of the point (x,y)
  to origin.
 | 
I  | |
| i [Complex] | 
The complex number  
i.
 | 
| id [Oo] | 
Return an integer identifying this object, unique for
    the current execution of the program.
 
 | 
| ifprintf [Printf] | 
Same as  
Printf.fprintf, but does not print anything.
 | 
| ifprintf [JavaStringPrintf] | 
This function can be passed to  
Printf.ifprintf to print a Java
    string through a "%a" conversion specification.
 | 
| ifprintf [JavaStringFormat] | 
This function can be passed to  
Format.ifprintf to print a Java
    string through a "%a" conversion specification.
 | 
| ifprintf [Format] | 
Same as  
fprintf above, but does not print anything.
 | 
| ignore [Pervasives] | 
Discard the value of its argument and return  
().
 | 
| ikfprintf [Printf] | 
Same as  
kfprintf above, but does not print anything.
 | 
| ikfprintf [JavaStringPrintf] | 
This function can be passed to  
Printf.ikfprintf to print a Java
    string through a "%a" conversion specification.
 | 
| ikfprintf [JavaStringFormat] | 
This function can be passed to  
Format.ikfprintf to print a Java
    string through a "%a" conversion specification.
 | 
| ikfprintf [Format] | 
Same as  
kfprintf above, but does not print anything.
 | 
| in_channel_length [Pervasives.LargeFile] | |
| in_channel_length [Pervasives] | 
Return the size (number of characters) of the regular file
    on which the given channel is opened.
 
 | 
| in_channel_of_descr [Unix] | 
Create an input channel reading from the given descriptor.
 
 | 
| in_channel_of_input_stream [JavaIOStreams] | in_channel_of_input_stream is converts the input stream is into a
    new input channel.
 | 
| incr [Pervasives] | 
Increment the integer contained in the given reference.
 
 | 
| incr_nat [Nat] | |
| incr_num [Num] | incr r is r:=!r+1, where r is a reference to a number.
 | 
| increment_and_get [AtomicInt64Array] | 
Atomically increments the value at passed index, and returns the new
    value.
 
 | 
| increment_and_get [AtomicInt64] | 
Atomically increments the current value, and returns the new value.
 
 | 
| increment_and_get [AtomicInt32Array] | 
Atomically increments the value at passed index, and returns the new
    value.
 
 | 
| increment_and_get [AtomicInt32] | 
Atomically increments the current value, and returns the new value.
 
 | 
| 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 character number of the first
   occurrence of character c in string s.
 | 
| index [StdLabels.String] | |
| index [JavaString.OCaml] | 
Similar to  
String.index.
 | 
| index_from [StringLabels] | 
Same as  
StringLabels.index, but start
   searching at the character position given as second argument.
 | 
| index_from [String] | String.index_from s i c returns the character number of the
   first occurrence of character c in string s after position i.
 | 
| index_from [StdLabels.String] | |
| index_from [JavaString.OCaml] | 
Similar to  
String.index_from.
 | 
| index_of [JavaStringBuilder] | 
Returns the index within the passed builder of the first occurrence
    of the passed string; see
    indexOf(...).
 
 | 
| index_of [JavaString] | index_of s sub returns the index of the first occurrence of sub
    in s if any, -1l otherwise; see
    indexOf(...).
 | 
| index_of_from [JavaStringBuilder] | 
Returns the index within the passed builder of the first occurrence
    of the passed string, starting at the passed index; see
    indexOf(...).
 
 | 
| inet6_addr_any [Unix] | 
A special IPv6 address, for use only with  
bind, representing
   all the Internet addresses that the host machine possesses.
 | 
| inet6_addr_loopback [Unix] | 
A special IPv6 address representing the host machine ( 
::1).
 | 
| inet_addr_any [Unix] | 
A special IPv4 address, for use only with  
bind, representing
   all the Internet addresses that the host machine possesses.
 | 
| inet_addr_loopback [Unix] | 
A special IPv4 address representing the host machine ( 
127.0.0.1).
 | 
| inet_addr_of_string [Unix] | 
Conversion from the printable representation of an Internet
    address to its internal representation.
 
 | 
| infinity [Pervasives] | 
Positive infinity.
 
 | 
| infix_tag [Obj] | |
| inherits [CamlinternalOO] | |
| init [StdLabels.Array] | |
| init [Random] | 
Initialize the generator, using the argument as a seed.
 
 | 
| init [ParallelArray.S] | |
| init [ParallelArray] | 
Similar to  
Array.init, except that computations are done in
    parallel; pool indicates the thread pool to use (defaulting to
    default_pool), while chunk_size indicates the size of each chunk
    to be allocated to a thread.
 | 
| init [JavaShortArray] | init len f creates and returns an array of len elements.
 | 
| init [JavaServlet.HTTP] | 
Initializes a new servlet by returning its value (the function is
      executed by init(...)).
 
 | 
| init [JavaServlet.Generic] | 
Initializes a new servlet by returning its value (the function is
      executed by init(...)).
 
 | 
| init [JavaLongArray] | init len f creates and returns an array of len elements.
 | 
| init [JavaIntArray] | init len f creates and returns an array of len elements.
 | 
| init [JavaFloatArray] | init len f creates and returns an array of len elements.
 | 
| init [JavaDoubleArray] | init len f creates and returns an array of len elements.
 | 
| init [JavaCharArray] | init len f creates and returns an array of len elements.
 | 
| init [JavaByteArray] | init len f creates and returns an array of len elements.
 | 
| init [JavaBooleanArray] | init len f creates and returns an array of len elements.
 | 
| init [JavaArraySignature.T] | |
| init [JavaApplet.Graphics] | 
The implementation of the init(...) method.
 
 | 
| init [JavaApplet.Swing] | 
The implementation of the init(...) method.
 
 | 
| init [JavaApplet.AWT] | 
The implementation of the init(...) method.
 
 | 
| init [Dynlink] | |
| init [ArrayLabels] | Array.init n f returns a fresh array of length n,
   with element number i initialized to the result of f i.
 | 
| init [Array] | Array.init n f returns a fresh array of length n,
   with element number i initialized to the result of f i.
 | 
| init_class [CamlinternalOO] | |
| init_mod [CamlinternalMod] | |
| initgroups [Unix] | initgroups user group initializes the group access list by
      reading the group database /etc/group and using all groups of
      which user is a member.
 | 
| input [Pervasives] | input ic buf pos len reads up to len characters from
   the given channel ic, storing them in string buf, starting at
   character number pos.
 | 
| input [Digest] | 
Read a digest from the given input channel.
 
 | 
| input_binary_int [Pervasives] | 
Read an integer encoded in binary format (4 bytes, big-endian)
   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_line [JavaString] | input_line ch reads a line from channel ch.
 | 
| input_stream_of_in_channel [JavaIOStreams] | input_stream_of_in_channel ic converts the input channel ic into
    a new input stream.
 | 
| input_value [Pervasives] | 
Read the representation of a structured value, as produced
   by  
Pervasives.output_value, and return the corresponding value.
 | 
| insert_boolean [JavaStringBuilder] | 
Inserts the passed boolean into the passed builder at the specified
    index; see insert(...).
 
 | 
| insert_char [JavaStringBuilder] | 
Inserts the passed character into the passed builder at the specified
    index; see insert(...).
 
 | 
| insert_double [JavaStringBuilder] | 
Inserts the passed double into the passed builder at the specified
    index; see insert(...).
 
 | 
| insert_float [JavaStringBuilder] | 
Inserts the passed float into the passed builder at the specified
    index; see insert(...).
 
 | 
| insert_int [JavaStringBuilder] | 
Inserts the passed integer into the passed builder at the specified
    index; see insert(...).
 
 | 
| insert_long [JavaStringBuilder] | 
Inserts the passed long into the passed builder at the specified
    index; see insert(...).
 
 | 
| insert_string [JavaStringBuilder] | 
Inserts the passed string into the passed builder at the specified
    index; see insert(...).
 
 | 
| instanceof [Java] | instanceof desc x returns true if x is an instance of desc.
 | 
| int [Random.State] | |
| 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 [Random.State] | |
| int32 [Random] | Random.int32 bound returns a random integer between 0 (inclusive)
     and bound (exclusive).
 | 
| int32 [Bigarray] | 
See  
Bigarray.char.
 | 
| int32_of_big_int [Big_int] | 
Convert a big integer to a 32-bit integer.
 
 | 
| int64 [Random.State] | |
| int64 [Random] | Random.int64 bound returns a random integer between 0 (inclusive)
     and bound (exclusive).
 | 
| int64 [Bigarray] | 
See  
Bigarray.char.
 | 
| int64_of_big_int [Big_int] | 
Convert a big integer to a 64-bit integer.
 
 | 
| 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_nat [Nat] | |
| int_of_num [Num] | |
| int_of_string [Pervasives] | 
Convert the given string to an integer.
 
 | 
| int_tag [Obj] | |
| int_value [JavaShort] | 
Returns the wrapped value, as an int.
 
 | 
| int_value [JavaLong] | 
Returns the wrapped value, as an int.
 
 | 
| int_value [JavaInt] | 
Returns the wrapped value, as an int.
 
 | 
| int_value [JavaFloat] | 
Returns the wrapped value, as an int.
 
 | 
| int_value [JavaDouble] | 
Returns the wrapped value, as an int.
 
 | 
| int_value [JavaByte] | 
Returns the wrapped value, as an int.
 
 | 
| integer_num [Num] | integer_num n returns the integer closest to n.
 | 
| inter [Set.S] | 
Set intersection.
 
 | 
| inter [MoreLabels.Set.S] | |
| interactive [Sys] | 
This reference is initially set to  
false in standalone
   programs and to true if the code is being executed under
   the interactive toplevel system ocaml.
 | 
| interrupt [ThreadGroup] | 
Interrupts all thread in the group (including children groups); see
    interrupt(...).
 
 | 
| interrupt [Thread] | 
Interrupts the thread; see interrupt(...).
 
 | 
| interrupted [Thread] | 
Tests whether the current thread has been interrupted, and sets its
    interrupted status to  
false; see
    interrupted(...).
 | 
| inv [Complex] | 
Multiplicative inverse ( 
1/z).
 | 
| invalid_arg [Pervasives] | 
Raise exception  
Invalid_argument with the given string.
 | 
| invoke_all [ThreadPoolExecutor] | invoke_all p l submits all functions from l to pool p, and then
    waits for the completion of all functions.
 | 
| invoke_all [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.invoke_all.
 | 
| invoke_all_time [ThreadPoolExecutor] | invoke_all_time p l t u is similar to invoke_all p l, except that
    the current thread will at most wait for t (time value whose unit
    is u).
 | 
| invoke_all_time [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.invoke_all_time.
 | 
| invoke_any [ThreadPoolExecutor] | invoke_any p l submits all function from l to pool p, and then
    waits for the completion of a function.
 | 
| invoke_any [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.invoke_any.
 | 
| invoke_any_time [ThreadPoolExecutor] | invoke_any_time p l t u is similar to invoke_any p l, except that
    the current thread will at most wait for t (time value whose unit
    is u).
 | 
| invoke_any_time [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.invoke_any_time.
 | 
| is_alive [Thread] | 
Tests whether the thread has started and not terminated; see
    isAlive(...).
 
 | 
| is_block [Obj] | |
| is_broken [CyclicBarrier] | 
Tests whether the barrier is broken.
 
 | 
| is_cancelled [ScheduledFuture] | 
Same as  
Future.is_cancelled.
 | 
| is_cancelled [Future] | 
Tests whether the task was cancelled before completion; see
    isCancelled(...).
 
 | 
| is_daemon [ThreadGroup] | 
Tests whether the group is a daemon one; see
    isDaemon(...).
 
 | 
| is_daemon [Thread] | 
Tests whether the thread is a daemon one; see
    isDaemon(...).
 
 | 
| is_destroyed [ThreadGroup] | 
Tests whether the group has been destroyed; see
    isDestroyed(...).
 
 | 
| is_digit [JavaChar] | 
Tests whether the passed value is a digit; see
    isDigit(...).
 
 | 
| is_digit_int [Nat] | |
| is_digit_normalized [Nat] | |
| is_digit_odd [Nat] | |
| is_digit_zero [Nat] | |
| is_directory [Sys] | 
Returns  
true if the given name refers to a directory,
    false if it refers to another kind of file.
 | 
| is_done [ScheduledFuture] | 
Same as  
Future.is_done.
 | 
| is_done [Future] | 
Tests whether the computation is completed; see
    isDone(...).
 
 | 
| is_empty [Stack] | 
Return  
true if the given stack is empty, false otherwise.
 | 
| is_empty [Set.S] | 
Test whether a set is empty or not.
 
 | 
| is_empty [Queue] | 
Return  
true if the given queue is empty, false otherwise.
 | 
| is_empty [MoreLabels.Set.S] | |
| is_empty [MoreLabels.Map.S] | |
| is_empty [Map.S] | 
Test whether a map is empty or not.
 
 | 
| is_empty [JavaString] | 
Tests whether the passed string is empty; see
    isEmpty(...).
 
 | 
| is_fair [Semaphore] | 
Tests whether the semaphore uses a fair policy; see
    isFair(...).
 
 | 
| 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_interrupted [Thread] | 
Tests whether the thread has been interrupted; see
    isInterrupted(...).
 
 | 
| is_letter [JavaChar] | 
Tests whether the passed value is a letter; see
    isLetter(...).
 
 | 
| is_letter_or_digit [JavaChar] | 
Tests whether the passed value is a letter or a digit; see
    isLetterOrDigit(...).
 
 | 
| is_lower_case [JavaChar] | 
Tests whether the passed value is lower case; see
    isLowerCase(...).
 
 | 
| is_marked [AtomicMarkableReference] | 
Returns the current mark.
 
 | 
| is_nat_int [Nat] | |
| is_native [Dynlink] | true if the program is native,
    false if the program is bytecode.
 | 
| is_not_null [ThreadPoolExecutor] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [ThreadLocal] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [ThreadGroup] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [Thread] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [Semaphore] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [ScheduledThreadPoolExecutor] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [ScheduledFuture] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [ReadWriteLock] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [Phaser] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [Lock] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaTimeZone] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaThrowable] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaStringBuilder] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaString] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [JavaShortArray] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [JavaShort] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaReferenceArray] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [JavaRandom] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaProperties] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaObject] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaLongArray] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [JavaLong] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaLocale] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaIntArray] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [JavaInt] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaFloatArray] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [JavaFloat] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaException] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaError] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaDoubleArray] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [JavaDouble] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaDate] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaCharArray] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [JavaChar] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaCalendar] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaByteArray] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [JavaByte] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaBooleanArray] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [JavaBoolean] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [JavaArraySignature.T] | |
| is_not_null [JavaArray] | is_not_null a returns false iff a is equal to null.
 | 
| is_not_null [Java] | is_not_null x returns false iff x is equal to null.
 | 
| is_not_null [Future] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [ForkJoinPool] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [ExecutorCompletionService] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [Exchanger] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [CyclicBarrier] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [CountDownLatch] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [Condition] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [AtomicStampedReference] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [AtomicReferenceArray] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [AtomicReference] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [AtomicMarkableReference] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [AtomicInt64Array] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [AtomicInt64] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [AtomicInt32Array] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [AtomicInt32] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_not_null [AtomicBool] | is_not_null obj returns false iff obj is equal to null.
 | 
| is_null [ThreadPoolExecutor] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [ThreadLocal] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [ThreadGroup] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [Thread] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [Semaphore] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [ScheduledThreadPoolExecutor] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [ScheduledFuture] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [ReadWriteLock] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [Phaser] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [Lock] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaTimeZone] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaThrowable] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaStringBuilder] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaString] | is_null x returns true iff x is equal to null.
 | 
| is_null [JavaShortArray] | is_null x returns true iff x is equal to null.
 | 
| is_null [JavaShort] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaReferenceArray] | is_null x returns true iff x is equal to null.
 | 
| is_null [JavaRandom] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaProperties] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaObject] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaLongArray] | is_null x returns true iff x is equal to null.
 | 
| is_null [JavaLong] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaLocale] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaIntArray] | is_null x returns true iff x is equal to null.
 | 
| is_null [JavaInt] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaFloatArray] | is_null x returns true iff x is equal to null.
 | 
| is_null [JavaFloat] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaException] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaError] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaDoubleArray] | is_null x returns true iff x is equal to null.
 | 
| is_null [JavaDouble] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaDate] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaCharArray] | is_null x returns true iff x is equal to null.
 | 
| is_null [JavaChar] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaCalendar] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaByteArray] | is_null x returns true iff x is equal to null.
 | 
| is_null [JavaByte] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaBooleanArray] | is_null x returns true iff x is equal to null.
 | 
| is_null [JavaBoolean] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [JavaArraySignature.T] | |
| is_null [JavaArray] | is_null a returns true iff a is equal to null.
 | 
| is_null [Java] | is_null x returns true iff x is equal to null.
 | 
| is_null [Future] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [ForkJoinPool] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [ExecutorCompletionService] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [Exchanger] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [CyclicBarrier] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [CountDownLatch] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [Condition] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [AtomicStampedReference] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [AtomicReferenceArray] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [AtomicReference] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [AtomicMarkableReference] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [AtomicInt64Array] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [AtomicInt64] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [AtomicInt32Array] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [AtomicInt32] | is_null obj returns true iff obj is equal to null.
 | 
| is_null [AtomicBool] | is_null obj returns true iff obj is equal to null.
 | 
| is_quiescent [ForkJoinPool] | 
Tests whether all threads in the pool are idle; see
    isQuiescent(...).
 
 | 
| is_relative [Filename] | 
Return  
true if the file name is relative to the current
   directory, false if it is absolute (i.e.
 | 
| is_shutdown [ThreadPoolExecutor] | 
Tests whether the pool has been shutdown; see
    isShutdown(...).
 
 | 
| is_shutdown [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.is_shutdown.
 | 
| is_shutdown [ForkJoinPool] | 
Tests whether the pool has been shutdown; see
    isShutdown(...).
 
 | 
| is_space_char [JavaChar] | 
Tests whether the passed value is a space character; see
    isSpaceChar(...).
 
 | 
| is_terminated [ThreadPoolExecutor] | 
Tests whether the pool has been terminated; see
    isTerminated(...).
 
 | 
| is_terminated [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.is_terminated.
 | 
| is_terminated [Phaser] | 
Tests whether the phaser has been terminated; see
    isTerminated(...).
 
 | 
| is_terminated [ForkJoinPool] | 
Tests whether shutdown is completed (including all tasks); see
    isTerminated(...).
 
 | 
| is_terminating [ThreadPoolExecutor] | 
Tests whether the pool is in the process of terminating; see
    isTerminating(...).
 
 | 
| is_terminating [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.is_terminating.
 | 
| is_terminating [ForkJoinPool] | 
Tests whether the pool is in the process shutdowning; see
    isTerminating(...).
 
 | 
| is_upper_case [JavaChar] | 
Tests whether the passed value is upper case; see
    isUpperCase(...).
 
 | 
| is_val [Lazy] | is_val x returns true if x has already been forced and
    did not raise an exception.
 | 
| is_whitespace [JavaChar] | 
Tests whether the passed value is a white space; see
    isWhitespace(...).
 
 | 
| is_zero_nat [Nat] | |
| isatty [Unix] | 
Return  
true if the given file descriptor refers to a terminal or
   console window, false otherwise.
 | 
| italian [JavaLocale] | |
| italy [JavaLocale] | |
| iter [Weak.S] | iter f t calls f on each element of t, in some unspecified
        order.
 | 
| iter [StringLabels] | String.iter f s applies function f in turn to all
   the characters of s.
 | 
| iter [String] | String.iter f s applies function f in turn to all
   the characters of s.
 | 
| iter [Stream] | Stream.iter f s scans the whole stream s, applying function f
   in turn to each stream element encountered.
 | 
| iter [StdLabels.String] | |
| iter [StdLabels.List] | |
| iter [StdLabels.Array] | |
| iter [Stack] | iter f s applies f in turn to all elements of s,
   from the element at the top of the stack to the element at the
   bottom of the stack.
 | 
| iter [Set.S] | iter f s applies f in turn to all elements of s.
 | 
| iter [Queue] | iter f q applies f in turn to all elements of q,
   from the least recently entered to the most recently entered.
 | 
| iter [ParallelArray.S] | |
| iter [ParallelArray] | 
Similar to  
Array.iter, except that computations are done in
    parallel; pool indicates the thread pool to use (defaulting to
    default_pool), while chunk_size indicates the size of each chunk
    to be allocated to a thread.
 | 
| iter [MoreLabels.Set.S] | |
| iter [MoreLabels.Map.S] | |
| iter [MoreLabels.Hashtbl.SeededS] | |
| 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 [JavaString.OCaml] | 
Similar to  
String.iter.
 | 
| iter [JavaShortArray] | iter f a applies f to each element of a.
 | 
| iter [JavaReferenceArray] | iter f a applies f to each element of a.
 | 
| iter [JavaLongArray] | iter f a applies f to each element of a.
 | 
| iter [JavaIntArray] | iter f a applies f to each element of a.
 | 
| iter [JavaFloatArray] | iter f a applies f to each element of a.
 | 
| iter [JavaDoubleArray] | iter f a applies f to each element of a.
 | 
| iter [JavaCharArray] | iter f a applies f to each element of a.
 | 
| iter [JavaByteArray] | iter f a applies f to each element of a.
 | 
| iter [JavaBooleanArray] | iter f a applies f to each element of a.
 | 
| iter [JavaArraySignature.T] | |
| iter [JavaArray] | iter f a applies f to the elements of a.
 | 
| iter [Java] | iter desc f it applies f to every element returned by it, after
    casting them to desc.
 | 
| iter [Hashtbl.SeededS] | |
| iter [Hashtbl.S] | |
| iter [Hashtbl] | Hashtbl.iter f tbl applies f to all bindings in table tbl.
 | 
| 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 [StringLabels] | 
Same as  
String.iter, but the
   function is applied to the index of the element as first argument
   (counting from 0), and the character itself as second argument.
 | 
| iteri [String] | 
Same as  
String.iter, but the
   function is applied to the index of the element as first argument
   (counting from 0), and the character itself as second argument.
 | 
| iteri [StdLabels.String] | |
| iteri [StdLabels.Array] | |
| iteri [ParallelArray.S] | |
| iteri [ParallelArray] | 
Similar to  
Array.iteri, except that computations are done in
    parallel; pool indicates the thread pool to use (defaulting to
    default_pool), while chunk_size indicates the size of each chunk
    to be allocated to a thread.
 | 
| iteri [ListLabels] | 
Same as  
List.iter, but the function is applied to the index of
   the element as first argument (counting from 0), and the element
   itself as second argument.
 | 
| iteri [List] | 
Same as  
List.iter, but the function is applied to the index of
   the element as first argument (counting from 0), and the element
   itself as second argument.
 | 
| iteri [JavaString.OCaml] | 
Similar to  
String.iteri.
 | 
| iteri [JavaShortArray] | iter f a applies f to each element of a (also passing element index).
 | 
| iteri [JavaReferenceArray] | iter f a applies f to each element of a (also passing element index).
 | 
| iteri [JavaLongArray] | iter f a applies f to each element of a (also passing element index).
 | 
| iteri [JavaIntArray] | iter f a applies f to each element of a (also passing element index).
 | 
| iteri [JavaFloatArray] | iter f a applies f to each element of a (also passing element index).
 | 
| iteri [JavaDoubleArray] | iter f a applies f to each element of a (also passing element index).
 | 
| iteri [JavaCharArray] | iter f a applies f to each element of a (also passing element index).
 | 
| iteri [JavaByteArray] | iter f a applies f to each element of a (also passing element index).
 | 
| iteri [JavaBooleanArray] | iter f a applies f to each element of a (also passing element index).
 | 
| iteri [JavaArraySignature.T] | |
| iteri [JavaArray] | iter f a applies f to the elements of a.
 | 
| 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  | |
| japan [JavaLocale] | |
| japanese [JavaLocale] | |
| join [Thread] | 
Waits for the termination of the passed thread; see
    join(...).
 
 | 
| join_time [Thread] | join_time t m is similar to join t, except that the current
    thread will at most wait for m milliseconds; see
    join(...).
 | 
| join_time_nanos [Thread] | join_time t m n is similar to join t, except that the current
    thread will at most wait for m milliseconds plus n nanoseconds; see
    join(...).
 | 
| junk [Stream] | 
Remove the first element of the stream, possibly unfreezing
   it before.
 
 | 
K  | |
| kbprintf [Printf] | 
Same as  
bprintf, but instead of returning immediately,
   passes the buffer to its first argument at the end of printing.
 | 
| kbprintf [JavaStringPrintf] | 
This function can be passed to  
Printf.kbprintf to print a Java
    string through a "%a" conversion specification.
 | 
| key_pressed [Graphics] | 
Return  
true if a keypress is available; that is, if read_key
   would not block.
 | 
| kfprintf [Printf] | 
Same as  
fprintf, but instead of returning immediately,
   passes the out channel to its first argument at the end of printing.
 | 
| kfprintf [JavaStringPrintf] | 
This function can be passed to  
Printf.kfprintf to print a Java
    string through a "%a" conversion specification.
 | 
| kfprintf [JavaStringFormat] | 
This function can be passed to  
Format.kfprintf to print a Java
    string through a "%a" conversion specification.
 | 
| kfprintf [Format] | 
Same as  
fprintf above, but instead of returning immediately,
   passes the formatter to its first argument at the end of printing.
 | 
| kill [Unix] | kill pid sig sends signal number sig to the process
   with id pid.
 | 
| kind [Bigarray.Array3] | 
Return the kind of the given big array.
 
 | 
| kind [Bigarray.Array2] | 
Return the kind of the given big array.
 
 | 
| kind [Bigarray.Array1] | 
Return the kind of the given big array.
 
 | 
| kind [Bigarray.Genarray] | 
Return the kind of the given big array.
 
 | 
| korea [JavaLocale] | |
| korean [JavaLocale] | |
| kprintf [Printf] | 
A deprecated synonym for  
ksprintf.
 | 
| kprintf [Format] | 
A deprecated synonym for  
ksprintf.
 | 
| kscanf [Scanf] | 
Same as  
Scanf.bscanf, but takes an additional function argument
    ef that is called in case of error: if the scanning process or
    some conversion fails, the scanning function aborts and calls the
    error handling function ef with the formatted input channel and the
    exception that aborted the scanning process as arguments.
 | 
| ksprintf [Printf] | 
Same as  
sprintf above, but instead of returning the string,
   passes it to the first argument.
 | 
| ksprintf [JavaStringPrintf] | 
This function can be passed to  
Printf.ksprintf to print a Java
    string through a "%a" conversion specification.
 | 
| ksprintf [JavaStringFormat] | 
This function can be passed to  
Format.ksprintf to print a Java
    string through a "%a" conversion specification.
 | 
| ksprintf [Format] | 
Same as  
sprintf above, but instead of returning the string,
   passes it to the first argument.
 | 
L  | |
| land_digit_nat [Nat] | |
| last_chars [Str] | last_chars s n returns the last n characters of s.
 | 
| last_index_of [JavaStringBuilder] | 
Returns the index within the passed builder of the last occurrence
    of the passed string; see
    lastIndexOf(...).
 
 | 
| last_index_of [JavaString] | last_index_of s sub returns the index of the last occurrence of
    sub in s if any, -1l otherwise; see
    lastIndexOf(...).
 | 
| last_index_of_from [JavaStringBuilder] | 
Returns the index within the passed builder of the last occurrence
    of the passed string, starting at the passed index; see
    indexOf(...).
 
 | 
| layout [Bigarray.Array3] | 
Return the layout of the given big array.
 
 | 
| layout [Bigarray.Array2] | 
Return the layout of the given big array.
 
 | 
| layout [Bigarray.Array1] | 
Return the layout of the given big array.
 
 | 
| layout [Bigarray.Genarray] | 
Return the layout of the given big array.
 
 | 
| lazy_from_fun [Lazy] | |
| lazy_from_val [Lazy] | |
| lazy_is_val [Lazy] | |
| lazy_set [AtomicReferenceArray] | lazy_set a i x eventually sets the value of a at index i to
    x.
 | 
| lazy_set [AtomicReference] | lazy_set a x eventually sets the value of a to x.
 | 
| lazy_set [AtomicInt64Array] | lazy_set a i x eventually sets the value of a at index i to
    x.
 | 
| lazy_set [AtomicInt64] | lazy_set a x eventually sets the value of a to x.
 | 
| lazy_set [AtomicInt32Array] | lazy_set a i x eventually sets the value of a at index i to
    x.
 | 
| lazy_set [AtomicInt32] | lazy_set a x eventually sets the value of a to x.
 | 
| lazy_set [AtomicBool] | lazy_set a x eventually sets the value of a to x.
 | 
| lazy_tag [Obj] | |
| ldexp [Pervasives] | ldexp x n returns x *. 2 ** n.
 | 
| le_big_int [Big_int] | |
| le_nat [Nat] | |
| le_num [Num] | |
| least_int [Int_misc] | |
| 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 [ParallelArray.S] | |
| length [ParallelArray] | 
Synonym for  
Array.length.
 | 
| length [MoreLabels.Hashtbl.SeededS] | |
| length [MoreLabels.Hashtbl.S] | |
| length [MoreLabels.Hashtbl] | |
| length [ListLabels] | 
Return the length (number of elements) of the given list.
 
 | 
| length [List] | 
Return the length (number of elements) of the given list.
 
 | 
| length [JavaStringBuilder] | 
Returns the length of the passed builder; see
    length(...).
 
 | 
| length [JavaString.OCaml] | 
Similar to  
String.length.
 | 
| length [JavaString] | 
Returns the length of the passed string; see
    length(...).
 
 | 
| length [JavaShortArray] | length a returns the length of a.
 | 
| length [JavaReferenceArray] | length a returns the length of a.
 | 
| length [JavaLongArray] | length a returns the length of a.
 | 
| length [JavaIntArray] | length a returns the length of a.
 | 
| length [JavaFloatArray] | length a returns the length of a.
 | 
| length [JavaDoubleArray] | length a returns the length of a.
 | 
| length [JavaCharArray] | length a returns the length of a.
 | 
| length [JavaByteArray] | length a returns the length of a.
 | 
| length [JavaBooleanArray] | length a returns the length of a.
 | 
| length [JavaArraySignature.T] | |
| length [JavaArray] | length a returns the length of a.
 | 
| length [Hashtbl.SeededS] | |
| length [Hashtbl.S] | |
| length [Hashtbl] | Hashtbl.length tbl returns the number of bindings in tbl.
 | 
| length [Buffer] | 
Return the number of characters currently contained in the buffer.
 
 | 
| length [AtomicReferenceArray] | 
Returns the length of the array.
 
 | 
| length [AtomicInt64Array] | 
Returns the length of the array.
 
 | 
| length [AtomicInt32Array] | 
Returns the length of the array.
 
 | 
| length [ArrayLabels] | 
Return the length (number of elements) of the given array.
 
 | 
| length [Array] | 
Return the length (number of elements) of the given array.
 
 | 
| length_nat [Nat] | |
| length_of_digit [Nat] | |
| length_of_int [Int_misc] | |
| length_sub [JavaArray] | length_sub a i returns the length of the sub array at index i of
    a.
 | 
| lexeme [Lexing] | Lexing.lexeme lexbuf returns the string matched by
           the regular expression.
 | 
| lexeme_char [Lexing] | Lexing.lexeme_char lexbuf i returns character number i in
   the matched string.
 | 
| lexeme_end [Lexing] | Lexing.lexeme_end lexbuf returns the offset in the input stream
   of the character following the last character of the matched
   string.
 | 
| lexeme_end_p [Lexing] | 
Like  
lexeme_end, but return a complete position instead
    of an offset.
 | 
| lexeme_start [Lexing] | Lexing.lexeme_start lexbuf returns the offset in the
   input stream of the first character of the matched string.
 | 
| lexeme_start_p [Lexing] | 
Like  
lexeme_start, but return a complete position instead
    of an offset.
 | 
| lineto [Graphics] | 
Draw a line with endpoints the current point and the given point,
   and move the current point to the given point.
 
 | 
| 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 [Unix] | 
Set up a socket for receiving connection requests.
 
 | 
| lnot [Pervasives] | 
Bitwise logical negation.
 
 | 
| load [JavaProperties] | |
| load_from_xml [JavaProperties] | |
| loadfile [Dynlink] | 
In bytecode: load the given bytecode object file ( 
.cmo file) or
    bytecode library file (.cma file), and link it with the running
    program.
 | 
| loadfile_private [Dynlink] | 
Same as  
loadfile, except that the compilation units just loaded
    are hidden (cannot be referenced) from other modules dynamically
    loaded afterwards.
 | 
| localtime [Unix] | 
Convert a time in seconds, as returned by  
Unix.time, into a date and
   a time.
 | 
| lock [Lock] | 
Acquires the lock.
 
 | 
| lock_interruptibly [Lock] | 
Similar to  
Lock.lock, except that some other thread may interrupt the
    current thread while blocked; see
    lockInterruptibly(...).
 | 
| lockf [Unix] | lockf fd cmd size puts a lock on a region of the file opened
   as fd.
 | 
| log [Pervasives] | 
Natural logarithm.
 
 | 
| log [Complex] | 
Natural logarithm (in base  
e).
 | 
| log10 [Pervasives] | 
Base 10 logarithm.
 
 | 
| log1p [Pervasives] | log1p x computes log(1.0 +. x) (natural logarithm),
    giving numerically-accurate results even if x is close to 0.0.
 | 
| 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.
 
 | 
| long_value [JavaShort] | 
Returns the wrapped value, as a long.
 
 | 
| long_value [JavaLong] | 
Returns the wrapped value, as a long.
 
 | 
| long_value [JavaInt] | 
Returns the wrapped value, as a long.
 
 | 
| long_value [JavaFloat] | 
Returns the wrapped value, as a long.
 
 | 
| long_value [JavaDouble] | 
Returns the wrapped value, as a long.
 
 | 
| long_value [JavaByte] | 
Returns the wrapped value, as a long.
 
 | 
| lookup_tables [CamlinternalOO] | |
| loop_at_exit [Graphics] | 
Loop before exiting the program, the list given as argument is the
    list of handlers and the events on which these handlers are called.
 
 | 
| lor_digit_nat [Nat] | |
| 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 [JavaString.OCaml] | 
Similar to  
String.lowercase.
 | 
| lowercase [Char] | 
Convert the given character to its equivalent lowercase character.
 
 | 
| lseek [Unix.LargeFile] | |
| lseek [Unix] | 
Set the current position for a file descriptor, and return the resulting
    offset (from the beginning of the file).
 
 | 
| lstat [Unix.LargeFile] | |
| lstat [Unix] | 
Same as  
Unix.stat, but in case the file is a symbolic link,
   return the information for the link itself.
 | 
| lt_big_int [Big_int] | |
| lt_nat [Nat] | |
| lt_num [Num] | |
| lxor_digit_nat [Nat] | |
M  | |
| magenta [Graphics] | |
| magic [Obj] | |
| major [Gc] | 
Do a minor collection and finish the current major collection cycle.
 
 | 
| major_slice [Gc] | 
Do a minor collection and a slice of major collection.
 
 | 
| make [ThreadPoolExecutor] | make core_pool_size:cps max_pool_size:mps kat u reh returns a new thread pool with: cps as its core pool size (number of threads kept in the pool,
      even if idle);, mps as its maximum pool size (maximum number of threads in the
      pool);, kat keep alive time (how long to keep alive idle threads not in
      the core);, u time unit for kat;, reh policy for blocked computations.
 | 
| make [ThreadLocal] | 
Returns a new thread-local variable whose initial value in each
    thread is the passed value; see
    ThreadLocal(...) and
    initialValue(...).
 
 | 
| make [ThreadGroup] | 
Returns a new group with optional parent, and name; see
    ThreadGroup(...).
 
 | 
| make [Thread] | make g n f x returns a new thread in group g with name n.
 | 
| 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 [Semaphore] | make ~fair:f p returns a new semaphore with p permits, f
    indicating whether a fair ordering policy is requested
    (defaulting to false); see
    Semaphore(...).
 | 
| make [ScheduledThreadPoolExecutor] | make core_pool_size:cps reh returns a new thread pool with: cps as its core pool size (number of threads kept in the pool,
      even if idle);, reh policy for blocked computations.
 | 
| make [Random.State] | 
Create a new state and initialize it with the given seed.
 
 | 
| make [Phaser] | make ~parent:p ~parties:n returns a new phaser with parent p
    (defaulting to null), and number of parties n (defaulting to
    0l); see
    Phaser(...).
 | 
| make [ParallelArray.S] | |
| make [ParallelArray] | 
Synonym for  
Array.make.
 | 
| make [JavaTimeZone] | 
Returns a new java.util.TimeZone instance, corresponding to
    the passed identifier.
 
 | 
| make [JavaThrowable] | 
Returns a new java.lang.Throwable instance;
    see Throwable(...).
 
 | 
| make [JavaStringBuilder] | 
Returns new empty java.lang.StringBuilder instance, with an
    initial capacity of 16 characters.
 
 | 
| make [JavaString.OCaml] | 
Similar to  
String.make.
 | 
| make [JavaShortArray] | make len creates and returns an array of len elements.
 | 
| make [JavaShort] | 
Returns a new java.lang.Short wrapper for the passed
    value.
 
 | 
| make [JavaRandom] | 
Returns a new java.util.Random instance.
 
 | 
| make [JavaProperties] | 
Returns a new java.util.Properties instance, with the passed
    defaults if not  
null, empty otherwise.
 | 
| make [JavaObject] | 
Returns a new java.lang.Object instance.
 
 | 
| make [JavaLongArray] | make len creates and returns an array of len elements.
 | 
| make [JavaLong] | 
Returns a new java.lang.Long wrapper for the passed
    value.
 
 | 
| make [JavaLocale] | |
| make [JavaIntArray] | make len creates and returns an array of len elements.
 | 
| make [JavaInt] | 
Returns a new java.lang.Integer wrapper for the passed
    value.
 
 | 
| make [JavaFloatArray] | make len creates and returns an array of len elements.
 | 
| make [JavaFloat] | 
Returns a new java.lang.Float wrapper for the passed
    value.
 
 | 
| make [JavaException] | 
Returns a new java.lang.Exception instance;
    see Exception(...).
 
 | 
| make [JavaError] | 
Returns a new java.lang.Error instance;
    see Error(...).
 
 | 
| make [JavaDoubleArray] | make len creates and returns an array of len elements.
 | 
| make [JavaDouble] | 
Returns a new java.lang.Double wrapper for the passed
    value.
 
 | 
| make [JavaDate] | 
Returns a new java.util.Date instance for the passed time,
    as the number of milliseconds since 1970-01-01 00:00:00.
 
 | 
| make [JavaCharArray] | make len creates and returns an array of len elements.
 | 
| make [JavaChar] | 
Returns a new java.lang.Character wrapper for the passed value.
 
 | 
| make [JavaByteArray] | make len creates and returns an array of len elements.
 | 
| make [JavaByte] | 
Returns a new java.lang.Byte wrapper for the passed
    value.
 
 | 
| make [JavaBooleanArray] | make len creates and returns an array of len elements.
 | 
| make [JavaBoolean] | 
Returns a new java.lang.Boolean wrapper for the passed value.
 
 | 
| make [JavaArraySignature.T] | |
| make [Java] | make desc param1 ... paramn calls the constructor whose descriptor
    is desc with parameters param1 ... paramn, and returns the
    created instance.
 | 
| make [ForkJoinPool] | make parallelism:p async returns a new thread pool with parallelism p
    (target number of active threads in pool).
 | 
| make [ExecutorCompletionService] | 
Returns a new completion service based on the passed thread pool;
    see ExecutorCompletionService(...).
 
 | 
| make [Exchanger] | 
Returns a new exchanger; see
    Exchanger(...).
 
 | 
| make [CyclicBarrier] | |
| make [CountDownLatch] | |
| make [AtomicStampedReference] | 
Returns a new container holding the passed value, with the passed
    stamp.
 
 | 
| make [AtomicReferenceArray] | 
Returns a new container holding an array of passed length.
 
 | 
| make [AtomicReference] | 
Returns a new container holding the passed value.
 
 | 
| make [AtomicMarkableReference] | 
Returns a new container holding the passed value, with the passed
    mark.
 
 | 
| make [AtomicInt64Array] | 
Returns a new container holding an array of passed length.
 
 | 
| make [AtomicInt64] | 
Returns a new container holding the passed value.
 
 | 
| make [AtomicInt32Array] | 
Returns a new container holding an array of passed length.
 
 | 
| make [AtomicInt32] | 
Returns a new container holding the passed value.
 
 | 
| make [AtomicBool] | 
Returns a new container holding the passed value.
 
 | 
| 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_array [Java] | make_array desc dim1 ... dimn builds and returns an array, whose
    number of dimensions and type of elements are determined by desc.
 | 
| make_array_dims [Java] | make_array_dims desc dim1 ... dimn is similar to Java.make_array,
    except that the array descriptor is made of two kinds of dimension
    specifiers, allowing to initialize only the first dimensions of the
    array.
 | 
| make_class [CamlinternalOO] | |
| make_class_store [CamlinternalOO] | |
| make_date_format [JavaDate] | 
Creates a date format from the passed style, locale, and time
    zone.
 
 | 
| make_date_time_format [JavaDate] | 
Creates a date/time format from the passed styles, locale, and time
    zone.
 
 | 
| 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 [ParallelArray.S] | |
| make_matrix [ParallelArray] | 
Synonym for  
Array.make_matrix.
 | 
| 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.
 | 
| make_nat [Nat] | |
| make_of_capacity [JavaStringBuilder] | 
Returns new empty java.lang.StringBuilder instance, with the
    passed capacity.
 
 | 
| make_of_char_sequence [JavaStringBuilder] | 
Returns a java.lang.StringBuilder instance, containing a copy
    of the passed sequence.
 
 | 
| make_of_seed [JavaRandom] | 
Returns a new java.util.Random instance, built using the passed
    seed.
 
 | 
| make_of_string [JavaStringBuilder] | 
Returns a java.lang.StringBuilder instance, containing a copy
    of the passed string.
 
 | 
| make_of_string [JavaShort] | 
Returns a new java.lang.Short corresponding to the
    passed string; see
    Short(...).
 
 | 
| make_of_string [JavaLong] | 
Returns a new java.lang.Long corresponding to the
    passed string; see
    Long(...).
 
 | 
| make_of_string [JavaInt] | 
Returns a new java.lang.Integer corresponding to the
    passed string; see
    Integer(...).
 
 | 
| make_of_string [JavaFloat] | 
Returns a new java.lang.Float corresponding to the
    passed string; see
    Float(...).
 
 | 
| make_of_string [JavaDouble] | 
Returns a new java.lang.Double corresponding to the
    passed string; see
    Double(...).
 
 | 
| make_of_string [JavaByte] | 
Returns a new java.lang.Byte corresponding to the
    passed string; see
    Byte(...).
 
 | 
| make_of_string [JavaBoolean] | 
Returns a new java.lang.Boolean corresponding to the passed
    string; see Boolean(...).
 
 | 
| make_power_base [Nat] | |
| make_reentrant [ReadWriteLock] | 
Returns a new read/write lock, whose read and write locks are
    reentrant, the parameter indicates whether a fair ordering policy
    is requested (defaulting to  
false); see
    ReentrantReadWriteLock(...).
 | 
| make_reentrant [Lock] | 
Returns a new reentrant lock, the parameter indicates whether a
    fair ordering policy is requested (defaulting to  
false); see
    ReentrantLock(...).
 | 
| make_secure [JavaRandom] | 
Returns a new java.security.SecureRandom instance, using
     
algorithm (if different from null) to generate the numbers as
    implemented by provider (if different from null).
 | 
| make_self_init [Random.State] | 
Create a new state and initialize it with a system-dependent
      low-entropy seed.
 
 | 
| make_simple_format [JavaDate] | 
Creates a format from the passed pattern, locale, and time zone.
 
 | 
| map [StringLabels] | String.map f s applies function f in turn to all
   the characters of s and stores the results in a new string that
   is returned.
 | 
| map [String] | String.map f s applies function f in turn to all
   the characters of s and stores the results in a new string that
   is returned.
 | 
| map [StdLabels.String] | |
| map [StdLabels.List] | |
| map [StdLabels.Array] | |
| map [ParallelArray.S] | |
| map [ParallelArray] | 
Similar to  
Array.map, except that computations are done in
    parallel; pool indicates the thread pool to use (defaulting to
    default_pool), while chunk_size indicates the size of each chunk
    to be allocated to a thread.
 | 
| map [MoreLabels.Map.S] | |
| map [MapReduce.Computation] | 
map operation, turning an input value into a list of key/value
      couples.
 
 | 
| 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 [JavaString.OCaml] | 
Similar to  
String.map.
 | 
| map [JavaShortArray] | map f a returns an array with elements f a_0, f a_1, ... where
    a_i is the element of a at index i.
 | 
| map [JavaLongArray] | map f a returns an array with elements f a_0, f a_1, ... where
    a_i is the element of a at index i.
 | 
| map [JavaIntArray] | map f a returns an array with elements f a_0, f a_1, ... where
    a_i is the element of a at index i.
 | 
| map [JavaFloatArray] | map f a returns an array with elements f a_0, f a_1, ... where
    a_i is the element of a at index i.
 | 
| map [JavaDoubleArray] | map f a returns an array with elements f a_0, f a_1, ... where
    a_i is the element of a at index i.
 | 
| map [JavaCharArray] | map f a returns an array with elements f a_0, f a_1, ... where
    a_i is the element of a at index i.
 | 
| map [JavaByteArray] | map f a returns an array with elements f a_0, f a_1, ... where
    a_i is the element of a at index i.
 | 
| map [JavaBooleanArray] | map f a returns an array with elements f a_0, f a_1, ... where
    a_i is the element of a at index i.
 | 
| map [JavaArraySignature.T] | |
| 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 [ParallelArray.S] | |
| mapi [ParallelArray] | 
Similar to  
Array.mapi, except that computations are done in
    parallel; pool indicates the thread pool to use (defaulting to
    default_pool), while chunk_size indicates the size of each chunk
    to be allocated to a thread.
 | 
| 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 [ListLabels] | 
Same as  
List.map, but the function is applied to the index of
   the element as first argument (counting from 0), and the element
   itself as second argument.
 | 
| mapi [List] | 
Same as  
List.map, but the function is applied to the index of
   the element as first argument (counting from 0), and the element
   itself as second argument.
 | 
| mapi [JavaShortArray] | map f a returns an array with elements f 0 a_0, f 1 a_1, ... where
    a_i is the element of a at index i.
 | 
| mapi [JavaLongArray] | map f a returns an array with elements f 0 a_0, f 1 a_1, ... where
    a_i is the element of a at index i.
 | 
| mapi [JavaIntArray] | map f a returns an array with elements f 0 a_0, f 1 a_1, ... where
    a_i is the element of a at index i.
 | 
| mapi [JavaFloatArray] | map f a returns an array with elements f 0 a_0, f 1 a_1, ... where
    a_i is the element of a at index i.
 | 
| mapi [JavaDoubleArray] | map f a returns an array with elements f 0 a_0, f 1 a_1, ... where
    a_i is the element of a at index i.
 | 
| mapi [JavaCharArray] | map f a returns an array with elements f 0 a_0, f 1 a_1, ... where
    a_i is the element of a at index i.
 | 
| mapi [JavaByteArray] | map f a returns an array with elements f 0 a_0, f 1 a_1, ... where
    a_i is the element of a at index i.
 | 
| mapi [JavaBooleanArray] | map f a returns an array with elements f 0 a_0, f 1 a_1, ... where
    a_i is the element of a at index i.
 | 
| mapi [JavaArraySignature.T] | |
| mapi [ArrayLabels] | 
Same as  
ArrayLabels.map, but the
   function is applied to the index of the element as first argument,
   and the element itself as second argument.
 | 
| mapi [Array] | 
Same as  
Array.map, but the
   function is applied to the index of the element as first argument,
   and the element itself as second argument.
 | 
| marshal [Obj] | |
| match_beginning [Str] | match_beginning() returns the position of the first character
   of the substring that was matched by the last call to a matching
   or searching function (see Str.matched_string for details).
 | 
| match_end [Str] | match_end() returns the position of the character following the
   last character of the substring that was matched by the last call
   to a matching or searching function (see Str.matched_string for
   details).
 | 
| matched_group [Str] | matched_group n s returns the substring of s that was matched
   by the nth group \(...\) of the regular expression that was
   matched by the last call to a matching or searching function (see
   Str.matched_string for details).
 | 
| matched_string [Str] | matched_string s returns the substring of s that was matched
   by the last call to one of the following matching or searching
   functions: Str.string_match, Str.search_forward, Str.search_backward, Str.string_partial_match, Str.global_substitute, Str.substitute_first
   provided that none of the following functions was called inbetween:, Str.global_replace, Str.replace_first, Str.split, Str.bounded_split, Str.split_delim, Str.bounded_split_delim, Str.full_split, Str.bounded_full_split
   Note: in the case of global_substitute and substitute_first,
   a call to matched_string is only valid within the subst argument,
   not after global_substitute or substitute_first returns.
 | 
| matches [JavaString] | |
| max [Pervasives] | 
Return the greater of the two arguments.
 
 | 
| max_array_length [Sys] | 
Maximum length of a normal array.
 
 | 
| max_big_int [Big_int] | 
Return the greater of its two arguments.
 
 | 
| max_binding [MoreLabels.Map.S] | |
| max_binding [Map.S] | 
Same as  
Map.S.min_binding, but returns the largest binding
        of the given map.
 | 
| max_elt [Set.S] | 
Same as  
Set.S.min_elt, but returns the largest element of the
       given set.
 | 
| max_elt [MoreLabels.Set.S] | |
| 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_memory [JavaRuntime] | 
Returns the maximum amount of memory to be used by the JVM
    (in bytes); see maxMemory(...).
 
 | 
| max_num [Num] | 
Return the greater of the two arguments.
 
 | 
| max_priority [Thread] | 
The maximum priority for a thread; see
    java.lang.Thread#MAX_PRIORITY.
 
 | 
| max_string_length [Sys] | 
Maximum length of a string.
 
 | 
| max_value [JavaShort] | 
The largest value for short values.
 
 | 
| max_value [JavaLong] | 
The largest value for long values.
 
 | 
| max_value [JavaInt] | 
The largest value for integer values.
 
 | 
| max_value [JavaFloat] | 
The largest value for float values.
 
 | 
| max_value [JavaDouble] | 
The largest value for double values.
 
 | 
| max_value [JavaChar] | 
The largest value for character values.
 
 | 
| max_value [JavaByte] | 
The largest value for byte values.
 
 | 
| mem [Weak.S] | mem t x returns true if there is at least one instance
        of x in t, false otherwise.
 | 
| mem [StdLabels.List] | |
| mem [Set.S] | mem x s tests whether x belongs to the set s.
 | 
| mem [ParallelArray.S] | |
| mem [ParallelArray] | mem ~pool ~chunk_size x a returns true iff there is an element
    e of a such that e = x.
 | 
| mem [MoreLabels.Set.S] | |
| mem [MoreLabels.Map.S] | |
| mem [MoreLabels.Hashtbl.SeededS] | |
| 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.SeededS] | |
| 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 [ParallelArray.S] | |
| memq [ParallelArray] | memq ~pool ~chunk_size x a returns true iff there is an element
    e of a such that e == x.
 | 
| memq [ListLabels] | 
Same as  
ListLabels.mem, but uses physical equality instead of structural
   equality to compare list elements.
 | 
| memq [List] | 
Same as  
List.mem, but uses physical equality instead of structural
   equality to compare list elements.
 | 
| merge [Weak.S] | merge t x returns an instance of x found in t if any,
        or else adds x to t and return x.
 | 
| merge [StdLabels.List] | |
| merge [Sort] | 
Merge two lists according to the given predicate.
 
 | 
| merge [MoreLabels.Map.S] | |
| merge [Map.S] | merge f m1 m2 computes a map whose keys is a subset of keys of m1
        and of m2.
 | 
| merge [ListLabels] | 
Merge two lists:
    Assuming that  
l1 and l2 are sorted according to the
    comparison function cmp, merge cmp l1 l2 will return a
    sorted list containting all the elements of l1 and l2.
 | 
| merge [List] | 
Merge two lists:
    Assuming that  
l1 and l2 are sorted according to the
    comparison function cmp, merge cmp l1 l2 will return a
    sorted list containting all the elements of l1 and l2.
 | 
| microseconds [TimeUnit] | 
Time unit for microseconds.
 
 | 
| milliseconds [TimeUnit] | 
Time unit for milliseconds.
 
 | 
| min [Pervasives] | 
Return the smaller of the two arguments.
 
 | 
| min_big_int [Big_int] | 
Return the smaller of its two arguments.
 
 | 
| min_binding [MoreLabels.Map.S] | |
| min_binding [Map.S] | 
Return the smallest binding of the given map
       (with respect to the  
Ord.compare ordering), or raise
       Not_found if the map is empty.
 | 
| min_elt [Set.S] | 
Return the smallest element of the given set
       (with respect to the  
Ord.compare ordering), or raise
       Not_found if the set is empty.
 | 
| min_elt [MoreLabels.Set.S] | |
| 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.
 
 | 
| min_priority [Thread] | 
The minimum priority for a thread; see
    java.lang.Thread#MIN_PRIORITY.
 
 | 
| min_value [JavaShort] | 
The smallest value for short values.
 
 | 
| min_value [JavaLong] | 
The smallest value for long values.
 
 | 
| min_value [JavaInt] | 
The smallest value for integer values.
 
 | 
| min_value [JavaFloat] | 
The smallest value for float values.
 
 | 
| min_value [JavaDouble] | 
The smallest value for double values.
 
 | 
| min_value [JavaChar] | 
The smallest value for character values.
 
 | 
| min_value [JavaByte] | 
The smallest value for byte values.
 
 | 
| 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.
 
 | 
| minutes [TimeUnit] | 
Time unit for minutes.
 
 | 
| mkdir [Unix] | 
Create a directory with the given permissions (see  
Unix.umask).
 | 
| mkfifo [Unix] | 
Create a named pipe with the given permissions (see  
Unix.umask).
 | 
| mktime [Unix] | 
Convert a date and time, specified by the  
tm argument, into
   a time in seconds, as returned by Unix.time.
 | 
| 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.
 | 
| monster_int [Int_misc] | |
| mouse_pos [Graphics] | 
Return the position of the mouse cursor, relative to the
   graphics window.
 
 | 
| moveto [Graphics] | 
Position the current point.
 
 | 
| mul [Nativeint] | 
Multiplication.
 
 | 
| mul [Int64] | 
Multiplication.
 
 | 
| mul [Int32] | 
Multiplication.
 
 | 
| mul [Complex] | 
Multiplication
 
 | 
| mult_big_int [Big_int] | 
Multiplication of two big integers.
 
 | 
| mult_digit_nat [Nat] | |
| mult_int_big_int [Big_int] | 
Multiplication of a big integer by a small integer
 
 | 
| mult_nat [Nat] | |
| mult_num [Num] | 
Multiplication
 
 | 
N  | |
| name_of_input [Scanf.Scanning] | Scanning.name_of_input ic returns the name of the character source
    for the formatted input channel ic.
 | 
| nan [Pervasives] | 
A special floating-point value denoting the result of an
   undefined operation such as  
0.0 /. 0.0.
 | 
| nan [JavaFloat] | 
The not-a-number constant.
 
 | 
| nan [JavaDouble] | 
The not-a-number constant.
 
 | 
| nano_time [JavaSystem] | 
Returns the value of the high-resolution time source in nanoseconds.
 
 | 
| nanoseconds [TimeUnit] | 
Time unit for nanoseconds.
 
 | 
| narrow [CamlinternalOO] | |
| nat_of_int [Nat] | |
| nat_of_num [Num] | |
| nat_of_string [Nat] | |
| nativeint [Random.State] | |
| nativeint [Random] | Random.nativeint bound returns a random integer between 0 (inclusive)
     and bound (exclusive).
 | 
| nativeint [Bigarray] | 
See  
Bigarray.char.
 | 
| nativeint_of_big_int [Big_int] | 
Convert a big integer to a native integer.
 
 | 
| neg [Nativeint] | 
Unary negation.
 
 | 
| neg [Int64] | 
Unary negation.
 
 | 
| neg [Int32] | 
Unary negation.
 
 | 
| neg [Complex] | 
Unary negation.
 
 | 
| neg_infinity [Pervasives] | 
Negative infinity.
 
 | 
| negative_infinity [JavaFloat] | 
The constant for the negative infinity.
 
 | 
| negative_infinity [JavaDouble] | 
The constant for the negative infinity.
 
 | 
| new_block [Obj] | |
| new_condition [Lock] | 
Returns a new condition associated with the passed lock; see
    newCondition(...).
 
 | 
| new_line [Lexing] | 
Update the  
lex_curr_p field of the lexbuf to reflect the start
    of a new line.
 | 
| new_method [CamlinternalOO] | |
| new_methods_variables [CamlinternalOO] | |
| new_variable [CamlinternalOO] | |
| next [Stream] | 
Return the first element of the stream and remove it from the
   stream.
 
 | 
| next_boolean [JavaRandom] | 
Generates a new pseudorandom boolean; see
    nextBoolean(...).
 
 | 
| next_bytes [JavaRandom] | 
Generates new pseudorandom bytes; see
    nextBytes(...).
 
 | 
| next_double [JavaRandom] | 
Generates a new pseudorandom double; see
    nextDouble(...).
 
 | 
| next_float [JavaRandom] | 
Generates a new pseudorandom float; see
    nextFloat(...).
 
 | 
| next_gaussian [JavaRandom] | 
Generates a new pseudorandom double that is Gaussian distributed; see
    nextGaussian(...).
 
 | 
| next_int [JavaRandom] | 
Generates a new pseudorandom integer; see
    nextInt(...).
 
 | 
| next_int_bound [JavaRandom] | 
Generates a new pseudorandom integer between 0 (inclusive) and the
    passed value (exclusive); see nextInt(...).
 
 | 
| next_long [JavaRandom] | 
Generates a new pseudorandom long; see
    nextLong(...).
 
 | 
| nice [Unix] | 
Change the process priority.
 
 | 
| no_scan_tag [Obj] | |
| norm [Complex] | 
Norm: given  
x + i.y, returns sqrt(x^2 + y^2).
 | 
| norm2 [Complex] | 
Norm squared: given  
x + i.y, returns x^2 + y^2.
 | 
| norm_priority [Thread] | 
The normal (i.
 
 | 
| normalize_ratio_flag [Arith_flags] | |
| normalize_ratio_when_printing_flag [Arith_flags] | |
| not [Pervasives] | 
The boolean negation.
 
 | 
| not_equal [Java] | not_equal x y returns false if x and y designate the very
    same reference.
 | 
| notify [JavaObject] | |
| notify_all [JavaObject] | |
| now [JavaDate] | 
Returns a new java.util.Date instance for the current time.
 
 | 
| now [JavaCalendar] | 
Returns a new java.util.Calendar instance for the current time,
    using the passed local and/or time zone.
 
 | 
| 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 [Buffer] | 
get the n-th character of the buffer.
 
 | 
| nth_digit_nat [Nat] | |
| nth_digit_nat_native [Nat] | |
| nth_dim [Bigarray.Genarray] | Genarray.nth_dim a n returns the n-th dimension of the
     big array a.
 | 
| null [ThreadPoolExecutor] | 
The  
null value.
 | 
| null [ThreadLocal] | 
The  
null value.
 | 
| null [ThreadGroup] | 
The  
null value.
 | 
| null [Thread] | 
The  
null value.
 | 
| null [Semaphore] | 
The  
null value.
 | 
| null [ScheduledThreadPoolExecutor] | 
The  
null value.
 | 
| null [ScheduledFuture] | 
The  
null value.
 | 
| null [ReadWriteLock] | 
The  
null value.
 | 
| null [Phaser] | 
The  
null value.
 | 
| null [Lock] | 
The  
null value.
 | 
| null [JavaTimeZone] | 
The  
null value.
 | 
| null [JavaThrowable] | 
The  
null value.
 | 
| null [JavaStringBuilder] | 
The  
null value.
 | 
| null [JavaString] | 
The  
null value.
 | 
| null [JavaShortArray] | 
The  
null value.
 | 
| null [JavaShort] | 
The  
null value.
 | 
| null [JavaReferenceArray] | 
The  
null value.
 | 
| null [JavaRandom] | 
The  
null value.
 | 
| null [JavaProperties] | 
The  
null value.
 | 
| null [JavaObject] | 
The  
null value.
 | 
| null [JavaLongArray] | 
The  
null value.
 | 
| null [JavaLong] | 
The  
null value.
 | 
| null [JavaLocale] | 
The  
null value.
 | 
| null [JavaIntArray] | 
The  
null value.
 | 
| null [JavaInt] | 
The  
null value.
 | 
| null [JavaFloatArray] | 
The  
null value.
 | 
| null [JavaFloat] | 
The  
null value.
 | 
| null [JavaException] | 
The  
null value.
 | 
| null [JavaError] | 
The  
null value.
 | 
| null [JavaDoubleArray] | 
The  
null value.
 | 
| null [JavaDouble] | 
The  
null value.
 | 
| null [JavaDate] | 
The  
null value.
 | 
| null [JavaCharArray] | 
The  
null value.
 | 
| null [JavaChar] | 
The  
null value.
 | 
| null [JavaCalendar] | 
The  
null value.
 | 
| null [JavaByteArray] | 
The  
null value.
 | 
| null [JavaByte] | 
The  
null value.
 | 
| null [JavaBooleanArray] | 
The  
null value.
 | 
| null [JavaBoolean] | 
The  
null value.
 | 
| null [JavaArraySignature.T] | |
| null [Java] | 
The  
null value.
 | 
| null [Future] | 
The  
null value.
 | 
| null [ForkJoinPool] | 
The  
null value.
 | 
| null [ExecutorCompletionService] | 
The  
null value.
 | 
| null [Exchanger] | 
The  
null value.
 | 
| null [CyclicBarrier] | 
The  
null value.
 | 
| null [CountDownLatch] | 
The  
null value.
 | 
| null [Condition] | 
The  
null value.
 | 
| null [AtomicStampedReference] | 
The  
null value.
 | 
| null [AtomicReferenceArray] | 
The  
null value.
 | 
| null [AtomicReference] | 
The  
null value.
 | 
| null [AtomicMarkableReference] | 
The  
null value.
 | 
| null [AtomicInt64Array] | 
The  
null value.
 | 
| null [AtomicInt64] | 
The  
null value.
 | 
| null [AtomicInt32Array] | 
The  
null value.
 | 
| null [AtomicInt32] | 
The  
null value.
 | 
| null [AtomicBool] | 
The  
null value.
 | 
| num_bits_int [Int_misc] | |
| num_digits_big_int [Big_int] | 
Return the number of machine words used to store the
           given big integer.
 
 | 
| num_digits_nat [Nat] | |
| num_dims [Bigarray.Genarray] | 
Return the number of dimensions of the given big array.
 
 | 
| num_leading_zero_bits_in_digit [Nat] | |
| num_of_big_int [Num] | |
| num_of_int [Num] | |
| num_of_nat [Num] | |
| num_of_ratio [Num] | |
| num_of_string [Num] | 
Convert a string to a number.
 
 | 
O  | |
| obj [Obj] | |
| object_tag [Obj] | |
| ocaml_version [Sys] | ocaml_version is the version of OCaml.
 | 
| 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_char [JavaChar] | 
Converts a plain OCaml  
char into a java_char.
 | 
| of_date [JavaCalendar] | 
Converts the passed date into a calendar.
 
 | 
| 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_iso8601 [JavaCalendar] | 
Converts the passed string into a calendar.
 
 | 
| of_list [Stream] | 
Return the stream holding the elements of the list in the same
   order.
 
 | 
| of_list [StdLabels.Array] | |
| of_list [ParallelArray.S] | |
| of_list [ParallelArray] | 
Synonym for  
Array.of_list.
 | 
| of_list [JavaShortArray] | of_list l returns the elements of l as an array.
 | 
| of_list [JavaLongArray] | of_list l returns the elements of l as an array.
 | 
| of_list [JavaIntArray] | of_list l returns the elements of l as an array.
 | 
| of_list [JavaFloatArray] | of_list l returns the elements of l as an array.
 | 
| of_list [JavaDoubleArray] | of_list l returns the elements of l as an array.
 | 
| of_list [JavaCharArray] | of_list l returns the elements of l as an array.
 | 
| of_list [JavaByteArray] | of_list l returns the elements of l as an array.
 | 
| of_list [JavaBooleanArray] | of_list l returns the elements of l as an array.
 | 
| of_list [JavaArraySignature.T] | |
| 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_object [JavaShortArray] | of_object o casts object o to array.
 | 
| of_object [JavaReferenceArray] | of_object o casts object o to array.
 | 
| of_object [JavaLongArray] | of_object o casts object o to array.
 | 
| of_object [JavaIntArray] | of_object o casts object o to array.
 | 
| of_object [JavaFloatArray] | of_object o casts object o to array.
 | 
| of_object [JavaDoubleArray] | of_object o casts object o to array.
 | 
| of_object [JavaCharArray] | of_object o casts object o to array.
 | 
| of_object [JavaByteArray] | of_object o casts object o to array.
 | 
| of_object [JavaBooleanArray] | of_object o casts object o to array.
 | 
| of_object [JavaArraySignature.T] | |
| of_ocaml [JavaShortArray] | of_ocaml a returns a Java array equivalent to a.
 | 
| of_ocaml [JavaLongArray] | of_ocaml a returns a Java array equivalent to a.
 | 
| of_ocaml [JavaIntArray] | of_ocaml a returns a Java array equivalent to a.
 | 
| of_ocaml [JavaFloatArray] | of_ocaml a returns a Java array equivalent to a.
 | 
| of_ocaml [JavaDoubleArray] | of_ocaml a returns a Java array equivalent to a.
 | 
| of_ocaml [JavaCharArray] | of_ocaml a returns a Java array equivalent to a.
 | 
| of_ocaml [JavaByteArray] | of_ocaml a returns a Java array equivalent to a.
 | 
| of_ocaml [JavaBooleanArray] | of_ocaml a returns a Java array equivalent to a.
 | 
| of_ocaml [JavaArraySignature.T] | |
| of_ocaml_string [JavaByteArray] | of_string x returns the array wrapped inside x.
 | 
| 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 [JavaString] | of_string s converts the OCaml string s into a Java string.
 | 
| of_string [JavaDate] | 
Converts the passed string into a date.
 
 | 
| of_string [Int64] | 
Convert the given string to a 64-bit integer.
 
 | 
| of_string [Int32] | 
Convert the given string to a 32-bit integer.
 
 | 
| one [Nativeint] | 
The native integer 1.
 
 | 
| one [Int64] | 
The 64-bit integer 1.
 
 | 
| one [Int32] | 
The 32-bit integer 1.
 
 | 
| one [Complex] | 
The complex number  
1.
 | 
| open_box [Format] | open_box d opens a new pretty-printing box
   with offset d.
 | 
| open_connection [Unix] | 
Connect to a server at the given address.
 
 | 
| 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 [Scanf.Scanning] | Scanning.open_in fname returns a formatted input channel for bufferized
    reading in text mode from file fname.
 | 
| 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 [JavaIOStreams] | open_in ?buffered str returns a new java.io.InputStream
    instance reading data from the file whose path is str.
 | 
| open_in_bin [Scanf.Scanning] | Scanning.open_in_bin fname returns a formatted input channel for
    bufferized reading in binary mode from file fname.
 | 
| 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_in_gen mode perm filename opens the named file for reading,
   as described 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 [JavaIOStreams] | open_out ?buffered str returns a new java.io.OutputStream
    instance writing data to the file whose path is str.
 | 
| 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_out_gen mode perm filename opens the named file for writing,
   as described above.
 | 
| open_process [Unix] | 
Same as  
Unix.open_process_out, but redirects both the standard input
   and standard output of the command to pipes connected to the two
   returned channels.
 | 
| open_process_full [Unix] | 
Similar to  
Unix.open_process, but the second argument specifies
   the environment passed to the command.
 | 
| open_process_in [Unix] | 
High-level pipe and process management.
 
 | 
| open_process_out [Unix] | 
Same as  
Unix.open_process_in, but redirect the standard input of
   the command to a pipe.
 | 
| open_tag [Format] | open_tag t opens the tag named t; the print_open_tag
   function of the formatter is called with t as argument;
   the tag marker mark_open_tag t will be flushed into the output
   device of the formatter.
 | 
| open_tbox [Format] | 
Opens a tabulation box.
 
 | 
| open_temp_file [Filename] | 
Same as  
Filename.temp_file, but returns both the name of a fresh
   temporary file, and an output channel opened (atomically) on
   this file.
 | 
| open_vbox [Format] | open_vbox d opens a new pretty-printing box
   with offset d.
 | 
| opendir [Unix] | 
Open a descriptor on a directory
 
 | 
| openfile [Unix] | 
Open the named file with the given flags.
 
 | 
| options [JavaServlet] | options resp l is an implementation of do_options _ _ _ resp
    where l is the list of methods supported by the servlet.
 | 
| or_big_int [Big_int] | 
Bitwise logical 'or'.
 
 | 
| os_type [Sys] | 
Operating system currently executing the OCaml program.
 
 | 
| out_channel_length [Pervasives.LargeFile] | |
| out_channel_length [Pervasives] | 
Return the size (number of characters) of the regular file
   on which the given channel is opened.
 
 | 
| out_channel_of_descr [Unix] | 
Create an output channel writing on the given descriptor.
 
 | 
| out_channel_of_output_stream [JavaIOStreams] | out_channel_of_output_stream os converts the output stream os
    into a new output channel.
 | 
| out_of_heap_tag [Obj] | |
| output [Pervasives] | output oc buf pos len writes len characters from string buf,
   starting at offset pos, to the given output channel oc.
 | 
| output [Digest] | 
Write a digest on the given output channel.
 
 | 
| output_binary_int [Pervasives] | 
Write one integer in binary format (4 bytes, big-endian)
   on the given output channel.
 
 | 
| output_buffer [Buffer] | output_buffer oc b writes the current contents of buffer b
   on the output channel oc.
 | 
| output_byte [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_stream_of_out_channel [JavaIOStreams] | output_stream_of_out_channel oc converts the output channel oc
    into a new output stream.
 | 
| output_string [Pervasives] | 
Write the string on the given output channel.
 
 | 
| output_string [JavaString] | output_string ch s prints s onto channel ch.
 | 
| output_value [Pervasives] | 
Write the representation of a structured value of any type
   to a channel.
 
 | 
| over_max_boxes [Format] | 
Tests if the maximum number of boxes allowed have already been opened.
 
 | 
P  | |
| parameter_info [JavaApplet.Graphics] | 
The value to be returned by the getParameterInfo(...) method.
 
 | 
| parameter_info [JavaApplet.Swing] | 
The value to be returned by the getParameterInfo(...) method.
 
 | 
| parameter_info [JavaApplet.AWT] | 
The value to be returned by the getParameterInfo(...) method.
 
 | 
| parameter_info_of_list [JavaApplet] | 
Converts a list of parameters into a parameter info, preserving the
    order of elements.
 
 | 
| params [CamlinternalOO] | |
| parent_dir_name [Filename] | 
The conventional name for the parent of the current directory
   (e.g.
 
 | 
| parent_of [ThreadGroup] | |
| parse [Arg] | Arg.parse speclist anon_fun usage_msg parses the command line.
 | 
| parse_argv [Arg] | Arg.parse_argv ~current args speclist anon_fun usage_msg parses
  the array args as if it were the command line.
 | 
| parse_argv_dynamic [Arg] | 
Same as  
Arg.parse_argv, except that the speclist argument is a
    reference and may be updated during the parsing.
 | 
| parse_boolean [JavaBoolean] | 
Converts the passed string into a boolean; see
    parseBoolean(...).
 
 | 
| parse_byte [JavaByte] | 
Converts the passed string into a byte wrapper, using the passed
    radix (defaulting to  
10l); see
    parseByte(...).
 | 
| parse_double [JavaDouble] | 
Converts the passed string into a double wrapper; see
    parseDouble(...).
 
 | 
| parse_dynamic [Arg] | 
Same as  
Arg.parse, except that the speclist argument is a reference
    and may be updated during the parsing.
 | 
| parse_float [JavaFloat] | 
Converts the passed string into a float wrapper; see
    parseFloat(...).
 
 | 
| parse_int [JavaInt] | 
Converts the passed string into a integer wrapper, using the passed
    radix (defaulting to  
10l); see
    parseInt(...).
 | 
| parse_long [JavaLong] | 
Converts the passed string into a long wrapper, using the passed
    radix (defaulting to  
10l); see
    parseLong(...).
 | 
| parse_short [JavaShort] | 
Converts the passed string into a short wrapper, using the passed
    radix (defaulting to  
10l); see
    parseShort(...).
 | 
| 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 [MoreLabels.Map.S] | |
| partition [Map.S] | partition p m returns a pair of maps (m1, m2), where
        m1 contains all the bindings of s that satisfy the
        predicate p, and m2 is the map with all the bindings of
        s that do not satisfy p.
 | 
| 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 [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 [Unix] | 
Create a pipe.
 
 | 
| plot [Graphics] | 
Plot the given point with the current drawing color.
 
 | 
| plots [Graphics] | 
Plot the given points with the current drawing color.
 
 | 
| point_color [Graphics] | 
Return the color of the given point in the backing store
   (see "Double buffering" below).
 
 | 
| polar [Complex] | polar norm arg returns the complex having norm norm
    and argument arg.
 | 
| poll [ExecutorCompletionService] | 
Returns (and removes from the service) a completed task if any, or
    returns  
None; see poll(...).
 | 
| poll_time [ExecutorCompletionService] | poll_time s t u is similar to pool s, except that the current
    thread will at most wait for t (time value whose unit is u); see
    poll(...).
 | 
| pool [ParallelArray.OptionalParameters] | 
The pool to be used for parallel computations.
 
 | 
| pop [Stack] | pop s removes and returns the topmost element in stack s,
   or raises Empty if the stack is empty.
 | 
| pop [Queue] | pop is a synonym for take.
 | 
| pos_in [Pervasives.LargeFile] | |
| pos_in [Pervasives] | 
Return the current reading position for the given channel.
 
 | 
| pos_out [Pervasives.LargeFile] | |
| pos_out [Pervasives] | 
Return the current writing position for the given channel.
 
 | 
| positive_infinity [JavaFloat] | 
The constant for the positive infinity.
 
 | 
| positive_infinity [JavaDouble] | 
The constant for the positive infinity.
 
 | 
| pow [Complex] | 
Power function.
 
 | 
| power_base_int [Nat] | |
| power_big_int_positive_big_int [Big_int] | 
Exponentiation functions.
 
 | 
| power_big_int_positive_int [Big_int] | |
| power_int_positive_big_int [Big_int] | |
| power_int_positive_int [Big_int] | |
| power_num [Num] | 
Exponentiation
 
 | 
| pp_close_box [Format] | |
| pp_close_tag [Format] | |
| pp_close_tbox [Format] | |
| pp_force_newline [Format] | |
| pp_get_all_formatter_output_functions [Format] | 
Deprecated.
 
 | 
| pp_get_ellipsis_text [Format] | |
| pp_get_formatter_out_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_formatter_output_functions [Format] | |
| pp_get_formatter_tag_functions [Format] | |
| pp_get_margin [Format] | |
| pp_get_mark_tags [Format] | |
| pp_get_max_boxes [Format] | |
| pp_get_max_indent [Format] | |
| pp_get_print_tags [Format] | |
| pp_open_box [Format] | |
| pp_open_hbox [Format] | |
| pp_open_hovbox [Format] | |
| pp_open_hvbox [Format] | |
| pp_open_tag [Format] | |
| pp_open_tbox [Format] | |
| pp_open_vbox [Format] | |
| pp_over_max_boxes [Format] | |
| pp_print_as [Format] | |
| pp_print_bool [Format] | |
| pp_print_break [Format] | |
| pp_print_char [Format] | |
| pp_print_cut [Format] | |
| pp_print_float [Format] | |
| pp_print_flush [Format] | |
| pp_print_if_newline [Format] | |
| pp_print_int [Format] | |
| pp_print_newline [Format] | |
| pp_print_space [Format] | |
| pp_print_string [Format] | |
| pp_print_tab [Format] | |
| pp_print_tbreak [Format] | |
| pp_set_all_formatter_output_functions [Format] | 
Deprecated.
 
 | 
| pp_set_ellipsis_text [Format] | |
| pp_set_formatter_out_channel [Format] | |
| pp_set_formatter_out_functions [Format] | |
| pp_set_formatter_output_functions [Format] | |
| pp_set_formatter_tag_functions [Format] | |
| pp_set_margin [Format] | |
| pp_set_mark_tags [Format] | |
| pp_set_max_boxes [Format] | |
| pp_set_max_indent [Format] | |
| pp_set_print_tags [Format] | |
| pp_set_tab [Format] | |
| pp_set_tags [Format] | |
| prc [JavaLocale] | |
| 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_endline [JavaString] | prerr_endline s prints s followed by a newline character onto the
    error ouput.
 | 
| 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_newline [JavaString] | prerr_newline () prints a newline character onto the error ouput.
 | 
| prerr_string [Pervasives] | 
Print a string on standard error.
 
 | 
| prerr_string [JavaString] | prerr_string s prints s onto the error ouput.
 | 
| 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_backtrace [Printexc] | Printexc.print_backtrace oc prints an exception backtrace
    on the output channel oc.
 | 
| print_bool [Format] | 
Prints a boolean in the current box.
 
 | 
| print_break [Format] | 
Inserts a break hint in a pretty-printing box.
 
 | 
| print_char [Pervasives] | 
Print a character on standard output.
 
 | 
| print_char [Format] | 
Prints a character in the current box.
 
 | 
| print_cut [Format] | print_cut () is used to mark a good break position.
 | 
| print_endline [Pervasives] | 
Print a string, followed by a newline character, on
   standard output and flush standard output.
 
 | 
| print_endline [JavaString] | print_endline s prints s followed by a newline character onto the
    standard ouput.
 | 
| print_float [Pervasives] | 
Print a floating-point number, in decimal, on standard output.
 
 | 
| print_float [Format] | 
Prints a floating point number in the current box.
 
 | 
| print_flush [Format] | 
Flushes the pretty printer: all opened boxes are closed,
   and all pending text is displayed.
 
 | 
| print_if_newline [Format] | 
Executes the next formatting command if the preceding line
   has just been split.
 
 | 
| print_int [Pervasives] | 
Print an integer, in decimal, on standard output.
 
 | 
| print_int [Format] | 
Prints an integer in the current box.
 
 | 
| print_newline [Pervasives] | 
Print a newline character on standard output, and flush
   standard output.
 
 | 
| print_newline [JavaString] | print_newline () prints a newline character onto the standard ouput.
 | 
| print_newline [Format] | 
Equivalent to  
print_flush followed by a new line.
 | 
| print_raw_backtrace [Printexc] | |
| print_space [Format] | print_space () is used to separate items (typically to print
   a space between two words).
 | 
| print_stack_trace [JavaThrowable] | 
Returns the stack trace; see printStackTrace(...).
 
 | 
| print_stack_trace [JavaException] | 
Returns the stack trace; see printStackTrace(...).
 
 | 
| print_stack_trace [JavaError] | 
Returns the stack trace; see printStackTrace(...).
 
 | 
| 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 [JavaString] | print_string s prints s onto the standard ouput.
 | 
| 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 [JavaStringPrintf] | 
This function can be passed to  
Printf.printf to print a Java
    string through a "%a" conversion specification.
 | 
| printf [JavaStringFormat] | 
This function can be passed to  
Format.printf to print a Java
    string through a "%a" conversion specification.
 | 
| printf [Format] | 
Same as  
fprintf above, but output on std_formatter.
 | 
| prohibit [Dynlink] | prohibit units prohibits dynamically-linked units from referencing
    the units named in list units.
 | 
| proxy [Java] | 
Synonym for  
Java.proxy_system.
 | 
| proxy_loader [Java] | proxy_loader desc cl impl returns an instance that implements the
    interfaces specified by desc, using the methods provided by impl.
 | 
| proxy_runtime [Java] | 
Similar to  
Java.proxy_loader, but uses the class loader that was used to
    load the OCaml-Java runtime.
 | 
| proxy_system [Java] | 
Similar to  
Java.proxy_loader, but uses the system class loader.
 | 
| public_method_label [CamlinternalOO] | |
| push [Stack] | push x s adds the element x at the top of stack s.
 | 
| push [Queue] | push is a synonym for add.
 | 
| putenv [Unix] | Unix.putenv name value sets the value associated to a
   variable in the process environment.
 | 
Q  | |
| quick_stat [Gc] | 
Same as  
stat except that live_words, live_blocks, free_words,
    free_blocks, largest_free, and fragments are set to 0.
 | 
| 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 command line, escaping all meta-characters.
 
 | 
R  | |
| raise [Pervasives] | 
Raise the given exception value
 
 | 
| randomize [MoreLabels.Hashtbl] | |
| randomize [Hashtbl] | 
After a call to  
Hashtbl.randomize(), hash tables are created in
    randomized mode by default: Hashtbl.create returns randomized
    hash tables, unless the ~random:false optional parameter is given.
 | 
| ratio_of_num [Num] | |
| raw_backtrace_to_string [Printexc] | |
| 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 s before position stop+1.
 | 
| rcontains_from [StdLabels.String] | |
| rcontains_from [JavaString.OCaml] | 
Similar to  
String.rcontains_from.
 | 
| 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_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.
 
 | 
| read_line [JavaString] | read_line () reads a line from the standard input.
 | 
| read_lock [ReadWriteLock] | 
Returns the read lock of the read/write lock; see
    readLock(...).
 
 | 
| readdir [Unix] | 
Return the next entry in a directory.
 
 | 
| readdir [Sys] | 
Return the names of all files present in the given directory.
 
 | 
| readlink [Unix] | 
Read the contents of a link.
 
 | 
| really_input [Pervasives] | really_input ic buf pos len reads len characters from channel ic,
   storing them in string buf, starting at character number pos.
 | 
| record_backtrace [Printexc] | Printexc.record_backtrace b turns recording of exception backtraces
    on (if b = true) or off (if b = false).
 | 
| recv [Unix] | 
Receive data from a connected socket.
 
 | 
| recvfrom [Unix] | 
Receive data from an unconnected socket.
 
 | 
| red [Graphics] | |
| reduce [MapReduce.Computation] | 
reduce operation, folding over all key/value couple in order to
      produce the final result.
 
 | 
| ref [STM] | 
Builds a value of type  
ref, that can then only be accessed during
    a transaction.
 | 
| 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 [Phaser] | 
Adds a new unarrived party to the phaser, and returns the current
    phase number; see register(...).
 
 | 
| register [Callback] | Callback.register n v registers the value v under
   the name n.
 | 
| register_exception [Callback] | Callback.register_exception n exn registers the
   exception contained in the exception value exn
   under the name n.
 | 
| register_printer [Printexc] | Printexc.register_printer fn registers fn as an exception
    printer.
 | 
| release [Semaphore] | |
| rem [Nativeint] | 
Integer remainder.
 
 | 
| rem [Int64] | 
Integer remainder.
 
 | 
| rem [Int32] | 
Integer remainder.
 
 | 
| remember_mode [Graphics] | 
Set remember mode on or off.
 
 | 
| remove [Weak.S] | remove t x removes from t one instance of x.
 | 
| remove [ThreadLocal] | 
Removes the value of the thread-local variable for the current
    thread.
 
 | 
| 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.SeededS] | |
| 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.SeededS] | |
| remove [Hashtbl.S] | |
| remove [Hashtbl] | Hashtbl.remove tbl x removes the current binding of x in tbl,
   restoring the previous binding if it exists.
 | 
| remove_assoc [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_assoc, but uses physical equality instead
   of structural equality to compare keys.
 | 
| remove_assq [List] | 
Same as  
List.remove_assoc, but uses physical equality instead
   of structural equality to compare keys.
 | 
| rename [Unix] | rename old new changes the name of a file from old to new.
 | 
| rename [Sys] | 
Rename a file.
 
 | 
| replace [MoreLabels.Hashtbl.SeededS] | |
| replace [MoreLabels.Hashtbl.S] | |
| replace [MoreLabels.Hashtbl] | |
| replace [JavaStringBuilder] | replace sb start end str replaces the characters from index start
    (inclusive) to index end (exclusive) from builder sb by
    characters from str; see
    replace(...).
 | 
| replace [Hashtbl.SeededS] | |
| 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_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 [MoreLabels.Hashtbl.SeededS] | |
| reset [MoreLabels.Hashtbl.S] | |
| reset [MoreLabels.Hashtbl] | |
| reset [Hashtbl.SeededS] | |
| reset [Hashtbl.S] | |
| reset [Hashtbl] | 
Empty a hash table and shrink the size of the bucket table
    to its initial size.
 
 | 
| reset [CyclicBarrier] | 
Resets the barrier to its original state.
 
 | 
| 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.
 | 
| resize_window [Graphics] | 
Resize and erase the graphics window.
 
 | 
| 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 l1 l2 gives the same result as
   ListLabels.rev (ListLabels.map2 f l1 l2), but is tail-recursive and
   more efficient.
 | 
| rev_map2 [List] | |
| 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_end_pos [Parsing] | 
Same as  
rhs_end, but return a position instead of an offset.
 | 
| rhs_start [Parsing] | 
Same as  
Parsing.symbol_start and Parsing.symbol_end, but
   return the offset of the string matching the nth item on the
   right-hand side of the rule, where n is the integer parameter
   to rhs_start and rhs_end.
 | 
| rhs_start_pos [Parsing] | 
Same as  
rhs_start, but return a position instead of an offset.
 | 
| 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 character number of the last
   occurrence of character c in string s.
 | 
| rindex [StdLabels.String] | |
| rindex [JavaString.OCaml] | 
Similar to  
String.rindex.
 | 
| rindex_from [StringLabels] | 
Same as  
StringLabels.rindex, but start
   searching at the character position given as second argument.
 | 
| rindex_from [String] | String.rindex_from s i c returns the character number of the
   last occurrence of character c in string s before position i+1.
 | 
| rindex_from [StdLabels.String] | |
| rindex_from [JavaString.OCaml] | 
Similar to  
String.rindex_from.
 | 
| 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 [Unix] | 
Remove an empty directory.
 
 | 
| rmoveto [Graphics] | rmoveto dx dy translates the current point by the given vector.
 | 
| round_num [Num] | round_num n returns the integer closest to n.
 | 
| run [STM] | run ~retries f executes the function f inside a newly-created
    transaction.
 | 
| run [JavaApplet.Graphics] | 
Callback called for each event.
 
 | 
| run_finalization [JavaSystem] | 
Runs the finalization methods of objects pending finalization; see
    runFinalization(...).
 
 | 
| run_initializers [CamlinternalOO] | |
| run_initializers_opt [CamlinternalOO] | |
| run_read_only [STM] | 
Akin to  
STM.run, but with a smaller overhead due to the fact that the
    transaction is guaranteed to only read values.
 | 
S  | |
| scanf [Scanf] | 
Same as  
Scanf.bscanf, but reads from the predefined formatted input
    channel Scanf.Scanning.stdin that is connected to Pervasives.stdin.
 | 
| schedule [ScheduledThreadPoolExecutor] | schedule p f x t u is similar to submit p f x, except that the
    evaluation of f x with start after t (time value whose unit is
    u).
 | 
| schedule_at_fixed_rate [ScheduledThreadPoolExecutor] | schedule_at_fixed_rate p f x t d u is similar to schedule p f x t u,
    except that f x will be re-evaluated at t + d, t + 2 * d, etc.
 | 
| schedule_with_fixed_delay [ScheduledThreadPoolExecutor] | schedule_with_fixed_delay p f x t d u is similar to schedule p f x t u,
    except that f x will be repeatedly re-evaluated, respecting a delay
    of d between the end of one execution and the beginning of the next
    one.
 | 
| search_backward [Str] | search_backward r s last searches the string s for a
  substring matching the regular expression r.
 | 
| search_forward [Str] | search_forward r s start searches the string s for a substring
   matching the regular expression r.
 | 
| seconds [TimeUnit] | 
Time unit for seconds.
 
 | 
| seeded_hash [MoreLabels.Hashtbl] | |
| seeded_hash [Hashtbl] | 
A variant of  
Hashtbl.hash that is further parameterized by
   an integer seed.
 | 
| seeded_hash_param [MoreLabels.Hashtbl] | |
| seeded_hash_param [Hashtbl] | 
A variant of  
Hashtbl.hash_param that is further parameterized by
   an integer seed.
 | 
| seek_in [Pervasives.LargeFile] | |
| seek_in [Pervasives] | seek_in chan pos sets the current reading position to pos
   for channel chan.
 | 
| seek_out [Pervasives.LargeFile] | |
| seek_out [Pervasives] | seek_out chan pos sets the current writing position to pos
   for channel chan.
 | 
| select [Unix] | 
Wait until some input/output operations become possible on
   some channels.
 
 | 
| self_init [Random] | 
Initialize the generator with a random seed chosen
   in a system-dependent way.
 
 | 
| send [Unix] | 
Send data over a connected socket.
 
 | 
| send [CamlinternalOO] | |
| sendcache [CamlinternalOO] | |
| sendself [CamlinternalOO] | |
| sendto [Unix] | 
Send data over an unconnected socket.
 
 | 
| service [JavaServlet.Generic] | service v inst req resp handles the request req through the
      servlet instance inst (associated to value v).
 | 
| service [JavaServlet.Default_Generic] | |
| session_created [JavaServlet.HTTPSessionListener] | 
Called to notify that a session was created; see
      sessionCreated(...).
 
 | 
| session_destroyed [JavaServlet.HTTPSessionListener] | 
Called to notify that a session is about to be invalidated; see
      sessionDestroyed(...).
 
 | 
| session_did_activate [JavaServlet.HTTPSessionActivationListener] | 
Called to notify that a session has just been activated; see
      sessionDidActivate(...).
 
 | 
| session_id_changed [JavaServlet.HTTPSessionIdListener] | 
Called to notify that the session identifier has changed; see
      sessionIdChanged(...).
 
 | 
| session_will_passivate [JavaServlet.HTTPSessionActivationListener] | 
Called to notify that a session is about to be passivated; see
      sessionWillPassivate(...).
 
 | 
| 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 [ThreadLocal] | 
Modifies the value of the thread-local variable for the current
    thread; see set(...).
 
 | 
| 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 [ParallelArray.S] | |
| set [ParallelArray] | 
Synonym for  
Array.set.
 | 
| set [JavaShortArray] | set a i x changes the element at index i in a to x.
 | 
| set [JavaReferenceArray] | set a i x changes the element at index i in a to x.
 | 
| set [JavaLongArray] | set a i x changes the element at index i in a to x.
 | 
| set [JavaIntArray] | set a i x changes the element at index i in a to x.
 | 
| set [JavaFloatArray] | set a i x changes the element at index i in a to x.
 | 
| set [JavaDoubleArray] | set a i x changes the element at index i in a to x.
 | 
| set [JavaCharArray] | set a i x changes the element at index i in a to x.
 | 
| set [JavaCalendar] | set cal f v returns a new instance that is equal to cal, with
    the field f changed to v; see
    set(...).
 | 
| set [JavaByteArray] | set a i x changes the element at index i in a to x.
 | 
| set [JavaBooleanArray] | set a i x changes the element at index i in a to x.
 | 
| set [JavaArraySignature.T] | |
| set [JavaArray] | set a i x changes the element at index i in a to x.
 | 
| set [Java] | set desc obj x changes the value of field desc for
    instance obj to x.
 | 
| set [Gc] | set r changes the GC parameters according to the control record r.
 | 
| set [Bigarray.Array3] | Array3.set a x y v, or alternatively a.{x,y,z} <- v,
     stores the value v at coordinates (x, y, z) in a.
 | 
| set [Bigarray.Array2] | Array2.set a x y v, or alternatively a.{x,y} <- v,
     stores the value v at coordinates (x, y) in a.
 | 
| set [Bigarray.Array1] | Array1.set a x v, also written a.{x} <- v,
     stores the value v at index x in a.
 | 
| set [Bigarray.Genarray] | 
Assign an element of a generic big array.
 
 | 
| set [AtomicStampedReference] | set a x s sets the value of a to x, and the stamp to s.
 | 
| set [AtomicReferenceArray] | set a i x sets the value of a at index i to x.
 | 
| set [AtomicReference] | set a x sets the value of a to x.
 | 
| set [AtomicMarkableReference] | set a x m sets the value of a to x, and the mark to m.
 | 
| set [AtomicInt64Array] | set a i x sets the value of a at index i to x.
 | 
| set [AtomicInt64] | set a x sets the value of a to x.
 | 
| set [AtomicInt32Array] | set a i x sets the value of a at index i to x.
 | 
| set [AtomicInt32] | set a x sets the value of a to x.
 | 
| set [AtomicBool] | set a x sets the value of a to x.
 | 
| 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] | 
Deprecated.
 
 | 
| 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_char_at [JavaStringBuilder] | 
Changes the character at the passed index in the passed builder; see
    setCharAt(...).
 
 | 
| set_close_on_exec [Unix] | 
Set the ``close-on-exec'' flag on the given descriptor.
 
 | 
| set_color [Graphics] | 
Set the current drawing color.
 
 | 
| set_continue_existing_periodic_tasks_after_shutdown_policy [ScheduledThreadPoolExecutor] | 
Changes whether periodic tasks should continue execution after
    shutdown; see
    setContinueExistingPeriodicTasksAfterShutdownPolicy(...).
 
 | 
| set_core_pool_size [ThreadPoolExecutor] | 
Changes the core size of the pool (number of threads kept in the
    pool, even if idle); see
    setCorePoolSize(...).
 
 | 
| set_core_pool_size [ScheduledThreadPoolExecutor] | |
| set_daemon [ThreadGroup] | 
Sets the daemon status of the group.
 
 | 
| set_daemon [Thread] | 
Changes the daemon status of the thread; see
    setDaemon(...).
 
 | 
| set_default [JavaTimeZone] | set_default tz changes the default time zone to tz if not null.
 | 
| set_default [JavaLocale] | set_default loc changes the default locale to loc.
 | 
| set_digit_nat [Nat] | |
| set_digit_nat_native [Nat] | |
| set_double_field [Obj] | |
| 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_execute_existing_delayed_tasks_after_shutdown_policy [ScheduledThreadPoolExecutor] | 
changes whether delayed tasks should continue execution after
    shutdown; see
    setExecuteExistingDelayedTasksAfterShutdownPolicy(...).
 
 | 
| 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_out_functions [Format] | set_formatter_out_functions out_funs
   Redirect the pretty-printer output to the functions out_funs.out_string
   and out_funs.out_flush as described in
   set_formatter_output_functions.
 | 
| set_formatter_output_functions [Format] | set_formatter_output_functions out flush redirects the
   pretty-printer output functions to the functions out and
   flush.
 | 
| set_formatter_tag_functions [Format] | set_formatter_tag_functions tag_funs changes the meaning of
   opening and closing tags to use the functions in tag_funs.
 | 
| set_keep_alive_time [ThreadPoolExecutor] | 
Changes the keep alive time (how long to keep alive idle threads not
    in the core); see
    setKeepAliveTime(...).
 
 | 
| set_keep_alive_time [ScheduledThreadPoolExecutor] | |
| set_length [JavaStringBuilder] | 
Sets the length of the passed builder to the passed value; see
    setLength(...).
 
 | 
| set_line_width [Graphics] | 
Set the width of points and lines drawn with the functions above.
 
 | 
| set_margin [Format] | set_margin d sets the value of the right margin
   to d (in characters): this value is used to detect line
   overflows that leads to split lines.
 | 
| set_mark_tags [Format] | set_print_tags b turns on or off the printing of tags, while
    set_mark_tags b turns on or off the output of tag markers.
 | 
| set_max_boxes [Format] | set_max_boxes max sets the maximum number of boxes simultaneously
   opened.
 | 
| set_max_indent [Format] | set_max_indent d sets the value of the maximum
   indentation limit to d (in characters):
   once this limit is reached, boxes are rejected to the left,
   if they do not fit on the current line.
 | 
| set_max_priority [ThreadGroup] | 
Sets the maximum priority of the group; see
    setMaxPriority(...).
 
 | 
| set_maximum_pool_size [ThreadPoolExecutor] | 
Changes the maximum pool size (maximum number of threads in the
    pool); see
    setMaximumPoolSize(...).
 
 | 
| set_maximum_pool_size [ScheduledThreadPoolExecutor] | |
| set_method [CamlinternalOO] | |
| set_methods [CamlinternalOO] | |
| set_name [Thread] | 
Changes the name of the thread; see
    setName(...).
 
 | 
| set_nonblock [Unix] | 
Set the ``non-blocking'' flag on the given descriptor.
 
 | 
| set_normalize_ratio [Arith_status] | 
Get or set the flag  
normalize_ratio.
 | 
| set_normalize_ratio_when_printing [Arith_status] | 
Get or set the flag  
normalize_ratio_when_printing.
 | 
| set_print_tags [Format] | |
| set_priority [Thread] | 
Changes the priority of the thread; see
    setPriority(...).
 
 | 
| set_property [JavaSystem] | set_property name value change the system property named name to
    value, returning its previous value if any; see
    setProperty(...).
 | 
| set_property [JavaProperties] | set_property props key value set the property with key key to
    value value in props, returning the previous value if any; see
    setProperty(...).
 | 
| set_rejected_execution_handler [ThreadPoolExecutor] | 
Changes the policy for blocked computations; see
    setRejectedExecutionHandler(...).
 
 | 
| set_rejected_execution_handler [ScheduledThreadPoolExecutor] | |
| set_remove_on_cancel_policy [ScheduledThreadPoolExecutor] | 
Changes whether tasks should be removed when cancelled.
 
 | 
| set_seed [JavaRandom] | |
| set_signal [Sys] | 
Same as  
Sys.signal but return value is ignored.
 | 
| set_state [Random] | 
Set the state of the generator used by the basic functions.
 
 | 
| set_tab [Format] | 
Sets a tabulation mark at the current insertion point.
 
 | 
| set_tag [Obj] | |
| set_tags [Format] | set_tags b turns on or off the treatment of tags (default is off).
 | 
| set_temp_dir_name [Filename] | 
Change the temporary directory returned by  
Filename.get_temp_dir_name
    and used by Filename.temp_file and Filename.open_temp_file.
 | 
| set_text_size [Graphics] | 
Set the character size used for drawing text.
 
 | 
| set_time_zone [JavaCalendar] | set_time_zone cal tz returns a new instance that is equal to cal,
    with the time zone set to tz; see
    setTimeZone(...).
 | 
| set_to_zero_nat [Nat] | |
| set_trace [Parsing] | 
Control debugging support for  
ocamlyacc-generated parsers.
 | 
| set_window_title [Graphics] | 
Set the title of the graphics window.
 
 | 
| setgid [Unix] | 
Set the real group id and effective group id for the process.
 
 | 
| setgroups [Unix] | setgroups groups sets the supplementary group IDs for the
      calling process.
 | 
| setitimer [Unix] | setitimer t s sets the interval timer t and returns
   its previous status.
 | 
| setsid [Unix] | 
Put the calling process in a new session and detach it from
   its controlling terminal.
 
 | 
| setsockopt [Unix] | 
Set or clear a boolean-valued option in the given socket.
 
 | 
| setsockopt_float [Unix] | 
Same as  
Unix.setsockopt for a socket option whose value is a
   floating-point number.
 | 
| setsockopt_int [Unix] | 
Same as  
Unix.setsockopt for an integer-valued socket option.
 | 
| setsockopt_optint [Unix] | 
Same as  
Unix.setsockopt for a socket option whose value is an
   int option.
 | 
| setuid [Unix] | 
Set the real user id and effective user id for the process.
 
 | 
| shift_left [Nativeint] | Nativeint.shift_left x y shifts x to the left by y bits.
 | 
| shift_left [Int64] | Int64.shift_left x y shifts x to the left by y bits.
 | 
| shift_left [Int32] | Int32.shift_left x y shifts x to the left by y bits.
 | 
| shift_left_big_int [Big_int] | shift_left_big_int b n returns b shifted left by n bits.
 | 
| shift_left_nat [Nat] | |
| 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_big_int [Big_int] | shift_right_big_int b n returns b shifted right by n bits.
 | 
| shift_right_logical [Nativeint] | Nativeint.shift_right_logical x y shifts x to the right
   by y bits.
 | 
| shift_right_logical [Int64] | Int64.shift_right_logical x y shifts x to the right by y bits.
 | 
| shift_right_logical [Int32] | Int32.shift_right_logical x y shifts x to the right by y bits.
 | 
| shift_right_nat [Nat] | |
| shift_right_towards_zero_big_int [Big_int] | shift_right_towards_zero_big_int b n returns b shifted
            right by n bits.
 | 
| short_value [JavaShort] | 
Returns the wrapped value, as a short.
 
 | 
| short_value [JavaLong] | 
Returns the wrapped value, as a short.
 
 | 
| short_value [JavaInt] | 
Returns the wrapped value, as a short.
 
 | 
| short_value [JavaFloat] | 
Returns the wrapped value, as a short.
 
 | 
| short_value [JavaDouble] | 
Returns the wrapped value, as a short.
 
 | 
| short_value [JavaByte] | 
Returns the wrapped value, as a short.
 
 | 
| shutdown [Unix] | 
Shutdown a socket connection.
 
 | 
| shutdown [ThreadPoolExecutor] | 
Begins a shutdown, executing all submitted tasks, but refusing new
    tasks; see
    shutdown(...).
 
 | 
| shutdown [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.shutdown.
 | 
| shutdown [ForkJoinPool] | 
Begins a shutdown, executing all submitted tasks, but refusing new
    tasks; see shutdown(...).
 
 | 
| 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.
 | 
| shutdown_now [ThreadPoolExecutor] | 
Begins a shhutdown by cancelling all submitted tasks, and cancelling
    running tasks; see
    shutdownNow(...).
 
 | 
| shutdown_now [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.shutdown_now.
 | 
| shutdown_now [ParallelArray] | 
Shutdowns  
default_pool.
 | 
| shutdown_now [ForkJoinPool] | 
Begins a shhutdown by cancelling all submitted tasks, and cancelling
    running tasks; see
    shutdownNow(...).
 
 | 
| 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_int [Int_misc] | |
| 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] | 
Signals the condition, unblocking one waiting thread; see
    signal(...).
 
 | 
| signal_all [Condition] | 
Signals the condition, unblocking all waiting threads; see
    signalAll(...).
 
 | 
| sigpending [Unix] | 
Return the set of blocked signals that are currently pending.
 
 | 
| sigpipe [Sys] | 
Broken pipe
 
 | 
| 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 [Unix] | sigsuspend sigs atomically sets the blocked signals to sigs
   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
 
 | 
| simplified_chinese [JavaLocale] | |
| sin [Pervasives] | 
Sine.
 
 | 
| single_write [Unix] | 
Same as  
write, but attempts to write only once.
 | 
| singleton [Set.S] | singleton x returns the one-element set containing only x.
 | 
| singleton [MoreLabels.Set.S] | |
| singleton [MoreLabels.Map.S] | |
| singleton [Map.S] | singleton x y returns the one-element map that contains a binding y
        for x.
 | 
| sinh [Pervasives] | 
Hyperbolic sine.
 
 | 
| 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 [Unix] | 
Stop execution for the given number of seconds.
 
 | 
| sleep [Thread] | |
| sleep_nanos [Thread] | |
| 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 [Unix] | 
Create a new socket in the given domain, and with the
   given kind.
 
 | 
| socketpair [Unix] | 
Create a pair of unnamed sockets, connected together.
 
 | 
| sort [StdLabels.List] | |
| sort [StdLabels.Array] | |
| sort [ParallelArray.S] | |
| sort [ParallelArray] | 
Similar to  
Array.sort, except that computations are done in
    parallel; pool indicates the thread pool to use (defaulting to
    default_pool), while chunk_size indicates the size of each chunk
    to be allocated to a thread.
 | 
| 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 [Set.S] | split x s returns a triple (l, present, r), where
          l is the set of elements of s that are
          strictly less than x;
          r is the set of elements of s that are
          strictly greater than x;
          present is false if s contains no element equal to x,
          or true if s contains an element equal to x.
 | 
| split [MoreLabels.Set.S] | |
| split [MoreLabels.Map.S] | |
| split [Map.S] | split x m returns a triple (l, data, r), where
          l is the map with all the bindings of m whose key
        is strictly less than x;
          r is the map with all the bindings of m whose key
        is strictly greater than x;
          data is None if m contains no binding for x,
          or Some v if m binds v to x.
 | 
| split [ListLabels] | 
Transform a list of pairs into a pair of lists:
    
split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]).
 | 
| split [List] | 
Transform a list of pairs into a pair of lists:
    
split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]).
 | 
| split [JavaString] | |
| split [ForkJoin] | split pool fork join f x computes f x by leveraging multiple
    threads from pool.
 | 
| split_array [ForkJoin] | split_array pool fork join f x is similar to split pool fork join f x,
    except that the fork function can generate more than two
    sub-computations.
 | 
| split_delim [Str] | 
Same as  
Str.split but occurrences of the
   delimiter at the beginning and at the end of the string are
   recognized and returned as empty strings in the result.
 | 
| split_list [ForkJoin] | split_list pool fork join f x is similar to split pool fork join f x,
    except that the fork function can generate more than two
    sub-computations.
 | 
| 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 [JavaStringPrintf] | 
This function can be passed to  
Printf.sprintf to print a Java
    string through a "%a" conversion specification.
 | 
| sprintf [JavaStringFormat] | 
This function can be passed to  
Format.sprintf to print a Java
    string through a "%a" conversion specification.
 | 
| sprintf [Format] | 
Same as  
printf above, but instead of printing on a formatter,
   returns a string containing the result of formatting the arguments.
 | 
| sqrt [Pervasives] | 
Square root.
 
 | 
| sqrt [Complex] | 
Square root.
 
 | 
| sqrt_big_int [Big_int] | sqrt_big_int a returns the integer square root of a,
           that is, the largest big integer r such that r * r <= a.
 | 
| sqrt_nat [Nat] | |
| square_big_int [Big_int] | 
Return the square of the given big integer
 
 | 
| square_nat [Nat] | |
| square_num [Num] | 
Squaring
 
 | 
| sscanf [Scanf] | 
Same as  
Scanf.bscanf, but reads from the given string.
 | 
| sscanf_format [Scanf] | 
Same as  
Scanf.bscanf_format, but reads from the given string.
 | 
| stable_sort [StdLabels.List] | |
| stable_sort [StdLabels.Array] | |
| stable_sort [ParallelArray.S] | |
| stable_sort [ParallelArray] | 
Synonym for  
ParallelArray.sort.
 | 
| stable_sort [ListLabels] | 
Same as  
ListLabels.sort, but the sorting algorithm is guaranteed to
   be stable (i.e.
 | 
| stable_sort [List] | 
Same as  
List.sort, but the sorting algorithm is guaranteed to
   be stable (i.e.
 | 
| stable_sort [ArrayLabels] | 
Same as  
ArrayLabels.sort, but the sorting algorithm is stable (i.e.
 | 
| stable_sort [Array] | 
Same as  
Array.sort, but the sorting algorithm is stable (i.e.
 | 
| start [Thread] | 
Starts the execution of the thread; see
    start(...).
 
 | 
| start [JavaApplet.Graphics] | 
The implementation of the start(...) method.
 
 | 
| start [JavaApplet.Swing] | 
The implementation of the start(...) method.
 
 | 
| start [JavaApplet.AWT] | 
The implementation of the start(...) method.
 
 | 
| starts_with [JavaString] | |
| stat [Unix.LargeFile] | |
| stat [Unix] | 
Return the information for the named file.
 
 | 
| stat [Gc] | 
Return the current values of the memory management counters in a
    
stat record.
 | 
| stats [Weak.S] | 
Return statistics on the table.
 
 | 
| stats [MoreLabels.Hashtbl.SeededS] | |
| stats [MoreLabels.Hashtbl.S] | |
| stats [MoreLabels.Hashtbl] | |
| stats [Hashtbl.SeededS] | |
| stats [Hashtbl.S] | |
| stats [Hashtbl] | Hashtbl.stats tbl returns statistics about the table tbl:
   number of buckets, size of the biggest bucket, distribution of
   buckets by size.
 | 
| stats [CamlinternalOO] | |
| std_formatter [Format] | 
The standard formatter used by the formatting functions
   above.
 
 | 
| stdbuf [Format] | 
The string buffer in which  
str_formatter writes.
 | 
| stderr [Unix] | 
File descriptor for standard error.
 
 | 
| stderr [Pervasives] | 
The standard error output for the process.
 
 | 
| stdib [Scanf.Scanning] | 
A deprecated alias for  
Scanning.stdin, the scanning buffer reading from
    Pervasives.stdin.
 | 
| stdin [Unix] | 
File descriptor for standard input.
 
 | 
| stdin [Scanf.Scanning] | 
The standard input notion for the  
Scanf module.
 | 
| stdin [Pervasives] | 
The standard input for the process.
 
 | 
| stdout [Unix] | 
File descriptor for standard output.
 
 | 
| stdout [Pervasives] | 
The standard output for the process.
 
 | 
| stop [JavaApplet.Graphics] | 
The implementation of the stop(...) method.
 
 | 
| stop [JavaApplet.Swing] | 
The implementation of the stop(...) method.
 
 | 
| stop [JavaApplet.AWT] | 
The implementation of the stop(...) method.
 
 | 
| store [JavaProperties] | store props str stores the properties props onto the stream str
    with optional comment commment; see
    store(...).
 | 
| store_to_xml [JavaProperties] | store_to_xml props str stores the properties props onto the
    stream str with optional comment commment; see
    storeToXML(...).
 | 
| 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 a substring of s that
   starts at position start matches 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_format [Pervasives] | 
Converts a format string into a string.
 
 | 
| string_of_inet_addr [Unix] | 
Return the printable representation of the given Internet address.
 
 | 
| string_of_int [Pervasives] | 
Return the string representation of an integer, in decimal.
 
 | 
| string_of_nat [Nat] | |
| string_of_num [Num] | 
Convert a number to a string, using fractional notation.
 
 | 
| string_partial_match [Str] | 
Similar to  
Str.string_match, but also returns true if
   the argument string is a prefix of a string that matches.
 | 
| string_property_names [JavaProperties] | string_property_names props returns the list of the keys for the
    properties defined in props (including defaults); see
    stringPropertyNames(...).
 | 
| 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 substring of s that starts at position start and
   has length len.
 | 
| sub [StdLabels.String] | |
| sub [StdLabels.Array] | |
| sub [ParallelArray.S] | |
| sub [ParallelArray] | 
Synonym for  
Array.sub.
 | 
| sub [Nativeint] | 
Subtraction.
 
 | 
| sub [JavaString.OCaml] | 
Similar to  
String.sub.
 | 
| sub [JavaShortArray] | sub a ofs len returns an array of len elements, copying elements
    from a starting at offset ofs.
 | 
| sub [JavaLongArray] | sub a ofs len returns an array of len elements, copying elements
    from a starting at offset ofs.
 | 
| sub [JavaIntArray] | sub a ofs len returns an array of len elements, copying elements
    from a starting at offset ofs.
 | 
| sub [JavaFloatArray] | sub a ofs len returns an array of len elements, copying elements
    from a starting at offset ofs.
 | 
| sub [JavaDoubleArray] | sub a ofs len returns an array of len elements, copying elements
    from a starting at offset ofs.
 | 
| sub [JavaCharArray] | sub a ofs len returns an array of len elements, copying elements
    from a starting at offset ofs.
 | 
| sub [JavaByteArray] | sub a ofs len returns an array of len elements, copying elements
    from a starting at offset ofs.
 | 
| sub [JavaBooleanArray] | sub a ofs len returns an array of len elements, copying elements
    from a starting at offset ofs.
 | 
| sub [JavaArraySignature.T] | |
| sub [Int64] | 
Subtraction.
 
 | 
| sub [Int32] | 
Subtraction.
 
 | 
| sub [Complex] | 
Subtraction
 
 | 
| sub [Buffer] | Buffer.sub b off len returns (a copy of) the substring of the
current contents of the buffer b starting at offset off of length
len bytes.
 | 
| 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_nat [Nat] | |
| 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.
 
 | 
| submit [ThreadPoolExecutor] | submit p f x submits to p and returns a future computing f x.
 | 
| submit [ScheduledThreadPoolExecutor] | 
Same as  
ThreadPoolExecutor.submit.
 | 
| submit [ExecutorCompletionService] | 
Same as  
ThreadPoolExecutor.submit.
 | 
| 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 [JavaStringBuilder] | substring sb start end returns a string containing the characters
    of sb from index start (inclusive) to index end (exclusive);
    see substring(...).
 | 
| substring [JavaString] | substring s start_idx end_idx returns the substring of s
    beginning at index start_idx (inclusive) and ending at index
    end_idx (exclusive); see
    substring(...).
 | 
| 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_end_pos [Parsing] | 
Same as  
symbol_end, but return a position instead of an offset.
 | 
| symbol_start [Parsing] | symbol_start and Parsing.symbol_end are to be called in the
   action part of a grammar rule only.
 | 
| symbol_start_pos [Parsing] | 
Same as  
symbol_start, but return a position instead of an offset.
 | 
| symlink [Unix] | symlink source dest creates the file dest as a symbolic link
   to the file source.
 | 
| synchronize [Graphics] | 
Synchronize the backing store and the on-screen window, by
   copying the contents of the backing store onto the graphics
   window.
 
 | 
| synchronized [Java] | synchronized obj (fun () -> ...) is equivalent to the Java code
    synchronized (obj) { ... }.
 | 
| sys_nat_of_string [Nat] | |
| system [Unix] | 
Execute the given command, wait until it terminates, and return
   its termination status.
 
 | 
T  | |
| tag [Obj] | |
| taiwan [JavaLocale] | |
| take [Queue] | take q removes and returns the first element in queue q,
   or raises Empty if the queue is empty.
 | 
| take [ExecutorCompletionService] | 
Waits for a task to complete, and returns it; see
    take(...).
 
 | 
| tan [Pervasives] | 
Tangent.
 
 | 
| tanh [Pervasives] | 
Hyperbolic tangent.
 
 | 
| tcdrain [Unix] | 
Waits until all output written on the given file descriptor
   has been transmitted.
 
 | 
| 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 [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 [Unix] | 
Return the status of the terminal referred to by the given
   file descriptor.
 
 | 
| tcsendbreak [Unix] | 
Send a break condition on the given file descriptor.
 
 | 
| tcsetattr [Unix] | 
Set the status of the terminal referred to by the given
   file descriptor.
 
 | 
| temp_dir_name [Filename] | |
| 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.
 
 | 
| throw [JavaThrowable] | 
Synonym for  
Java.throw.
 | 
| throw [JavaException] | 
Synonym for  
Java.throw.
 | 
| throw [JavaError] | 
Synonym for  
Java.throw.
 | 
| throw [Java] | throw x raises the instance x, that will be wrapped into either
    a Java_exception, or a Java_error on the OCaml side.
 | 
| 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.
 
 | 
| 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_char [JavaChar] | 
Converts a  
java_char into a plain OCaml char.
 | 
| to_char_array [JavaString] | 
Converts the passed string into an array of characters; see
    toCharArray(...).
 
 | 
| to_date [JavaCalendar] | 
Converts the passed calendar into a date.
 
 | 
| to_float [Nativeint] | 
Convert the given native integer to a floating-point number.
 
 | 
| to_float [Int64] | 
Convert the given 64-bit integer to a floating-point number.
 
 | 
| to_float [Int32] | 
Convert the given 32-bit integer to a floating-point number.
 
 | 
| to_hex [Digest] | 
Return the printable hexadecimal representation of the given digest.
 
 | 
| to_int [Nativeint] | 
Convert the given native integer (type  
nativeint) to an
   integer (type int).
 | 
| to_int [Int64] | 
Convert the given 64-bit integer (type  
int64) to an
   integer (type int).
 | 
| to_int [Int32] | 
Convert the given 32-bit integer (type  
int32) to an
   integer (type int).
 | 
| to_int32 [Nativeint] | 
Convert the given native integer to a
   32-bit integer (type  
int32).
 | 
| to_int32 [Int64] | 
Convert the given 64-bit integer (type  
int64) to a
   32-bit integer (type int32).
 | 
| to_iso8601 [JavaCalendar] | 
Converts the passed calendar into a string.
 
 | 
| to_language_tag [JavaLocale] | 
Returns the IETF BCP 47 language tag of the passed locale; see
    toLanguageTag(...).
 
 | 
| to_list [StdLabels.Array] | |
| to_list [ParallelArray.S] | |
| to_list [ParallelArray] | 
Synonym for  
Array.to_list.
 | 
| to_list [JavaShortArray] | to_list a returns the elements of a as a list.
 | 
| to_list [JavaLongArray] | to_list a returns the elements of a as a list.
 | 
| to_list [JavaIntArray] | to_list a returns the elements of a as a list.
 | 
| to_list [JavaFloatArray] | to_list a returns the elements of a as a list.
 | 
| to_list [JavaDoubleArray] | to_list a returns the elements of a as a list.
 | 
| to_list [JavaCharArray] | to_list a returns the elements of a as a list.
 | 
| to_list [JavaByteArray] | to_list a returns the elements of a as a list.
 | 
| to_list [JavaBooleanArray] | to_list a returns the elements of a as a list.
 | 
| to_list [JavaArraySignature.T] | |
| 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_lower_case [JavaString] | 
Returns a copy of the passed string with all characters converted to
    lower case; see toLowerCase(...).
 
 | 
| to_lower_case [JavaChar] | 
Converts the passed value to lower case; see
    toLowerCase(...).
 
 | 
| to_nativeint [Int64] | 
Convert the given 64-bit integer (type  
int64) to a
   native integer.
 | 
| to_object [JavaShortArray] | to_object a casts a to a bare object.
 | 
| to_object [JavaReferenceArray] | to_object a casts a to a bare object.
 | 
| to_object [JavaLongArray] | to_object a casts a to a bare object.
 | 
| to_object [JavaIntArray] | to_object a casts a to a bare object.
 | 
| to_object [JavaFloatArray] | to_object a casts a to a bare object.
 | 
| to_object [JavaDoubleArray] | to_object a casts a to a bare object.
 | 
| to_object [JavaCharArray] | to_object a casts a to a bare object.
 | 
| to_object [JavaByteArray] | to_object a casts a to a bare object.
 | 
| to_object [JavaBooleanArray] | to_object a casts a to a bare object.
 | 
| to_object [JavaArraySignature.T] | |
| to_ocaml [JavaShortArray] | to_ocaml a returns an OCaml array equivalent to a.
 | 
| to_ocaml [JavaLongArray] | to_ocaml a returns an OCaml array equivalent to a.
 | 
| to_ocaml [JavaIntArray] | to_ocaml a returns an OCaml array equivalent to a.
 | 
| to_ocaml [JavaFloatArray] | to_ocaml a returns an OCaml array equivalent to a.
 | 
| to_ocaml [JavaDoubleArray] | to_ocaml a returns an OCaml array equivalent to a.
 | 
| to_ocaml [JavaCharArray] | to_ocaml a returns an OCaml array equivalent to a.
 | 
| to_ocaml [JavaByteArray] | to_ocaml a returns an OCaml array equivalent to a.
 | 
| to_ocaml [JavaBooleanArray] | to_ocaml a returns an OCaml array equivalent to a.
 | 
| to_ocaml [JavaArraySignature.T] | |
| to_ocaml_string [JavaByteArray] | to_string x returns the array x as wrapped into a string.
 | 
| 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 [JavaStringBuilder] | 
Returns the contents of the passed builder as a string; see
    toString(...).
 
 | 
| to_string [JavaString] | to_string s converts the Java string s into an OCaml string.
 | 
| to_string [JavaShortArray] | |
| to_string [JavaShort] | 
Converts the passed short into a string; see
    toString(...).
 
 | 
| to_string [JavaReferenceArray] | |
| to_string [JavaObject] | |
| to_string [JavaLongArray] | |
| to_string [JavaLong] | 
Converts the passed long into a string; see
    toString(...).
 
 | 
| to_string [JavaIntArray] | |
| to_string [JavaInt] | 
Converts the passed integer into a string; see
    toString(...).
 
 | 
| to_string [JavaFloatArray] | |
| to_string [JavaFloat] | 
Converts the passed float into a string; see
    toString(...).
 
 | 
| to_string [JavaDoubleArray] | |
| to_string [JavaDouble] | 
Converts the passed double into a string; see
    toString(...).
 
 | 
| to_string [JavaDate] | 
Converts the passed date into a string.
 
 | 
| to_string [JavaCharArray] | |
| to_string [JavaChar] | 
Converts the passed character into a string; see
    toString(...).
 
 | 
| to_string [JavaByteArray] | |
| to_string [JavaByte] | 
Converts the passed byte into a string; see
    toString(...).
 
 | 
| to_string [JavaBooleanArray] | |
| to_string [JavaBoolean] | 
Converts the passed boolean into a string; see
    toString(...).
 
 | 
| to_string [JavaArraySignature.T] | |
| to_string [Int64] | 
Return the string representation of its argument, in decimal.
 
 | 
| to_string [Int32] | 
Return the string representation of its argument, in signed decimal.
 
 | 
| to_upper_case [JavaString] | 
Returns a copy of the passed string with all characters converted to
    upper case; see toUpperCase(...).
 
 | 
| to_upper_case [JavaChar] | 
Converts the passed value to upper case; see
    toUpperCase(...).
 
 | 
| top [Stack] | top s returns the topmost element in stack s,
   or raises Empty if the stack is empty.
 | 
| top [Queue] | top is a synonym for peek.
 | 
| total_memory [JavaRuntime] | 
Returns the total amount of memory used by the JVM (in bytes); see
    totalMemory(...).
 
 | 
| total_size [Marshal] | 
See  
Marshal.header_size.
 | 
| traditional_chinese [JavaLocale] | |
| transfer [Queue] | transfer q1 q2 adds all of q1's elements at the end of
   the queue q2, then clears q1.
 | 
| transp [Graphics] | 
In matrices of colors, this color represent a 'transparent'
   point: when drawing the corresponding image, all pixels on the
   screen corresponding to a transparent pixel in the image will
   not be modified, while other points will be set to the color
   of the corresponding point in the image.
 
 | 
| trim [StringLabels] | 
Return a copy of the argument, without leading and trailing whitespace.
 
 | 
| trim [String] | 
Return a copy of the argument, without leading and trailing
   whitespace.
 
 | 
| trim [StdLabels.String] | |
| trim [JavaString.OCaml] | 
Similar to  
String.trim.
 | 
| trim [JavaString] | 
Returns a copy of the passed string, without leading and trailing
    spaces; see trim(...).
 
 | 
| trim_to_size [JavaStringBuilder] | 
Minimizes the amount of memory used by the passed builder; see
    trimToSize(...).
 
 | 
| true_ [JavaBoolean] | 
The constant for the wrapper around the  
true value.
 | 
| truncate [Unix.LargeFile] | |
| truncate [Unix] | 
Truncates the named file to the given size.
 
 | 
| truncate [Pervasives] | 
Same as  
Pervasives.int_of_float.
 | 
| truncate [Obj] | |
| try_acquire [Semaphore] | try_acquire s p is similar to acquire s p, except the function
    always returns immediately returning true if acquisition was
    successful; see
    tryAcquire(...).
 | 
| try_acquire_time [Semaphore] | try_acquire_time s p t u is similar to try_acquire s p, except
    that the current thread will at most wait for t (time value whose
    unit is u); see
    tryAcquire(...).
 | 
| try_lock [Lock] | 
Acquires the lock if available, returning  
true.
 | 
| try_lock_time [Lock] | try_lock_time l t u is similar to lock_interruptibly l, except
    that the current thread will at most wait for t (time value whose
    unit is u).
 | 
U  | |
| uk [JavaLocale] | |
| umask [Unix] | 
Set the process's file mode creation mask, and return the previous
    mask.
 
 | 
| unaligned_tag [Obj] | |
| uncapitalize [StringLabels] | 
Return a copy of the argument, with the first character set to lowercase.
 
 | 
| uncapitalize [String] | 
Return a copy of the argument, with the first character set to lowercase.
 
 | 
| uncapitalize [StdLabels.String] | |
| uncapitalize [JavaString.OCaml] | 
Similar to  
String.uncapitalize.
 | 
| unescaped [Scanf] | 
Return a copy of the argument with escape sequences, following the
    lexical conventions of OCaml, replaced by their corresponding
    special characters.
 
 | 
| union [Set.S] | 
Set union.
 
 | 
| union [MoreLabels.Set.S] | |
| unit_big_int [Big_int] | 
The big integer  
1.
 | 
| unix [Sys] | 
True if  
Sys.os_type = "Unix".
 | 
| unlink [Unix] | 
Removes the named file
 
 | 
| unlock [Lock] | 
Releases the lock; see
    unlock(...).
 
 | 
| unmarshal [Obj] | |
| unsafe_blit [StdLabels.String] | |
| unsafe_fill [StdLabels.String] | |
| unsafe_get [StdLabels.String] | |
| unsafe_get [StdLabels.Array] | |
| unsafe_get [ParallelArray.S] | |
| unsafe_get [Bigarray.Array3] | 
Like  
Bigarray.Array3.get, but bounds checking is not always
      performed.
 | 
| unsafe_get [Bigarray.Array2] | 
Like  
Bigarray.Array2.get, but bounds checking is not always
      performed.
 | 
| unsafe_get [Bigarray.Array1] | 
Like  
Bigarray.Array1.get, but bounds checking is not always performed.
 | 
| unsafe_set [StdLabels.String] | |
| unsafe_set [StdLabels.Array] | |
| unsafe_set [ParallelArray.S] | |
| unsafe_set [Bigarray.Array3] | 
Like  
Bigarray.Array3.set, but bounds checking is not always
      performed.
 | 
| unsafe_set [Bigarray.Array2] | 
Like  
Bigarray.Array2.set, but bounds checking is not always
      performed.
 | 
| unsafe_set [Bigarray.Array1] | 
Like  
Bigarray.Array1.set, but bounds checking is not always performed.
 | 
| unwrap [ThreadPoolExecutor] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [ThreadLocal] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [ThreadGroup] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [Thread] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [Semaphore] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [ScheduledThreadPoolExecutor] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [ScheduledFuture] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [ReadWriteLock] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [Phaser] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [Lock] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaTimeZone] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaThrowable] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaStringBuilder] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaString] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaShortArray] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaShort] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaReferenceArray] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaRandom] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaProperties] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaObject] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaLongArray] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaLong] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaLocale] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaIntArray] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaInt] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaFloatArray] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaFloat] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaException] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaError] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaDoubleArray] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaDouble] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaDate] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaCharArray] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaChar] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaCalendar] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaByteArray] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaByte] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaBooleanArray] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaBoolean] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [JavaArraySignature.T] | |
| unwrap [JavaArray] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [Java] | unwrap x unwraps the option x into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [Future] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [ForkJoinPool] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [ExecutorCompletionService] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [Exchanger] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [CyclicBarrier] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [CountDownLatch] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [Condition] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [AtomicStampedReference] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [AtomicReferenceArray] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [AtomicReference] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [AtomicMarkableReference] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [AtomicInt64Array] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [AtomicInt64] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [AtomicInt32Array] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [AtomicInt32] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| unwrap [AtomicBool] | unwrap obj unwraps the option obj into a bare reference: Some x is mapped to x;, None is mapped to null.
 | 
| update_mod [CamlinternalMod] | |
| 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 [JavaString.OCaml] | 
Similar to  
String.uppercase.
 | 
| uppercase [Char] | 
Convert the given character to its equivalent uppercase character.
 
 | 
| us [JavaLocale] | |
| usage [Arg] | Arg.usage speclist usage_msg prints to standard error
    an error message that includes the list of valid options.
 | 
| usage_string [Arg] | 
Returns the message that would have been printed by  
Arg.usage,
    if provided with the same parameters.
 | 
| utimes [Unix] | 
Set the last access time (second arg) and last modification time
   (third arg) for a file.
 
 | 
V  | |
| value_bound [JavaServlet.HTTPSessionBindingListener] | 
Called to notify that an object is being bound to a session as its
      identifier; see
      valueBound(...).
 
 | 
| value_of [JavaShort] | 
Converts the passed bare short into a short wrapper; see
    valueOf(...).
 
 | 
| value_of [JavaLong] | 
Converts the passed bare long into a long wrapper; see
    valueOf(...).
 
 | 
| value_of [JavaInt] | 
Converts the passed bare integer into a integer wrapper; see
    valueOf(...).
 
 | 
| value_of [JavaFloat] | 
Converts the passed bare float into a float wrapper; see
    valueOf(...).
 
 | 
| value_of [JavaDouble] | 
Converts the passed bare double into a double wrapper; see
    valueOf(...).
 
 | 
| value_of [JavaChar] | 
Converts the passed bare character into a character wrapper;
    see valueOf(...).
 
 | 
| value_of [JavaByte] | 
Converts the passed bare byte into a byte wrapper; see
    valueOf(...).
 
 | 
| value_of [JavaBoolean] | 
Converts the passed bare boolean into a boolean wrapper;
    see valueOf(...).
 
 | 
| value_of_string [JavaShort] | 
Converts the passed string into a short wrapper, using the passed
    radix (defaulting to  
10l); see
    valueOf(...).
 | 
| value_of_string [JavaLong] | 
Converts the passed string into a long wrapper, using the passed
    radix (defaulting to  
10l); see
    valueOf(...).
 | 
| value_of_string [JavaInt] | 
Converts the passed string into a integer wrapper, using the passed
    radix (defaulting to  
10l); see
    valueOf(...).
 | 
| value_of_string [JavaFloat] | 
Converts the passed string into a float wrapper; see
    valueOf(...).
 
 | 
| value_of_string [JavaDouble] | 
Converts the passed string into a double wrapper; see
    valueOf(...).
 
 | 
| value_of_string [JavaByte] | 
Converts the passed string into a byte wrapper, using the passed
    radix (defaulting to  
10l); see
    valueOf(...).
 | 
| value_of_string [JavaBoolean] | 
Converts the passed string into a boolean wrapper;
    see valueOf(...).
 
 | 
| value_unbound [JavaServlet.HTTPSessionBindingListener] | 
Called to notify that an object is being unbound from a session; see
      valueUnbound(...).
 
 | 
W  | |
| wait [Unix] | 
Wait until one of the children processes die, and return its pid
   and termination status.
 
 | 
| wait [JavaObject] | |
| 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_timeout [JavaObject] | wait_timeout obj ms waits for a notification on the monitor of obj,
    or a time of ms milliseconds has elapsed; see
    wait(...).
 | 
| wait_timeout_nanos [JavaObject] | wait_timeout_nanos obj ms ns waits for a notification on the monitor of obj,
    or a time of to milliseconds and na nanoseconds has elapsed; see
    wait(...).
 | 
| waitpid [Unix] | 
Same as  
Unix.wait, but waits for the child process whose pid is given.
 | 
| weak_compare_and_set [AtomicStampedReference] | 
Similar to  
AtomicStampedReference.compare_and_set, with a weak semantics: may be
    faster on some platforms, but does not provide ordering guarantees.
 | 
| weak_compare_and_set [AtomicReferenceArray] | 
Similar to  
AtomicReferenceArray.compare_and_set, with a weak semantics: may be
    faster on some platforms, but does not provide ordering guarantees.
 | 
| weak_compare_and_set [AtomicReference] | 
Similar to  
AtomicReference.compare_and_set, with a weak semantics: may be
    faster on some platforms, but does not provide ordering guarantees.
 | 
| weak_compare_and_set [AtomicMarkableReference] | 
Similar to  
AtomicMarkableReference.compare_and_set, with a weak semantics: may be
    faster on some platforms, but does not provide ordering guarantees.
 | 
| weak_compare_and_set [AtomicInt64Array] | 
Similar to  
AtomicInt64Array.compare_and_set, with a weak semantics: may be
    faster on some platforms, but does not provide ordering guarantees.
 | 
| weak_compare_and_set [AtomicInt64] | 
Similar to  
AtomicInt64.compare_and_set, with a weak semantics: may be
    faster on some platforms, but does not provide ordering guarantees.
 | 
| weak_compare_and_set [AtomicInt32Array] | 
Similar to  
AtomicInt32Array.compare_and_set, with a weak semantics: may be
    faster on some platforms, but does not provide ordering guarantees.
 | 
| weak_compare_and_set [AtomicInt32] | 
Similar to  
AtomicInt32.compare_and_set, with a weak semantics: may be
    faster on some platforms, but does not provide ordering guarantees.
 | 
| weak_compare_and_set [AtomicBool] | 
Similar to  
AtomicBool.compare_and_set, with a weak semantics: may be
    faster on some platforms, but does not provide ordering guarantees.
 | 
| white [Graphics] | |
| widen [CamlinternalOO] | |
| win32 [Sys] | 
True if  
Sys.os_type = "Win32".
 | 
| word_size [Sys] | 
Size of one word on the machine currently executing the OCaml
   program, in bits: 32 or 64.
 
 | 
| wrap [ThreadPoolExecutor] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [ThreadLocal] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [ThreadGroup] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [Thread] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [Semaphore] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [ScheduledThreadPoolExecutor] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [ScheduledFuture] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [ReadWriteLock] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [Phaser] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [Lock] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaTimeZone] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaThrowable] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaStringBuilder] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaString] | wrap x wraps the reference x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [JavaShortArray] | wrap x wraps the array x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [JavaShort] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaReferenceArray] | wrap x wraps the array x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [JavaRandom] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaProperties] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaObject] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaLongArray] | wrap x wraps the array x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [JavaLong] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaLocale] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaIntArray] | wrap x wraps the array x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [JavaInt] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaFloatArray] | wrap x wraps the array x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [JavaFloat] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaException] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaError] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaDoubleArray] | wrap x wraps the array x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [JavaDouble] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaDate] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaCharArray] | wrap x wraps the array x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [JavaChar] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaCalendar] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaByteArray] | wrap x wraps the array x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [JavaByte] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaBooleanArray] | wrap x wraps the array x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [JavaBoolean] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [JavaArraySignature.T] | |
| wrap [JavaArray] | wrap x wraps the array x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [Java] | wrap x wraps the reference x into an option type: Some x if x is not null;, None if x is null.
 | 
| wrap [Future] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [ForkJoinPool] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [ExecutorCompletionService] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [Exchanger] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [CyclicBarrier] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [CountDownLatch] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [Condition] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [AtomicStampedReference] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [AtomicReferenceArray] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [AtomicReference] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [AtomicMarkableReference] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [AtomicInt64Array] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [AtomicInt64] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [AtomicInt32Array] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [AtomicInt32] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap [AtomicBool] | wrap obj wraps the reference obj into an option type: Some x if obj is not null;, None if obj is null.
 | 
| wrap_boolean_array [JavaArray] | wrap_boolean_array a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_boolean_array2 [JavaArray] | wrap_boolean_array2 a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_byte_array [JavaArray] | wrap_byte_array a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_byte_array2 [JavaArray] | wrap_byte_array2 a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_char_array [JavaArray] | wrap_char_array a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_char_array2 [JavaArray] | wrap_byte_array2 a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_double_array [JavaArray] | wrap_double_array a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_double_array2 [JavaArray] | wrap_double_array2 a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_float_array [JavaArray] | wrap_float_array a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_float_array2 [JavaArray] | wrap_float_array2 a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_int_array [JavaArray] | wrap_int_array a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_int_array2 [JavaArray] | wrap_int_array2 a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_long_array [JavaArray] | wrap_long_array a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_long_array2 [JavaArray] | wrap_long_array2 a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_reference_array [JavaArray] | wrap_reference_array a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_reference_array2 [JavaArray] | wrap_reference_array2 a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_short_array [JavaArray] | wrap_short_array a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrap_short_array2 [JavaArray] | wrap_short_array2 a wraps the passed specialized array into an
   unspecialized one.
 | 
| wrapped [JavaArray] | wrapped a returns the wrapped array.
 | 
| 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_lock [ReadWriteLock] | 
Returns the write lock of the read/write lock; see
    writeLock(...).
 
 | 
X  | |
| xor_big_int [Big_int] | 
Bitwise logical 'exclusive or'.
 
 | 
Y  | |
| yellow [Graphics] | |
| yield [Thread] | 
Indicates that the current thread wants to yield its use of a
    processor; see yield(...).
 
 | 
Z  | |
| zero [Nativeint] | 
The native integer 0.
 
 | 
| zero [Int64] | 
The 64-bit integer 0.
 
 | 
| zero [Int32] | 
The 32-bit integer 0.
 
 | 
| zero [Complex] | 
The complex number  
0.
 | 
| zero_big_int [Big_int] | 
The big integer  
0.
 |