( * ) [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] |
See
Filename.basename .
|
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
normalize d 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
normalize d 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] | |
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] | |
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] |
See
Thread.wait_write .
|
wait_signal [Thread] | wait_signal sigs suspends the execution of the calling thread
until the process receives one of the signals specified in the
list sigs .
|
wait_timed_read [Thread] | |
wait_timed_write [Thread] |
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] |