| ( * ) [Pervasives] | Integer multiplication. |
| ( ** ) [Pervasives] | Exponentiation |
| ( *. ) [Pervasives] | Floating-point multiplication |
| (!) [Pervasives] |
|
| (!=) [Pervasives] | Negation of |
| (&&) [Pervasives] | The boolean ``and''. |
| (&) [Pervasives] | |
| (+) [Pervasives] | Integer addition. |
| (+.) [Pervasives] | Floating-point addition |
| (-) [Pervasives] | Integer subtraction. |
| (-.) [Pervasives] | Floating-point subtraction |
| (/) [Pervasives] | Integer division. |
| (/.) [Pervasives] | Floating-point division. |
| (:=) [Pervasives] |
|
| (<) [Pervasives] | See |
| (<=) [Pervasives] | See |
| (<>) [Pervasives] | Negation of |
| (=) [Pervasives] |
|
| (==) [Pervasives] |
|
| (>) [Pervasives] | See |
| (>=) [Pervasives] | Structural ordering functions. |
| (@) [Pervasives] | List concatenation. |
| (^) [Pervasives] | String concatenation. |
| (^^) [Pervasives] |
|
| (asr) [Pervasives] |
|
| (land) [Pervasives] | Bitwise logical and. |
| (lor) [Pervasives] | Bitwise logical or. |
| (lsl) [Pervasives] |
|
| (lsr) [Pervasives] |
|
| (lxor) [Pervasives] | Bitwise logical exclusive or. |
| (mod) [Pervasives] | Integer remainder. |
| (or) [Pervasives] | |
| (||) [Pervasives] | The boolean ``or''. |
| (~-) [Pervasives] | Unary negation. |
| (~-.) [Pervasives] | Unary negation. |
A | |
| abs [Pervasives] | Return the absolute value of the argument. |
| abs [Nativeint] | Return the absolute value of its argument. |
| abs [Int64] | Return the absolute value of its argument. |
| abs [Int32] | Return the absolute value of its argument. |
| abs_float [Pervasives] | Return the absolute value of the argument. |
| 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] | See |
| add [Weak.S] |
|
| add [Set.S] |
|
| add [Queue] |
|
| add [Nativeint] | Addition. |
| add [MoreLabels.Set.S] | |
| add [MoreLabels.Map.S] | |
| add [MoreLabels.Hashtbl.S] | |
| add [MoreLabels.Hashtbl] | |
| add [Map.S] |
|
| add [Int64] | Addition. |
| add [Int32] | Addition. |
| add [Hashtbl.S] | |
| add [Hashtbl] |
|
| add [Dbm] |
|
| add [Complex] | Addition |
| add_available_units [Dynlink] | Same as |
| add_buffer [Buffer] |
|
| add_channel [Buffer] |
|
| add_char [Buffer] |
|
| add_initializer [CamlinternalOO] | |
| add_interfaces [Dynlink] |
|
| add_nat [Nat] | |
| add_string [Buffer] |
|
| add_substitute [Buffer] |
|
| add_substring [Buffer] |
|
| alarm [Unix] | Schedule a |
| 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_unsafe_modules [Dynlink] | Govern whether unsafe object files are allowed to be dynamically linked. |
| always [Event] |
|
| append [StdLabels.List] | |
| append [StdLabels.Array] | |
| append [ListLabels] | Catenate two lists. |
| append [List] | Catenate two lists. |
| append [ArrayLabels] |
|
| append [Array] |
|
| 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. |
| asin [Pervasives] | See |
| assoc [StdLabels.List] | |
| assoc [ListLabels] |
|
| assoc [List] |
|
| assq [StdLabels.List] | |
| assq [ListLabels] | Same as |
| assq [List] | Same as |
| at_exit [Pervasives] | Register the given function to be called at program termination time. |
| atan [Pervasives] | See |
| atan2 [Pervasives] | The usual trigonometric functions. |
| auto_synchronize [Graphics] | By default, drawing takes place both on the window displayed on screen, and in a memory area (the ``backing store''). |
B | |
| background [Graphics] | See |
| basename [Filename] | Split a file name into directory name / base file name. |
| beginning_of_input [Scanf.Scanning] |
|
| biggest_int [Int_misc] | |
| bind [Unix] | Bind a socket to an address. |
| bits [Random.State] | |
| bits [Random] | Return 30 random bits in a nonnegative integer. |
| bits_of_float [Int64] | Return the internal representation of the given float according to the IEEE 754 floating-point ``double format'' bit layout. |
| bits_of_float [Int32] | Return the internal representation of the given float according to the IEEE 754 floating-point ``single format'' bit layout. |
| black [Graphics] | |
| blit [Weak] |
|
| blit [StringLabels] |
|
| blit [String] |
|
| blit [StdLabels.String] | |
| blit [StdLabels.Array] | |
| blit [ArrayLabels] |
|
| blit [Array] |
|
| blit_image [Graphics] |
|
| 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] |
|
| bool_of_string [Pervasives] | Convert the given string to a boolean. |
| bounded_full_split [Str] | Same as |
| bounded_split [Str] | Same as |
| bounded_split_delim [Str] | Same as |
| bprintf [Printf] | Same as |
| bprintf [Format] | Same as |
| bscanf [Scanf] |
|
| bscanf_format [Scanf] |
|
| button_down [Graphics] | Return |
C | |
| 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] | |
| cardinal [Set.S] | Return the number of elements of a set. |
| cardinal [MoreLabels.Set.S] | |
| catch [Printexc] |
|
| catch_break [Sys] |
|
| ceil [Pervasives] | See |
| channel [Digest] | If |
| char_of_int [Pervasives] | Return the character with the given ASCII code. |
| chdir [Unix] | Change the process working directory. |
| chdir [Sys] | Change the current working directory of the process. |
| check [Weak] |
|
| check_suffix [Filename] |
|
| chmod [Unix] | Change the permissions of the named file. |
| choose [Set.S] | Return one element of the given set, or raise |
| choose [MoreLabels.Set.S] | |
| choose [Event] |
|
| chop_extension [Filename] | Return the given file name without its extension. |
| chop_suffix [Filename] |
|
| 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. |
| classify_float [Pervasives] | Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number. |
| clear [Weak.S] | Remove all elements from the table. |
| clear [Stack] | Discard all elements from a stack. |
| clear [Queue] | Discard all elements from a queue. |
| clear [MoreLabels.Hashtbl.S] | |
| clear [MoreLabels.Hashtbl] | |
| clear [Hashtbl.S] | |
| clear [Hashtbl] | Empty a hash table. |
| clear [Buffer] | Empty the buffer. |
| clear_available_units [Dynlink] | Empty the list of compilation units accessible to dynamically-linked programs. |
| clear_close_on_exec [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. |
| close [Unix] | Close a file descriptor. |
| close [Dbm] | Close the given 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 [Pervasives] | Close the given channel. |
| close_in_noerr [Pervasives] | Same as |
| close_out [Pervasives] | Close the given channel, flushing all buffered write operations. |
| close_out_noerr [Pervasives] | Same as |
| close_process [Unix] | Close channels opened by |
| close_process_full [Unix] | Close channels opened by |
| close_process_in [Unix] | Close channels opened by |
| close_process_out [Unix] | Close channels opened by |
| close_subwindow [GraphicsX11] | Close the sub-window having the given identifier. |
| close_tag [Format] |
|
| close_tbox [Format] | Closes the most recently opened tabulation box. |
| closedir [Unix] | Close a directory descriptor. |
| closure_tag [Obj] | |
| code [Char] | Return the ASCII code of the argument. |
| combine [StdLabels.List] | |
| combine [ListLabels] | Transform a pair of lists into a list of pairs:
|
| combine [List] | Transform a pair of lists into a list of pairs:
|
| command [Sys] | Execute the given shell command and return its exit code. |
| compact [Gc] | Perform a full major collection and compact the heap. |
| compare [StringLabels] | The comparison function for strings, with the same specification as
|
| compare [String] | The comparison function for strings, with the same specification as
|
| compare [StdLabels.String] | |
| compare [Set.OrderedType] | A total ordering function over the set elements. |
| compare [Set.S] | Total ordering between sets. |
| compare [Pervasives] |
|
| compare [Nativeint] | The comparison function for native integers, with the same specification as
|
| compare [MoreLabels.Set.S] | |
| compare [MoreLabels.Map.S] | |
| compare [Map.OrderedType] | A total ordering function over the keys. |
| compare [Map.S] | Total ordering between maps. |
| compare [Int64] | The comparison function for 64-bit integers, with the same specification as
|
| compare [Int32] | The comparison function for 32-bit integers, with the same specification as
|
| compare [Char] | The comparison function for characters, with the same specification as
|
| compare_digits_nat [Nat] | |
| compare_int [Int_misc] | |
| compare_nat [Nat] | |
| complement_nat [Nat] | |
| concat [StringLabels] |
|
| concat [String] |
|
| concat [StdLabels.String] | |
| concat [StdLabels.List] | |
| concat [StdLabels.Array] | |
| concat [ListLabels] | Concatenate a list of lists. |
| concat [List] | Concatenate a list of lists. |
| concat [Filename] |
|
| concat [ArrayLabels] | Same as |
| concat [Array] | Same as |
| conj [Complex] | Conjugate: given the complex |
| connect [Unix] | Connect a socket to an address. |
| contains [StringLabels] |
|
| contains [String] |
|
| contains [StdLabels.String] | |
| contains_from [StringLabels] |
|
| contains_from [String] |
|
| contains_from [StdLabels.String] | |
| contents [Buffer] | Return a copy of the current contents of the buffer. |
| copy [StringLabels] | Return a copy of the given string. |
| copy [String] | Return a copy of the given string. |
| copy [StdLabels.String] | |
| copy [StdLabels.Array] | |
| copy [Stack] | Return a copy of the given stack. |
| copy [Random.State] | Return a copy of the given state. |
| copy [Queue] | Return a copy of the given queue. |
| copy [Oo] |
|
| copy [MoreLabels.Hashtbl.S] | |
| copy [MoreLabels.Hashtbl] | |
| copy [Hashtbl.S] | |
| copy [Hashtbl] | Return a copy of the given hashtable. |
| copy [CamlinternalOO] | |
| copy [ArrayLabels] |
|
| copy [Array] |
|
| copy_nat [Nat] | |
| cos [Pervasives] | See |
| cosh [Pervasives] | See |
| count [Weak.S] | Count the number of elements in the table. |
| count [Stream] | Return the current count of the stream elements, i.e. |
| counters [Gc] | Return |
| create [Weak.S] |
|
| create [Weak] |
|
| create [StringLabels] |
|
| create [String] |
|
| create [StdLabels.String] | |
| create [StdLabels.Array] | |
| create [Stack] | Return a new stack, initially empty. |
| create [Queue] | Return a new queue, initially empty. |
| create [Mutex] | Return a new mutex. |
| create [MoreLabels.Hashtbl.S] | |
| create [MoreLabels.Hashtbl] | |
| create [Hashtbl.S] | |
| create [Hashtbl] |
|
| create [Buffer] |
|
| create [ArrayLabels] | |
| create [Array] | |
| create_alarm [Gc] |
|
| create_image [Graphics] |
|
| create_matrix [StdLabels.Array] | |
| 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_env [Unix] |
|
| create_table [CamlinternalOO] | |
| current [Arg] | Position (in |
| current_dir_name [Filename] | The conventional name for the current directory (e.g. |
| current_point [Graphics] | Return the position of the current point. |
| current_x [Graphics] | Return the abscissa of the current point. |
| current_y [Graphics] | Return the ordinate of the current point. |
| curveto [Graphics] |
|
| custom_tag [Obj] | |
| cyan [Graphics] | |
D | |
| data_size [Marshal] | See |
| decr [Pervasives] | Decrement the integer contained in the given reference. |
| decr_nat [Nat] | |
| 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. |
| delete_alarm [Gc] |
|
| 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. |
| diff [Set.S] | Set difference. |
| diff [MoreLabels.Set.S] | |
| dirname [Filename] | See |
| 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_digit_nat [Nat] | |
| div_nat [Nat] | |
| domain_of_sockaddr [Unix] | Return the socket domain adequate for the given socket address. |
| double_array_tag [Obj] | |
| double_tag [Obj] | |
| draw_arc [Graphics] |
|
| draw_char [Graphics] | See |
| draw_circle [Graphics] |
|
| draw_ellipse [Graphics] |
|
| draw_image [Graphics] | Draw the given image with lower left corner at the given point. |
| draw_poly [Graphics] |
|
| draw_poly_line [Graphics] |
|
| draw_rect [Graphics] |
|
| draw_segments [Graphics] |
|
| draw_string [Graphics] | Draw a character or a character string with lower left corner at current position. |
| dummy_class [CamlinternalOO] | |
| dummy_pos [Lexing] | A value of type |
| dummy_table [CamlinternalOO] | |
| dump_image [Graphics] | Convert an image to a color matrix. |
| dup [Unix] | Return a new file descriptor referencing the same file as the given descriptor. |
| dup [Obj] | |
| dup2 [Unix] |
|
E | |
| elements [Set.S] | Return the list of all elements of the given set. |
| elements [MoreLabels.Set.S] | |
| empty [Stream] | Return |
| empty [Set.S] | The empty set. |
| empty [MoreLabels.Set.S] | |
| empty [MoreLabels.Map.S] | |
| empty [Map.S] | The empty map. |
| end_of_input [Scanf.Scanning] |
|
| environment [Unix] | Return the process environment, as an array of strings with the format ``variable=value''. |
| eprintf [Printf] | Same as |
| eprintf [Format] | Same as |
| epsilon_float [Pervasives] | The smallest positive float |
| eq_nat [Nat] | |
| equal [Set.S] |
|
| equal [MoreLabels.Set.S] | |
| equal [MoreLabels.Map.S] | |
| equal [Map.S] |
|
| equal [Hashtbl.HashedType] | The equality predicate used to compare keys. |
| err_formatter [Format] | A formatter to use with formatting functions below for output to standard error. |
| error_message [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 Objective Caml. |
| escaped [String] | Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of Objective Caml. |
| escaped [StdLabels.String] | |
| escaped [Char] | Return a string representing the given character, with special characters escaped following the lexical conventions of Objective Caml. |
| establish_server [Unix] | Establish a server on the given address. |
| executable_name [Sys] | The name of the file containing the executable currently running. |
| execv [Unix] |
|
| execve [Unix] | Same as |
| execvp [Unix] | Same as |
| execvpe [Unix] | Same as |
| exists [StdLabels.List] | |
| exists [Set.S] |
|
| exists [MoreLabels.Set.S] | |
| exists [ListLabels] |
|
| exists [List] |
|
| exists2 [StdLabels.List] | |
| exists2 [ListLabels] | Same as |
| exists2 [List] | Same as |
| exit [Pervasives] | Terminate the process, returning the given status code to the operating system: usually 0 to indicate no errors, and a small positive integer to indicate failure. |
| exp [Pervasives] | Exponential. |
| exp [Complex] | Exponentiation. |
F | |
| failwith [Pervasives] | Raise exception |
| fast_sort [StdLabels.List] | |
| fast_sort [StdLabels.Array] | |
| fast_sort [ListLabels] | Same as |
| fast_sort [List] | Same as |
| fast_sort [ArrayLabels] | Same as |
| fast_sort [Array] | Same as |
| 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] |
|
| fill [StringLabels] |
|
| fill [String] |
|
| fill [StdLabels.String] | |
| fill [StdLabels.Array] | |
| fill [ArrayLabels] |
|
| fill [Array] |
|
| fill_arc [Graphics] | Fill an elliptical pie slice with the current color. |
| fill_circle [Graphics] | Fill a circle with the current color. |
| fill_ellipse [Graphics] | Fill an ellipse with the current color. |
| fill_poly [Graphics] | Fill the given polygon with the current color. |
| fill_rect [Graphics] |
|
| filter [StdLabels.List] | |
| filter [Set.S] |
|
| filter [MoreLabels.Set.S] | |
| filter [ListLabels] |
|
| filter [List] |
|
| final_tag [Obj] | |
| finalise [Gc] |
|
| finalise_release [Gc] | A finalisation function may call |
| find [Weak.S] |
|
| find [StdLabels.List] | |
| find [MoreLabels.Map.S] | |
| find [MoreLabels.Hashtbl.S] | |
| find [MoreLabels.Hashtbl] | |
| find [Map.S] |
|
| find [ListLabels] |
|
| find [List] |
|
| find [Hashtbl.S] | |
| find [Hashtbl] |
|
| find [Dbm] |
|
| find_all [Weak.S] |
|
| find_all [StdLabels.List] | |
| find_all [MoreLabels.Hashtbl.S] | |
| find_all [MoreLabels.Hashtbl] | |
| find_all [ListLabels] |
|
| find_all [List] |
|
| find_all [Hashtbl.S] | |
| find_all [Hashtbl] |
|
| first_chars [Str] |
|
| firstkey [Dbm] | See |
| flatten [StdLabels.List] | |
| flatten [ListLabels] | Same as |
| flatten [List] | Same as |
| float [Random.State] | |
| float [Random] |
|
| float [Pervasives] | Same as |
| float_of_bits [Int64] | Return the floating-point number whose internal representation,
according to the IEEE 754 floating-point ``double format'' bit layout,
is the given |
| float_of_bits [Int32] | Return the floating-point number whose internal representation,
according to the IEEE 754 floating-point ``single format'' bit layout,
is the given |
| float_of_int [Pervasives] | Convert an integer to floating-point. |
| float_of_nat [Nat] | |
| float_of_string [Pervasives] | Convert the given string to a float. |
| floating_precision [Arith_flags] | |
| floor [Pervasives] | Round the given float to an integer value. |
| 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 |
| fold [Weak.S] |
|
| fold [Set.S] |
|
| fold [Queue] |
|
| fold [MoreLabels.Set.S] | |
| fold [MoreLabels.Map.S] | |
| fold [MoreLabels.Hashtbl.S] | |
| fold [MoreLabels.Hashtbl] | |
| fold [Map.S] |
|
| fold [Hashtbl.S] | |
| fold [Hashtbl] |
|
| fold_left [StdLabels.List] | |
| fold_left [StdLabels.Array] | |
| fold_left [ListLabels] |
|
| fold_left [List] |
|
| fold_left [ArrayLabels] |
|
| fold_left [Array] |
|
| fold_left2 [StdLabels.List] | |
| fold_left2 [ListLabels] |
|
| fold_left2 [List] |
|
| fold_right [StdLabels.List] | |
| fold_right [StdLabels.Array] | |
| fold_right [ListLabels] |
|
| fold_right [List] |
|
| fold_right [ArrayLabels] |
|
| fold_right [Array] |
|
| fold_right2 [StdLabels.List] | |
| fold_right2 [ListLabels] |
|
| fold_right2 [List] |
|
| for_all [StdLabels.List] | |
| for_all [Set.S] |
|
| for_all [MoreLabels.Set.S] | |
| for_all [ListLabels] |
|
| for_all [List] |
|
| for_all2 [StdLabels.List] | |
| for_all2 [ListLabels] | Same as |
| for_all2 [List] | Same as |
| force [Lazy] |
|
| force_newline [Format] | Forces a newline in the current box. |
| force_val [Lazy] |
|
| 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_of_string [Pervasives] |
|
| formatter_of_buffer [Format] |
|
| formatter_of_out_channel [Format] |
|
| forward_tag [Obj] | |
| fprintf [Printf] |
|
| fprintf [Format] |
|
| frexp [Pervasives] |
|
| from [Stream] |
|
| from_channel [Scanf.Scanning] |
|
| from_channel [Marshal] |
|
| from_channel [Lexing] | Create a lexer buffer on the given input channel. |
| from_file [Scanf.Scanning] | Bufferized file reading in text mode. |
| from_file_bin [Scanf.Scanning] | Bufferized file reading in binary mode. |
| from_function [Scanf.Scanning] |
|
| from_function [Lexing] | Create a lexer buffer with the given function as its reading method. |
| from_string [Scanf.Scanning] |
|
| from_string [Marshal] |
|
| from_string [Lexing] | Create a lexer buffer which reads from the given string. |
| fscanf [Scanf] | Same as |
| 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 |
| full_major [Gc] | Do a minor collection, finish the current major collection cycle, and perform a complete new cycle. |
| full_split [Str] | Same as |
G | |
| gcd_int [Int_misc] | |
| gcd_nat [Nat] | |
| ge_nat [Nat] | |
| get [Weak] |
|
| get [StringLabels] |
|
| get [String] |
|
| get [StdLabels.String] | |
| get [StdLabels.Array] | |
| get [Gc] | Return the current values of the GC parameters in a |
| get [ArrayLabels] |
|
| get [Array] |
|
| get_all_formatter_output_functions [Format] | Return the current output functions of the pretty-printer, including line breaking and indentation functions. |
| get_approx_printing [Arith_status] | |
| get_copy [Weak] |
|
| get_ellipsis_text [Format] | Return the text of the ellipsis. |
| get_error_when_null_denominator [Arith_status] | |
| get_floating_precision [Arith_status] | |
| get_formatter_output_functions [Format] | Return the current output functions of the pretty-printer. |
| get_formatter_tag_functions [Format] | Return the current tag functions of the pretty-printer. |
| get_image [Graphics] | Capture the contents of a rectangle on the screen as an image. |
| get_margin [Format] | Returns the position of the right margin. |
| get_mark_tags [Format] | Return the current status of 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_method [CamlinternalOO] | |
| get_method_label [CamlinternalOO] | |
| get_method_labels [CamlinternalOO] | |
| get_normalize_ratio [Arith_status] | |
| get_normalize_ratio_when_printing [Arith_status] | |
| get_print_tags [Format] | |
| get_public_method [CamlinternalOO] | |
| get_state [Random] | Return the current state of the generator used by the basic functions. |
| get_variable [CamlinternalOO] | |
| get_variables [CamlinternalOO] | |
| getaddrinfo [Unix] |
|
| 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 |
| getgrnam [Unix] | Find an entry in |
| getgroups [Unix] | Return the list of groups to which the user executing the process belongs. |
| gethostbyaddr [Unix] | Find an entry in |
| gethostbyname [Unix] | Find an entry in |
| 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] |
|
| 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 |
| getprotobynumber [Unix] | Find an entry in |
| getpwnam [Unix] | Find an entry in |
| getpwuid [Unix] | Find an entry in |
| getservbyname [Unix] | Find an entry in |
| getservbyport [Unix] | Find an entry in |
| 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_float [Unix] | Same as |
| getsockopt_int [Unix] | Same as |
| getsockopt_optint [Unix] | Same as |
| gettimeofday [Unix] | Same as |
| getuid [Unix] | Return the user id of the user executing the process. |
| global_replace [Str] |
|
| global_substitute [Str] |
|
| gmtime [Unix] | Convert a time in seconds, as returned by |
| green [Graphics] | |
| group_beginning [Str] |
|
| group_end [Str] |
|
| gt_nat [Nat] | |
| guard [Event] |
|
H | |
| handle_unix_error [Unix] |
|
| hash [MoreLabels.Hashtbl] | |
| hash [Hashtbl.HashedType] | A hashing function on keys. |
| hash [Hashtbl] |
|
| hash_param [MoreLabels.Hashtbl] | |
| hash_param [Hashtbl] |
|
| hd [StdLabels.List] | |
| hd [ListLabels] | Return the first element of the given list. |
| hd [List] | Return the first element of the given list. |
| header_size [Marshal] | The bytes representing a marshaled value are composed of a fixed-size header and a variable-sized data part, whose size can be determined from the header. |
I | |
| i [Complex] | The complex number |
| id [Oo] | Return an integer identifying this object, unique for the current execution of the program. |
| ifprintf [Printf] | Same as |
| ifprintf [Format] | Same as |
| ignore [Pervasives] | Discard the value of its argument and return |
| 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. |
| incr [Pervasives] | Increment the integer contained in the given reference. |
| incr_nat [Nat] | |
| index [StringLabels] |
|
| index [String] |
|
| index [StdLabels.String] | |
| index_from [StringLabels] | Same as |
| index_from [String] | Same as |
| index_from [StdLabels.String] | |
| inet6_addr_any [Unix] | A special IPv6 address, for use only with |
| inet6_addr_loopback [Unix] | A special IPv6 address representing the host machine ( |
| inet_addr_any [Unix] | A special IPv4 address, for use only with |
| inet_addr_loopback [Unix] | A special IPv4 address representing the host machine ( |
| 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 [Dynlink] | Initialize the |
| init [ArrayLabels] |
|
| init [Array] |
|
| init_class [CamlinternalOO] | |
| init_mod [CamlinternalMod] | |
| input [Pervasives] |
|
| 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 |
| input_char [Pervasives] | Read one character from the given input channel. |
| input_line [Pervasives] | Read characters from the given input channel, until a newline character is encountered. |
| input_value [Pervasives] | Read the representation of a structured value, as produced
by |
| int [Random.State] | |
| int [Random] |
|
| int32 [Random.State] | |
| int32 [Random] |
|
| int64 [Random.State] | |
| int64 [Random] |
|
| 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_string [Pervasives] | Convert the given string to an integer. |
| int_tag [Obj] | |
| inter [Set.S] | Set intersection. |
| inter [MoreLabels.Set.S] | |
| interactive [Sys] | This reference is initially set to |
| inv [Complex] | Multiplicative inverse ( |
| invalid_arg [Pervasives] | Raise exception |
| is_block [Obj] | |
| is_digit_int [Nat] | |
| is_digit_normalized [Nat] | |
| is_digit_odd [Nat] | |
| is_digit_zero [Nat] | |
| is_directory [Sys] | Returns |
| is_empty [Stack] | Return |
| is_empty [Set.S] | Test whether a set is empty or not. |
| is_empty [Queue] | Return |
| is_empty [MoreLabels.Set.S] | |
| is_empty [MoreLabels.Map.S] | |
| is_empty [Map.S] | Test whether a map is empty or not. |
| is_implicit [Filename] | Return |
| is_int [Obj] | |
| is_nat_int [Nat] | |
| is_relative [Filename] | Return |
| is_zero_nat [Nat] | |
| isatty [Unix] | Return |
| iter [Weak.S] |
|
| iter [StringLabels] |
|
| iter [String] |
|
| iter [Stream] |
|
| iter [StdLabels.String] | |
| iter [StdLabels.List] | |
| iter [StdLabels.Array] | |
| iter [Stack] |
|
| iter [Set.S] |
|
| iter [Queue] |
|
| iter [MoreLabels.Set.S] | |
| iter [MoreLabels.Map.S] | |
| iter [MoreLabels.Hashtbl.S] | |
| iter [MoreLabels.Hashtbl] | |
| iter [Map.S] |
|
| iter [ListLabels] |
|
| iter [List] |
|
| iter [Hashtbl.S] | |
| iter [Hashtbl] |
|
| iter [Dbm] |
|
| iter [ArrayLabels] |
|
| iter [Array] |
|
| iter2 [StdLabels.List] | |
| iter2 [ListLabels] |
|
| iter2 [List] |
|
| iteri [StdLabels.Array] | |
| iteri [ArrayLabels] | Same as |
| iteri [Array] | Same as |
J | |
| junk [Stream] | Remove the first element of the stream, possibly unfreezing it before. |
K | |
| kbprintf [Printf] | Same as |
| key_pressed [Graphics] | Return |
| kfprintf [Printf] | Formatted output functions with continuations. |
| kfprintf [Format] | Same as |
| kill [Unix] |
|
| kprintf [Printf] | A deprecated synonym for |
| kprintf [Format] | A deprecated synonym for |
| kscanf [Scanf] | Same as |
| ksprintf [Printf] | Same as |
| ksprintf [Format] | Same as |
L | |
| land_digit_nat [Nat] | |
| last_chars [Str] |
|
| lazy_from_fun [Lazy] |
|
| lazy_from_val [Lazy] |
|
| lazy_is_val [Lazy] |
|
| lazy_tag [Obj] | |
| ldexp [Pervasives] |
|
| le_nat [Nat] | |
| least_int [Int_misc] | |
| length [Weak] |
|
| 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 [MoreLabels.Hashtbl.S] | |
| length [MoreLabels.Hashtbl] | |
| length [ListLabels] | Return the length (number of elements) of the given list. |
| length [List] | Return the length (number of elements) of the given list. |
| length [Hashtbl.S] | |
| length [Hashtbl] |
|
| length [Buffer] | Return the number of characters currently contained in the buffer. |
| length [ArrayLabels] | Return the length (number of elements) of the given array. |
| length [Array] | Return the length (number of elements) of the given array. |
| length_nat [Nat] | |
| length_of_digit [Nat] | |
| length_of_int [Int_misc] | |
| lexeme [Lexing] |
|
| lexeme_char [Lexing] |
|
| lexeme_end [Lexing] |
|
| lexeme_end_p [Lexing] | Like |
| lexeme_start [Lexing] |
|
| lexeme_start_p [Lexing] | Like |
| lineto [Graphics] | Draw a line with endpoints the current point and the given point, and move the current point to the given point. |
| link [Unix] |
|
| 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. |
| loadfile [Dynlink] | Load the given bytecode object file ( |
| loadfile_private [Dynlink] | Same as |
| localtime [Unix] | Convert a time in seconds, as returned by |
| lock [Mutex] | Lock the given mutex. |
| lockf [Unix] |
|
| log [Pervasives] | Natural logarithm. |
| log [Complex] | Natural logarithm (in base |
| log10 [Pervasives] | Base 10 logarithm. |
| logand [Nativeint] | Bitwise logical and. |
| logand [Int64] | Bitwise logical and. |
| logand [Int32] | Bitwise logical and. |
| lognot [Nativeint] | Bitwise logical negation |
| lognot [Int64] | Bitwise logical negation |
| lognot [Int32] | Bitwise logical negation |
| logor [Nativeint] | Bitwise logical or. |
| logor [Int64] | Bitwise logical or. |
| logor [Int32] | Bitwise logical or. |
| logxor [Nativeint] | Bitwise logical exclusive or. |
| logxor [Int64] | Bitwise logical exclusive or. |
| logxor [Int32] | Bitwise logical exclusive or. |
| lookup_tables [CamlinternalOO] | |
| 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 [Char] | Convert the given character to its equivalent lowercase character. |
| lseek [Unix.LargeFile] | |
| lseek [Unix] | Set the current position for a file descriptor |
| lstat [Unix.LargeFile] | |
| lstat [Unix] | Same as |
| lt_nat [Nat] | |
| 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 [StringLabels] |
|
| make [String] |
|
| make [StdLabels.String] | |
| make [StdLabels.Array] | |
| make [Random.State] | Create a new state and initialize it with the given seed. |
| make [ArrayLabels] |
|
| make [Array] |
|
| make_class [CamlinternalOO] | |
| make_class_store [CamlinternalOO] | |
| make_formatter [Format] |
|
| make_image [Graphics] | Convert the given color matrix to an image. |
| make_lexer [Genlex] | Construct the lexer function. |
| make_matrix [StdLabels.Array] | |
| make_matrix [ArrayLabels] |
|
| make_matrix [Array] |
|
| make_nat [Nat] | |
| make_power_base [Nat] | |
| make_self_init [Random.State] | Create a new state and initialize it with a system-dependent low-entropy seed. |
| map [StdLabels.List] | |
| map [StdLabels.Array] | |
| map [MoreLabels.Map.S] | |
| map [Map.S] |
|
| map [ListLabels] |
|
| map [List] |
|
| map [ArrayLabels] |
|
| map [Array] |
|
| map2 [StdLabels.List] | |
| map2 [ListLabels] |
|
| map2 [List] |
|
| mapi [StdLabels.Array] | |
| mapi [MoreLabels.Map.S] | |
| mapi [Map.S] | Same as |
| mapi [ArrayLabels] | Same as |
| mapi [Array] | Same as |
| marshal [Obj] | |
| match_beginning [Str] |
|
| match_end [Str] |
|
| matched_group [Str] |
|
| matched_string [Str] |
|
| max [Pervasives] | Return the greater of the two arguments. |
| max_array_length [Sys] | Maximum length of a normal array. |
| max_elt [Set.S] | Same as |
| max_elt [MoreLabels.Set.S] | |
| max_float [Pervasives] | The largest positive finite value of type |
| 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_string_length [Sys] | Maximum length of a string. |
| mem [Weak.S] |
|
| mem [StdLabels.List] | |
| mem [Set.S] |
|
| mem [MoreLabels.Set.S] | |
| mem [MoreLabels.Map.S] | |
| mem [MoreLabels.Hashtbl.S] | |
| mem [MoreLabels.Hashtbl] | |
| mem [Map.S] |
|
| mem [ListLabels] |
|
| mem [List] |
|
| mem [Hashtbl.S] | |
| mem [Hashtbl] |
|
| mem_assoc [StdLabels.List] | |
| mem_assoc [ListLabels] | Same as |
| mem_assoc [List] | Same as |
| mem_assq [StdLabels.List] | |
| mem_assq [ListLabels] | Same as |
| mem_assq [List] | Same as |
| memq [StdLabels.List] | |
| memq [ListLabels] | Same as |
| memq [List] | Same as |
| merge [Weak.S] |
|
| merge [StdLabels.List] | |
| merge [Sort] | Merge two lists according to the given predicate. |
| merge [ListLabels] | Merge two lists:
Assuming that |
| merge [List] | Merge two lists:
Assuming that |
| min [Pervasives] | Return the smaller of the two arguments. |
| min_elt [Set.S] | Return the smallest element of the given set
(with respect to the |
| min_elt [MoreLabels.Set.S] | |
| min_float [Pervasives] | The smallest positive, non-zero, non-denormalized value of type |
| 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. |
| minor [Gc] | Trigger a minor collection. |
| minus_one [Nativeint] | The native integer -1. |
| minus_one [Int64] | The 64-bit integer -1. |
| minus_one [Int32] | The 32-bit integer -1. |
| mkdir [Unix] | Create a directory with the given permissions. |
| mkfifo [Unix] | Create a named pipe with the given permissions. |
| mktime [Unix] | Convert a date and time, specified by the |
| mod_float [Pervasives] |
|
| modf [Pervasives] |
|
| 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_digit_nat [Nat] | |
| mult_nat [Nat] | |
N | |
| name_of_input [Scanf.Scanning] |
|
| nan [Pervasives] | A special floating-point value denoting the result of an
undefined operation such as |
| narrow [CamlinternalOO] | |
| nat_of_int [Nat] | |
| nat_of_string [Nat] | |
| nativeint [Random.State] | |
| nativeint [Random] |
|
| neg [Nativeint] | Unary negation. |
| neg [Int64] | Unary negation. |
| neg [Int32] | Unary negation. |
| neg [Complex] | Unary negation. |
| neg_infinity [Pervasives] | Negative infinity. |
| new_block [Obj] | |
| new_channel [Event] | Return a new channel. |
| new_method [CamlinternalOO] | |
| new_methods_variables [CamlinternalOO] | |
| new_variable [CamlinternalOO] | |
| next [Stream] | Return the first element of the stream and remove it from the stream. |
| nextkey [Dbm] | Enumerate all keys in the given database, in an unspecified order. |
| nice [Unix] | Change the process priority. |
| no_scan_tag [Obj] | |
| norm [Complex] | Norm: given |
| norm2 [Complex] | Norm squared: given |
| normalize_ratio_flag [Arith_flags] | |
| normalize_ratio_when_printing_flag [Arith_flags] | |
| not [Pervasives] | The boolean negation. |
| npeek [Stream] |
|
| nth [StdLabels.List] | |
| nth [ListLabels] | Return the |
| nth [List] | Return the |
| nth [Buffer] | get the n-th character of the buffer. |
| nth_digit_nat [Nat] | |
| num_bits_int [Int_misc] | |
| num_digits_nat [Nat] | |
| num_leading_zero_bits_in_digit [Nat] | |
O | |
| obj [Obj] | |
| object_tag [Obj] | |
| ocaml_version [Sys] |
|
| of_channel [Stream] | Return the stream of the characters read from the input channel. |
| of_float [Nativeint] | Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0). |
| of_float [Int64] | Convert the given floating-point number to a 64-bit integer, discarding the fractional part (truncate towards 0). |
| of_float [Int32] | Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0). |
| of_int [Nativeint] | Convert the given integer (type |
| of_int [Int64] | Convert the given integer (type |
| of_int [Int32] | Convert the given integer (type |
| of_int32 [Nativeint] | Convert the given 32-bit integer (type |
| of_int32 [Int64] | Convert the given 32-bit integer (type |
| of_list [Stream] | Return the stream holding the elements of the list in the same order. |
| of_list [StdLabels.Array] | |
| of_list [ArrayLabels] |
|
| of_list [Array] |
|
| of_nativeint [Int64] | Convert the given native integer (type |
| of_string [Stream] | Return the stream of the characters of the string parameter. |
| of_string [Nativeint] | Convert the given string to a native integer. |
| of_string [Int64] | Convert the given string to a 64-bit integer. |
| of_string [Int32] | Convert the given string to a 32-bit integer. |
| one [Nativeint] | The native integer 1. |
| one [Int64] | The 64-bit integer 1. |
| one [Int32] | The 32-bit integer 1. |
| one [Complex] | The complex number |
| open_box [Format] |
|
| 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_hovbox [Format] |
|
| open_hvbox [Format] |
|
| open_in [Pervasives] | Open the named file for reading, and return a new input channel on that file, positionned at the beginning of the file. |
| open_in_bin [Pervasives] | Same as |
| open_in_gen [Pervasives] |
|
| open_out [Pervasives] | Open the named file for writing, and return a new output channel on that file, positionned at the beginning of the file. |
| open_out_bin [Pervasives] | Same as |
| open_out_gen [Pervasives] |
|
| open_process [Unix] | Same as |
| open_process_full [Unix] | Similar to |
| open_process_in [Unix] | High-level pipe and process management. |
| open_process_out [Unix] | Same as |
| open_subwindow [GraphicsX11] | Create a sub-window of the current Caml graphics window and return its identifier. |
| open_tag [Format] |
|
| open_tbox [Format] | Opens a tabulation box. |
| open_temp_file [Filename] | Same as |
| open_vbox [Format] |
|
| opendbm [Dbm] | Open a descriptor on an NDBM database. |
| opendir [Unix] | Open a descriptor on a directory |
| openfile [Unix] | Open the named file with the given flags. |
| os_type [Sys] | Operating system currently executing the Caml 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_of_heap_tag [Obj] | |
| output [Pervasives] |
|
| 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_byte [Pervasives] | Write one 8-bit integer (as the single character with that code) on the given output channel. |
| output_char [Pervasives] | Write the character on the given output channel. |
| output_string [Pervasives] | Write the string on the given output channel. |
| output_value [Pervasives] | Write the representation of a structured value of any type to a channel. |
| over_max_boxes [Format] | Tests if the maximum number of boxes allowed have already been opened. |
P | |
| params [CamlinternalOO] | |
| parent_dir_name [Filename] | The conventional name for the parent of the current directory (e.g. |
| parse [Arg] |
|
| parse_argv [Arg] |
|
| partition [StdLabels.List] | |
| partition [Set.S] |
|
| partition [MoreLabels.Set.S] | |
| partition [ListLabels] |
|
| partition [List] |
|
| pause [Unix] | Wait until a non-ignored, non-blocked signal is delivered. |
| peek [Stream] | Return |
| peek [Queue] |
|
| 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] |
|
| poll [Event] | Non-blocking version of |
| pop [Stack] |
|
| pop [Queue] |
|
| pos_in [Pervasives.LargeFile] | |
| pos_in [Pervasives] | Return the current reading position for the given channel. |
| pos_out [Pervasives.LargeFile] | |
| pos_out [Pervasives] | Return the current writing position for the given channel. |
| pow [Complex] | Power function. |
| power_base_int [Nat] | |
| pp_close_box [Format] | |
| pp_close_tag [Format] | |
| pp_close_tbox [Format] | |
| pp_force_newline [Format] | |
| pp_get_all_formatter_output_functions [Format] | |
| pp_get_ellipsis_text [Format] | |
| pp_get_formatter_output_functions [Format] | |
| pp_get_formatter_tag_functions [Format] | These functions are the basic ones: usual functions operating on the standard formatter are defined via partial evaluation of these primitives. |
| pp_get_margin [Format] | |
| pp_get_mark_tags [Format] | |
| pp_get_max_boxes [Format] | |
| pp_get_max_indent [Format] | |
| pp_get_print_tags [Format] | |
| pp_open_box [Format] | |
| pp_open_hbox [Format] | |
| pp_open_hovbox [Format] | |
| pp_open_hvbox [Format] | |
| pp_open_tag [Format] | |
| pp_open_tbox [Format] | |
| pp_open_vbox [Format] | |
| pp_over_max_boxes [Format] | |
| pp_print_as [Format] | |
| pp_print_bool [Format] | |
| pp_print_break [Format] | |
| pp_print_char [Format] | |
| pp_print_cut [Format] | |
| pp_print_float [Format] | |
| pp_print_flush [Format] | |
| pp_print_if_newline [Format] | |
| pp_print_int [Format] | |
| pp_print_newline [Format] | |
| pp_print_space [Format] | |
| pp_print_string [Format] | |
| pp_print_tab [Format] | |
| pp_print_tbreak [Format] | |
| pp_set_all_formatter_output_functions [Format] | |
| pp_set_ellipsis_text [Format] | |
| pp_set_formatter_out_channel [Format] | |
| pp_set_formatter_output_functions [Format] | |
| pp_set_formatter_tag_functions [Format] | |
| pp_set_margin [Format] | |
| pp_set_mark_tags [Format] | |
| pp_set_max_boxes [Format] | |
| pp_set_max_indent [Format] | |
| pp_set_print_tags [Format] | |
| pp_set_tab [Format] | |
| pp_set_tags [Format] | |
| pred [Pervasives] |
|
| pred [Nativeint] | Predecessor. |
| pred [Int64] | Predecessor. |
| pred [Int32] | Predecessor. |
| prerr_char [Pervasives] | Print a character on standard error. |
| prerr_endline [Pervasives] | Print a string, followed by a newline character on standard error and flush standard error. |
| prerr_float [Pervasives] | Print a floating-point number, in decimal, on standard error. |
| prerr_int [Pervasives] | Print an integer, in decimal, on standard error. |
| prerr_newline [Pervasives] | Print a newline character on standard error, and flush standard error. |
| prerr_string [Pervasives] | Print a string on standard error. |
| print [Printexc] |
|
| print_as [Format] |
|
| 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_endline [Pervasives] | Print a string, followed by a newline character, on standard output and flush standard output. |
| print_float [Pervasives] | Print a floating-point number, in decimal, on standard output. |
| print_float [Format] | Prints a floating point number in the current box. |
| print_flush [Format] | Flushes the pretty printer: all opened boxes are closed, and all pending text is displayed. |
| print_if_newline [Format] | Executes the next formatting command if the preceding line has just been split. |
| print_int [Pervasives] | Print an integer, in decimal, on standard output. |
| print_int [Format] | Prints an integer in the current box. |
| print_newline [Pervasives] | Print a newline character on standard output, and flush standard output. |
| print_newline [Format] | Equivalent to |
| print_space [Format] |
|
| print_stat [Gc] | Print the current values of the memory management counters (in human-readable form) into the channel argument. |
| print_string [Pervasives] | Print a string on standard output. |
| print_string [Format] |
|
| print_tab [Format] |
|
| print_tbreak [Format] | Break hint in a tabulation box. |
| printf [Printf] | Same as |
| printf [Format] | Same as |
| prohibit [Dynlink] |
|
| public_method_label [CamlinternalOO] | |
| push [Stack] |
|
| push [Queue] |
|
| putenv [Unix] |
|
Q | |
| quick_stat [Gc] | Same as |
| quote [Str] |
|
| quote [Filename] | Return a quoted version of a file name, suitable for use as one argument in a command line, escaping all meta-characters. |
R | |
| raise [Pervasives] | Raise the given exception value |
| rcontains_from [StringLabels] |
|
| rcontains_from [String] |
|
| rcontains_from [StdLabels.String] | |
| read [Unix] |
|
| read_float [Pervasives] | Flush standard output, then read one line from standard input and convert it to a floating-point number. |
| read_int [Pervasives] | Flush standard output, then read one line from standard input and convert it to an integer. |
| read_key [Graphics] | Wait for a key to be pressed, and return the corresponding character. |
| read_line [Pervasives] | Flush standard output, then read characters from standard input until a newline character is encountered. |
| readdir [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] |
|
| receive [Event] |
|
| recv [Unix] | Receive data from a connected socket. |
| recvfrom [Unix] | Receive data from an unconnected socket. |
| red [Graphics] | |
| ref [Pervasives] | Return a fresh reference containing the given value. |
| regexp [Str] | Compile a regular expression. |
| regexp_case_fold [Str] | Same as |
| regexp_string [Str] |
|
| regexp_string_case_fold [Str] |
|
| register [Callback] |
|
| register_exception [Callback] |
|
| 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 [Sys] | Remove the given file name from the file system. |
| remove [Set.S] |
|
| remove [MoreLabels.Set.S] | |
| remove [MoreLabels.Map.S] | |
| remove [MoreLabels.Hashtbl.S] | |
| remove [MoreLabels.Hashtbl] | |
| remove [Map.S] |
|
| remove [Hashtbl.S] | |
| remove [Hashtbl] |
|
| remove [Dbm] |
|
| remove_assoc [StdLabels.List] | |
| remove_assoc [ListLabels] |
|
| remove_assoc [List] |
|
| remove_assq [StdLabels.List] | |
| remove_assq [ListLabels] | Same as |
| remove_assq [List] | Same as |
| rename [Unix] |
|
| rename [Sys] | Rename a file. |
| replace [MoreLabels.Hashtbl.S] | |
| replace [MoreLabels.Hashtbl] | |
| replace [Hashtbl.S] | |
| replace [Hashtbl] |
|
| replace [Dbm] |
|
| replace_first [Str] | Same as |
| replace_matched [Str] |
|
| repr [Obj] | |
| reset [Buffer] | Empty the buffer and deallocate the internal string holding the
buffer contents, replacing it with the initial internal string
of length |
| 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] |
|
| rev_append [List] |
|
| rev_map [StdLabels.List] | |
| rev_map [ListLabels] |
|
| rev_map [List] | |
| rev_map2 [StdLabels.List] | |
| rev_map2 [ListLabels] |
|
| rev_map2 [List] | |
| rewinddir [Unix] | Reposition the descriptor to the beginning of the directory |
| rgb [Graphics] |
|
| rhs_end [Parsing] | See |
| rhs_end_pos [Parsing] | Same as |
| rhs_start [Parsing] | Same as |
| rhs_start_pos [Parsing] | Same as |
| rindex [StringLabels] |
|
| rindex [String] |
|
| rindex [StdLabels.String] | |
| rindex_from [StringLabels] | Same as |
| rindex_from [String] | Same as |
| rindex_from [StdLabels.String] | |
| rlineto [Graphics] | Draw a line with endpoints the current point and the current point translated of the given vector, and move the current point to this point. |
| rmdir [Unix] | Remove an empty directory. |
| rmoveto [Graphics] |
|
| run_initializers [CamlinternalOO] | |
| run_initializers_opt [CamlinternalOO] | |
S | |
| scanf [Scanf] | Same as |
| search_backward [Str] |
|
| search_forward [Str] |
|
| seek_in [Pervasives.LargeFile] | |
| seek_in [Pervasives] |
|
| seek_out [Pervasives.LargeFile] | |
| seek_out [Pervasives] |
|
| select [Unix] | Wait until some input/output operations become possible on some channels. |
| select [Event] | ``Synchronize'' on an alternative of events. |
| self_init [Random] | Initialize the generator with a more-or-less random seed chosen in a system-dependent way. |
| send [Unix] | Send data over a connected socket. |
| send [Event] |
|
| send [CamlinternalOO] | |
| sendcache [CamlinternalOO] | |
| sendself [CamlinternalOO] | |
| sendto [Unix] | Send data over an unconnected socket. |
| set [Weak] |
|
| set [StringLabels] |
|
| set [String] |
|
| set [StdLabels.String] | |
| set [StdLabels.Array] | |
| set [Gc] |
|
| set [ArrayLabels] |
|
| set [Array] |
|
| set_all_formatter_output_functions [Format] |
|
| set_approx_printing [Arith_status] | Get or set the flag |
| set_binary_mode_in [Pervasives] |
|
| set_binary_mode_out [Pervasives] |
|
| set_close_on_exec [Unix] | Set the ``close-on-exec'' flag on the given descriptor. |
| set_color [Graphics] | Set the current drawing color. |
| set_digit_nat [Nat] | |
| set_ellipsis_text [Format] | Set the text of the ellipsis printed when too many boxes
are opened (a single dot, |
| set_error_when_null_denominator [Arith_status] | Get or set the flag |
| set_field [Obj] | |
| set_floating_precision [Arith_status] | Get or set the parameter |
| set_font [Graphics] | Set the font used for drawing text. |
| set_formatter_out_channel [Format] | Redirect the pretty-printer output to the given channel. |
| set_formatter_output_functions [Format] |
|
| set_formatter_tag_functions [Format] | |
| set_line_width [Graphics] | Set the width of points and lines drawn with the functions above. |
| set_margin [Format] |
|
| set_mark_tags [Format] |
|
| set_max_boxes [Format] |
|
| set_max_indent [Format] |
|
| set_method [CamlinternalOO] | |
| set_methods [CamlinternalOO] | |
| set_nonblock [Unix] | Set the ``non-blocking'' flag on the given descriptor. |
| set_normalize_ratio [Arith_status] | Get or set the flag |
| set_normalize_ratio_when_printing [Arith_status] | Get or set the flag |
| set_print_tags [Format] | |
| set_signal [Sys] | Same as |
| set_state [Random] | Set the state of the generator used by the basic functions. |
| set_tab [Format] | Sets a tabulation mark at the current insertion point. |
| set_tag [Obj] | |
| set_tags [Format] |
|
| set_text_size [Graphics] | Set the character size used for drawing text. |
| set_to_zero_nat [Nat] | |
| 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. |
| setitimer [Unix] |
|
| 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 |
| setsockopt_int [Unix] | Same as |
| setsockopt_optint [Unix] | Same as |
| setuid [Unix] | Set the real user id and effective user id for the process. |
| shift_left [Nativeint] |
|
| shift_left [Int64] |
|
| shift_left [Int32] |
|
| shift_left_nat [Nat] | |
| shift_right [Nativeint] |
|
| shift_right [Int64] |
|
| shift_right [Int32] |
|
| shift_right_logical [Nativeint] |
|
| shift_right_logical [Int64] |
|
| shift_right_logical [Int32] |
|
| shift_right_nat [Nat] | |
| shutdown [Unix] | Shutdown a socket connection. |
| shutdown_connection [Unix] | ``Shut down'' a connection established with |
| 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_int [Int_misc] | |
| signal [Sys] | Set the behavior of the system on receipt of a given signal. |
| sigpending [Unix] | Return the set of blocked signals that are currently pending. |
| sigpipe [Sys] | Broken pipe |
| sigprocmask [Unix] |
|
| sigprof [Sys] | Profiling interrupt |
| sigquit [Sys] | Interactive termination |
| sigsegv [Sys] | Invalid memory reference |
| sigstop [Sys] | Stop |
| sigsuspend [Unix] |
|
| sigterm [Sys] | Termination |
| sigtstp [Sys] | Interactive stop |
| sigttin [Sys] | Terminal read from background process |
| sigttou [Sys] | Terminal write from background process |
| sigusr1 [Sys] | Application-defined signal 1 |
| sigusr2 [Sys] | Application-defined signal 2 |
| sigvtalrm [Sys] | Timeout in virtual time |
| sin [Pervasives] | See |
| single_write [Unix] | Same as |
| singleton [Set.S] |
|
| singleton [MoreLabels.Set.S] | |
| sinh [Pervasives] | See |
| size [Obj] | |
| size [Nativeint] | The size in bits of a native integer. |
| size_x [Graphics] | See |
| size_y [Graphics] | Return the size of the graphics window. |
| sleep [Unix] | Stop execution for the given number of seconds. |
| 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 [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] |
|
| split [Str] |
|
| split [StdLabels.List] | |
| split [Set.S] |
|
| split [MoreLabels.Set.S] | |
| split [ListLabels] | Transform a list of pairs into a pair of lists:
|
| split [List] | Transform a list of pairs into a pair of lists:
|
| split_delim [Str] | Same as |
| sprintf [Printf] | Same as |
| sprintf [Format] | Same as |
| sqrt [Pervasives] | Square root |
| sqrt [Complex] | Square root. |
| sqrt_nat [Nat] | |
| square_nat [Nat] | |
| sscanf [Scanf] | Same as |
| sscanf_format [Scanf] | Same as |
| stable_sort [StdLabels.List] | |
| stable_sort [StdLabels.Array] | |
| stable_sort [ListLabels] | Same as |
| stable_sort [List] | Same as |
| stable_sort [ArrayLabels] | Same as |
| stable_sort [Array] | Same as |
| stat [Unix.LargeFile] | |
| stat [Unix] | Return the information for the named file. |
| stat [Gc] | Return the current values of the memory management counters in a
|
| stats [Weak.S] | Return statistics on the table. |
| stats [CamlinternalOO] | |
| std_formatter [Format] | The standard formatter used by the formatting functions above. |
| stdbuf [Format] | The string buffer in which |
| stderr [Unix] | File descriptor for standard error. |
| stderr [Pervasives] | The standard error ouput for the process. |
| stdib [Scanf.Scanning] | The scanning buffer reading from |
| stdin [Unix] | File descriptor for standard input. |
| stdin [Pervasives] | The standard input for the process. |
| stdout [Unix] | File descriptor for standard output. |
| stdout [Pervasives] | The standard output for the process. |
| str_formatter [Format] | A formatter to use with formatting functions below for
output to the |
| string [Digest] | Return the digest of the given string. |
| string_after [Str] |
|
| string_before [Str] |
|
| string_match [Str] |
|
| 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_partial_match [Str] | Similar to |
| string_tag [Obj] | |
| sub [StringLabels] |
|
| sub [String] |
|
| sub [StdLabels.String] | |
| sub [StdLabels.Array] | |
| sub [Nativeint] | Subtraction. |
| sub [Int64] | Subtraction. |
| sub [Int32] | Subtraction. |
| sub [Complex] | Subtraction |
| sub [Buffer] |
|
| sub [ArrayLabels] |
|
| sub [Array] |
|
| sub_nat [Nat] | |
| subset [Set.S] |
|
| subset [MoreLabels.Set.S] | |
| substitute_first [Str] | Same as |
| substring [Digest] |
|
| succ [Pervasives] |
|
| succ [Nativeint] | Successor. |
| succ [Int64] | Successor. |
| succ [Int32] | Successor. |
| symbol_end [Parsing] | See |
| symbol_end_pos [Parsing] | Same as |
| symbol_start [Parsing] |
|
| symbol_start_pos [Parsing] | Same as |
| symlink [Unix] |
|
| sync [Event] | ``Synchronize'' on an event: offer all the communication possibilities specified in the event to the outside world, and block until one of the communications succeed. |
| synchronize [Graphics] | Synchronize the backing store and the on-screen window, by copying the contents of the backing store onto the graphics window. |
| sys_nat_of_string [Nat] | |
| system [Unix] | Execute the given command, wait until it terminates, and return its termination status. |
T | |
| tag [Obj] | |
| take [Queue] |
|
| tan [Pervasives] | See |
| tanh [Pervasives] | The usual hyperbolic trigonometric functions. |
| 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:
|
| tcflush [Unix] | Discard data written on the given file descriptor but not yet
transmitted, or data received but not yet read, depending on the
second argument: |
| tcgetattr [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] | The name of the temporary directory:
Under Unix, the value of the |
| temp_file [Filename] |
|
| text_size [Graphics] | Return the dimensions of the given text, if it were drawn with the current font and size. |
| time [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] |
|
| to_channel [Marshal] |
|
| 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 |
| to_int [Int64] | Convert the given 64-bit integer (type |
| to_int [Int32] | Convert the given 32-bit integer (type |
| to_int32 [Nativeint] | Convert the given native integer to a
32-bit integer (type |
| to_int32 [Int64] | Convert the given 64-bit integer (type |
| to_list [StdLabels.Array] | |
| to_list [ArrayLabels] |
|
| to_list [Array] |
|
| to_nativeint [Int64] | Convert the given 64-bit integer (type |
| to_string [Printexc] |
|
| to_string [Nativeint] | Return the string representation of its argument, in decimal. |
| to_string [Marshal] |
|
| to_string [Int64] | Return the string representation of its argument, in decimal. |
| to_string [Int32] | Return the string representation of its argument, in signed decimal. |
| top [Stack] |
|
| top [Queue] |
|
| total_size [Marshal] | See |
| transfer [Queue] |
|
| transp [Graphics] | In matrices of colors, this color represent a ``transparent'' point: when drawing the corresponding image, all pixels on the screen corresponding to a transparent pixel in the image will not be modified, while other points will be set to the color of the corresponding point in the image. |
| truncate [Unix.LargeFile] | |
| truncate [Unix] | Truncates the named file to the given size. |
| truncate [Pervasives] | Same as |
| truncate [Obj] | |
| try_lock [Mutex] | Same as |
U | |
| umask [Unix] | Set the process's file mode creation mask, and return the previous mask. |
| 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] | |
| union [Set.S] | Set union. |
| union [MoreLabels.Set.S] | |
| unlink [Unix] | Removes the named file |
| unlock [Mutex] | Unlock the given mutex. |
| unmarshal [Obj] | |
| unsafe_blit [StdLabels.String] | |
| unsafe_fill [StdLabels.String] | |
| unsafe_get [StdLabels.String] | |
| unsafe_get [StdLabels.Array] | |
| unsafe_set [StdLabels.String] | |
| unsafe_set [StdLabels.Array] | |
| update_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 [Char] | Convert the given character to its equivalent uppercase character. |
| usage [Arg] |
|
| utimes [Unix] | Set the last access time (second arg) and last modification time (third arg) for a file. |
W | |
| wait [Unix] | Wait until one of the children processes die, and return its pid and termination status. |
| 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. |
| waitpid [Unix] | Same as |
| white [Graphics] | |
| widen [CamlinternalOO] | |
| window_id [GraphicsX11] | Return the unique identifier of the Caml graphics window. |
| word_size [Sys] | Size of one word on the machine currently executing the Caml program, in bits: 32 or 64. |
| wrap [Event] |
|
| wrap_abort [Event] |
|
| write [Unix] |
|
Y | |
| yellow [Graphics] | |
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 |