Index of values


( * ) [Int_intf.S]
( * ) [Float]
(!) [Ref]
(!=) [Common]
(%) [Int.Infix]
mod and div operators that have the right behavior on negative numbers, that is, x % y always returns a positive int between 0 and y-1.
(+) [Int_intf.S]
(+) [Float]
(+) [Bucket.Contents]
(-) [Int_intf.S]
(-) [Float]
(-) [Bucket.Contents]
(/%) [Int.Infix]
(/) [Time.Span]
(/) [Int_intf.S]
(/) [Float]
(//) [Int.Infix]
float division of integers
(:=) [Ref]
(<) [Comparable.Infix]
(<.) [Robustly_comparable.S]
(<.) [Float_robust_compare]
(</>) [String.Infix]
(<=) [Comparable.Infix]
(<=.) [Robustly_comparable.S]
(<=.) [Float_robust_compare]
(<>) [Comparable.Infix]
(<>.) [Robustly_comparable.S]
(<>.) [Float_robust_compare]
(<|>) [Array.Infix]
(=) [Comparable.Infix]
(=.) [Robustly_comparable.S]
(=.) [Float_robust_compare]
(==) [Common]
(>) [Comparable.Infix]
(>.) [Robustly_comparable.S]
(>.) [Float_robust_compare]
(>=) [Comparable.Infix]
(>=.) [Robustly_comparable.S]
(>=.) [Float_robust_compare]
(>>=) [Monad.Infix2]
(>>=) [Monad.Infix]
t >>= f returns a computation that sequences the computations represented by two monad elements.
(>>|) [Monad.Infix2]
(>>|) [Monad.Infix]
t >>| f is t >>= (fun a -> return (f a)).
(@) [List.Infix]
(^/) [Common]
same as Filename.concat
(|!) [Function]
(|!) [Common]
Functions from function.ml

A
abbreviation [TZ.Zone]
abbreviation zone t returns Zone.t abbreviation name such as EDT, EST, JST of given zone at the time t.
abort [Unix_ext]
abrt [Signal]
Specific signals
abs [Time.Span]
abs [Int_intf.S]
abs [Float]
abs_diff [Time]
diff t1 t2 returns the absolute span of time t1 minus time t2.
accept [Unix]
Accept connections on the given socket.
access [Unix]
Check that the process has the given permissions over the named file.
add [Unix_ext.Resource_usage]
add ru1 ru2 adds two rusage structures (e.g.
add [Timer]
add timer handler ?randomize ?interval span
add [Time.Ofday]
add t s shifts the time of day t by the span s.
add [Time.Span]
Basic operations on spans
add [Time]
add t s adds the span s to time t and returns the resulting time.
add [Int_set]
add t i add i to the set
add [Hash_set_intf.S1]
add [Hash_set_intf.Gen.S]
strict_add fails if element is already there
add [Hash_set_intf.S]
add [Float]
add [Fast_hashtbl]
add [Set_intf.S1]
add [Set_intf.Gen.S]
add [Map_intf.S2]
add [Map_intf.Gen.S]
returns a new map with the specified new binding; if the key was already bound, its previous binding disappears.
add [Int64]
add [Set_intf.S]
add [Map_intf.S]
add [Bag]
add t v adds v to the bag t, returning an element that can later be removed from the bag.
add_abs [Timer]
add_abs timer handler ?randomize ?interval time same as Timer.add, but takes an absolute time time for scheduling the event rather than a span.
add_buffer [Bigbuffer]
add_buffer b1 b2 appends the current contents of buffer b2 at the end of buffer b1.
add_business_days [Time.Date]
add_business_days t ~is_holiday n returns t when n=0 even if t is not a business day.
add_channel [Bigbuffer]
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 [Bigbuffer]
add_char b c appends the character c at the end of the buffer b.
add_days [Time.Date]
add_range [Int_set]
add_range t i j add all the numbers between i and j (inclusive) to the set.
add_string [Bigbuffer]
add_string b s appends the string s at the end of the buffer b.
add_substitute [Bigbuffer]
add_substitute b f s appends the string pattern s at the end of the buffer b with substitution.
add_substring [Bigbuffer]
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.
add_to_groups [Hashtbl_intf.S2]
add_to_groups [Hashtbl_intf.Gen.S]
add_to_groups [Hashtbl_intf.S]
add_weekdays [Time.Date]
add_weekdays t n returns t when n=0 even if t is not a weekday
alarm [Unix]
Schedule a SIGALRM signal after the given number of seconds.
align [Arg]
all [Pretty_printer]
all [Month]
allocated_bytes [Gc]
Return the total number of bytes allocated since the program was started.
alrm [Signal]
Timeout
always [Quickcheck]
generator that always returns given value
always [OUnit_utils]
generator that always returns given value
am_holding_mutex [Mutex0]
am_holding_mutex [Mutex]
append [List]
E.g.
append [Array]
apply [Result]
apply [Option]
apply x f run optional function on argument and return an option
apr [Month]
are_disjoint [Interval_intf.Gen.S]
are_disjoint_as_open_intervals [Interval_intf.Gen.S]
argv [Sys]
The command line arguments given to the process.
ascending [Comparable.S]
ascending [Comparable.Inherit]
ascending [Comparable.Make]
ascending [Comparable.Poly]
ascending [Common]
A comparator that returns results in ascending order.
assoc [List]
assoc' [List]
assoc_exn' [List]
assoc_opt [List]
assoc_opt a l returns the value associated with key a in the list of pairs l as an option.
aug [Month]

B
back_index [Dequeue]
backtrace_status [Printexc]
base [Substring_intf.S]
base [Make_substring.F]
basename [Filename]
Respects the posix semantic.
big_contents [Bigbuffer]
Return a copy of the current contents of the buffer as a bigstring.
bigstring_bigstring [Make_substring.Blit]
bigstring_kind [Unix_ext.IOVec]
bigstring_string [Make_substring.Blit]
bin_decimal [Common]
bin_immutable [Common]
bin_inet_addr [Unix]
bin_poly_t [Interval_intf.S.Set]
bin_poly_t [Interval_intf.S]
bin_read_decimal [Common]
bin_read_decimal_ [Common]
bin_read_decimal__ [Common]
bin_read_immutable [Common]
bin_read_immutable_ [Common]
bin_read_immutable__ [Common]
bin_read_inet_addr [Unix]
bin_read_inet_addr_ [Unix]
bin_read_inet_addr__ [Unix]
bin_read_only [Common]
bin_read_poly_t [Interval_intf.S.Set]
bin_read_poly_t [Interval_intf.S]
bin_read_poly_t_ [Interval_intf.S.Set]
bin_read_poly_t_ [Interval_intf.S]
bin_read_poly_t__ [Interval_intf.S.Set]
bin_read_poly_t__ [Interval_intf.S]
bin_read_read_only [Common]
bin_read_read_only_ [Common]
bin_read_read_only__ [Common]
bin_read_read_write [Common]
bin_read_read_write_ [Common]
bin_read_read_write__ [Common]
bin_read_sexp_list [Sexp.Sexp_list]
bin_read_sexp_list_ [Sexp.Sexp_list]
bin_read_sexp_list__ [Sexp.Sexp_list]
bin_read_sexp_option [Sexp.Sexp_option]
bin_read_sexp_option_ [Sexp.Sexp_option]
bin_read_sexp_option__ [Sexp.Sexp_option]
bin_read_sockaddr [Unix]
bin_read_sockaddr_ [Unix]
bin_read_sockaddr__ [Unix]
bin_read_socket_domain [Unix]
bin_read_socket_domain_ [Unix]
bin_read_socket_domain__ [Unix]
bin_read_socket_type [Unix]
bin_read_socket_type_ [Unix]
bin_read_socket_type__ [Unix]
bin_read_sysinfo [Linux_ext]
bin_read_sysinfo_ [Linux_ext]
bin_read_sysinfo__ [Linux_ext]
bin_read_t [Time.Date]
bin_read_t [Interval_intf.S1.Set]
bin_read_t [Interval_intf.S1]
bin_read_t [Interval_intf.S.Set]
bin_read_t [Interval_intf.S]
bin_read_t [Bucket.Make]
bin_read_t_ [Time.Date]
bin_read_t_ [Interval_intf.S1.Set]
bin_read_t_ [Interval_intf.S1]
bin_read_t_ [Interval_intf.S.Set]
bin_read_t_ [Interval_intf.S]
bin_read_t_ [Bucket.Make]
bin_read_t__ [Time.Date]
bin_read_t__ [Interval_intf.S1.Set]
bin_read_t__ [Interval_intf.S1]
bin_read_t__ [Interval_intf.S.Set]
bin_read_t__ [Interval_intf.S]
bin_read_t__ [Bucket.Make]
bin_read_tcp_bool_option [Linux_ext]
bin_read_tcp_bool_option_ [Linux_ext]
bin_read_tcp_bool_option__ [Linux_ext]
bin_read_write [Common]
bin_read_write_only [Common]
bin_read_write_only_ [Common]
bin_read_write_only__ [Common]
bin_reader_decimal [Common]
bin_reader_immutable [Common]
bin_reader_inet_addr [Unix]
bin_reader_poly_t [Interval_intf.S.Set]
bin_reader_poly_t [Interval_intf.S]
bin_reader_read_only [Common]
bin_reader_read_write [Common]
bin_reader_sexp_list [Sexp.Sexp_list]
bin_reader_sexp_option [Sexp.Sexp_option]
bin_reader_sockaddr [Unix]
bin_reader_socket_domain [Unix]
bin_reader_socket_type [Unix]
bin_reader_sysinfo [Linux_ext]
bin_reader_t [Time.Date]
bin_reader_t [Interval_intf.S1.Set]
bin_reader_t [Interval_intf.S1]
bin_reader_t [Interval_intf.S.Set]
bin_reader_t [Interval_intf.S]
bin_reader_t [Bucket.Make]
bin_reader_tcp_bool_option [Linux_ext]
bin_reader_write_only [Common]
bin_sexp_list [Sexp.Sexp_list]
bin_sexp_option [Sexp.Sexp_option]
bin_size_decimal [Common]
bin_size_immutable [Common]
bin_size_inet_addr [Unix]
bin_size_poly_t [Interval_intf.S.Set]
bin_size_poly_t [Interval_intf.S]
bin_size_read_only [Common]
bin_size_read_write [Common]
bin_size_sexp_list [Sexp.Sexp_list]
bin_size_sexp_option [Sexp.Sexp_option]
bin_size_sockaddr [Unix]
bin_size_socket_domain [Unix]
bin_size_socket_type [Unix]
bin_size_sysinfo [Linux_ext]
bin_size_t [Time.Date]
bin_size_t [Interval_intf.S1.Set]
bin_size_t [Interval_intf.S1]
bin_size_t [Interval_intf.S.Set]
bin_size_t [Interval_intf.S]
bin_size_t [Bucket.Make]
bin_size_tcp_bool_option [Linux_ext]
bin_size_write_only [Common]
bin_sockaddr [Unix]
bin_socket_domain [Unix]
bin_socket_type [Unix]
bin_sysinfo [Linux_ext]
bin_t [Time.Date]
bin_t [Interval_intf.S1.Set]
bin_t [Interval_intf.S1]
bin_t [Interval_intf.S.Set]
bin_t [Interval_intf.S]
bin_t [Bucket.Make]
bin_tcp_bool_option [Linux_ext]
bin_write_decimal [Common]
bin_write_decimal_ [Common]
bin_write_immutable [Common]
bin_write_immutable_ [Common]
bin_write_inet_addr [Unix]
bin_write_inet_addr_ [Unix]
bin_write_only [Common]
bin_write_poly_t [Interval_intf.S.Set]
bin_write_poly_t [Interval_intf.S]
bin_write_poly_t_ [Interval_intf.S.Set]
bin_write_poly_t_ [Interval_intf.S]
bin_write_read_only [Common]
bin_write_read_only_ [Common]
bin_write_read_write [Common]
bin_write_read_write_ [Common]
bin_write_sexp_list [Sexp.Sexp_list]
bin_write_sexp_list_ [Sexp.Sexp_list]
bin_write_sexp_option [Sexp.Sexp_option]
bin_write_sexp_option_ [Sexp.Sexp_option]
bin_write_sockaddr [Unix]
bin_write_sockaddr_ [Unix]
bin_write_socket_domain [Unix]
bin_write_socket_domain_ [Unix]
bin_write_socket_type [Unix]
bin_write_socket_type_ [Unix]
bin_write_sysinfo [Linux_ext]
bin_write_sysinfo_ [Linux_ext]
bin_write_t [Time.Date]
bin_write_t [Interval_intf.S1.Set]
bin_write_t [Interval_intf.S1]
bin_write_t [Interval_intf.S.Set]
bin_write_t [Interval_intf.S]
bin_write_t [Bucket.Make]
bin_write_t_ [Time.Date]
bin_write_t_ [Interval_intf.S1.Set]
bin_write_t_ [Interval_intf.S1]
bin_write_t_ [Interval_intf.S.Set]
bin_write_t_ [Interval_intf.S]
bin_write_t_ [Bucket.Make]
bin_write_tcp_bool_option [Linux_ext]
bin_write_tcp_bool_option_ [Linux_ext]
bin_write_write_only [Common]
bin_write_write_only_ [Common]
bin_writer_decimal [Common]
bin_writer_immutable [Common]
bin_writer_inet_addr [Unix]
bin_writer_poly_t [Interval_intf.S.Set]
bin_writer_poly_t [Interval_intf.S]
bin_writer_read_only [Common]
bin_writer_read_write [Common]
bin_writer_sexp_list [Sexp.Sexp_list]
bin_writer_sexp_option [Sexp.Sexp_option]
bin_writer_sockaddr [Unix]
bin_writer_socket_domain [Unix]
bin_writer_socket_type [Unix]
bin_writer_sysinfo [Linux_ext]
bin_writer_t [Time.Date]
bin_writer_t [Interval_intf.S1.Set]
bin_writer_t [Interval_intf.S1]
bin_writer_t [Interval_intf.S.Set]
bin_writer_t [Interval_intf.S]
bin_writer_t [Bucket.Make]
bin_writer_tcp_bool_option [Linux_ext]
bin_writer_write_only [Common]
bind [Monad.S2]
bind [Monad.Basic2]
bind [Monad.Basic]
bind [Monad.Make2]
bind [Monad.Make]
bind [Monad.S]
bind t f = t >>= f
bind [Unix]
Bind a socket to an address.
bit_and [Int_intf.S]
bit_not [Int_intf.S]
bit_or [Int_intf.S]
bit_xor [Int_intf.S]
bits [OUnit_utils.Random]
bits_of_float [Int64]
bits_of_float [Int32]
blit [Make_substring.Base]
blit [String]
blit [Array]
blit [Bigstring]
blit ~src ~src_pos ~dst ~dst_pos ~len blits len characters from bigstring src starting at position src_pos to bigstring dst at position dst_pos.
blit_bigstring_string [Bigstring]
blit_bigstring_string ~src ~src_pos ~dst ~dst_pos ~len blits len characters from bigstring src starting at position src_pos to string dst at position dst_pos.
blit_from_bigstring [Substring_intf.S]
blit_from_bigstring [Make_substring.Base]
blit_from_bigstring [Make_substring.F]
blit_from_string [Substring_intf.S]
blit_from_string [Make_substring.Base]
blit_from_string [Make_substring.F]
blit_string_bigstring [Bigstring]
blit_string_bigstring ~src ~src_pos ~dst ~dst_pos ~len blits len characters from string src starting at position src_pos to bigstring dst at position dst_pos.
blit_to_bigstring [Substring_intf.S]
blit_to_bigstring [Make_substring.Base]
blit_to_bigstring [Make_substring.F]
blit_to_string [Substring_intf.S]
blit_to_string [Make_substring.Base]
blit_to_string [Make_substring.F]
block_forever [Thread]
block_forever () will block the calling thread forever.
blocking_create [Lock_file]
blocking_create t tries to create the lock.
bool [OUnit_utils.Random]
bot [Fqueue]
like bot_exn, but returns result optionally, without exception
bot_exn [Fqueue]
returns the bottom (most-recently enqueued element).
both [Option]
bound [Interval_intf.Gen.S]
bounds [Interval_intf.Gen.S]
bounds_exn [Interval_intf.Gen.S]
bprintf [Printf]
bprintf [Bigbuffer.Printf]
bprintf [Bigbuffer.Format]
broadcast [Condition]
business_dates_between [Time.Date]
bytes [Byte_units]

C
call [Result]
call [Option]
call x f run optional function on argument
capitalize [String]
cardinal [Set_intf.S1]
cardinal [Set_intf.Gen.S]
cardinal [Map_intf.S2]
cardinal [Map_intf.Gen.S]
cardinal map
cardinal [Set_intf.S]
cardinal [Map_intf.S]
cartesian_product [List]
cartesian_product [Array]
catch [Printexc]
catch_break [Sys]
catch_break governs whether interactive interrupt (ctrl-C) terminates the program or raises the Break exception.
ceil [Float]
cg [Quickcheck]
cg [OUnit_utils]
char generator
chdir [Unix]
Change the process working directory.
chdir [Sys]
Change the current working directory of the process.
check [Error_check.ReportAllFails]
check [Error_check.Step]
check [Error_check.Timer]
check [Error_check.ToggleN]
check [Error_check.Toggle]
check_args [Bigstring]
check_args ~loc ~pos ~len bstr checks the position and length arguments pos and len for bigstrings bstr.
check_heap_property [Heap]
check_suffix [Filename]
chld [Signal]
Child process terminated
chmod [Unix]
Change the permissions of the named file.
choose [Set_intf.S1]
choose [Set_intf.Gen.S]
choose [Set_intf.S]
choose_exn [Set_intf.S1]
choose_exn [Set_intf.Gen.S]
choose_exn [Set_intf.S]
chop_extension [Filename]
chop_prefix [String]
chop_prefix s ~pref returns a copy s without the leading pref
chop_prefix_opt [String]
chop_suffix [String]
chop_suffix s ~suf returns a copy s without the trailing suff
chop_suffix [Filename]
chop_suffix_opt [String]
chown [Unix]
Change the owner uid and owner gid of the named file.
chroot [Unix]
Change the process root directory.
classify [Float]
clear [Squeue]
clears the queue
clear [Hash_set_intf.S1]
clear [Hash_set_intf.Gen.S]
clear [Hash_set_intf.S]
clear [Hash_queue.S]
clear [Hash_queue.Make]
clear [Fast_hashtbl]
clear [Doubly_linked]
clear t removes all elements from the list in constant time.
clear [Stack]
clear t discards all elements from t.
clear [Queue]
clear t discards all elements from t.
clear [Hashtbl_intf.S2]
clear [Hashtbl_intf.Gen.S]
clear [Hashtbl_intf.S]
clear [Bigbuffer]
Empty the buffer.
clear [Bag]
clear t removes all elements from the bag.
clear_close_on_exec [Unix]
Clear the ``close-on-exec'' flag on the given descriptor.
clear_nonblock [Unix]
Clear the ``non-blocking'' flag on the given descriptor.
clock_process_cputime_id [Linux_ext]
Clock functions
clock_thread_cputime_id [Linux_ext]
clock_thread_cputime_id the clock measuring the CPU-time of a thread.
close [Out_channel]
close [In_channel]
close [Unix]
Close a file descriptor.
close_linebuf [Linebuf]
Closes the line buffer (and the underlying file).
close_noerr [Out_channel]
close_noerr [In_channel]
close_process [Unix]
Close channels opened by UnixLabels.open_process, wait for the associated command to terminate, and return its termination status.
close_process_full [Unix]
Close channels opened by UnixLabels.open_process_full, wait for the associated command to terminate, and return its termination status.
close_process_in [Unix]
Close channels opened by UnixLabels.open_process_in, wait for the associated command to terminate, and return its termination status.
close_process_out [Unix]
Close channels opened by UnixLabels.open_process_out, wait for the associated command to terminate, and return its termination status.
closed_linebuf [Linebuf]
closedir [Unix]
Close a directory descriptor.
combine [List]
Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].
combine [Array]
combine ar combines two arrays to an array of pairs.
combine_alist [Map_intf.S2]
combine_alist [Map_intf.Gen.S]
combines an association list into a map, folding together the bound values (for experts only)
combine_alist [Map_intf.S]
command [Sys]
Execute the given shell command and return its exit code.
compact [Gc]
Perform a full major collection and compact the heap.
compare [Tuple.T3]
compare [Tuple.T2]
compare [String]
compare [Set_intf.S1]
compare [Set_intf.Gen.S]
compare [Set_intf.Elt]
compare [Map_intf.S2]
compare [Map_intf.Gen.S]
Total ordering between maps.
compare [Map_intf.Key]
compare [List]
lexicographic
compare [Comparable.S]
compare [Comparable.Inherit]
compare [Comparable.Make]
compare [Set_intf.S]
compare [Map_intf.S]
compare_int [Int_conversions]
compare_value [Interval_intf.Gen.S]
concat [Substring_intf.S]
concat [Make_substring.F]
concat [String]
concatanate all strings in the list using separator sep (default sep "")
concat [List]
Concatenate a list of lists.
concat [Filename]
concat [Array]
concat_array [String]
concat_array sep ar like String.concat, but operates on arrays
concat_bigstring [Substring_intf.S]
concat_bigstring [Make_substring.F]
concat_map [String]
Like map, but allows replacement of a single character with zero or two or more characters.
concat_map [List]
concat_map t ~f is concat (map t ~f), except that there is no guarantee about the order in which f is applied to the elements of t.
concat_string [Substring_intf.S]
concat_string [Make_substring.F]
cond_pop [Heap]
cond_pop heap cond
cond_pop [Hash_heap.S]
cond_pop [Hash_heap.Make]
cond_pop_heap_el [Heap]
cond_pop_heap_el heap cond
cond_pop_with_key [Hash_heap.S]
cond_pop_with_key [Hash_heap.Make]
condition_timedwait [Unix_ext]
condition_timedwait cnd mtx timeout waits on condition variable cond with mutex mtx until either the condition is signalled, or until timeout expires.
connect [Unix]
Connect a socket to an address.
cons [List]
const [Function]
produces a function that just returns its first argument
const [Common]
cont [Signal]
Continue
container [Hash_queue.Make]
container [Container.S1]
container [Container.S0_phantom]
container [Container.S0]
contains [Interval_intf.GenSet.S]
contains [Interval_intf.Gen.S]
contains [String]
contains_dup [List]
contains_dup True if there are any two elements in the list which are the same.
contains_from [String]
contains_interval [Interval_intf.Gen.S]
contains_set [Interval_intf.GenSet.S]
contents [Bigbuffer]
Return a copy of the current contents of the buffer.
convert [TZ.Date_time]
convert ~from_tz ~to_tz datetime convert datetime in from_tz to to_tz
convert [Int_conversions]
copy [Heap]
copy heap
copy [Hash_heap.S]
copy [Hash_heap.Make]
copy [Doubly_linked]
copy t returns a copy of t.
copy [String]
copy [Stack]
copy t returns a copy of t.
copy [Queue]
copy t returns a copy of t.
copy [Hashtbl_intf.S2]
copy [Hashtbl_intf.Gen.S]
copy [Hashtbl_intf.S]
copy [Array]
count [List]
count f l is the number of elements in l that satisfy the predicate f.
counters [Gc]
Return (minor_words, promoted_words, major_words).
crc32 [Crc]
Compute the 32-bit crc
crc32hex [Crc]
String version of the crc, encoded in hex.
create [Weekday]
create [Unique_id.Id]
create [Unique_id.Unit_ref]
create [Tuple.T3]
create [Tuple.T2]
create [Timer]
create ?min_size () creates a new timer.
create [Time.Ofday]
create [Time.Span]
create [Time.Date]
create [Squeue]
create maxsize returns a synchronized queue bounded to have no more than maxsize elements.
create [Space_safe_tuple.T3]
create [Space_safe_tuple.T2]
create [Set_once]
create [Ref]
create [Piecewise_linear.S]
create [Out_channel]
create [Mutex0]
create [Month]
create [Substring_intf.S]
create base ~pos ~len creates a a substring of the base sequence of length len starting at position pos, i.e.
create [Make_substring.Base]
create [Make_substring.F]
create [Lock_file]
create ~path ~message tries to create a file at path containing the text message.
create [Interval_intf.GenSet.S]
create [Interval_intf.Gen.S]
create [Int_set]
create [In_channel]
create [Heap]
create ?min_size cmp
create [Hash_set_intf.S1]
create [Hash_set_intf.Gen.S]
create [Hash_set_intf.S]
create [Hash_queue.S]
create [Hash_queue.Make]
create [Hash_heap.S]
create [Hash_heap.Make]
create [Force_once]
create f creates a new force_once
create [Fast_hashtbl]
create [Error_check.ReportAllFails]
create [Error_check.Step]
create [Error_check.Timer]
create [Error_check.ToggleN]
create [Error_check.Toggle]
create [Doubly_linked]
creating doubly-linked lists
create [Dequeue]
create [Thread]
Thread.create funct arg creates a new thread of control, in which the function application funct arg is executed concurrently with the other threads of the program.
create [String]
create [Stack]
create () returns an empty stack.
create [Queue]
create () returns an empty queue.
create [Mutex]
create [Hashtbl_intf.S2]
create [Hashtbl_intf.Gen.S]
create [Hashtbl_intf.S]
create [Condition]
create [Array]
create [Bigstring]
create length
create [Bigbuffer]
create n returns a fresh buffer, initially empty.
create [Bag]
create () returns an empty bag.
create [Agnostic_mutex]
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_error_checking_mutex [Unix_ext]
create_error_checking_mutex () like Mutex.create, but creates an error-checking mutex.
create_exn [Lock_file]
create_exn ~path ~message is like create except that it throws an exception on failure instead of returning a boolean value
create_from_intervals [Interval_intf.GenSet.S]
create_mapped [Hashtbl_intf.S2]
create_mapped [Hashtbl_intf.Gen.S]
create_mapped [Hashtbl_intf.S]
create_pid [Lock_file]
create_pid ~path creates a file at path containing the pid of the process
create_pid_exn [Lock_file]
create_pid_exn ~path creates a file at path containing the pid of the process.
create_process [Unix]
create_process ~prog ~args forks a new process that executes the program prog with arguments args.
create_process_env [Unix]
create_process_env ~prog ~args ~env as create process, but takes an additional parameter that extends, or replaces the current environment.
create_with_key [Hashtbl_intf.S2]
create_with_key [Hashtbl_intf.Gen.S]
create_with_key [Hashtbl_intf.S]
critical_section [Mutex0]
critical_section [Mutex]
critical_section [Common]
critical_section [Agnostic_mutex]
current [Arg]
current_dir_name [Filename]
functions from the standard library For these function definitions check the standard library
curry [Tuple.T3]
curry [Tuple.T2]

D
daemonize [Daemon]
daemonize_wait [Daemon]
data [Map_intf.S2]
data [Map_intf.Gen.S]
returns list of data in map
data [Hashtbl_intf.S2]
data [Hashtbl_intf.Gen.S]
Returns the list of all data for given hashtable.
data [Hashtbl_intf.S]
data [Map_intf.S]
dates_between [Time.Date]
day [Time.Span]
day [Time.Date]
day_of_week [Time.Date]
deactivate [Timer]
deactivate timer deactives a timer.
dec [Month]
decimal_of_sexp [Common]
decr [Int_intf.S]
dedup [List]
dedup (de-duplicate).
delay [Thread]
delay d suspends the execution of the calling thread for d seconds.
delete_alarm [Gc]
delete_alarm a will stop the calls to the function associated to a.
deq [Fqueue]
alias for pop
deq_exn [Fqueue]
alias for pop_exn
dequeue [Hash_queue.S]
dequeue [Hash_queue.Make]
dequeue [Queue]
dequeue t returns None if t is empty, otherwise it removes and returns the front of t
dequeue_all [Hash_queue.S]
dequeue_all [Hash_queue.Make]
dequeue_exn [Hash_queue.S]
dequeue_exn [Hash_queue.Make]
dequeue_exn [Queue]
dequeue_exn t removes and returns the front of t, raising Empty if t is empty.
dequeue_with_key [Hash_queue.S]
dequeue_with_key [Hash_queue.Make]
dequeue_with_key_exn [Hash_queue.S]
dequeue_with_key_exn [Hash_queue.Make]
descending [Comparable.S]
descending [Comparable.Inherit]
descending [Comparable.Make]
descending [Comparable.Poly]
descending [Common]
A comparator that returns results in descending order.
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 [Time]
diff t1 t2 returns time t1 minus time t2.
diff [Time.Date]
diff t1 t2 returns date t1 minus date t2 in days.
diff [Set_intf.S1]
diff [Set_intf.Gen.S]
diff [Set_intf.S]
dirfd [Unix_ext]
Extract a file descriptor from a directory handle.
dirname [Filename]
discard_exn [Fqueue]
Returns version of queue with top element removed
div [Int64]
domain_of_sockaddr [Unix]
Return the socket domain adequate for the given socket address.
drop [Unix_ext.IOVec]
drop iovec n drops n characters from iovec.
drop [List]
drop_back [Dequeue]
drop_front [Dequeue]
drop_indices_greater_than [Dequeue]
drop_indices_less_than [Dequeue]
drop_prefix [Substring_intf.S]
drop_prefix [Make_substring.F]
drop_prefix [String]
drop_prefix s n drops the longest prefix of s of length less than or equal to n
drop_suffix [Substring_intf.S]
drop_suffix [Make_substring.F]
drop_suffix [String]
drop_suffix s n drops the longest suffix of s of length less than or equal to n
drop_while [List]
drop_while l ~f keeps dropping elements while f el is true and returns the rest in order.
dup [Unix]
Return a new file descriptor referencing the same file as the given descriptor.
dup2 [Unix]
dup2 fd1 fd2 duplicates fd1 to fd2, closing fd2 if already opened.

E
elements [Set_intf.S1]
elements [Set_intf.Gen.S]
elements [Set_intf.S]
empty [Unix_ext.IOVec]
empty the empty I/O-vector.
empty [Interval_intf.Gen.S]
empty [Fqueue]
The empty queue
empty [Unix.Select_fds]
empty [Set_intf.S1]
empty [Set_intf.Gen.S]
empty [Map_intf.S2]
empty [Map_intf.Gen.S]
the empty map
empty [Array]
empty () creates an empty array
empty [Set_intf.S]
empty [Map_intf.S]
end_of_day [Time.Ofday]
enq [Fqueue]
alias for push
enqueue [Hash_queue.S]
enqueue [Hash_queue.Make]
enqueue [Queue]
enqueue t x adds x to the end of t.
enqueue_exn [Hash_queue.S]
enqueue_exn [Hash_queue.Make]
environment [Unix]
Return the process environment, as an array of strings with the format ``variable=value''.
eprintf [Printf]
epsilon [Time.Span]
epsilon [Float_robust_compare]
epsilon [Float]
equal [Signal]
equal [Ref]
equal t1 t2 returns true if t1 and t2 are the same ref cell.
equal [Option]
equal [Mutex0]
equal [Hashable.S_binable]
equal [Hashable.S]
equal [Hash_set_intf.S1]
equal [Hash_set_intf.Gen.S]
equal [Hash_set_intf.S]
equal [Doubly_linked.Elt]
equal [Doubly_linked]
predicates
equal [String]
fast equality function on strings, doesn't use compare_val
equal [Set_intf.S1]
equal [Set_intf.Gen.S]
equal [Mutex]
equal [Map_intf.S2]
equal [Map_intf.Gen.S]
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data.
equal [Hashtbl_intf.S2]
equal [Hashtbl_intf.Gen.S]
equal [Hashtbl_intf.S]
equal [Condition]
equal [Set_intf.S]
equal [Map_intf.S]
equal [Common]
toplevel binding for polymorphic equality (=).
equal [Bag.Elt]
equal [Agnostic_mutex]
error [Result]
error_message [Unix]
Return a string describing the given error code.
escaped [String]
escaped [Char]
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]
execv prog args execute the program in file prog, with the arguments args, and the current process environment.
execve [Unix]
Same as UnixLabels.execv, except that the third argument provides the environment to the program executed.
execvp [Unix]
Same as UnixLabels.execv respectively, except that the program is searched in the path.
execvpe [Unix]
Same as UnixLabels.execvp respectively, except that the program is searched in the path.
exists [Hash_queue.Make]
exists [Set_intf.S1]
exists [Set_intf.Gen.S]
exists [Map_intf.S2]
exists [Map_intf.Gen.S]
exists [Container.S1_noclass]
exists [Container.S0_phantom_noclass]
exists [Container.S0_noclass]
exists [Set_intf.S]
exists [Map_intf.S]
exists2 [List]
exit [Thread]
Terminate prematurely the currently executing thread.
exit_immediately [Unix_ext]
exit_immediately exit_code immediately calls the exit system call with the given exit code without performing any other actions (unlike Pervasives.exit).
exitf [Printf]
exitf [Common]
expand [Filename]
expand Makes a path absolute by expanding .
explode [Filename]

F
fail [Result]
failwithf [Sexpable]
failwithf [Printf]
failwith, invalid_arg, and exit accepting printf's format.
failwithf [Common]
fast_sort [List]
fast_sort [Array]
fchmod [Unix]
Change the permissions of an opened file.
fchown [Unix]
Change the owner uid and owner gid of an opened file.
fdatasync [Unix_ext]
Synchronize the kernel buffers of a given file descriptor with disk, but do not necessarily write file attributes.
feb [Month]
fg [Quickcheck]
fg [OUnit_utils]
signed float generator
file_descr_of_int [Unix_ext]
file_descr_of_int n converts an integer to a file descriptor.
file_descr_realpath [Linux_ext]
Pathname resolution
file_exists [Sys]
Test if a file with the given name exists.
fill [String]
fill [Array]
fill [Bucket.S]
fill [Bucket.Make]
filter [Set_intf.S1]
filter [Set_intf.Gen.S]
filter [Map_intf.S2]
filter [Map_intf.Gen.S]
filter for map
filter [List]
filter p l returns all the elements of the list l that satisfy the predicate p.
filter [Array]
filter ~f array removes the elements for which f returns false.
filter [Set_intf.S]
filter [Map_intf.S]
filter_inplace [Doubly_linked]
filter_inplace t ~f removes all elements of t that don't satisfy f.
filter_inplace [Queue]
filter_inplace t ~f removes all elements of t that don't satisfy f.
filter_inplace [Hashtbl_intf.S2]
filter_inplace [Hashtbl_intf.Gen.S]
filter_inplace t ~f removes all the elements from t that don't satisfy f.
filter_inplace [Hashtbl_intf.S]
filter_map [Set_intf.S1]
filter_map [Map_intf.S2]
filter_map [Map_intf.Gen.S]
returns new map with bound values filtered by f applied to the bound values
filter_map [List]
filter_map f l is the sublist of l containing only elements for which f returns Some e.
filter_map [Hashtbl_intf.S2]
filter_map [Hashtbl_intf.Gen.S]
returns new map with bound values filtered by f applied to the bound values
filter_map [Hashtbl_intf.S]
filter_map [Array]
filter_map ~f array maps f over array and filters None out of the results.
filter_map [Map_intf.S]
filter_mapi [Map_intf.S2]
filter_mapi [Map_intf.Gen.S]
like filter_map, but function takes both key and data as arguments
filter_mapi [Hashtbl_intf.S2]
filter_mapi [Hashtbl_intf.Gen.S]
like filter_map, but function takes both key and data as arguments
filter_mapi [Hashtbl_intf.S]
filter_mapi [Array]
Same as filter_map but uses Array.mapi.
filter_mapi [Map_intf.S]
filter_opt [List]
filter_opt l is the sublist of l containing only elements which are Some e.
filter_opt [Array]
filter_opt array returns a new array where None entries are omitted and Some x entries are replaced with x.
filteri [List]
find_all is another name for List.filter.
filteri [Array]
Like filter except f also receives the index.
filteri_inplace [Hashtbl_intf.S2]
filteri_inplace [Hashtbl_intf.Gen.S]
filteri_inplace [Hashtbl_intf.S]
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 [TZ.Zone]
lookup db t looks up a Zone.t by it's name (as listed in available_zones) and returns it.
find [Hash_queue.Make]
find [Hash_heap.S]
find [Hash_heap.Make]
find [Fast_hashtbl]
find [Map_intf.S2]
find [Map_intf.Gen.S]
find [Hashtbl_intf.S2]
find [Hashtbl_intf.Gen.S]
find t k returns Some (the current binding) of k in t, or None if no such binding exists
find [Hashtbl_intf.S]
find [Container.S1_noclass]
find [Container.S0_phantom_noclass]
find [Container.S0_noclass]
find [Map_intf.S]
find_a_dup [List]
find_a_dup returns a duplicate from the list (no guarantees about which duplicate you get), or None if there are no dups.
find_all [List]
find_default [Hashtbl_intf.S2]
find_default [Hashtbl_intf.Gen.S]
find_default t k ~default returns the data associated with key k if it is in the table t, otherwise it lets d = default() and adds it to the table.
find_default [Hashtbl_intf.S]
find_elt [Doubly_linked]
find_elt t ~f finds the first element in t that satisfies f, by testing each of element of t in turn until f succeeds.
find_elt [Bag]
find_elt t ~f looks at elements in the bag one-by-one until it finds one elt such that f (Elt.value elt), in which case it returns Some elt.
find_exn [TZ.Zone]
find_exn [Hash_heap.S]
find_exn [Hash_heap.Make]
find_exn [Fast_hashtbl]
find_exn [Map_intf.S2]
find_exn [Map_intf.Gen.S]
returns the value bound to the given key, raising Not_found if none such exists
find_exn [List]
find_exn t ~f returns the first element of t that satisfies f.
find_exn [Hashtbl_intf.S2]
find_exn [Hashtbl_intf.Gen.S]
find_exn t k returns the current binding of k in t, or raises Not_found if no such binding exists.
find_exn [Hashtbl_intf.S]
find_exn [Array]
find_exn f t returns the first a in t for which f t.(i) is true.
find_exn [Map_intf.S]
find_heap_el [Heap]
find_heap_el heap el
find_map [List]
find_map t f applies f to each element of t until it finds f a = Some b, at which point it returns Some b.
find_pop [Hash_heap.S]
find_pop [Hash_heap.Make]
find_pop_exn [Hash_heap.S]
find_pop_exn [Hash_heap.Make]
findi [List]
findi [Array]
findi_exn [Array]
findi_exn f ar returns the first index i of ar for which f ar.(i) is true.
first [Doubly_linked]
first_elt [Doubly_linked]
constant-time extraction of first and last elements.
flatten [List]
Same as concat.
flatten_no_order [List]
Same as flatten but faster and without preserving any ordering (ie for lists that are essentially viewed as multi-sets.
float [OUnit_utils.Random]
float_of_bits [Int64]
float_of_bits [Int32]
floor [Float]
flush [Out_channel]
fnmatch [Unix_ext]
fold [Hash_set_intf.S1]
fold [Hash_set_intf.Gen.S]
fold [Hash_set_intf.S]
fold [Hash_queue.Make]
fold [Fast_hashtbl]
fold [Dequeue]
fold [Set_intf.S1]
fold [Set_intf.Gen.S]
fold [Map_intf.S2]
fold [Map_intf.Gen.S]
folds over keys and data in map
fold [Hashtbl_intf.S2]
fold [Hashtbl_intf.Gen.S]
fold [Hashtbl_intf.S]
fold [Container.S1_noclass]
fold [Container.S0_phantom_noclass]
fold [Container.S0_noclass]
fold [Set_intf.S]
fold [Map_intf.S]
fold_left [List]
List.fold_left f a [b1; ...; bn] is f (... (f (f a b1) b2) ...) bn.
fold_left [Array]
fold_left2 [List]
Same as List.for_all, but for a two-argument predicate.
fold_lefti [List]
fold_lefti is just like fold_left, but it also passes in the index of each element as the first argument to the folded function.
fold_lines [In_channel]
fold_lines ?fix_win_eol t ~init ~f folds over the lines read from t using input_line.
fold_right [List]
List.fold_right f [a1; ...; an] b is f a1 (f a2 (... (f an b) ...)).
fold_right [Array]
fold_right2 [List]
List.fold_right2 f [a1; ...; an] [b1; ...; bn] c is f a1 b1 (f a2 b2 (... (f an bn c) ...)).
foldi [Hash_queue.S]
foldi [Hash_queue.Make]
foldi [Dequeue]
foldn [Quickcheck]
foldn [OUnit_utils]
for_all [Hash_queue.Make]
for_all [Set_intf.S1]
for_all [Set_intf.Gen.S]
for_all [Map_intf.S2]
for_all [Map_intf.Gen.S]
same semantics as similar functions in List
for_all [Container.S1_noclass]
for_all [Container.S0_phantom_noclass]
for_all [Container.S0_noclass]
for_all [Set_intf.S]
for_all [Map_intf.S]
for_all2 [List]
Same as List.exists, but for a two-argument predicate.
force [Force_once]
force t runs the thunk if it hadn't already been forced, else it raises an exception.
forever [Function]
forever f runs f () until it throws an exception and returns the exception.
fork [Unix]
Fork a new process.
formatter_of_buffer [Bigbuffer.Format]
fpe [Signal]
Arithmetic exception
fprintf [Printf]
frange [List]
frange is similar to range, but for floats.
frequency [Quickcheck]
Given list of (frequency,value) pairs, returns value with probability proportional to given frequency
frequency [OUnit_utils]
Given list of (frequency,value) pairs, returns value with probability proportional to given frequency
frequencyg [OUnit_utils]
like frequency, but returns generator
frequencyl [Quickcheck]
like frequency, but returns generator
fri [Weekday]
front_index [Dequeue]
fst3 [Common]
triple handling
fstat [Unix.Native_file]
Return the information for the file associated with the given descriptor.
fstat [Unix]
Return the information for the file associated with the given descriptor.
fsync [Unix_ext]
Synchronize the kernel buffers of a given file descriptor with disk.
ftruncate [Unix.Native_file]
ftruncate [Unix]
Truncates the file corresponding to the given descriptor to the given size.
full_major [Gc]
Do a minor collection, finish the current major collection cycle, and perform a complete new cycle.

G
general [Memo]
Returns memoized version of any function with a single argument.
get [Weekday]
get [Unix_ext.Resource_usage]
get [Unix_ext.RLimit]
get [Unix_ext.Clock]
get tid
get [Set_once]
get [Piecewise_linear.S]
get [Month]
get [Dequeue]
get [String]
get [Gc]
Return the current values of the GC parameters in a control record.
get [Array]
get1 [Tuple.T3]
get1 [Tuple.T2]
get1 [Space_safe_tuple.T3]
get1 [Space_safe_tuple.T2]
get2 [Tuple.T3]
get2 [Tuple.T2]
get2 [Space_safe_tuple.T3]
get2 [Space_safe_tuple.T2]
get3 [Tuple.T3]
get3 [Space_safe_tuple.T3]
get_back [Dequeue]
get_backtrace [Printexc]
get_cmp [Heap]
get_cmp heap
get_digit [Char]
get_digit 'i' = Some i if is_digit i and None otherwise.
get_digit_exn [Char]
get_event_interval [Timer]
get_event_interval event
get_event_time [Timer]
get_event_time event
get_front [Dequeue]
get_inet_addr [Unix]
Get inet_addr of a hostname or IP
get_opt_len [Bigstring]
get_opt_len bstr ~pos opt_len
get_pos_len [Ordered_collection_common]
get_pos_len_exn [Ordered_collection_common]
get_pos_len and get_pos_len_exn are intended to be used by functions that take a sequence (array, string, bigstring, ...) and an optional pos and len specifying a subrange of the sequence.
get_resolution [Unix_ext.Clock]
get_resolution clock
get_sockaddr [Unix]
Get a sockaddr from a hostname or IP, and a port
get_terminal_size [Linux_ext]
Getting terminal size
get_time [Unix_ext.Clock]
get_time clock
get_timer [Timer]
get_timer event
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]
getenv_exn [Unix]
Return the value associated to a variable in the process environment.
getenv_exn [Sys]
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_float [Unix]
Same as UnixLabels.getsockopt for a socket option whose value is a floating-point number.
getsockopt_int [Unix]
Same as UnixLabels.getsockopt for an integer-valued socket option.
getsockopt_optint [Unix]
Same as UnixLabels.getsockopt for a socket option whose value is an int option.
gettcpopt_bool [Linux_ext]
gettcpopt_bool sock opt
gettimeofday [Unix]
Same as UnixLabels.time, but with resolution better than 1 second.
getuid [Unix]
Return the user id of the user executing the process.
gigabytes [Byte_units]
gmtime [Unix]
Convert a time in seconds, as returned by UnixLabels.time, into a date and a time.
group [List]
group l ~break returns a list of lists (i.e., groups) whose concatenation is equal to the original list.
group [Hashtbl_intf.S2]
group [Hashtbl_intf.Gen.S]
group [Hashtbl_intf.S]
group_by [Set_intf.S1]
group_by [Set_intf.Gen.S]
group_by [Set_intf.S]
groupi [List]
This is just like group, except that you get the index in the original list of the current element along with the two elements.

H
handle [Signal]
handle t f is set t (`Handle f).
handle_default [Signal]
handle_default t is set t `Default.
handle_uncaught [Exn]
handle_uncaught ~exit f catches an exception escaping f and prints an error message to stderr.
handle_unix_error [Unix]
handle_unix_error f x applies f to x and returns the result.
has_key [Map_intf.S2]
has_key [Map_intf.Gen.S]
equivalent to mem
has_key [Map_intf.S]
hash [Hashable.S_binable]
hash [Hashable.S]
hash [String]
slightly faster hash function on strings
hash [Hashtbl]
hash_param [Hashtbl]
hd [List]
hd_exn [List]
Return the given list without its first element.
heap_el_get_el [Heap]
heap_el_get_el heap_el
heap_el_is_valid [Heap]
heap_el_is_valid heap_el
heap_el_mem [Heap]
heap_el_mem heap heap_el
hour [Time.Span]
hup [Signal]
Hangup on controlling terminal

I
id [Thread]
Return the identifier of the given thread.
ident [Memo]
Returns memoized version of any function where data is kept until argument changes.
ident [Function]
The identity function
ident [Common]
idrss [Unix_ext.Resource_usage]
if_indextoname [Unix_ext]
ifprintf [Printf]
ignore [Signal]
ignore t is set t `Ignore.
ignore [Monad.S2]
ignore [Monad.Make2]
ignore [Monad.Make]
ignore [Monad.S]
ignore t = map t ~f:(fun _ -> ()).
ignore [Force_once]
ignore () = create (fun () -> ())
ill [Signal]
Invalid hardware instruction
immutable_of_sexp [Common]
implode [Filename]
in_channel_length [Common]
in_channel_of_descr [Unix]
Create an input channel reading from the given descriptor.
in_channel_realpath [Linux_ext]
inblock [Unix_ext.Resource_usage]
incr [Int_intf.S]
index [String]
index_from [String]
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_sexp [Unix]
inet_addr_of_string [Unix]
Conversion from the printable representation of an Internet address to its internal representation.
init [TZ]
init () pre-load all available time zones from disk, this function has no effect if it is called multiple times
init [String]
init [List]
init f n is [(f 0); (f 1); ...; (f (n-1))].
init [Array]
initgroups [Unix_ext]
initialized_zones [TZ]
available_zones () returns a sorted list of time zones that have been loaded from disk thus far.
input [In_channel]
input [Bigstring]
input ?min_len ic ?pos ?len bstr tries to read len bytes (guarantees to read at least min_len bytes (must be greater than or equal to zero and smaller or equal to len), if possible, before returning) from input channel ic, and writes them to bigstring bstr starting at position pos.
input_all [In_channel]
input_binary_int [In_channel]
input_byte [In_channel]
input_char [In_channel]
input_line [In_channel]
input_line ?fix_win_eol t reads a line from t and returns it, without the newline ("\n") character at the end, and, if fix_win_eol the trailing "\r\n" is dropped.
input_lines [In_channel]
input_lines ?fix_win_eol t returns the list of lines read from t using input_line.
input_lines [Common]
Completely reads an input channel and returns the results as a list of strings.
input_value [In_channel]
insert_after [Doubly_linked]
insert_before [Doubly_linked]
constant-time insertion of a new element.
insert_first [Doubly_linked]
insert_last [Doubly_linked]
int [Signal]
Interactive interrupt (ctrl-C)
int [OUnit_utils.Random]
int [Int_conversions]
int32 [Int_conversions]
int32_to_int64 [Int_conversions]
int32_to_nativeint [Int_conversions]
int64 [OUnit_utils.Random]
int64 [Int_conversions]
int_of_file_descr [Unix_ext]
int_of_file_descr fd converts file descriptor fd to the internal integer value.
int_of_float [Std_internal]
int_to_int64 [Int_conversions]
int_to_nativeint [Int_conversions]
inter [Set_intf.S1]
inter [Set_intf.Gen.S]
inter [Set_intf.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.
intersect [Interval_intf.Gen.S]
intervals_are_a_partition [Interval_intf.Gen.S]
invalid_argf [Printf]
invalid_argf [Common]
invariant [Weekday]
invariant [Month]
invariant [Hash_queue.S]
invariant [Hash_queue.Make]
invariant [Doubly_linked]
invariant [Dequeue]
invariant [Stack]
invariant [Bag]
iround [Float]
iround_exn [Float]
is_activated [Timer]
is_activated timer
is_alpha [Char]
is_alphanum [Char]
is_business_day [Time.Date]
is_digit [Char]
Predicates
is_directory [Sys]
Returns true if the given name refers to a directory, false if it refers to another kind of file.
is_empty [Interval_intf.Gen.S]
is_empty [Heap]
is_empty heap
is_empty [Hash_set_intf.S1]
is_empty [Hash_set_intf.Gen.S]
is_empty [Hash_set_intf.S]
is_empty [Hash_queue.Make]
is_empty [Fqueue]
is_empty [Dequeue]
is_empty [String]
is_empty s returns true iff s is empty (i.e.
is_empty [Set_intf.S1]
is_empty [Set_intf.Gen.S]
is_empty [Map_intf.S2]
is_empty [Map_intf.Gen.S]
Test whether a map is empty or not.
is_empty [Container.S1_noclass]
is_empty [Container.S0_phantom_noclass]
is_empty [Container.S0_noclass]
is_empty [Set_intf.S]
is_empty [Map_intf.S]
is_empty_or_singleton [Interval_intf.Gen.S]
is_error [Result]
is_first [Doubly_linked]
is_implicit [Filename]
is_inf [Float]
Ordinary t-only infinity test.
is_last [Doubly_linked]
is_locked [Lock_file]
is_locked path returns true when the file at path exists and is locked, false otherwise.
is_lowercase [Char]
is_mmapped [Bigstring]
is_mmapped bstr
is_nan [Float]
Ordinary t-only nan test.
is_none [Option]
is_none t returns true iff t = None.
is_ok [Result]
is_ok [Unix.Process_status]
is_posix_valid [Filename]
is_prefix [String]
is_prefix s ~prefix returns true if s starts with prefix.
is_print [Char]
is_relative [Filename]
is_some [Option]
is_some t returns true iff t = Some x.
is_sorted [List]
is_suffix [String]
is_suffix s ~suffix returns true if s ends with suffix.
is_sun_or_sat [Weekday]
is_sun_or_sat returns true if t is Sunday or Saturday
is_uppercase [Char]
is_weekday [Time.Date]
is_whitespace [Char]
isatty [Unix]
Return true if the given file descriptor refers to a terminal or console window, false otherwise.
isrss [Unix_ext.Resource_usage]
iter [Result]
iter [Heap]
iter heap ~f iterate over heap with function f.
iter [Hash_set_intf.S1]
iter [Hash_set_intf.Gen.S]
iter [Hash_set_intf.S]
iter [Hash_queue.Make]
iter [Hash_heap.S]
iter [Hash_heap.Make]
iter [Fast_hashtbl]
iter [Dequeue]
iter [Set_intf.S1]
iter [Set_intf.Gen.S]
iter [Map_intf.S2]
iter [Map_intf.Gen.S]
iterator for map
iter [Hashtbl_intf.S2]
iter [Hashtbl_intf.Gen.S]
iter [Hashtbl_intf.S]
iter [Container.S1_noclass]
iter [Container.S0_phantom_noclass]
iter [Container.S0_noclass]
iter [Set_intf.S]
iter [Map_intf.S]
iter2 [List]
List.iter2 f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.
iter_lines [In_channel]
iter_lines ?fix_win_eol t ~f applies f to each line read from t using input_line.
iter_vals [Hash_heap.S]
iter_vals [Hash_heap.Make]
iter_vals [Hashtbl_intf.S2]
iter_vals [Hashtbl_intf.Gen.S]
iter_vals t ~f is like iter, except it only supplies the value to f, not the key.
iter_vals [Hashtbl_intf.S]
iteri [Hash_queue.S]
iteri [Hash_queue.Make]
iteri [Dequeue]
iteri [List]
iteri is just like iter, but it also passes in the index of each element as the first argument to the iter'd function.
iteri [Array]
ixrss [Unix_ext.Resource_usage]

J
jan [Month]
join [Monad.S2]
join [Monad.Make2]
join [Monad.Make]
join [Monad.S]
join t is t >>= (fun t' -> t').
join [Thread]
join th suspends the execution of the calling thread until the thread th has terminated.
jul [Month]
jun [Month]

K
kbprintf [Printf]
keys [Map_intf.S2]
keys [Map_intf.Gen.S]
returns list of keys in map
keys [Hashtbl_intf.S2]
keys [Hashtbl_intf.Gen.S]
Returns the list of all keys for given hashtable.
keys [Hashtbl_intf.S]
keys [Map_intf.S]
kfprintf [Printf]
kill [Signal]
Termination (cannot be ignored)
kilobytes [Byte_units]
kprintf [Common]
ksprintf [Printf]

L
last [Doubly_linked]
last [List]
The final element of a list.
last [Array]
last_elt [Doubly_linked]
last_exn [List]
returns final element of list
laws [Quickcheck]
laws iter gen func applies func repeatedly (iter times) on output of gen, and if func ever returns false, then the input that caused the failure is returned optionally.
laws2 [Quickcheck]
laws_exn [Quickcheck]
Like laws, but throws an exception instead of returning an option.
lbound [Interval_intf.GenSet.S]
lbound [Interval_intf.Gen.S]
lbound_exn [Interval_intf.GenSet.S]
lbound_exn [Interval_intf.Gen.S]
length [Squeue]
returns the number of elements in the queue.
length [Out_channel]
length [Substring_intf.S]
length [Make_substring.Base]
length [Make_substring.F]
length [In_channel]
length [Heap]
length heap
length [Hash_set_intf.S1]
length [Hash_set_intf.Gen.S]
length [Hash_set_intf.S]
length [Hash_queue.Make]
length [Fqueue]
length [Fast_hashtbl]
length [Dequeue]
length [String]
length [Hashtbl_intf.S2]
length [Hashtbl_intf.Gen.S]
length [Hashtbl_intf.S]
length [Container.S1_noclass]
length [Container.S0_phantom_noclass]
length [Container.S0_noclass]
length [Bigstring]
length bstr
length [Bigbuffer]
Return the number of characters currently contained in the buffer.
level [Bucket.S]
level [Bucket.Make]
lfindi [String]
lfindi s ~f returns the index i of the first character in s satisfying f i s.[i].
lg [Quickcheck]
lg [OUnit_utils]
list generator
link [Unix]
link source dest creates a hard link named dest to the file named new.
list_intersect [Interval_intf.Gen.S]
listen [Unix]
Set up a socket for receiving connection requests.
localtime [Unix]
Convert a time in seconds, as returned by UnixLabels.time, into a date and a time.
lock [Mutex]
lock mtx locks mtx, possibly waiting for it to be released first by another thread.
lock [Agnostic_mutex]
lockf [Unix]
lockf fd cmd size place a lock on a file_descr that prevents any other process from calling lockf successfully on the same file.
lookup [Hash_queue.S]
lookup [Hash_queue.Make]
lookup_exn [Hash_queue.S]
lookup_exn [Hash_queue.Make]
lowercase [String]
lowercase [Char]
lpop [Squeue]
returns the element popped and the length of the queue after this element was popped.
lseek [Unix.Native_file]
lseek [Unix]
Set the current position for a file descriptor
lsplit2 [String]
lsplit2 line ~on optionally returns line split into two strings around the first appearance of on from the left
lsplit2_exn [String]
If the string s contains the character on, then lsplit2_exn s ~on returns a pair containing s split around the first appearance of on (from the left).
lstat [Unix.Native_file]
Same as UnixLabels.stat, but in case the file is a symbolic link, return the information for the link itself.
lstat [Unix]
Same as UnixLabels.stat, but in case the file is a symbolic link, return the information for the link itself.
lstrip [String]
lstrip s returns a string with consecutive white space (tabs, spaces, newlines, and carriage returns) stripped from the beginning of s.

M
machine_zone [TZ]
machine_zone () returns the machines current (name, Zone.t) if it can be determined, or None if it cannot.
machine_zone_exn [TZ]
majflt [Unix_ext.Resource_usage]
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 [Unix_ext.Wordexp_flags]
make l
make [Unix_ext.Fnmatch_flags]
make l
make [String]
make [Bucket.S]
make [Bucket.Make]
make_matrix [Array]
many_readers_many_writers [Thread_safe_queue]
many_readers_one_writer [Thread_safe_queue]
map [Result]
map [Option]
map o f map 'a option to a 'b option using ~f
map [Monad.S2]
map [Monad.Make2]
map [Monad.Make]
map [Interval_intf.Gen.S]
map [Monad.S]
map t ~f is t >>| f.
map [String]
map f s applies f to each character in s, and returns the resulting string.
map [Set_intf.S1]
map [Map_intf.S2]
map [Map_intf.Gen.S]
returns new map with bound values replaced by f applied to the bound values
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 [Hashtbl_intf.S2]
map [Hashtbl_intf.Gen.S]
map t f returns new table with bound values replaced by f applied to the bound values
map [Hashtbl_intf.S]
map [Array]
map [Map_intf.S]
map1 [Tuple.T3]
map1 [Tuple.T2]
map2 [Tuple.T3]
map2 [Tuple.T2]
map2 [Option]
map2 o f map 'a option and 'b option to a 'c option using ~f
map2 [List]
List.map2 f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn].
map2 [Array]
map3 [Tuple.T3]
map3 [List]
map_file [Bigstring]
map_file shared fd n memory-maps n characters of the data associated with descriptor fd to a bigstring.
mapi [Map_intf.S2]
mapi [Map_intf.Gen.S]
like map, but function takes both key and data as arguments
mapi [List]
mapi is just like map, but it also passes in the index of each element as the first argument to the mapped function.
mapi [Hashtbl_intf.S2]
mapi [Hashtbl_intf.Gen.S]
like map, but function takes both key and data as arguments
mapi [Hashtbl_intf.S]
mapi [Array]
mapi [Map_intf.S]
mar [Month]
max [Int_set]
max t the biggest number in the set (if it exists)
max [Comparable.S]
max [Comparable.Inherit]
max [Comparable.Make]
max_array_length [Sys]
Maximum length of a normal array.
max_elt [Set_intf.S1]
max_elt [Set_intf.Gen.S]
max_elt [Map_intf.S2]
max_elt [Map_intf.Gen.S]
max_elt map
max_elt [Set_intf.S]
max_elt [Map_intf.S]
max_elt_exn [Set_intf.S1]
max_elt_exn [Set_intf.Gen.S]
max_elt_exn [Map_intf.S2]
max_elt_exn [Map_intf.Gen.S]
max_elt_exn map
max_elt_exn [Set_intf.S]
max_elt_exn [Map_intf.S]
max_inan [Float]
max_int [Int_intf.S]
max_iovecs [Unix_ext.IOVec]
max_length [Array]
Array lengths l satisfy 0 <= l < max_length.
max_string_length [Sys]
Maximum length of a string.
max_value [Time.Ofday]
max_value [Time.Span]
max_value [Time]
Maximum value.
max_value [Time.Date]
max_value [Float]
maxrss [Unix_ext.Resource_usage]
may [Month]
may [Common]
Option handling
mcast_join [Unix_ext]
mcast_join ?ifname sock addr join a multicast group at addr with socket sock, optionally using network interface ifname.
mcast_leave [Unix_ext]
mcast_leave ?ifname sock addr leaves a multicast group at addr with socket sock, optionally using network interface ifname.
megabytes [Byte_units]
mem [Int_set]
mem t i test whether i is a member of the set
mem [Heap]
mem heap el
mem [Hash_set_intf.S1]
mem [Hash_set_intf.Gen.S]
mem [Hash_set_intf.S]
mem [Hash_queue.S]
mem [Hash_queue.Make]
mem [Hash_heap.S]
mem [Hash_heap.Make]
mem [Fast_hashtbl]
mem [Set_intf.S1]
mem [Set_intf.Gen.S]
mem [Map_intf.S2]
mem [Map_intf.Gen.S]
mem key map tests whether map contains a binding for key
mem [List]
mem a l is true if and only if a is equal to an element of l.
mem [Hashtbl_intf.S2]
mem [Hashtbl_intf.Gen.S]
mem [Hashtbl_intf.S]
mem [Array]
mem el arr returns true iff arr.(i) = el for some i
mem [Set_intf.S]
mem [Map_intf.S]
mem_assoc [List]
mem_assoc' [List]
memq [List]
merge [Map_intf.S2]
merge [Map_intf.Gen.S]
merges two maps
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.
merge [Hashtbl_intf.S2]
merge [Hashtbl_intf.Gen.S]
merge [Hashtbl_intf.S]
merge [Map_intf.S]
min [Int_set]
min t the smallest number in the set (if it exists)
min [Comparable.S]
min [Comparable.Inherit]
min [Comparable.Make]
min_combine [List]
min_combine combines two lists, possibly of different length, and returns a list the length of the shorter list.
min_elt [Set_intf.S1]
min_elt [Set_intf.Gen.S]
min_elt [Map_intf.S2]
min_elt [Map_intf.Gen.S]
min_elt map
min_elt [Set_intf.S]
min_elt [Map_intf.S]
min_elt_exn [Set_intf.S1]
min_elt_exn [Set_intf.Gen.S]
min_elt_exn [Map_intf.S2]
min_elt_exn [Map_intf.Gen.S]
min_elt_exn map
min_elt_exn [Set_intf.S]
min_elt_exn [Map_intf.S]
min_inan [Float]
min that returns the other value if one of the values is a nan.
min_int [Int_intf.S]
min_value [Time.Ofday]
min_value [Time.Span]
min_value [Time]
Minimum value.
min_value [Time.Date]
min_value [Float]
minflt [Unix_ext.Resource_usage]
minor [Gc]
Trigger a minor collection.
minus_one [Int_intf.S]
minute [Time.Span]
mkdir [Unix]
Create a directory with the given permissions.
mkdtemp [Unix_ext]
mkdtemp prefix creates a temporary directory with prefix, automatically appending a suffix of six random characters to make the name unique.
mkfifo [Unix]
Create a named pipe with the given permissions.
mknod [Unix_ext]
mknod ?file_kind ?perm ?major ?minor path creates a filesystem entry.
mkstemp [Unix_ext]
mkstemp prefix creates and opens a unique temporary file with prefix, automatically appending a suffix of six random characters to make the name unique.
mktime [Unix]
Convert a date and time, specified by the tm argument, into a time in seconds, as returned by UnixLabels.time.
mod_float [Float]
modf [Float]
mon [Weekday]
month [Time.Date]
msgrcv [Unix_ext.Resource_usage]
msgsnd [Unix_ext.Resource_usage]
mul [Int64]
mutex_timedlock [Unix_ext]
mutex_timedlock mtx timeout tries to lock mtx, but returns once timeout expires.

N
name [Linebuf]
nativeint [Int_conversions]
nativeint_to_int64 [Int_conversions]
neg [Int_intf.S]
never_returns [Common]
newline [Out_channel]
next [Doubly_linked]
constant-time move to next or previous element.
nget [String]
nget s i Gets the char at normalized position i in s.
nget [Array]
Array access with normalized index.
nice [Unix]
Change the process priority.
nivcsw [Unix_ext.Resource_usage]
nng [Quickcheck]
nng [OUnit_utils]
natural number generator
non [Function]
Negates a function
normalize [Ordered_collection_common]
normalize [Filename]
normalize path Removes as much "." and ".." from the path as possible.
normalize [Array]
normalize array index returns a new index into the array such that if index is less than zero, the returned index will "wrap around" -- i.e.
normalize_path [Filename]
nov [Month]
now [Time]
nset [String]
nset s i c Sets the char at normalized position i to c.
nset [Array]
Array modification with normalized index.
nsignals [Unix_ext.Resource_usage]
nswap [Unix_ext.Resource_usage]
nth [List]
Return the n-th element of the given list.
nth [Bigbuffer]
get the (zero-based) n-th character of the buffer.
nth_exn [List]
List reversal.
num_bits [Word_size]
num_bits [Int_intf.S]
num_threads [Thread]
num_threads () attempts to return the number of currently running threads by parsing /proc.
nvcsw [Unix_ext.Resource_usage]

O
ocaml_version [Sys]
ocaml_version is the version of Objective Caml.
oct [Month]
of_alist [Map_intf.S2]
of_alist [Map_intf.Gen.S]
creates map from association list with unique keys
of_alist [Hashtbl_intf.S2]
of_alist [Hashtbl_intf.Gen.S]
of_alist l returns a new hashtable populated with the supplied data
of_alist [Hashtbl_intf.S]
of_alist [Map_intf.S]
of_alist_exn [Map_intf.S2]
of_alist_exn [Map_intf.Gen.S]
creates map from association list with unique keys.
of_alist_exn [Hashtbl_intf.S2]
of_alist_exn [Hashtbl_intf.Gen.S]
of_alist_exn [Hashtbl_intf.S]
of_alist_exn [Map_intf.S]
of_alist_multi [Map_intf.S2]
of_alist_multi [Map_intf.Gen.S]
creates map from association list with possibly repeated keys.
of_alist_multi [Map_intf.S]
of_alist_shadow [Hashtbl_intf.S2]
of_alist_shadow [Hashtbl_intf.Gen.S]
of_alist_shadow [Hashtbl_intf.S]
of_array [Heap]
of_array ?min_size cmp ar
of_array [Set_intf.S1]
of_array [Set_intf.Gen.S]
of_array [Set_intf.S]
of_bigstring [Unix_ext.IOVec]
of_bigstring ?pos ?len bstr
of_bigstring [Substring_intf.S]
of_bigstring [Make_substring.Base]
of_bigstring [Make_substring.F]
of_caml_int [Signal]
of_caml_int constructs a Signal.t given an O'Caml internal signal number.
of_char [String]
of_date_ofday [Time]
All these conversion functions use the current time zone.
of_date_ofday_utc [Time]
Assume the specified date and time of day are UTC
of_date_time_strings [Time]
of_day [Time.Span]
of_filename_string [Time]
of_float [Floatable.S]
of_float [Int64]
of_gmt_offset [TZ.Zone]
of_gmt_offset offset returns a timezone with a static GMT offset (given in hours).
of_hr [Time.Span]
of_int [Weekday]
of_int i returns i'th weekday if i is in 0,1,...,6.
of_int [Month]
of_int i returns i'th month if i is in 1,2,...,12.
of_int [Float]
of_int [Nativeint]
of_int [Int64]
of_int [Int63]
of_int [Int32]
of_int [Int]
of_int [Char]
of_int32 [Nativeint]
of_int32 [Int64]
of_int32 [Int32]
of_int32 [Int]
of_int32_exn [Int_intf.S]
of_int64 [Float]
of_int64 [Nativeint]
of_int64 [Int64]
of_int64 [Int32]
of_int64 [Int]
of_int64_exn [Int_intf.S]
of_int64_exn [Int]
of_int_exn [Weekday]
of_int_exn i should have i in 0,1,...,6 and returns the i'th weekday.
of_int_exn [Month]
of_int_exn i should have i in 1,2,...,12 and returns the i'th month.
of_int_exn [Int_intf.S]
of_int_exn [Char]
of_int_sec [Time.Span]
of_list [Hash_set_intf.S1]
of_list [Hash_set_intf.Gen.S]
of_list [Hash_set_intf.S]
of_list [Doubly_linked]
of_list l returns a doubly-linked list t with the same elements as l and in the same order (i.e.
of_list [Set_intf.S1]
of_list [Set_intf.Gen.S]
of_list [Queue]
of_list list returns a queue t with the elements of list in the same order as the elements of list (i.e.
of_list [Array]
of_list [Set_intf.S]
of_list_rev [Array]
of_list_rev l converts from list then reverses in place
of_min [Time.Span]
of_ms [Time.Span]
of_nativeint [Nativeint]
of_nativeint [Int64]
of_nativeint [Int32]
of_nativeint [Int]
of_nativeint_exn [Int_intf.S]
of_sec [Time.Ofday]
of_sec [Time.Span]
of_span_since_midnight [Time.Ofday]
of_string [Unix_ext.IOVec]
of_string ?pos ?len str
of_string [Time.Span]
of_string [Sexpable.To_stringable]
of_string [Substring_intf.S]
of_string [Make_substring.Base]
of_string [Make_substring.F]
of_string [Stringable.S]
of_string [Bigstring]
of_string ?pos ?len str
of_string_fix_proto [Time]
of_string_iso8601_extended [Time.Ofday]
of_system_int [Signal]
of_system_int and to_system_int return and take respectively a signal number corresponding to those in the system's /usr/include/bits/signum.h (or equivalent).
of_time [TZ.Date_time]
datetime_of_time zone time returns a datetime representation of time in the given zone.
of_tm [Time.Date]
of_unix [Unix.Process_status]
ofday_occurrence [Time]
ofday_occurrence ofday side now returns a Time.t that is the occurrence of ofday which is the latest occurrence before now or the earliest occurrence after now, according to side.
ofday_occurrence_utc [Time]
ok [Result]
ok_fst [Result]
useful in List.partition
one [Int_intf.S]
one_reader_many_writers [Thread_safe_queue]
one_reader_one_writer [Thread_safe_queue]
oneof [Quickcheck]
Given a list of generators, returns generator that randomly uses one of the generators from the list
oneof [OUnit_utils]
Given a list of generators, returns generator that randomly uses one of the generators from the list
open_connection [Unix]
Connect to a server at the given address.
open_linebuf [Linebuf]
Open a linebuffer from the passed filename.
open_process [Unix]
open_process_full [Unix]
open_process_in [Unix]
High-level pipe and process management.
open_process_out [Unix]
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.
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.
oublock [Unix_ext.Resource_usage]
out_channel_length [Common]
out_channel_of_descr [Unix]
Create an output channel writing on the given descriptor.
out_channel_realpath [Linux_ext]
out_channel_realpath oc
output [Out_channel]
output [Bigstring]
output ?min_len oc ?pos ?len bstr tries to output len bytes (guarantees to write at least min_len bytes (must be equal to or greater than zero), if possible, before returning) from bigstring bstr starting at position pos to output channel oc.
output_binary_int [Out_channel]
output_buffer [Bigbuffer]
output_buffer oc b writes the current contents of buffer b on the output channel oc.
output_byte [Out_channel]
output_char [Out_channel]
output_lines [Out_channel]
output_string [Out_channel]
output_value [Out_channel]

P
pack_float [Binary_packing]
pack_signed_16 [Binary_packing]
encode and pack the specified int as a signed 2 byte int, and place it in the buffer starting at pos
pack_signed_32 [Binary_packing]
encode and pack the specified int32 as a signed 4 byte int, and place it in the buffer starting at pos
pack_signed_32_int [Binary_packing]
encode and pack the specified int as a signed 4 byte int, and place it in the buffer starting at pos.
pack_signed_64 [Binary_packing]
encode and pack the specified int64 as a signed 8 byte int, and place it in the buffer starting at pos
pack_signed_64_int [Binary_packing]
encode and pack the specified int as a signed 8 byte int, and place it in the buffer starting at pos.
pack_signed_8 [Binary_packing]
encode and pack the specified int as a signed 1 byte int, and place it in the buffer starting at pos
pack_unsigned_8 [Binary_packing]
encode and pack the specified int as an unsigned 1 byte int, and place it in the buffer starting at pos
parent [Filename]
parent path
parent_dir_name [Filename]
parse [Arg]
parse_argv [Arg]
partial_iter [Queue]
partial_iter t ~f iterates through t until f returns `Stop
partition [Set_intf.S1]
partition [Set_intf.Gen.S]
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.
partition [Set_intf.S]
partition_map [List]
partition_map t ~f partitions t according to f.
pause [Time]
Pause (and don't throw an exception)
pause [Unix]
Wait until a non-ignored, non-blocked signal is delivered.
peek [Queue]
peek t returns None if t is empty, otherwise it returns Some x where x is the front of t.
peek_exn [Queue]
peek_exn t raises Empty if t is empty, otherwise it returns the front of t.
permute [List]
permute l shuffles l, using Random.int
permute [Array]
permute ar randomly permutes ar in place
permute [Array_permute]
randomly permute an array.
pfg [Quickcheck]
pfg [OUnit_utils]
positive float generator
pg [Quickcheck]
pg [OUnit_utils]
pair generator
phys_equal [Mutex0]
phys_equal [Common]
pipe [Signal]
Broken pipe
pipe [Unix]
Create a pipe.
png [OUnit_utils]
poly_t_of_sexp [Interval_intf.S.Set]
poly_t_of_sexp [Interval_intf.S]
pop [Squeue]
pops an element off the queue, blocking until something is available
pop [Heap]
pop heap
pop [Hash_heap.S]
pop [Hash_heap.Make]
pop [Fqueue]
Like pop_exn, but returns result optionally, without exception
pop [Stack]
pop t returns None if t is empty, otherwise it returns Some x where x is the top of t and removes x from the top of t.
pop_exn [Heap]
pop_exn heap
pop_exn [Hash_heap.S]
pop_exn [Hash_heap.Make]
pop_exn [Fqueue]
Like top_exn, but returns pair of the top element, and a new queue with the top element removed
pop_exn [Stack]
pop_exn t removes and returns the top element of t, raising Empty if t is empty.
pop_heap_el [Heap]
pop_heap_el heap
pop_heap_el_exn [Heap]
pop_heap_el_exn heap
pop_with_key [Hash_heap.S]
pop_with_key [Hash_heap.Make]
pop_with_key_exn [Hash_heap.S]
pop_with_key_exn [Hash_heap.Make]
pos [Out_channel]
pos [Substring_intf.S]
pos [Make_substring.F]
pos [In_channel]
pos_in [Common]
pos_out [Common]
pp [Time.Ofday]
pp [Time.Span]
pp [Time]
pp [Time.Date]
pp [Exn]
pp [String]
This has to be public for interactive top-levels.
pr_get_pdeathsig [Linux_ext]
pr_get_pdeathsig () get the signal that will be sent to the currently executing process when its parent dies.
pr_set_pdeathsig [Linux_ext]
Parent death notifications
pred [Int_intf.S]
prefix [Substring_intf.S]
prefix [Make_substring.F]
prefix [String]
prefix s n returns the longest prefix of s of length less than or equal to n
prettify_string [Int_conversions]
prev [Doubly_linked]
previous_weekday [Time.Date]
print [Printexc]
print [Backtrace]
print_backtrace [Printexc]
print_stat [Gc]
Print the current values of the memory management counters (in human-readable form) into the channel argument.
printf [Printf]
prof [Signal]
Profiling interrupt
protect [Exn]
protect [Common]
protectx [Exn]
Executes f and afterwards executes finally, whether f throws an exception or not.
protectx [Common]
See exn.mli
pselect [Unix_ext]
pselect rfds wfds efds timeout sigmask like Unix.select but also allows one to wait for the arrival of signals.
push [Squeue]
Blocks until there's room on the queue, then pushes.
push [Heap]
push heap el pushes element el on heap.
push [Hash_heap.S]
push [Hash_heap.Make]
push [Fqueue]
push a single element on queue
push [Stack]
push t x adds x to the top of stack t.
push_back [Dequeue]
push_exn [Hash_heap.S]
push_exn [Hash_heap.Make]
push_front [Dequeue]
push_heap_el [Heap]
push_heap_el heap heap_el pushes heap_el on heap.
push_or_drop [Squeue]
Pushes an event on the queue if the queue is less than maxsize, otherwise drops it.
push_top [Fqueue]
push a single element on the *top* of the queue
push_uncond [Squeue]
Does not block, may grow the queue past maxsize
putenv [Unix]
Unix.putenv ~key ~data 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.
quit [Signal]
Interactive termination
quote [Filename]

R
randomize [Time.Span]
randomize t ~percent returns a random span between t - percent * t and t + percent * t
range [List]
range stride low high is the list of integers from low(inclusive) to high(exclusive), stepping by stride.
ranges [Int_set]
ranges t return a list of all ranges that make up the set
rcontains_from [String]
read [Linebuf]
Calls try_read every 0.01 seconds and returns when a line is available.
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 [Bigstring]
read ?min_len fd ?pos ?len bstr reads at least min_len (must be greater than or equal zero) and at most len (must be greater than or equal to min_len) bytes from file descriptor fd, and writes them to bigstring bstr starting at position pos.
read_assume_fd_is_nonblocking [Unix_ext]
read_assume_fd_is_nonblocking fd ?pos ?len buf calls the system call read ASSUMING THAT IT IS NOT GOING TO BLOCK.
read_assume_fd_is_nonblocking [Bigstring]
read_assume_fd_is_nonblocking fd ?pos ?len bstr reads up to len bytes into bigstring bstr starting at position pos from file descriptor fd without yielding to other OCaml-threads.
read_lines [Common]
read_lines filename Opens filename, reads all lines, and closes the file.
read_only_of_sexp [Common]
read_wrap [Common]
read_wrap ~f fname executes ~f on the open input channel from fname, and closes it afterwards.
read_write_of_sexp [Common]
readdir [Unix]
Return the next entry in a directory.
readdir [Sys]
Return the names of all files present in the given directory.
readdir_ino [Unix_ext]
readdir_ino dh return the next entry in a directory (((filename, inode)).
readlink [Unix]
Read the contents of a link.
really_input [In_channel]
really_input [Bigstring]
really_input ic ?pos ?len bstr reads exactly len bytes from input channel ic, and writes them to bigstring bstr starting at position pos.
really_output [Bigstring]
really_output oc ?pos ?len bstr outputs exactly len bytes from bigstring bstr starting at position pos to output channel oc.
really_read [Bigstring]
really_read fd ?pos ?len bstr reads len bytes from file descriptor fd, and writes them to bigstring bstr starting at position pos.
really_recv [Bigstring]
really_recv sock ?pos ?len bstr receives len bytes from socket sock, and writes them to bigstring bstr starting at position pos.
really_send_no_sigpipe [Bigstring]
really_send_no_sigpipe sock ?pos ?len bstr sends len bytes in bigstring bstr starting at position pos to socket sock without blocking and ignoring SIGPIPE.
really_write [Bigstring]
really_write fd ?pos ?len bstr writes len bytes in bigstring bstr starting at position pos to file descriptor fd.
realpath [Unix_ext]
realpath path
record_backtrace [Printexc]
recv [Unix]
Receive data from an unconnected socket.
recvfrom [Unix]
Receive data from an unconnected socket.
reduce [List]
reduce [Array]
reduce f [a1; ...; an] is f (... (f (f a1 a2) a3) ...) an.
reduce_exn [List]
reduce f [a1; ...; an] is f (... (f (f a1 a2) a3) ...) an.
reduce_exn [Array]
register [Pretty_printer]
rem [Int_intf.S]
remove [Timer]
remove event removes event from its associated timer.
remove [Heap]
remove heap_el removes heap_el from its associated heap.
remove [Hash_set_intf.S1]
remove [Hash_set_intf.Gen.S]
strict_remove fails if element wasn't there
remove [Hash_set_intf.S]
remove [Hash_queue.S]
remove [Hash_queue.Make]
remove [Hash_heap.S]
remove [Hash_heap.Make]
remove [Fast_hashtbl]
remove [Doubly_linked]
constant-time removal of an element.
remove [Sys]
Remove the given file name from the file system.
remove [Set_intf.S1]
remove [Set_intf.Gen.S]
remove [Map_intf.S2]
remove [Map_intf.Gen.S]
returns a new map with any binding for the key in question removed
remove [Hashtbl_intf.S2]
remove [Hashtbl_intf.Gen.S]
remove [Hashtbl_intf.S]
remove [Set_intf.S]
remove [Map_intf.S]
remove [Bag]
remove t elt removes elt from the bag t, raising an exception if elt is not in the bag.
remove_all [Hashtbl_intf.S2]
remove_all [Hashtbl_intf.Gen.S]
remove_all t k removes all bindings associated wity key k from t.
remove_all [Hashtbl_intf.S]
remove_assoc [List]
remove_assoc' [List]
remove_exn [Hash_queue.S]
remove_exn [Hash_queue.Make]
remove_first [Doubly_linked]
remove_last [Doubly_linked]
remove_one [Bag]
remove_one t removes some element from the bag, and returns its value.
rename [Unix]
rename old new changes the name of a file from old to new.
rename [Sys]
Rename a file.
repeat [Quickcheck]
repeat [OUnit_utils]
replace [Ref]
replace t f is t := f !t
replace [Hash_queue.S]
replace [Hash_queue.Make]
replace [Hash_heap.S]
replace [Hash_heap.Make]
replace [Fast_hashtbl]
replace [Hashtbl_intf.S2]
replace [Hashtbl_intf.Gen.S]
replace [Hashtbl_intf.S]
replace [Array]
replace t i ~f = t.(i) <- f (t.(i)).
replace_all [Array]
modifies an array in place -- ar.(i) will be set to f(ar.(i))
replace_exn [Hash_queue.S]
replace_exn [Hash_queue.Make]
reraise [Exn]
reraise_uncaught [Exn]
reraisef [Exn]
reschedule [Timer]
reschedule event ?randomize ?interval span reschedules event to start by time span span later than originally scheduled, and change its interval behaviour as described for Timer.add.
reset [Linebuf]
reopens the file and seeks to the beginning.
reset [Bigbuffer]
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.
return [Monad.S2]
return [Monad.Basic2]
return [Monad.Basic]
return [Monad.Make2]
return [Monad.Make]
return [Monad.S]
return v returns the (trivial) computation that returns v.
rev [List]
List.rev_append l1 l2 reverses l1 and concatenates it to l2.
rev [Array]
rev ar reverses ar in place
rev_append [List]
rev_filter_map [List]
rev_filter_map f l is the reversed sublist of l containing only elements for which f returns Some e.
rev_map [List]
List.rev_map f l gives the same result as List.rev (ListLabels.map f l), but is more efficient.
rev_map2 [List]
List.fold_left2 f a [b1; ...; bn] [c1; ...; cn] is f (... (f (f a b1 c1) b2 c2) ...) bn cn.
rev_map3 [List]
rev_map_append [List]
rev_map_append ~f l1 l2 reverses l1 mapping f over each element, and appends the result to the front of l2.
reverse_pairs [List]
reverse_pairs l reverses each tuple inside an association list.
rewinddir [Unix]
Reposition the descriptor to the beginning of the directory
rfindi [String]
rfindi s ~f returns the index i of the last character in s satisfying f i s.[i].
rindex [String]
rindex_from [String]
rmdir [Unix]
Remove an empty directory.
rnd_state [OUnit_utils.Random]
root [Filename]
The path of the root.
round [Std_internal]
round [Float]
rsplit2 [String]
rsplit2 line ~on optionally returns line split into two strings around the first appearance of on from the right
rsplit2_exn [String]
If the string s contains the character char, then rsplit2_exn s char returns a pair containing s split around the first appearance of char (from the right).
rstrip [String]
rstrip s returns a string with consecutive white space (tabs, spaces, newlines, and carriage returns) stripped from the end of s.

S
sat [Weekday]
scale [Time.Span]
computes absolute value of span
scale [Float]
sec [Std]
second [Time.Span]
seek [Out_channel]
seek [In_channel]
seek_in [Common]
seek_out [Common]
segv [Signal]
Invalid memory reference
select [Unix]
select [Thread]
Suspend the execution of the calling thead until input/output becomes possible on the given Unix file descriptors.
self [Thread]
Return the thread currently executing.
send [Signal]
send signal ~pid sends signal to the process whose process id is pid.
send [Unix]
Send data over an unconnected socket.
send_no_sigpipe [Linux_ext]
send_no_sigpipe sock ?pos ?len buf tries to do a blocking send on socket sock given buffer buf, offset pos and length len.
send_nonblocking_no_sigpipe [Linux_ext]
send_nonblocking_no_sigpipe sock ?pos ?len buf tries to do a nonblocking send on socket sock given buffer buf, offset pos and length len.
send_nonblocking_no_sigpipe [Bigstring]
send_nonblocking_no_sigpipe sock ?pos ?len bstr tries to send len bytes in bigstring bstr starting at position pos to socket sock.
sendfile [Linux_ext]
Filesystem functions
sendmsg_nonblocking_no_sigpipe [Linux_ext]
sendmsg_nonblocking_no_sigpipe sock ?count iovecs tries to do a nonblocking send on socket sock using count I/O-vectors iovecs.
sendmsg_nonblocking_no_sigpipe [Bigstring]
sendmsg_nonblocking_no_sigpipe sock ?count iovecs sends count iovecs of bigstrings to socket sock.
sendto [Unix]
Send data over an unconnected socket.
sep [Month]
set [Unix_ext.RLimit]
set [Signal]
set t b is ignore (signal t b)
set [Set_once]
set [Dequeue]
set [String]
set [Gc]
set r changes the GC parameters according to the control record r.
set [Array]
set_binary_mode [Out_channel]
set_binary_mode [In_channel]
set_close_on_exec [Unix]
Set the ``close-on-exec'' flag on the given descriptor.
set_exn [Set_once]
set_in_channel_timeout [Unix]
Set a timeout for a socket associated with an in_channel
set_nonblock [Unix]
Set the ``non-blocking'' flag on the given descriptor.
set_out_channel_timeout [Unix]
Set a timeout for a socket associated with an out_channel
set_time [Unix_ext.Clock]
set_time clock time sets clock to the time in seconds.
setgid [Unix]
Set the real group id and effective group id for the process.
setitimer [Unix]
setitimer t s sets the interval timer t and returns its previous status.
setsid [Unix.Terminal_io]
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 UnixLabels.setsockopt for a socket option whose value is a floating-point number.
setsockopt_int [Unix]
Same as UnixLabels.setsockopt for an integer-valued socket option.
setsockopt_optint [Unix]
Same as UnixLabels.setsockopt for a socket option whose value is an int option.
settcpopt_bool [Linux_ext]
settcpopt_bool sock opt v sets the current value of the boolean TCP socket option opt for socket sock to value v.
setuid [Unix]
Set the real user id and effective user id for the process.
sexp_of_decimal [Common]
sexp_of_file_kind [Unix]
Socket
sexp_of_immutable [Common]
sexp_of_inet_addr [Unix]
sexp_of_poly_t [Interval_intf.S.Set]
sexp_of_poly_t [Interval_intf.S]
sexp_of_read_only [Common]
sexp_of_read_write [Common]
sexp_of_setattr_when [Terminal_io_intf.Types]
sexp_of_sockaddr [Unix]
sexp_of_socket_domain [Unix]
sexp_of_socket_type [Unix]
sexp_of_sys_behavior [Signal]
sexp_of_sysinfo [Linux_ext]
sexp_of_t [Terminal_io_intf.Types]
sexp_of_t [Unique_id.Unit_ref]
sexp_of_t [TZ.Zone]
sexp_of_t [Time.Date]
sexp_of_t [Sexpable.S3]
sexp_of_t [Sexpable.S2]
sexp_of_t [Sexpable.S1]
sexp_of_t [Sexpable.Of_stringable]
sexp_of_t [Interval_intf.S1.Set]
sexp_of_t [Interval_intf.S1]
sexp_of_t [Interval_intf.S.Set]
sexp_of_t [Interval_intf.S]
sexp_of_t [Sexpable.S]
sexp_of_t [Hash_set_intf.S1]
sexp_of_t [Hash_set_intf.S]
sexp_of_t [Force_once]
sexp_of_t [Fast_hashtbl]
sexp_of_t [Exn]
sexp_of_t [Error_check.ReportAllFails]
sexp_of_t [Error_check.Step]
sexp_of_t [Error_check.Timer]
sexp_of_t [Error_check.ToggleN]
sexp_of_t [Error_check.Toggle]
sexp_of_t [Doubly_linked.Elt]
sexp_of_t [Unix.Process_status]
sexp_of_t [Unix.File_descr]
sexp_of_t [Bucket.Make]
sexp_of_t [Bag.Elt]
sexp_of_t [Bag]
sexp_of_t_mode [Month]
sexp_of_t_style [Time.Date]
sexp_of_t_style controls how sexp_of_t works sexp_ot_t_style sexp ---------------- ----------------------- `List_ymd ((y 2008) (m 4) (d 29)) `Atom_yyyy_mm_dd 2008-04-29
sexp_of_tcp_bool_option [Linux_ext]
sexp_of_write_only [Common]
sg [Quickcheck]
sg [OUnit_utils]
string generator
shadow_add [Hashtbl_intf.S2]
shadow_add [Hashtbl_intf.Gen.S]
shadow_add [Hashtbl_intf.S]
shadow_find [Hashtbl_intf.S2]
shadow_find [Hashtbl_intf.Gen.S]
shadow_find [Hashtbl_intf.S]
shift [Weekday]
shift t i goes forward (or backward) the specified number of weekdays
shift [Month]
shift t i goes forward (or backward) the specified number of months
shift_left [Int_intf.S]
shift_right [Int_intf.S]
shift_right_logical [Int_intf.S]
shutdown [Unix]
Shutdown a socket connection.
shutdown_connection [Unix]
``Shut down'' a connection established with UnixLabels.open_connection; that is, transmit an end-of-file condition to the server reading on the other side of the connection.
sigmask [Thread]
sigmask cmd sigs changes the set of blocked signals for the calling thread.
sign [Float]
signal [Signal]
signal t Set the behavior of the system on receipt of a given signal.
signal [Condition]
sigpending [Signal]
sigpending () returns the set of blocked signals that are currently pending.
sigprocmask [Signal]
sigprocmask cmd sigs changes the set of blocked signals.
sigsuspend [Signal]
sigsuspend sigs atomically sets the blocked signals to sigs and waits for a non-ignored, non-blocked signal to be delivered.
single_write [Unix]
Same as write but ensures that all errors are reported and that no character has ever been written when an error is reported.
singleton [Set_intf.S1]
singleton [Set_intf.Gen.S]
singleton [Map_intf.S2]
singleton [Map_intf.Gen.S]
map with one key, data pair
singleton [Set_intf.S]
singleton [Map_intf.S]
sleep [Unix]
Stop execution for the given number of seconds.
slice [Ordered_collection_common]
slice [String]
slice s start stop gets a slice of s between start and stop.
slice [List]
slice l start stop returns a new list including elements l.(start) through l.(stop-1), normalized python-style.
slice [Array]
slice array start stop returns a fresh array including elements array.(start) through array.(stop-1) with the small tweak that the start and stop positions are normalized and a stop index of 0 means the same thing a stop index of Array.length array.
small_diff [Time.Ofday]
snd3 [Common]
Returns the second element of a triple.
sockaddr_of_sexp [Unix]
socket [Unix]
Create a new socket in the given domain, and with the given kind.
socket_domain_of_sexp [Unix]
socket_type_of_sexp [Unix]
socketpair [Unix]
Create a pair of unnamed sockets, connected together.
some [Option]
some_elt [Bag]
sort [List]
sort [Array]
sort_and_align [Arg]
sorted_copy [Array]
sorted_copy ar cmp returns a shallow copy of ar that is sorted.
split [String]
split s ~on
split [Set_intf.S1]
split [Set_intf.Gen.S]
split [List]
Transform a list of pairs into a pair of lists: split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]).
split [Filename]
split filename returns (dirname filename, basename filename)
split [Array]
split ar splits an array of pairs into two arrays of single elements.
split [Set_intf.S]
split_n [List]
split_n n [e1; ...; em] is ([e1; ...; en], [en+1; ...; em]).
split_on_chars [String]
split_on_chars s ~on
sprintf [Printf]
ss_fst [Common]
space safe double and triple handling
ss_fst3 [Common]
ss_snd [Common]
ss_snd3 [Common]
ss_trd3 [Common]
stable_dedup [List]
stable_dedup Same as dedup but maintains the order of the list and doesn't allow compare function to be specified (uses set membership).
stable_sort [List]
stable_sort [Array]
start_of_day [Time.Ofday]
stat [Unix.Native_file]
Return the information for the named file.
stat [Unix]
Return the information for the named file.
stat [Gc]
Return the current values of the memory management counters in a stat record.
state [Error_check.ReportAllFails]
state [Error_check.Step]
state [Error_check.Timer]
state [Error_check.ToggleN]
state [Error_check.Toggle]
statistic [Quickcheck]
statistic_number [Quickcheck]
stderr [Out_channel]
stderr [Unix]
File descriptor for standard standard error.
stdin [In_channel]
stdin [Unix]
File descriptor for standard input.
stdout [Out_channel]
stdout [Unix]
File descriptor for standard output.
stime [Unix_ext.Resource_usage]
stop [Signal]
Stop
stop_me_now [Low_level_debug]
stop_upon_exit [Low_level_debug]
stop_upon_sigbus [Low_level_debug]
stop_upon_sigpipe [Low_level_debug]
stop_upon_sigsegv [Low_level_debug]
strict_add [Hash_set_intf.S1]
strict_add [Hash_set_intf.Gen.S]
strict_add [Hash_set_intf.S]
strict_remove [Hash_set_intf.S1]
strict_remove [Hash_set_intf.Gen.S]
strict_remove [Hash_set_intf.S]
string_bigstring [Make_substring.Blit]
string_kind [Unix_ext.IOVec]
string_of_inet_addr [Unix]
Return the printable representation of the given Internet address.
string_of_time [TZ]
string_of_time zone time returns a string representation of time in the given zone in the form like "2008-11-18 15:34:56.123".
string_string [Make_substring.Blit]
strip [String]
strip s returns a string with consecutive white space (tabs, spaces, newlines, and carriage returns) stripped from the beginning and end of s.
sub [Time.Ofday]
sub [Time.Span]
sub [Time]
sub t s subtracts the span s from time t and returns the resulting time.
sub [Float]
sub [String]
sub [List]
sub pos len l is the len-element sublist of l, starting at pos.
sub [Int64]
sub [Array]
sub [Bigbuffer]
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_copy [Bigstring]
sub_copy ?pos ?len bstr
sub_shared [Bigstring]
sub_shared ?pos ?len bstr
subset [Set_intf.S1]
subset [Set_intf.Gen.S]
subset [Set_intf.S]
succ [Int_intf.S]
suffix [Substring_intf.S]
suffix [Make_substring.F]
suffix [String]
suffix s n returns the longest suffix of s of length less than or equal to n
sum_int [Quickcheck]
sum_int [OUnit_utils]
sun [Weekday]
swap [Tuple.T2]
swap [Ref]
swap t1 t2 swaps the values in t1 and t2.
swap [Array]
swap arr i j swaps the value at index i with that at index j.
swap [Array_permute]
symlink [Unix]
symlink source dest creates the file dest as a symbolic link to the file source.
sync [Unix_ext]
Synchronize all filesystem buffers with disk.
sys_behavior [Signal]
sys_behavior t Query the default system behavior for a signal.
sys_behavior_of_sexp [Signal]
Terminate the process
sysconf [Unix_ext]
sysinfo [Linux_ext]
sysinfo_of_sexp [Linux_ext]
Memory unit size in bytes
system [Unix]
Execute the given command, wait until it terminates, and return its termination status.

T
t_of_sexp [TZ.Zone]
t_of_sexp [Time.Date]
t_of_sexp [Sexpable.S3]
t_of_sexp [Sexpable.S2]
t_of_sexp [Sexpable.S1]
t_of_sexp [Sexpable.Of_stringable]
t_of_sexp [Interval_intf.S1.Set]
t_of_sexp [Interval_intf.S1]
t_of_sexp [Interval_intf.S.Set]
t_of_sexp [Interval_intf.S]
t_of_sexp [Sexpable.S]
t_of_sexp [Hash_set_intf.S1]
t_of_sexp [Hash_set_intf.S]
t_of_sexp [Unix.Process_status]
t_of_sexp [Bucket.Make]
t_of_sexp__ [Unix.Process_status]
tail [Linebuf]
Seeks to the end of the file and blocks until another line is available -- this new line is not returned.
take [List]
take l n is fst (split_n n l).
take [Bucket.S]
take [Bucket.Make]
take_at_most [Bucket.S]
take_at_most [Bucket.Make]
take_back [Dequeue]
take_front [Dequeue]
tcdrain [Unix.Terminal_io]
Waits until all output written on the given file descriptor has been transmitted.
tcflow [Unix.Terminal_io]
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.Terminal_io]
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.Terminal_io]
Return the status of the terminal referred to by the given file descriptor.
tcp_bool_option_of_sexp [Linux_ext]
tcsendbreak [Unix.Terminal_io]
Send a break condition on the given file descriptor.
tcsetattr [Unix.Terminal_io]
Set the status of the terminal referred to by the given file descriptor.
temp_dir [Filename]
Same as temp_file but creates a temporary directory.
temp_dir_name [Filename]
temp_file [Filename]
temp_file ?temp_dir_name prefix suffix
term [Signal]
Termination
test [Binary_packing]
test_invariants [Fqueue]
test via asserts whether invariants hold
tg [Quickcheck]
tg [OUnit_utils]
triple generator
threads_have_been_created [Thread]
true iff Thread.create has ever been called, even if there is currently only one running thread.
thu [Weekday]
time [Unix]
Return the current time since 00:00:00 GMT, Jan.
time_of_string [TZ]
time_of_string zone str read in the given string assuming that it represents a time in zone and return the appropriate Time.t
timedlock [Mutex]
timedlock mtx timeout like lock, but takes a timeout parameter.
timedwait [Condition]
timegm [Unix]
Convert a UTC time in a tm record to a time in seconds
times [Unix]
Return the execution times of the process.
tl [List]
Return the first element of the given list.
tl_exn [List]
to_alist [Map_intf.S2]
to_alist [Map_intf.Gen.S]
creates association list from map.
to_alist [Hashtbl_intf.S2]
to_alist [Hashtbl_intf.Gen.S]
Returns the list of all (key,data) pairs for given hashtable.
to_alist [Hashtbl_intf.S]
to_alist [Map_intf.S]
to_alist_shadow [Hashtbl_intf.S2]
to_alist_shadow [Hashtbl_intf.Gen.S]
to_alist_shadow [Hashtbl_intf.S]
to_array [Hash_queue.Make]
to_array [Set_intf.S1]
to_array [Set_intf.Gen.S]
to_array [Container.S1_noclass]
to_array [Container.S0_phantom_noclass]
to_array [Container.S0_noclass]
to_array [Set_intf.S]
to_bigstring [Substring_intf.S]
to_bigstring [Make_substring.F]
to_caml_int [Signal]
to_date [Time]
to_date_ofday [Time]
to_date_ofday_utc [Time]
Produce the current UTC date and time of day
to_day [Time.Span]
to_filename_string [Time]
to_filename_string t converts t to string with format YYYY-MM-DD_HH-MM-SS.mmm which is suitable for using in filenames
to_float [Floatable.S]
to_float [Int64]
to_hr [Time.Span]
to_int [Weekday]
to_int t returns an int in 0,1,...6.
to_int [Month]
to_int t returns an int in 1,2,...12.
to_int [Float]
to_int [Unix.File_descr]
to_int [Nativeint]
to_int [Int64]
to_int [Int63]
to_int [Int32]
to_int [Int]
to_int [Char]
to_int32 [Nativeint]
to_int32 [Int64]
to_int32 [Int32]
to_int32 [Int]
to_int32_exn [Int_intf.S]
to_int32_exn [Nativeint]
to_int64 [Int_intf.S]
to_int64 [Float]
to_int_exn [Int_intf.S]
to_int_exn [Nativeint]
to_list [Hash_set_intf.S1]
to_list [Hash_set_intf.Gen.S]
to_list [Hash_set_intf.S]
to_list [Hash_queue.Make]
to_list [Fqueue]
converts queue to list, from most to least recently enqueued item
to_list [Set_intf.S1]
to_list [Set_intf.Gen.S]
to_list [Container.S1_noclass]
to_list [Container.S0_phantom_noclass]
to_list [Container.S0_noclass]
to_list [Set_intf.S]
to_list_rev [String]
Returns the reversed list of characters contained in a list.
to_min [Time.Span]
to_ms [Time.Span]
to_nativeint [Nativeint]
to_nativeint [Int64]
to_nativeint [Int32]
to_nativeint [Int]
to_nativeint_exn [Int_intf.S]
to_ofday [Time]
to_parts [Time.Ofday]
to_parts [Time.Span]
to_poly [Interval_intf.S.Set]
to_poly [Interval_intf.S]
to_sec [Time.Ofday]
since midnight
to_sec [Time.Span]
to_sec_string [Time.Ofday]
to_sec_string t returns a string with trailing milliseconds trimmed
to_span_since_midnight [Time.Ofday]
to_string [Unique_id.Unit_ref]
to_string [Time.Span]
to_string [Signal]
to_string t returns a human-readable name: "sigabrt", "sigalrm", ...
to_string [Sexpable.To_stringable]
to_string [Substring_intf.S]
to_string [Make_substring.F]
to_string [Stringable.S]
to_string [Int_set]
to_string [Exn]
to_string [Unix.File_descr]
to_string [Printexc]
to_string [List]
to_string [Char]
to_string [Bigstring]
to_string ?pos ?len bstr
to_string_fix_proto [Time]
to_string_hum [TZ.Zone]
to_string_hum t full internal description of the zone.
to_string_hum [Time.Span]
to_string_hum [Unix.Process_status]
to_string_hum [Int]
to_string_iso8601_basic [Time.Date]
to_string_iso8601_extended [Time.Date]
to_string_old [Time]
to_string_old [Time.Date]
to_string_trimmed [Time.Ofday]
to_string_trimmed t return a string with trailing seconds and subseconds trimmed off if they are 0
to_string_trimmed [Time]
to_string_trimmed t Same as to_string, but removes trailing seconds and milliseconds if they are 0
to_system_int [Signal]
to_time [TZ.Date_time]
time_of_datetime zone datetime returns a time representing the datetime in the given zone.
today [Time.Date]
top [Heap]
top heap
top [Hash_heap.S]
top [Hash_heap.Make]
top [Fqueue]
like top_exn, but returns result optionally, without exception
top [Stack]
top t returns None if t is empty, otherwise it returns Some x where x is the top of t.
top_exn [Heap]
top_exn heap
top_exn [Hash_heap.S]
top_exn [Hash_heap.Make]
top_exn [Fqueue]
Like bot_exn, except returns top (least-recently enqueued element
top_exn [Stack]
top_exn t returns the top element of t, raising Empty if t is empty.
top_heap_el [Heap]
top_heap_el heap
top_heap_el_exn [Heap]
top_heap_el_exn heap
top_with_key [Hash_heap.S]
top_with_key [Hash_heap.Make]
top_with_key_exn [Hash_heap.S]
top_with_key_exn [Hash_heap.Make]
tr [String]
tr target replacement s replaces every instance of target in s with replacement.
tr_inplace [String]
tr_inplace target replacement s destructively modifies s (in place!) replacing every instance of target in s with replacement.
transfer [Doubly_linked]
transfer ~src ~dst has the same behavior as iter src ~f:(insert_last dst); clear src except that it runs in constant time.
transfer [Queue]
transfer ~src ~dst adds all of the elements of src to the end of dst, then clears src.
transfer_queue [Squeue]
Transfers all elements from the squeue to an ordinary queue.
transfer_queue_in [Squeue]
Transfers all the elements from an ordinary queue into the squeue.
transfer_queue_in_uncond [Squeue]
transfer_queue_nowait [Squeue]
Transfers all elements from the squeue to an ordinary queue.
trd3 [Common]
Returns the third element of a triple.
truncate [Std_internal]
truncate [Float]
truncate [Unix.Native_file]
truncate [Unix]
Truncates the named file to the given size.
try_lock [Mutex]
try_lock mtx like lock, but returns immediately with false if the mutex is already being held by another thread, or acquires the mutex and returns true otherwise.
try_lock [Agnostic_mutex]
try_read [Linebuf]
Tries to read a line from the file.
try_read_lnum [Linebuf]
try_read_lnum is like try_read except also provides the line number of the read line.
try_read_lnum_verbose [Linebuf]
Like try_read, except that it returns more verbose errors
trywith [Result]
tstp [Signal]
Interactive stop
ttin [Signal]
Terminal read from background process
ttou [Signal]
Terminal write from background process
tue [Weekday]
tune [Gc]
Adjust the specified GC parameters.

U
ubound [Interval_intf.GenSet.S]
ubound [Interval_intf.Gen.S]
ubound_exn [Interval_intf.GenSet.S]
ubound_exn [Interval_intf.Gen.S]
uig [Quickcheck]
uig [OUnit_utils]
umask [Unix]
Set the process creation mask, and return the previous mask.
uncapitalize [String]
uncurry [Tuple.T3]
uncurry [Tuple.T2]
union [Set_intf.S1]
union [Set_intf.Gen.S]
union [Set_intf.S]
union_list [Set_intf.S1]
union_list [Set_intf.Gen.S]
union_list [Set_intf.S]
unit [Monad.Make]
unit [Memo]
Returns memoized version of any function with argument unit.
unit [Monad.S]
unit = return ()
unix_error [Unix_ext]
unlink [Unix]
Removes the named file
unlock [Mutex]
unlock mtx unlocks mtx.
unlock [Agnostic_mutex]
unpack_float [Binary_packing]
unpack_signed_16 [Binary_packing]
unpack a signed 2 byte int from the given buf starting at pos
unpack_signed_32 [Binary_packing]
unpack a signed 4 byte int32 from the given buf starting at pos
unpack_signed_32_int [Binary_packing]
unpack a signed 4 byte int32 from the given buf starting at pos.
unpack_signed_64 [Binary_packing]
unpack a signed 8 byte int64 from the given buf starting at pos
unpack_signed_64_int [Binary_packing]
unpack a signed 8 byte int from the given buf starting at pos.
unpack_signed_8 [Binary_packing]
unpack_unsigned_8 [Binary_packing]
unpack an unsigned 1 byte int from the given buf starting at pos
unroot [Filename]
unroot ~path f returns f relative to path.
unsafe_blit [Bigstring]
unsafe_blit ~src ~src_pos ~dst ~dst_pos ~len similar to Bigstring.blit, but does not perform any bounds checks.
unsafe_blit_bigstring_string [Bigstring]
unsafe_blit_bigstring_string ~src ~src_pos ~dst ~dst_pos ~len similar to Bigstring.blit_bigstring_string, but does not perform any bounds checks.
unsafe_blit_string_bigstring [Bigstring]
unsafe_blit_string_bigstring ~src ~src_pos ~dst ~dst_pos ~len similar to Bigstring.blit_string_bigstring, but does not perform any bounds checks.
unsafe_destroy [Bigstring]
unsafe_destroy bstr destroys the bigstring by deallocating its associated data or, if memory-mapped, unmapping the corresponding file, and setting all dimensions to zero.
unsafe_get [Array]
unsafe_input [Bigstring]
unsafe_input ~min_len ic ~pos ~len bstr similar to Bigstring.input, but does not perform any bounds checks.
unsafe_of_int [Char]
unsafe_output [Bigstring]
unsafe_output ~min_len oc ~pos ~len bstr similar to Bigstring.output, but does not perform any bounds checks.
unsafe_read [Bigstring]
unsafe_read ~min_len fd ~pos ~len bstr similar to Bigstring.read, but does not perform any bounds checks.
unsafe_read_assume_fd_is_nonblocking [Bigstring]
unsafe_read_assume_fd_is_nonblocking fd ~pos ~len bstr similar to Bigstring.read_assume_fd_is_nonblocking, but does not perform any bounds checks.
unsafe_really_recv [Bigstring]
unsafe_really_recv sock ~pos ~len bstr similar to Bigstring.really_recv, but does not perform any bounds checks.
unsafe_really_send_no_sigpipe [Bigstring]
unsafe_really_send_no_sigpipe sock ~pos ~len bstr similar to Bigstring.send, but does not perform any bounds checks.
unsafe_really_write [Bigstring]
unsafe_really_write fd ~pos ~len bstr similar to Bigstring.write, but does not perform any bounds checks.
unsafe_send_nonblocking_no_sigpipe [Bigstring]
unsafe_send_nonblocking_no_sigpipe sock ~pos ~len bstr similar to Bigstring.send_nonblocking_no_sigpipe, but does not perform any bounds checks.
unsafe_sendmsg_nonblocking_no_sigpipe [Bigstring]
unsafe_sendmsg_nonblocking_no_sigpipe fd iovecs count similar to Bigstring.sendmsg_nonblocking_no_sigpipe, but does not perform any bounds checks.
unsafe_set [Array]
unsafe_tail [Linebuf]
unsafe_write [Bigstring]
unsafe_write fd ~pos ~len bstr similar to Bigstring.write, but does not perform any bounds checks.
unsafe_write_assume_fd_is_nonblocking [Bigstring]
unsafe_write_assume_fd_is_nonblocking fd ~pos ~len bstr similar to Bigstring.write_assume_fd_is_nonblocking, but does not perform any bounds checks.
unsafe_writev [Bigstring]
unsafe_writev fd iovecs count similar to Bigstring.writev, but does not perform any bounds checks.
until_empty [Stack]
until_empty t f repeatedly pops an element v off of t and runs f v until t becomes empty.
until_empty [Bag]
until_empty t f repeatedly removes a value v from t and runs f v, continuing until t is empty.
update [Heap]
update heap_el el updates heap_el with element el in its associated heap.
update_broadcast [Mutex0]
update_broadcast [Mutex]
update_broadcast mtx cnd ~f updates some state within a critical section protected by mutex mtx using function f and broadcasts condition variable cnd after finishing.
update_signal [Mutex0]
update_signal [Mutex]
update_signal mtx cnd ~f updates some state within a critical section protected by mutex mtx using function f and signals condition variable cnd after finishing.
uppercase [String]
uppercase [Char]
usage [Arg]
usr1 [Signal]
Application-defined signal 1
usr2 [Signal]
Application-defined signal 2
utime [Unix_ext.Resource_usage]
utimes [Unix]
Set the last access time (second arg) and last modification time (third arg) for a file.
uw [Common]
unwraps an option, throwing Not_found if it is None

V
value [Option]
value None ~default = default value (Some x) ~default = x
value [Doubly_linked.Elt]
value [Bag.Elt]
value_exn [Option]
value_exn (Some x) = x.
value_exn_message [Option]
value_exn_message message (Some x) = x.
value_map [Option]
value_map None ~default ~f = default value_map (Some x) ~default ~f = f x
vtalrm [Signal]

W
wait [Unix]
Wait until one of the children processes die, and return its pid and termination status.
wait [Condition]
wait_not_empty [Squeue]
wait_not_empty sq Waits for something to be available.
wait_pid [Thread]
wait_pid p suspends the execution of the calling thread until the Unix process specified by the process identifier p terminates.
wait_read [Thread]
wait_signal [Thread]
wait_signal sigs suspends the execution of the calling thread until the process receives one of the signals specified in the list sigs.
wait_timed_read [Thread]
wait_timed_write [Thread]
Same as Thread.wait_read and Thread.wait_write, but wait for at most the amount of time given as second argument (in seconds).
wait_write [Thread]
Suspend the execution of the calling thread until at least one character is available for reading (Thread.wait_read) or one character can be written without blocking (wait_write) on the given Unix file descriptor.
waitpid [Unix]
Same as UnixLabels.wait, but waits for the process whose pid is given.
wed [Weekday]
weekdays_between [Time.Date]
word_size [Word_size]
word_size [Sys]
Size of one word on the machine currently executing the Caml program, in bits: 32 or 64.
wordexp [Unix_ext]
words [Byte_units]
wrap_exn [Option]
wrap_exn f provides an exception-free interface to f.
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 [Bigstring]
write fd ?pos ?len bstr writes len bytes in bigstring bstr starting at position pos to file descriptor fd.
write_assume_fd_is_nonblocking [Unix_ext]
write_assume_fd_is_nonblocking fd ?pos ?len buf calls the system call write ASSUMING THAT IT IS NOT GOING TO BLOCK.
write_assume_fd_is_nonblocking [Bigstring]
write_assume_fd_is_nonblocking fd ?pos ?len bstr writes len bytes in bigstring bstr starting at position pos to file descriptor fd without yielding to other OCaml-threads.
write_lines [Common]
write_lines fname lines writes each string in lines (plus a newlnie) to file fname.
write_only_of_sexp [Common]
write_wrap [Common]
write_wrap ~f fname executes ~f on the open output channel from fname, and closes it afterwards.
writev [Unix_ext]
writev fd ?count iovecs like Unix_ext.writev_assume_fd_is_nonblocking, but does not require the descriptor to not block.
writev [Bigstring]
writev fd ?count iovecs writes count iovecs of bigstrings to file descriptor fd.
writev_assume_fd_is_nonblocking [Unix_ext]
writev_assume_fd_is_nonblocking fd ?count iovecs calls the system call writev ASSUMING THAT IT IS NOT GOING TO BLOCK using count I/O-vectors iovecs.
writev_assume_fd_is_nonblocking [Bigstring]
writev_assume_fd_is_nonblocking fd ?count iovecs writes count iovecs of bigstrings to file descriptor fd without yielding to other OCaml-threads.

Y
year [Time.Date]
yield [Thread]
Re-schedule the calling thread without suspending it.

Z
zero [Time.Span]
zero [Int_intf.S]
zero [Float]
zero [Bucket.Contents]