( * ) [Int_intf.S] | |
( * ) [Float_intf.S] | |
( * ) [Byte_units.Infix] | |
(!) [Ref] | |
(!=) [Common] | |
(%) [Int.Infix] |
mod and div operators that have the right behavior on negative numbers,
that is,
x % y always returns a value between 0 and y-1.
|
(%:) [Command.Spec] | (name %: typ) specifies a required anonymous argument of type typ .
|
(&) [Common] | |
(+) [Span] |
Basic operations on spans
|
(+) [Int_intf.S] | |
(+) [Float_intf.S] | |
(+) [Flags_intf.S] | |
(+) [Commutative_group.S] | |
(+) [Byte_units.Infix] | |
(+) [Bucket.Contents] | |
(++) [Command.Spec] |
command-line spec composition
|
(+<) [Command.Spec] |
add a leftmost parameter onto the type of main
|
(+>) [Command.Spec] |
add a rightmost parameter onto the type of main
|
(-) [Span] | |
(-) [Int_intf.S] | |
(-) [Float_intf.S] | |
(-) [Flags_intf.S] | |
(-) [Commutative_group.S] | |
(-) [Byte_units.Infix] | |
(-) [Bucket.Contents] | |
(/%) [Int.Infix] | |
(/) [Span] | |
(/) [Int_intf.S] | |
(/) [Float_intf.S] | |
(/) [Byte_units.Infix] | |
(//) [Span] | |
(//) [Int.Infix] |
float division of integers
|
(:=) [Ref] | |
(<) [Polymorphic_compare] | |
(<) [No_polymorphic_compare] | |
(<) [Polymorphic_compare_intf.Infix] | |
(<) [Comparable.Make_common.Replace_polymorphic_compare] | |
(<.) [Robustly_comparable.S] | |
(</>) [String.Infix] | |
(<=) [Polymorphic_compare] | |
(<=) [No_polymorphic_compare] | |
(<=) [Polymorphic_compare_intf.Infix] | |
(<=) [Comparable.Make_common.Replace_polymorphic_compare] | |
(<=.) [Robustly_comparable.S] | |
(<>) [Polymorphic_compare] | |
(<>) [No_polymorphic_compare] | |
(<>) [Polymorphic_compare_intf.Infix] | |
(<>) [Comparable.Make_common.Replace_polymorphic_compare] | |
(<>.) [Robustly_comparable.S] | |
(<|>) [Array.Infix] | |
(=) [Polymorphic_compare] | |
(=) [No_polymorphic_compare] | |
(=) [Polymorphic_compare_intf.Infix] | |
(=) [Comparable.Make_common.Replace_polymorphic_compare] | |
(=.) [Robustly_comparable.S] | |
(==) [Common] | |
(==>) [Common] | |
(>) [Polymorphic_compare] | |
(>) [No_polymorphic_compare] | |
(>) [Polymorphic_compare_intf.Infix] | |
(>) [Comparable.Make_common.Replace_polymorphic_compare] | |
(>.) [Robustly_comparable.S] | |
(>=) [Polymorphic_compare] | |
(>=) [No_polymorphic_compare] | |
(>=) [Polymorphic_compare_intf.Infix] | |
(>=) [Comparable.Make_common.Replace_polymorphic_compare] | |
(>=.) [Robustly_comparable.S] | |
(>>=) [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
|
(|!) [Fn] |
A 'pipe' operator.
|
(|!) [Common] |
Functions from function.ml
|
__Pa_ounit_b11b1370174a4540cf9e67839ea5dff5_test_list_1 [Stable.Unit_tests] | |
__Pa_ounit_b11b1370174a4540cf9e67839ea5dff5_test_list_2 [Stable] | |
_squelch_unused_module_warning_ [Std] | |
_squelch_unused_module_warning_ [No_polymorphic_compare] | |
A | |
abbreviation [Zone] | abbreviation zone t returns t abbreviation name such as EDT, EST, JST of given
zone at the time t .
|
abort [Unix] | |
abrt [Signal] |
| Dump_core | Abnormal termination |
|
abs [Span] |
absolute value
|
abs [Int_intf.S] | |
abs [Float_intf.S] | |
abs_diff [Time_internal.T] | |
abs_diff [Time] | abs_diff t1 t2 returns the absolute span of time t1 minus time t2 .
|
abs_float [Common] | |
accept [Unix] |
Accept connections on the given socket.
|
access [Unix] |
Check that the process has the given permissions over the named file.
|
access_exn [Unix] | |
ad_hoc [Command.Deprecated.Spec] | |
add [Time_internal.T] | |
add [Time] | add t s adds the span s to time t and returns the resulting time.
|
add [Univ_map.Multi] | |
add [Univ_map.With_fold] | |
add [Univ_map] | |
add [Timer] | add timer handler ?randomize ?interval span
|
add [Ofday] | add t s shifts the time of day t by the span s .
|
add [Int_set] | add t i add i to the set
|
add [Hash_set_intf.Accessors] | |
add [Float_intf.S] | |
add [Unix.Resource_usage] | add ru1 ru2 adds two rusage structures (e.g.
|
add [Core_set_intf.Accessors] | |
add [Core_map_intf.Accessors] |
returns a new map with the specified new binding;
if the key was already bound, its previous binding disappears.
|
add [List.Assoc] | |
add [Core_hashtbl_intf.Accessors] | |
add [Bounded_int_table] | |
add [Bag] | add t v adds v to the bag t , returning an element that can
later be removed from the bag.
|
add [Avltree] |
adds the specified key and data to the tree destructively (previous t's are no longer
valid) using the specified comparison function.
|
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 [Date] | add_business_days t ~is_holiday n returns a business day even when
n=0 .
|
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 [Date] | |
add_exn [Univ_map] | |
add_exn [Core_hashtbl_intf.Accessors] | |
add_exn [Bounded_int_table] | |
add_finalizer [Gc] | add_finalizer b f ensures that f runs after b becomes unreachable.
|
add_finalizer_exn [Gc] | |
add_months [Date] | add_months t n returns date with max days for the month if the date would be
invalid.
|
add_multi [Core_map_intf.Accessors] |
if key is not present then add a singleton list, otherwise, cons data
on the head of the existing list.
|
add_multi [Core_hashtbl_intf.Accessors] | add_multi t ~key ~data if key is present in the table then cons
data on the list, otherwise add key with a single element list.
|
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_weekdays [Date] | add_weekdays t 0 returns the next weekday if t is a weekend and t otherwise.
|
addr_info_of_sexp [Unix] |
Address information returned by
Unix.getaddrinfo .
|
alarm [Unix] |
Schedule a
SIGALRM signal after the given number of seconds.
|
align [Arg] |
Align the documentation strings by inserting spaces at the first
space, according to the length of the keyword.
|
all [Pretty_printer] | |
all [Month] | |
all [Monad.S2] | |
all [Monad.Make2] | |
all [Monad.Make] | |
all [Monad.S] | |
all_ignore [Monad.S2] | |
all_ignore [Monad.Make2] | |
all_ignore [Monad.Make] | |
all_ignore [Monad.S] | |
allocated_bytes [Gc] |
Return the total number of bytes allocated since the program was
started.
|
allocation_policy [Gc.Control.Fields] | |
allocation_policy [Gc.Control] | |
alrm [Signal] |
| Terminate | Timeout |
|
always [Quickcheck] |
generator that always returns given value
|
am_holding_mutex [Mutex0] | |
am_holding_mutex [Mutex] | |
am_recording [Backtrace.Exn] | |
and_ [Blang] | |
anon [Command.Spec] | anon spec specifies a command that, among other things, takes
the anonymous arguments specified by spec .
|
append [List] |
E.g.
|
append [Array] | Array.append v1 v2 returns a fresh array containing the
concatenation of the arrays v1 and v2 .
|
apply [Result] | |
apply [Option] | apply x f run optional function on argument and return an option
|
apply_n_times [Fn] | apply_n_times ~n f x is the n -fold application of f to x .
|
are_disjoint [Interval_intf.Gen] |
Returns true iff a given set of intervals are disjoint
|
are_disjoint [Flags_intf.S] | |
are_disjoint_as_open_intervals [Interval_intf.Gen] |
Returns true iff a given set of intervals would be disjoint if considered as open
intervals.
|
args [Command.Spec] |
the arguments passed to the command
|
argv [Sys] |
The command line arguments given to the process.
|
array_of_sexp [Std_internal] | |
ascending [Comparable.S_common] | |
ascending [Comparable.Make_common] | |
ascending [Comparable.Poly] | |
ascending [Common] |
A comparator that returns results in ascending order.
|
B | |
back_index [Dequeue] | |
backtrace [Exn] | Printexc.get_backtrace
|
backtrace_status [Printexc] | |
base [Substring_intf.S] | |
base [Make_substring.F] | |
base [Blang] | |
basename [Filename] |
Respects the posix semantic.
|
basic [Command] | basic ~summary ?readme spec main is a basic command that executes a function main
which is passed parameters parsed from the command line according to spec .
|
between [Comparable.S_common] | |
between [Comparable.Make_common] | |
between [Comparable.Poly] | |
big_contents [Bigbuffer] |
Return a copy of the current contents of the buffer as a bigstring.
|
bigstring_bigstring [Make_substring.Blit] | |
bigstring_kind [Unix.IOVec] | |
bigstring_string [Make_substring.Blit] | |
bin_decimal [Common] | |
bin_immutable [Common] | |
bin_no_raise [Sexp] | |
bin_outer [Float_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_no_raise [Sexp] | |
bin_read_no_raise_ [Sexp] | |
bin_read_no_raise__ [Sexp] | |
bin_read_only [Common] | |
bin_read_outer [Float_intf.S] | |
bin_read_outer_ [Float_intf.S] | |
bin_read_outer__ [Float_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_array [Std_internal] | |
bin_read_sexp_array_ [Std_internal] | |
bin_read_sexp_array__ [Std_internal] | |
bin_read_sexp_bool [Std_internal] | |
bin_read_sexp_bool_ [Std_internal] | |
bin_read_sexp_bool__ [Std_internal] | |
bin_read_sexp_list [Std_internal] | |
bin_read_sexp_list_ [Std_internal] | |
bin_read_sexp_list__ [Std_internal] | |
bin_read_sexp_opaque [Std_internal] | |
bin_read_sexp_opaque_ [Std_internal] | |
bin_read_sexp_opaque__ [Std_internal] | |
bin_read_sexp_option [Std_internal] | |
bin_read_sexp_option [Stable_internal] | |
bin_read_sexp_option_ [Std_internal] | |
bin_read_sexp_option_ [Stable_internal] | |
bin_read_sexp_option__ [Std_internal] | |
bin_read_sexp_option__ [Stable_internal] | |
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_t [Time] | |
bin_read_t [Weekday] | |
bin_read_t [Unique_id_intf.Id] | |
bin_read_t [Zone] | |
bin_read_t [Stable_internal.Sexp] | |
bin_read_t [Stable_containers.Map.V1] | |
bin_read_t [Stable_containers.Hash_set.V1] | |
bin_read_t [Stable_containers.Hashtbl.V1] | |
bin_read_t [Stable_containers.Set.V1] | |
bin_read_t [Zone.Stable.V1] | |
bin_read_t [Weekday.Stable.V1] | |
bin_read_t [Time.Stable.V1] | |
bin_read_t [String_id.Stable.V1] | |
bin_read_t [Span.Stable.V1] | |
bin_read_t [Span] | |
bin_read_t [Source_code_position0] | |
bin_read_t [Source_code_position] | |
bin_read_t [Signal] | |
bin_read_t [Stable_unit_test_intf.Arg] | |
bin_read_t [Result.Stable.V1] | |
bin_read_t [Result] | |
bin_read_t [Ref] | |
bin_read_t [Piecewise_linear.Key] | |
bin_read_t [Piecewise_linear.S] | |
bin_read_t [Pid] | |
bin_read_t [Or_error] | |
bin_read_t [Ordering] | |
bin_read_t [Ofday.Stable.V1] | |
bin_read_t [Ofday] | |
bin_read_t [Month.Stable.V1] | |
bin_read_t [Month] | |
bin_read_t [Linux_ext.Sysinfo] | |
bin_read_t [Int_intf.S] | |
bin_read_t [Interval_intf.S.Set] | |
bin_read_t [Interval_intf.S] | |
bin_read_t [Interval_intf.S1.Set] | |
bin_read_t [Interval_intf.S1] | |
bin_read_t [Interval.Stable.V1.Ofday] | |
bin_read_t [Interval.Stable.V1.Int] | |
bin_read_t [Interval.Stable.V1.Float] | |
bin_read_t [Info] | |
bin_read_t [Identifiable.S] | |
bin_read_t [T.T_bin] | |
bin_read_t [Fqueue] | |
bin_read_t [Float_intf.S.Terse] | |
bin_read_t [Float_intf.S.Class] | |
bin_read_t [Dequeue] | |
bin_read_t [Date.Stable.V1] | |
bin_read_t [Date] | |
bin_read_t [Unix.Inet_addr] | |
bin_read_t [Unix.Protocol_family] | |
bin_read_t [Unix.File_descr] | |
bin_read_t [String] | |
bin_read_t [Stack] | |
bin_read_t [Sexp.Sexp_maybe] | |
bin_read_t [Sexp.Sexp_opaque] | |
bin_read_t [Sexp.Sexp_array] | |
bin_read_t [Sexp.Sexp_list] | |
bin_read_t [Sexp.Sexp_option] | |
bin_read_t [Sexp] | |
bin_read_t [Set.Poly] | |
bin_read_t [Queue] | |
bin_read_t [Map.Poly] | |
bin_read_t [List] | |
bin_read_t [Lazy] | |
bin_read_t [Core_hashtbl_intf.Key_binable] | |
bin_read_t [Hashtbl.Poly] | |
bin_read_t [Gc.Control] | |
bin_read_t [Gc.Stat] | |
bin_read_t [Char] | |
bin_read_t [Array] | |
bin_read_t [Constrained_float.S] | |
bin_read_t [Comparator.Pre_binable] | |
bin_read_t [Byte_units.Measure] | |
bin_read_t [Byte_units] | |
bin_read_t [Bucket.S] | |
bin_read_t [Bucket.Contents] | |
bin_read_t [Bucket.Make] | |
bin_read_t [Bounded_int_table.With_key] | |
bin_read_t [Bool] | |
bin_read_t [Blang.Stable.V1] | |
bin_read_t [Blang] | |
bin_read_t [Bigstring] | |
bin_read_t_ [Time] | |
bin_read_t_ [Weekday] | |
bin_read_t_ [Unique_id_intf.Id] | |
bin_read_t_ [Zone] | |
bin_read_t_ [Stable_internal.Sexp] | |
bin_read_t_ [Stable_containers.Map.V1] | |
bin_read_t_ [Stable_containers.Hash_set.V1] | |
bin_read_t_ [Stable_containers.Hashtbl.V1] | |
bin_read_t_ [Stable_containers.Set.V1] | |
bin_read_t_ [Zone.Stable.V1] | |
bin_read_t_ [Weekday.Stable.V1] | |
bin_read_t_ [Time.Stable.V1] | |
bin_read_t_ [String_id.Stable.V1] | |
bin_read_t_ [Span.Stable.V1] | |
bin_read_t_ [Span] | |
bin_read_t_ [Source_code_position0] | |
bin_read_t_ [Source_code_position] | |
bin_read_t_ [Signal] | |
bin_read_t_ [Stable_unit_test_intf.Arg] | |
bin_read_t_ [Result.Stable.V1] | |
bin_read_t_ [Result] | |
bin_read_t_ [Ref] | |
bin_read_t_ [Piecewise_linear.Key] | |
bin_read_t_ [Piecewise_linear.S] | |
bin_read_t_ [Pid] | |
bin_read_t_ [Or_error] | |
bin_read_t_ [Ordering] | |
bin_read_t_ [Ofday.Stable.V1] | |
bin_read_t_ [Ofday] | |
bin_read_t_ [Month.Stable.V1] | |
bin_read_t_ [Month] | |
bin_read_t_ [Linux_ext.Sysinfo] | |
bin_read_t_ [Int_intf.S] | |
bin_read_t_ [Interval_intf.S.Set] | |
bin_read_t_ [Interval_intf.S] | |
bin_read_t_ [Interval_intf.S1.Set] | |
bin_read_t_ [Interval_intf.S1] | |
bin_read_t_ [Interval.Stable.V1.Ofday] | |
bin_read_t_ [Interval.Stable.V1.Int] | |
bin_read_t_ [Interval.Stable.V1.Float] | |
bin_read_t_ [Info] | |
bin_read_t_ [Identifiable.S] | |
bin_read_t_ [T.T_bin] | |
bin_read_t_ [Fqueue] | |
bin_read_t_ [Float_intf.S.Terse] | |
bin_read_t_ [Float_intf.S.Class] | |
bin_read_t_ [Dequeue] | |
bin_read_t_ [Date.Stable.V1] | |
bin_read_t_ [Date] | |
bin_read_t_ [Unix.Inet_addr] | |
bin_read_t_ [Unix.Protocol_family] | |
bin_read_t_ [Unix.File_descr] | |
bin_read_t_ [String] | |
bin_read_t_ [Stack] | |
bin_read_t_ [Sexp.Sexp_maybe] | |
bin_read_t_ [Sexp.Sexp_opaque] | |
bin_read_t_ [Sexp.Sexp_array] | |
bin_read_t_ [Sexp.Sexp_list] | |
bin_read_t_ [Sexp.Sexp_option] | |
bin_read_t_ [Sexp] | |
bin_read_t_ [Set.Poly] | |
bin_read_t_ [Queue] | |
bin_read_t_ [Map.Poly] | |
bin_read_t_ [List] | |
bin_read_t_ [Lazy] | |
bin_read_t_ [Core_hashtbl_intf.Key_binable] | |
bin_read_t_ [Hashtbl.Poly] | |
bin_read_t_ [Gc.Control] | |
bin_read_t_ [Gc.Stat] | |
bin_read_t_ [Char] | |
bin_read_t_ [Array] | |
bin_read_t_ [Constrained_float.S] | |
bin_read_t_ [Comparator.Pre_binable] | |
bin_read_t_ [Byte_units.Measure] | |
bin_read_t_ [Byte_units] | |
bin_read_t_ [Bucket.S] | |
bin_read_t_ [Bucket.Contents] | |
bin_read_t_ [Bucket.Make] | |
bin_read_t_ [Bounded_int_table.With_key] | |
bin_read_t_ [Bool] | |
bin_read_t_ [Blang.Stable.V1] | |
bin_read_t_ [Blang] | |
bin_read_t_ [Bigstring] | |
bin_read_t__ [Time] | |
bin_read_t__ [Weekday] | |
bin_read_t__ [Unique_id_intf.Id] | |
bin_read_t__ [Zone] | |
bin_read_t__ [Stable_internal.Sexp] | |
bin_read_t__ [Stable_containers.Map.V1] | |
bin_read_t__ [Stable_containers.Hash_set.V1] | |
bin_read_t__ [Stable_containers.Hashtbl.V1] | |
bin_read_t__ [Stable_containers.Set.V1] | |
bin_read_t__ [Zone.Stable.V1] | |
bin_read_t__ [Weekday.Stable.V1] | |
bin_read_t__ [Time.Stable.V1] | |
bin_read_t__ [String_id.Stable.V1] | |
bin_read_t__ [Span.Stable.V1] | |
bin_read_t__ [Span] | |
bin_read_t__ [Source_code_position0] | |
bin_read_t__ [Source_code_position] | |
bin_read_t__ [Signal] | |
bin_read_t__ [Stable_unit_test_intf.Arg] | |
bin_read_t__ [Result.Stable.V1] | |
bin_read_t__ [Result] | |
bin_read_t__ [Ref] | |
bin_read_t__ [Piecewise_linear.Key] | |
bin_read_t__ [Piecewise_linear.S] | |
bin_read_t__ [Pid] | |
bin_read_t__ [Or_error] | |
bin_read_t__ [Ordering] | |
bin_read_t__ [Ofday.Stable.V1] | |
bin_read_t__ [Ofday] | |
bin_read_t__ [Month.Stable.V1] | |
bin_read_t__ [Month] | |
bin_read_t__ [Linux_ext.Sysinfo] | |
bin_read_t__ [Int_intf.S] | |
bin_read_t__ [Interval_intf.S.Set] | |
bin_read_t__ [Interval_intf.S] | |
bin_read_t__ [Interval_intf.S1.Set] | |
bin_read_t__ [Interval_intf.S1] | |
bin_read_t__ [Interval.Stable.V1.Ofday] | |
bin_read_t__ [Interval.Stable.V1.Int] | |
bin_read_t__ [Interval.Stable.V1.Float] | |
bin_read_t__ [Info] | |
bin_read_t__ [Identifiable.S] | |
bin_read_t__ [T.T_bin] | |
bin_read_t__ [Fqueue] | |
bin_read_t__ [Float_intf.S.Terse] | |
bin_read_t__ [Float_intf.S.Class] | |
bin_read_t__ [Dequeue] | |
bin_read_t__ [Date.Stable.V1] | |
bin_read_t__ [Date] | |
bin_read_t__ [Unix.Inet_addr] | |
bin_read_t__ [Unix.Protocol_family] | |
bin_read_t__ [Unix.File_descr] | |
bin_read_t__ [String] | |
bin_read_t__ [Stack] | |
bin_read_t__ [Sexp.Sexp_maybe] | |
bin_read_t__ [Sexp.Sexp_opaque] | |
bin_read_t__ [Sexp.Sexp_array] | |
bin_read_t__ [Sexp.Sexp_list] | |
bin_read_t__ [Sexp.Sexp_option] | |
bin_read_t__ [Sexp] | |
bin_read_t__ [Set.Poly] | |
bin_read_t__ [Queue] | |
bin_read_t__ [Map.Poly] | |
bin_read_t__ [List] | |
bin_read_t__ [Lazy] | |
bin_read_t__ [Core_hashtbl_intf.Key_binable] | |
bin_read_t__ [Hashtbl.Poly] | |
bin_read_t__ [Gc.Control] | |
bin_read_t__ [Gc.Stat] | |
bin_read_t__ [Char] | |
bin_read_t__ [Array] | |
bin_read_t__ [Constrained_float.S] | |
bin_read_t__ [Comparator.Pre_binable] | |
bin_read_t__ [Byte_units.Measure] | |
bin_read_t__ [Byte_units] | |
bin_read_t__ [Bucket.S] | |
bin_read_t__ [Bucket.Contents] | |
bin_read_t__ [Bucket.Make] | |
bin_read_t__ [Bounded_int_table.With_key] | |
bin_read_t__ [Bool] | |
bin_read_t__ [Blang.Stable.V1] | |
bin_read_t__ [Blang] | |
bin_read_t__ [Bigstring] | |
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_reader_decimal [Common] | |
bin_reader_immutable [Common] | |
bin_reader_no_raise [Sexp] | |
bin_reader_outer [Float_intf.S] | |
bin_reader_read_only [Common] | |
bin_reader_read_write [Common] | |
bin_reader_sexp_array [Std_internal] | |
bin_reader_sexp_bool [Std_internal] | |
bin_reader_sexp_list [Std_internal] | |
bin_reader_sexp_opaque [Std_internal] | |
bin_reader_sexp_option [Std_internal] | |
bin_reader_sexp_option [Stable_internal] | |
bin_reader_sockaddr [Unix] | |
bin_reader_socket_domain [Unix] | |
bin_reader_socket_type [Unix] | |
bin_reader_t [Time] | |
bin_reader_t [Weekday] | |
bin_reader_t [Unique_id_intf.Id] | |
bin_reader_t [Zone] | |
bin_reader_t [Stable_internal.Sexp] | |
bin_reader_t [Stable_containers.Map.V1] | |
bin_reader_t [Stable_containers.Hash_set.V1] | |
bin_reader_t [Stable_containers.Hashtbl.V1] | |
bin_reader_t [Stable_containers.Set.V1] | |
bin_reader_t [Zone.Stable.V1] | |
bin_reader_t [Weekday.Stable.V1] | |
bin_reader_t [Time.Stable.V1] | |
bin_reader_t [String_id.Stable.V1] | |
bin_reader_t [Span.Stable.V1] | |
bin_reader_t [Span] | |
bin_reader_t [Source_code_position0] | |
bin_reader_t [Source_code_position] | |
bin_reader_t [Signal] | |
bin_reader_t [Stable_unit_test_intf.Arg] | |
bin_reader_t [Result.Stable.V1] | |
bin_reader_t [Result] | |
bin_reader_t [Ref] | |
bin_reader_t [Piecewise_linear.Key] | |
bin_reader_t [Piecewise_linear.S] | |
bin_reader_t [Pid] | |
bin_reader_t [Or_error] | |
bin_reader_t [Ordering] | |
bin_reader_t [Ofday.Stable.V1] | |
bin_reader_t [Ofday] | |
bin_reader_t [Month.Stable.V1] | |
bin_reader_t [Month] | |
bin_reader_t [Linux_ext.Sysinfo] | |
bin_reader_t [Int_intf.S] | |
bin_reader_t [Interval_intf.S.Set] | |
bin_reader_t [Interval_intf.S] | |
bin_reader_t [Interval_intf.S1.Set] | |
bin_reader_t [Interval_intf.S1] | |
bin_reader_t [Interval.Stable.V1.Ofday] | |
bin_reader_t [Interval.Stable.V1.Int] | |
bin_reader_t [Interval.Stable.V1.Float] | |
bin_reader_t [Info] | |
bin_reader_t [Identifiable.S] | |
bin_reader_t [T.T_bin] | |
bin_reader_t [Fqueue] | |
bin_reader_t [Float_intf.S.Terse] | |
bin_reader_t [Float_intf.S.Class] | |
bin_reader_t [Dequeue] | |
bin_reader_t [Date.Stable.V1] | |
bin_reader_t [Date] | |
bin_reader_t [Unix.Inet_addr] | |
bin_reader_t [Unix.Protocol_family] | |
bin_reader_t [Unix.File_descr] | |
bin_reader_t [String] | |
bin_reader_t [Stack] | |
bin_reader_t [Sexp.Sexp_maybe] | |
bin_reader_t [Sexp.Sexp_opaque] | |
bin_reader_t [Sexp.Sexp_array] | |
bin_reader_t [Sexp.Sexp_list] | |
bin_reader_t [Sexp.Sexp_option] | |
bin_reader_t [Sexp] | |
bin_reader_t [Set.Poly] | |
bin_reader_t [Queue] | |
bin_reader_t [Map.Poly] | |
bin_reader_t [List] | |
bin_reader_t [Lazy] | |
bin_reader_t [Core_hashtbl_intf.Key_binable] | |
bin_reader_t [Hashtbl.Poly] | |
bin_reader_t [Gc.Control] | |
bin_reader_t [Gc.Stat] | |
bin_reader_t [Char] | |
bin_reader_t [Array] | |
bin_reader_t [Constrained_float.S] | |
bin_reader_t [Comparator.Pre_binable] | |
bin_reader_t [Byte_units.Measure] | |
bin_reader_t [Byte_units] | |
bin_reader_t [Bucket.S] | |
bin_reader_t [Bucket.Contents] | |
bin_reader_t [Bucket.Make] | |
bin_reader_t [Bounded_int_table.With_key] | |
bin_reader_t [Bool] | |
bin_reader_t [Blang.Stable.V1] | |
bin_reader_t [Blang] | |
bin_reader_t [Bigstring] | |
bin_reader_tcp_bool_option [Linux_ext] | |
bin_sexp_array [Std_internal] | |
bin_sexp_bool [Std_internal] | |
bin_sexp_list [Std_internal] | |
bin_sexp_opaque [Std_internal] | |
bin_sexp_option [Std_internal] | |
bin_sexp_option [Stable_internal] | |
bin_size_decimal [Common] | |
bin_size_immutable [Common] | |
bin_size_no_raise [Sexp] | |
bin_size_outer [Float_intf.S] | |
bin_size_read_only [Common] | |
bin_size_read_write [Common] | |
bin_size_sexp_array [Std_internal] | |
bin_size_sexp_bool [Std_internal] | |
bin_size_sexp_list [Std_internal] | |
bin_size_sexp_opaque [Std_internal] | |
bin_size_sexp_option [Std_internal] | |
bin_size_sexp_option [Stable_internal] | |
bin_size_sockaddr [Unix] | |
bin_size_socket_domain [Unix] | |
bin_size_socket_type [Unix] | |
bin_size_t [Time] | |
bin_size_t [Weekday] | |
bin_size_t [Unique_id_intf.Id] | |
bin_size_t [Zone] | |
bin_size_t [Stable_internal.Sexp] | |
bin_size_t [Stable_containers.Map.V1] | |
bin_size_t [Stable_containers.Hash_set.V1] | |
bin_size_t [Stable_containers.Hashtbl.V1] | |
bin_size_t [Stable_containers.Set.V1] | |
bin_size_t [Zone.Stable.V1] | |
bin_size_t [Weekday.Stable.V1] | |
bin_size_t [Time.Stable.V1] | |
bin_size_t [String_id.Stable.V1] | |
bin_size_t [Span.Stable.V1] | |
bin_size_t [Span] | |
bin_size_t [Source_code_position0] | |
bin_size_t [Source_code_position] | |
bin_size_t [Signal] | |
bin_size_t [Stable_unit_test_intf.Arg] | |
bin_size_t [Result.Stable.V1] | |
bin_size_t [Result] | |
bin_size_t [Ref] | |
bin_size_t [Piecewise_linear.Key] | |
bin_size_t [Piecewise_linear.S] | |
bin_size_t [Pid] | |
bin_size_t [Or_error] | |
bin_size_t [Ordering] | |
bin_size_t [Ofday.Stable.V1] | |
bin_size_t [Ofday] | |
bin_size_t [Month.Stable.V1] | |
bin_size_t [Month] | |
bin_size_t [Linux_ext.Sysinfo] | |
bin_size_t [Int_intf.S] | |
bin_size_t [Interval_intf.S.Set] | |
bin_size_t [Interval_intf.S] | |
bin_size_t [Interval_intf.S1.Set] | |
bin_size_t [Interval_intf.S1] | |
bin_size_t [Interval.Stable.V1.Ofday] | |
bin_size_t [Interval.Stable.V1.Int] | |
bin_size_t [Interval.Stable.V1.Float] | |
bin_size_t [Info] | |
bin_size_t [Identifiable.S] | |
bin_size_t [T.T_bin] | |
bin_size_t [Fqueue] | |
bin_size_t [Float_intf.S.Terse] | |
bin_size_t [Float_intf.S.Class] | |
bin_size_t [Dequeue] | |
bin_size_t [Date.Stable.V1] | |
bin_size_t [Date] | |
bin_size_t [Unix.Inet_addr] | |
bin_size_t [Unix.Protocol_family] | |
bin_size_t [Unix.File_descr] | |
bin_size_t [String] | |
bin_size_t [Stack] | |
bin_size_t [Sexp.Sexp_maybe] | |
bin_size_t [Sexp.Sexp_opaque] | |
bin_size_t [Sexp.Sexp_array] | |
bin_size_t [Sexp.Sexp_list] | |
bin_size_t [Sexp.Sexp_option] | |
bin_size_t [Sexp] | |
bin_size_t [Set.Poly] | |
bin_size_t [Queue] | |
bin_size_t [Map.Poly] | |
bin_size_t [List] | |
bin_size_t [Lazy] | |
bin_size_t [Core_hashtbl_intf.Key_binable] | |
bin_size_t [Hashtbl.Poly] | |
bin_size_t [Gc.Control] | |
bin_size_t [Gc.Stat] | |
bin_size_t [Char] | |
bin_size_t [Array] | |
bin_size_t [Constrained_float.S] | |
bin_size_t [Comparator.Pre_binable] | |
bin_size_t [Byte_units.Measure] | |
bin_size_t [Byte_units] | |
bin_size_t [Bucket.S] | |
bin_size_t [Bucket.Contents] | |
bin_size_t [Bucket.Make] | |
bin_size_t [Bounded_int_table.With_key] | |
bin_size_t [Bool] | |
bin_size_t [Blang.Stable.V1] | |
bin_size_t [Blang] | |
bin_size_t [Bigstring] | |
bin_size_tcp_bool_option [Linux_ext] | |
bin_sockaddr [Unix] |
The type of socket addresses.
|
bin_socket_domain [Unix] |
The type of socket domains.
|
bin_socket_type [Unix] |
The type of socket kinds, specifying the semantics of
communications.
|
bin_t [Time] | |
bin_t [Weekday] | |
bin_t [Unique_id_intf.Id] | |
bin_t [Zone] | |
bin_t [Stable_internal.Sexp] | |
bin_t [Stable_containers.Map.V1] | |
bin_t [Stable_containers.Hash_set.V1] | |
bin_t [Stable_containers.Hashtbl.V1] | |
bin_t [Stable_containers.Set.V1] | |
bin_t [Zone.Stable.V1] | |
bin_t [Weekday.Stable.V1] | |
bin_t [Time.Stable.V1] | |
bin_t [String_id.Stable.V1] | |
bin_t [Span.Stable.V1] | |
bin_t [Span] | |
bin_t [Source_code_position0] | |
bin_t [Source_code_position] | |
bin_t [Signal] | |
bin_t [Stable_unit_test_intf.Arg] | |
bin_t [Result.Stable.V1] | |
bin_t [Result] | |
bin_t [Ref] | |
bin_t [Piecewise_linear.Key] | |
bin_t [Piecewise_linear.S] | |
bin_t [Pid] | |
bin_t [Or_error] | |
bin_t [Ordering] | |
bin_t [Ofday.Stable.V1] | |
bin_t [Ofday] | |
bin_t [Month.Stable.V1] | |
bin_t [Month] | |
bin_t [Linux_ext.Sysinfo] | |
bin_t [Int_intf.S] | |
bin_t [Interval_intf.S.Set] | |
bin_t [Interval_intf.S] | |
bin_t [Interval_intf.S1.Set] | |
bin_t [Interval_intf.S1] | |
bin_t [Interval.Stable.V1.Ofday] | |
bin_t [Interval.Stable.V1.Int] | |
bin_t [Interval.Stable.V1.Float] | |
bin_t [Info] | |
bin_t [Identifiable.S] | |
bin_t [T.T_bin] | |
bin_t [Fqueue] | |
bin_t [Float_intf.S.Terse] | |
bin_t [Float_intf.S.Class] | |
bin_t [Dequeue] | |
bin_t [Date.Stable.V1] | |
bin_t [Date] | |
bin_t [Unix.Inet_addr] | |
bin_t [Unix.Protocol_family] | |
bin_t [Unix.File_descr] | |
bin_t [String] | |
bin_t [Stack] | |
bin_t [Sexp.Sexp_maybe] | |
bin_t [Sexp.Sexp_opaque] | |
bin_t [Sexp.Sexp_array] | |
bin_t [Sexp.Sexp_list] | |
bin_t [Sexp.Sexp_option] | |
bin_t [Sexp] | |
bin_t [Set.Poly] | |
bin_t [Queue] | |
bin_t [Map.Poly] | |
bin_t [List] | |
bin_t [Lazy] | |
bin_t [Core_hashtbl_intf.Key_binable] | |
bin_t [Hashtbl.Poly] | |
bin_t [Gc.Control] | |
bin_t [Gc.Stat] | |
bin_t [Char] | |
bin_t [Array] | |
bin_t [Constrained_float.S] | |
bin_t [Comparator.Pre_binable] | |
bin_t [Byte_units.Measure] | |
bin_t [Byte_units] | |
bin_t [Bucket.S] | |
bin_t [Bucket.Contents] | |
bin_t [Bucket.Make] | |
bin_t [Bounded_int_table.With_key] | |
bin_t [Bool] | |
bin_t [Blang.Stable.V1] | |
bin_t [Blang] | |
bin_t [Bigstring] | |
bin_tcp_bool_option [Linux_ext] | |
bin_write_decimal [Common] | |
bin_write_decimal_ [Common] | |
bin_write_immutable [Common] | |
bin_write_immutable_ [Common] | |
bin_write_no_raise [Sexp] | |
bin_write_no_raise_ [Sexp] | |
bin_write_outer [Float_intf.S] | |
bin_write_outer_ [Float_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_array [Std_internal] | |
bin_write_sexp_array_ [Std_internal] | |
bin_write_sexp_bool [Std_internal] | |
bin_write_sexp_bool_ [Std_internal] | |
bin_write_sexp_list [Std_internal] | |
bin_write_sexp_list_ [Std_internal] | |
bin_write_sexp_opaque [Std_internal] | |
bin_write_sexp_opaque_ [Std_internal] | |
bin_write_sexp_option [Std_internal] | |
bin_write_sexp_option [Stable_internal] | |
bin_write_sexp_option_ [Std_internal] | |
bin_write_sexp_option_ [Stable_internal] | |
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_t [Time] | |
bin_write_t [Weekday] | |
bin_write_t [Unique_id_intf.Id] | |
bin_write_t [Zone] | |
bin_write_t [Stable_internal.Sexp] | |
bin_write_t [Stable_containers.Map.V1] | |
bin_write_t [Stable_containers.Hash_set.V1] | |
bin_write_t [Stable_containers.Hashtbl.V1] | |
bin_write_t [Stable_containers.Set.V1] | |
bin_write_t [Zone.Stable.V1] | |
bin_write_t [Weekday.Stable.V1] | |
bin_write_t [Time.Stable.V1] | |
bin_write_t [String_id.Stable.V1] | |
bin_write_t [Span.Stable.V1] | |
bin_write_t [Span] | |
bin_write_t [Source_code_position0] | |
bin_write_t [Source_code_position] | |
bin_write_t [Signal] | |
bin_write_t [Stable_unit_test_intf.Arg] | |
bin_write_t [Result.Stable.V1] | |
bin_write_t [Result] | |
bin_write_t [Ref] | |
bin_write_t [Piecewise_linear.Key] | |
bin_write_t [Piecewise_linear.S] | |
bin_write_t [Pid] | |
bin_write_t [Or_error] | |
bin_write_t [Ordering] | |
bin_write_t [Ofday.Stable.V1] | |
bin_write_t [Ofday] | |
bin_write_t [Month.Stable.V1] | |
bin_write_t [Month] | |
bin_write_t [Linux_ext.Sysinfo] | |
bin_write_t [Int_intf.S] | |
bin_write_t [Interval_intf.S.Set] | |
bin_write_t [Interval_intf.S] | |
bin_write_t [Interval_intf.S1.Set] | |
bin_write_t [Interval_intf.S1] | |
bin_write_t [Interval.Stable.V1.Ofday] | |
bin_write_t [Interval.Stable.V1.Int] | |
bin_write_t [Interval.Stable.V1.Float] | |
bin_write_t [Info] | |
bin_write_t [Identifiable.S] | |
bin_write_t [T.T_bin] | |
bin_write_t [Fqueue] | |
bin_write_t [Float_intf.S.Terse] | |
bin_write_t [Float_intf.S.Class] | |
bin_write_t [Dequeue] | |
bin_write_t [Date.Stable.V1] | |
bin_write_t [Date] | |
bin_write_t [Unix.Inet_addr] | |
bin_write_t [Unix.Protocol_family] | |
bin_write_t [Unix.File_descr] | |
bin_write_t [String] | |
bin_write_t [Stack] | |
bin_write_t [Sexp.Sexp_maybe] | |
bin_write_t [Sexp.Sexp_opaque] | |
bin_write_t [Sexp.Sexp_array] | |
bin_write_t [Sexp.Sexp_list] | |
bin_write_t [Sexp.Sexp_option] | |
bin_write_t [Sexp] | |
bin_write_t [Set.Poly] | |
bin_write_t [Queue] | |
bin_write_t [Map.Poly] | |
bin_write_t [List] | |
bin_write_t [Lazy] | |
bin_write_t [Core_hashtbl_intf.Key_binable] | |
bin_write_t [Hashtbl.Poly] | |
bin_write_t [Gc.Control] | |
bin_write_t [Gc.Stat] | |
bin_write_t [Char] | |
bin_write_t [Array] | |
bin_write_t [Constrained_float.S] | |
bin_write_t [Comparator.Pre_binable] | |
bin_write_t [Byte_units.Measure] | |
bin_write_t [Byte_units] | |
bin_write_t [Bucket.S] | |
bin_write_t [Bucket.Contents] | |
bin_write_t [Bucket.Make] | |
bin_write_t [Bounded_int_table.With_key] | |
bin_write_t [Bool] | |
bin_write_t [Blang.Stable.V1] | |
bin_write_t [Blang] | |
bin_write_t [Bigstring] | |
bin_write_t_ [Time] | |
bin_write_t_ [Weekday] | |
bin_write_t_ [Unique_id_intf.Id] | |
bin_write_t_ [Zone] | |
bin_write_t_ [Stable_internal.Sexp] | |
bin_write_t_ [Stable_containers.Map.V1] | |
bin_write_t_ [Stable_containers.Hash_set.V1] | |
bin_write_t_ [Stable_containers.Hashtbl.V1] | |
bin_write_t_ [Stable_containers.Set.V1] | |
bin_write_t_ [Zone.Stable.V1] | |
bin_write_t_ [Weekday.Stable.V1] | |
bin_write_t_ [Time.Stable.V1] | |
bin_write_t_ [String_id.Stable.V1] | |
bin_write_t_ [Span.Stable.V1] | |
bin_write_t_ [Span] | |
bin_write_t_ [Source_code_position0] | |
bin_write_t_ [Source_code_position] | |
bin_write_t_ [Signal] | |
bin_write_t_ [Stable_unit_test_intf.Arg] | |
bin_write_t_ [Result.Stable.V1] | |
bin_write_t_ [Result] | |
bin_write_t_ [Ref] | |
bin_write_t_ [Piecewise_linear.Key] | |
bin_write_t_ [Piecewise_linear.S] | |
bin_write_t_ [Pid] | |
bin_write_t_ [Or_error] | |
bin_write_t_ [Ordering] | |
bin_write_t_ [Ofday.Stable.V1] | |
bin_write_t_ [Ofday] | |
bin_write_t_ [Month.Stable.V1] | |
bin_write_t_ [Month] | |
bin_write_t_ [Linux_ext.Sysinfo] | |
bin_write_t_ [Int_intf.S] | |
bin_write_t_ [Interval_intf.S.Set] | |
bin_write_t_ [Interval_intf.S] | |
bin_write_t_ [Interval_intf.S1.Set] | |
bin_write_t_ [Interval_intf.S1] | |
bin_write_t_ [Interval.Stable.V1.Ofday] | |
bin_write_t_ [Interval.Stable.V1.Int] | |
bin_write_t_ [Interval.Stable.V1.Float] | |
bin_write_t_ [Info] | |
bin_write_t_ [Identifiable.S] | |
bin_write_t_ [T.T_bin] | |
bin_write_t_ [Fqueue] | |
bin_write_t_ [Float_intf.S.Terse] | |
bin_write_t_ [Float_intf.S.Class] | |
bin_write_t_ [Dequeue] | |
bin_write_t_ [Date.Stable.V1] | |
bin_write_t_ [Date] | |
bin_write_t_ [Unix.Inet_addr] | |
bin_write_t_ [Unix.Protocol_family] | |
bin_write_t_ [Unix.File_descr] | |
bin_write_t_ [String] | |
bin_write_t_ [Stack] | |
bin_write_t_ [Sexp.Sexp_maybe] | |
bin_write_t_ [Sexp.Sexp_opaque] | |
bin_write_t_ [Sexp.Sexp_array] | |
bin_write_t_ [Sexp.Sexp_list] | |
bin_write_t_ [Sexp.Sexp_option] | |
bin_write_t_ [Sexp] | |
bin_write_t_ [Set.Poly] | |
bin_write_t_ [Queue] | |
bin_write_t_ [Map.Poly] | |
bin_write_t_ [List] | |
bin_write_t_ [Lazy] | |
bin_write_t_ [Core_hashtbl_intf.Key_binable] | |
bin_write_t_ [Hashtbl.Poly] | |
bin_write_t_ [Gc.Control] | |
bin_write_t_ [Gc.Stat] | |
bin_write_t_ [Char] | |
bin_write_t_ [Array] | |
bin_write_t_ [Constrained_float.S] | |
bin_write_t_ [Comparator.Pre_binable] | |
bin_write_t_ [Byte_units.Measure] | |
bin_write_t_ [Byte_units] | |
bin_write_t_ [Bucket.S] | |
bin_write_t_ [Bucket.Contents] | |
bin_write_t_ [Bucket.Make] | |
bin_write_t_ [Bounded_int_table.With_key] | |
bin_write_t_ [Bool] | |
bin_write_t_ [Blang.Stable.V1] | |
bin_write_t_ [Blang] | |
bin_write_t_ [Bigstring] | |
bin_write_tcp_bool_option [Linux_ext] | |
bin_write_tcp_bool_option_ [Linux_ext] | |
bin_writer_decimal [Common] | |
bin_writer_immutable [Common] | |
bin_writer_no_raise [Sexp] | |
bin_writer_outer [Float_intf.S] | |
bin_writer_read_only [Common] | |
bin_writer_read_write [Common] | |
bin_writer_sexp_array [Std_internal] | |
bin_writer_sexp_bool [Std_internal] | |
bin_writer_sexp_list [Std_internal] | |
bin_writer_sexp_opaque [Std_internal] | |
bin_writer_sexp_option [Std_internal] | |
bin_writer_sexp_option [Stable_internal] | |
bin_writer_sockaddr [Unix] | |
bin_writer_socket_domain [Unix] | |
bin_writer_socket_type [Unix] | |
bin_writer_t [Time] | |
bin_writer_t [Weekday] | |
bin_writer_t [Unique_id_intf.Id] | |
bin_writer_t [Zone] | |
bin_writer_t [Stable_internal.Sexp] | |
bin_writer_t [Stable_containers.Map.V1] | |
bin_writer_t [Stable_containers.Hash_set.V1] | |
bin_writer_t [Stable_containers.Hashtbl.V1] | |
bin_writer_t [Stable_containers.Set.V1] | |
bin_writer_t [Zone.Stable.V1] | |
bin_writer_t [Weekday.Stable.V1] | |
bin_writer_t [Time.Stable.V1] | |
bin_writer_t [String_id.Stable.V1] | |
bin_writer_t [Span.Stable.V1] | |
bin_writer_t [Span] | |
bin_writer_t [Source_code_position0] | |
bin_writer_t [Source_code_position] | |
bin_writer_t [Signal] | |
bin_writer_t [Stable_unit_test_intf.Arg] | |
bin_writer_t [Result.Stable.V1] | |
bin_writer_t [Result] | |
bin_writer_t [Ref] | |
bin_writer_t [Piecewise_linear.Key] | |
bin_writer_t [Piecewise_linear.S] | |
bin_writer_t [Pid] | |
bin_writer_t [Or_error] | |
bin_writer_t [Ordering] | |
bin_writer_t [Ofday.Stable.V1] | |
bin_writer_t [Ofday] | |
bin_writer_t [Month.Stable.V1] | |
bin_writer_t [Month] | |
bin_writer_t [Linux_ext.Sysinfo] | |
bin_writer_t [Int_intf.S] | |
bin_writer_t [Interval_intf.S.Set] | |
bin_writer_t [Interval_intf.S] | |
bin_writer_t [Interval_intf.S1.Set] | |
bin_writer_t [Interval_intf.S1] | |
bin_writer_t [Interval.Stable.V1.Ofday] | |
bin_writer_t [Interval.Stable.V1.Int] | |
bin_writer_t [Interval.Stable.V1.Float] | |
bin_writer_t [Info] | |
bin_writer_t [Identifiable.S] | |
bin_writer_t [T.T_bin] | |
bin_writer_t [Fqueue] | |
bin_writer_t [Float_intf.S.Terse] | |
bin_writer_t [Float_intf.S.Class] | |
bin_writer_t [Dequeue] | |
bin_writer_t [Date.Stable.V1] | |
bin_writer_t [Date] | |
bin_writer_t [Unix.Inet_addr] | |
bin_writer_t [Unix.Protocol_family] | |
bin_writer_t [Unix.File_descr] | |
bin_writer_t [String] | |
bin_writer_t [Stack] | |
bin_writer_t [Sexp.Sexp_maybe] | |
bin_writer_t [Sexp.Sexp_opaque] | |
bin_writer_t [Sexp.Sexp_array] | |
bin_writer_t [Sexp.Sexp_list] | |
bin_writer_t [Sexp.Sexp_option] | |
bin_writer_t [Sexp] | |
bin_writer_t [Set.Poly] | |
bin_writer_t [Queue] | |
bin_writer_t [Map.Poly] | |
bin_writer_t [List] | |
bin_writer_t [Lazy] | |
bin_writer_t [Core_hashtbl_intf.Key_binable] | |
bin_writer_t [Hashtbl.Poly] | |
bin_writer_t [Gc.Control] | |
bin_writer_t [Gc.Stat] | |
bin_writer_t [Char] | |
bin_writer_t [Array] | |
bin_writer_t [Constrained_float.S] | |
bin_writer_t [Comparator.Pre_binable] | |
bin_writer_t [Byte_units.Measure] | |
bin_writer_t [Byte_units] | |
bin_writer_t [Bucket.S] | |
bin_writer_t [Bucket.Contents] | |
bin_writer_t [Bucket.Make] | |
bin_writer_t [Bounded_int_table.With_key] | |
bin_writer_t [Bool] | |
bin_writer_t [Blang.Stable.V1] | |
bin_writer_t [Blang] | |
bin_writer_t [Bigstring] | |
bin_writer_tcp_bool_option [Linux_ext] | |
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.
|
bind_any [Unix.Inet_addr] |
A special address, for use only with
bind , representing all the Internet addresses
that the host machine possesses.
|
bind_any_inet6 [Unix.Inet_addr] | |
bit_and [Int_intf.S] | |
bit_not [Int_intf.S] | |
bit_or [Int_intf.S] | |
bit_xor [Int_intf.S] | |
bits [Random.State] |
These functions are the same as the basic functions, except that they use (and
update) the given PRNG state instead of the default one.
|
bits [Random] |
Return 30 random bits in a nonnegative integer.
|
bits_of_float [Int64] | |
bits_of_float [Int32] | |
blit [Make_substring.Base] | |
blit [String] | |
blit [Array] | Array.blit v1 o1 v2 o2 len copies len elements
from array v1 , starting at element number o1 , to array v2 ,
starting at element number o2 .
|
blit [Bigstring] | |
blit [Bigbuffer] | |
blit_bigstring_string [Bigstring] | |
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_of_int_2_digits [Time_internal.Helpers] | |
blit_string_of_int_3_digits [Time_internal.Helpers] | |
blit_string_of_int_4_digits [Time_internal.Helpers] | |
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.Nfs] | blocking_create ?message path like create, but sleeps for 1 second between lock
attempts and does not return until it succeeds
|
blocking_create [Lock_file] | blocking_create t tries to create the lock.
|
bool [Command.Spec] | |
bool [Random.State] | |
bool [Random] | Random.bool () returns true or false with probability 0.5 each.
|
bool_of_sexp [Std_internal] | |
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] | bound t x returns None iff is_empty t .
|
bounds [Interval_intf.Gen] | |
bounds_exn [Interval_intf.Gen] | |
bprintf [Printf] | |
bprintf [Bigbuffer.Printf] | |
bprintf [Bigbuffer.Format] | |
broadcast [Condition] | |
build_info [Command.Deprecated] | |
business_dates_between [Date] | |
bytes [Heap_block] | bytes t returns the number of bytes on the heap taken by heap block t , including
the header.
|
bytes [Byte_units] | |
C | |
c_int_size [Sys] | c_int_size returns the number of bits in a C int .
|
call [Result] | |
call [Option] | call x f run optional function on argument
|
capitalize [String] | |
cartesian_product [List] | |
cartesian_product [Array] | |
catch [Printexc] | |
catch_break [Sys] |
Warning: this function clobbers the Signal.int (SIGINT) handler.
|
ceil [Common] | |
cg [Quickcheck] |
character generator
|
change [Univ_map.Multi] | |
change [Univ_map.With_fold] | |
change [Univ_map.With_default] | |
change [Univ_map] | |
change [Core_map_intf.Accessors] | change map key f updates the given map by changing the value stored
under key according to f .
|
change [Core_hashtbl_intf.Accessors] | change t key f updates the given table by changing the value stored under key
according to f , just like Map.change (see that for example).
|
change_exn [Univ_map] | |
char_of_sexp [Std_internal] | |
chdir [Unix] |
Change the process working directory.
|
chdir [Sys] |
Change the current working directory of the process.
|
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_heap_property h asserts that h has the heap property: that all
nodes are less than their children by h 's comparison function.
|
check_suffix [Filename] | check_suffix name suff returns true if the filename name
ends with the suffix suff .
|
chld [Signal] |
| Ignore | Child process terminated |
|
chmod [Unix] |
Change the permissions of the named file.
|
choose [Core_set_intf.Accessors] | |
choose [Bag] | choose t returns some element in the bag.
|
choose_exn [Core_set_intf.Accessors] | |
chop_extension [Filename] |
Return the given file name without its extension.
|
chop_prefix [String] | |
chop_prefix_exn [String] | chop_prefix s ~pref returns a copy s without the leading pref
|
chop_suffix [String] | |
chop_suffix [Filename] | chop_suffix name suff removes the suffix suff from
the filename name .
|
chop_suffix_exn [String] | chop_suffix s ~suf returns a copy s without the trailing suff
|
chown [Unix] |
Change the owner uid and owner gid of the named file.
|
chroot [Unix] |
Change the process root directory.
|
classify [Float_intf.S] | |
classify_float [Common] | |
clear [Squeue] |
clears the queue
|
clear [Hash_set_intf.Accessors] | |
clear [Hash_queue.S] |
clear the queue
|
clear [Hash_queue.Make] | |
clear [Doubly_linked] | clear t removes all elements from the list in constant time.
|
clear [Dequeue] | clear t removes all elements from t .
|
clear [Stack] | clear t discards all elements from t .
|
clear [Queue] | clear t discards all elements from t .
|
clear [Core_hashtbl_intf.Accessors] | |
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.
|
close [Out_channel] | |
close [In_channel] | |
close [Unix] |
Close a file descriptor.
|
close_in [Common] |
we have our own version of these two, the INRIA version doesn't release the runtime
lock.
|
close_out [Common] | |
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.
|
closedir [Unix] |
Close a directory descriptor.
|
code [Unix.Exit] | |
combine [Result] | |
combine [Array] | combine ar combines two arrays to an array of pairs.
|
combine_errors [Or_error] | combine_errors ts returns Ok if every element in ts is Ok , else it returns
Error with all the errors in ts .
|
combine_errors_unit [Or_error] | combine_errors_unit returns Ok if every element in ts is Ok () , else it
returns Error with all the errors in ts , like combine_errors .
|
command [Sys] |
Execute the given shell command and return its exit code.
|
command_exn [Sys] | |
compact [Gc] |
Perform a full major collection and compact the heap.
|
compactions [Gc.Stat.Fields] | |
compactions [Gc.Stat] | |
comparator [Set] | |
comparator [Map] | |
comparator [Comparator.S1] | |
comparator [Comparator.S_binable] | |
comparator [Comparator.S] | |
comparator [Comparable.S_common] | |
compare [Tuple.T3] | |
compare [Tuple.T2] | |
compare [Stable_internal.Sexp] | |
compare [Weekday.Stable.V1] | |
compare [Time.Stable.V1] | |
compare [String_id.Stable.V1] | |
compare [Span.Stable.V1] | |
compare [Source_code_position0] | |
compare [Result.Stable.V1] | |
compare [Result] | |
compare [Polymorphic_compare] | |
compare [Ordering] | |
compare [Option] | |
compare [No_polymorphic_compare] | |
compare [Month.Stable.V1] | |
compare [Hashable.S] | |
compare [Fqueue] | |
compare [Date.Stable.V1] | |
compare [Sexp.Sexp_maybe] | |
compare [Sexp.Sexp_opaque] | |
compare [Sexp.Sexp_array] | |
compare [Sexp.Sexp_list] | |
compare [Sexp.Sexp_option] | |
compare [Core_set_intf.S.Tree] | |
compare [Core_set_intf.S] | |
compare [Set.Poly] | |
compare [Set] | |
compare [Core_map_intf.S] | |
compare [Map.Poly] | |
compare [List] |
lexicographic
|
compare [Core_hashtbl_intf.Key] | |
compare [Comparator.Pre_binable] | |
compare [Comparator.Pre] | |
compare [Polymorphic_compare_intf.S] | |
compare [Comparable.Make_common.Replace_polymorphic_compare] | |
compare [Blang.Stable.V1] | |
compare [Blang] | |
compare_direct [Core_set_intf.Accessors] | |
compare_direct [Core_map_intf.Accessors] |
Total ordering between maps.
|
compare_immutable [Common] | |
compare_read_only [Common] |
Handy types for marking things read-only and read-write.
|
compare_read_write [Common] | |
compare_sexp_array [Std_internal] | |
compare_sexp_bool [Std_internal] | |
compare_sexp_list [Std_internal] | |
compare_sexp_opaque [Std_internal] | |
compare_sexp_option [Std_internal] | |
compare_sexp_option [Stable_internal] | |
compare_t [Stable_internal.Sexp] | |
compare_t [Source_code_position0] | |
compare_value [Interval_intf.Gen] | |
complement [Flags_intf.S] | |
compose [Fn] | compose f g x is f (g x)
|
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 p1 p2 returns a path equivalent to p1 ^ "/" ^ p2 .
|
concat [Array] |
Same as
Array.append , but concatenates a list of arrays.
|
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 [Queue] | |
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_map [Array] | |
concat_mapi [List] | concat_mapi t ~f is like concat_map, but passes the index as an argument
|
concat_no_order [List] |
Same as
concat but faster and without preserving any ordering (ie for lists that are
essentially viewed as multi-sets.
|
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] | |
connect [Unix] |
Connect a socket to an address.
|
cons [List] | |
const [Fn] |
produces a function that just returns its first argument
|
const [Common] | |
const [Command.Spec] |
a hard-coded parameter
|
constant [Blang] | |
constant_value [Blang] | |
constr_name [Univ] | |
cont [Signal] |
| Continue | Continue |
|
contains [Interval_intf.Gen_set] | |
contains [Interval_intf.Gen] | |
contains [String] | |
contains_dup [List] | contains_dup True if there are any two elements in the list which are the same.
|
contains_set [Interval_intf.Gen_set] | |
contents [Bigbuffer] |
Return a copy of the current contents of the buffer.
|
conv [Type_equal] | conv t x uses the type equality t : (a, b) t as evidence to safely cast x
from type a to type b .
|
convert [Time] | |
copy [Heap] | copy heap
|
copy [Hash_set_intf.Accessors] | |
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 [Core_hashtbl_intf.Accessors] | |
copy [Array] | Array.copy a returns a copy of a , that is, a fresh array
containing the same elements as a .
|
copy [Random.State] | |
core_file_size [Unix.RLimit] | |
cores [Linux_ext] | cores ()
|
count [Hash_queue.Make] | |
count [List] | count f l is the number of elements in l that satisfy the
predicate f .
|
count [Container.Generic_phantom] | |
count [Container.Generic] | |
count [Container.S1_phantom] | |
count [Container.S1] | |
count [Container.S0_phantom] | |
count [Container.S0] | |
count [Container.Make] | |
counters [Gc] |
Return
(minor_words, promoted_words, major_words) .
|
cpu_seconds [Unix.RLimit] | |
crc32 [Crc] |
Compute the 32-bit crc
|
crc32hex [Crc] |
String version of the crc, encoded in hex.
|
create [Weekday] | |
create [Uuid] | create () returns a new t guaranteed to not be equal to any other UUID generated
by any process anywhere.
|
create [Unpack_buffer] | |
create [Univ_map.Multi.Key] | |
create [Univ_map.With_fold.Key] | |
create [Univ_map.With_default.Key] | |
create [Univ_map.Key] | |
create [Univ.Constr] | create name to_sexp
if the type 'a doesn't support sexp conversion, then a good practice
is to use sexp_of_opaque as the converter.
|
create [Univ] | create var arg creates a new t from a constr and the argument to the constr.
|
create [Unique_id_intf.Id] | |
create [Union_find] | create v returns a new object in its own equivalence class that has value v .
|
create [Type_equal.Id] | create ~name defines a new type identity.
|
create [Tuple.T3] | |
create [Tuple.T2] | |
create [Timer] | create ?min_size () creates a new timer.
|
create [Thread_safe_queue] | |
create [Squeue] | create maxsize returns a synchronized queue bounded to have no more than
maxsize elements.
|
create [Span] | |
create [Space_safe_tuple.T3] | |
create [Space_safe_tuple.T2] | |
create [Set_once] | |
create [Ref] | |
create [Piecewise_linear.S] | |
create [Out_channel] | |
create [Ofday] | |
create [Nano_mutex] | create () returns a new, unlocked mutex.
|
create [Mutex0] | |
create [Substring_intf.S] | create ?pos ?len base creates 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.Nfs] | lock ?message path tries to create and lock the file at path by creating a hard
link to path .nfs_lock.
|
create [Lock_file] | create ?close_on_exec ?message path tries to create a file at path containing the
text message , which defaults to the pid of the locking process.
|
create [Linux_ext.Epoll] | create ~num_file_descrs creates a new epoll set able to watch file descriptors in
[0, num_file_descrs).
|
create [Interval_intf.S] | |
create [Interval_intf.Gen_set] | |
create [Interval_intf.Gen] | create l u returns the interval with lower bound l and upper bound u , unless
l > u , in which case create returns the empty interval.
|
create [Info] |
For
create msg z sexp_of_z , be careful to use only immutable values for z, or be
aware that z will be lazily converted to a sexp at a later point in time, which will
pick up the then-current state of z .
|
create [In_channel] | |
create [Host_and_port] | |
create [Heap_block] | create v returns Some t if v is a heap block, where t is physically equal
to v
|
create [Heap] | create ?min_size cmp
|
create [Hash_set_intf.Creators] | |
create [Hash_heap.S] | |
create [Hash_queue.S] | create () returns an empty queue.
|
create [Hash_heap.Make] | |
create [Hash_queue.Make] | |
create [Force_once] | create f creates a new force_once
|
create [Doubly_linked] |
creating doubly-linked lists
|
create [Dequeue] | |
create [Weak] | |
create [Unix.Resource_usage.Fields] | |
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 [Core_hashtbl_intf.Creators] | |
create [Gc.Control.Fields] | |
create [Gc.Stat.Fields] | |
create [Condition] | |
create [Array] | create ~len x creates an array of length len with the value x populated in each
element
|
create [Command.Spec.Arg_type] |
an argument type includes information about how to parse values of that type from
the command line, and (optionally) how to auto-complete partial arguments of that
type via bash's programmable TAB-completion.
|
create [Byte_units] | |
create [Bucket.S] | |
create [Bucket.Make] | |
create [Bounded_int_table.With_key] | |
create [Bounded_int_table] | create ~num_keys ~key_to_int returns a table where the keys can map to 0
..
|
create [Bigstring] | create length
|
create [Bigbuffer] | create n returns a fresh buffer, initially empty.
|
create [Bag] | create () returns an empty bag.
|
create' [Thread_safe_queue] | |
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_bigstring [Binable0] | |
create_bin_prot [Unpack_buffer.Unpack_one] | create_bin_prot reader returns an unpacker that reads the "size-prefixed" bin_prot
encoding, in which a value is encoded by first writing the length of the bin_prot
data as a 64-bit int, and then writing the data itself.
|
create_bin_prot [Unpack_buffer] | create_bin_prot reader returns an unpack buffer that unpacks the "size-prefixed"
bin_prot encoding, in which a value is encoded by first writing the length of the
bin_prot data as a 64-bit int, and then writing the bin_prot data itself.
|
create_ending_after [Interval.Time] | create_ending_after ?zone (od1, od2) ~now returns the smallest interval (t1 t2)
with minimum t2 such that t2 >= now , to_ofday t1 = od1 , and to_ofday t2 =
od2 .
|
create_ending_before [Interval.Time] | create_ending_before ?zone (od1, od2) ~ubound returns the smallest interval (t1
t2) with maximum t2 such that t2 <= ubound , to_ofday t1 = od1 , and to_ofday
t2 = od2 .
|
create_exn [Lock_file.Nfs] | create_exn ?message path like create, but throws an exception when it fails to
obtain the lock
|
create_exn [Lock_file] | create_exn ?message path is like create except that it throws an exception on
failure instead of returning a boolean value
|
create_exn [Heap_block] | |
create_exn [Date] | create_exn ~y ~m ~d creates the date specified in the arguments.
|
create_from_intervals [Interval_intf.Gen_set] | |
create_mapped [Core_hashtbl_intf.Creators] | |
create_process [Unix] | create_process ~prog ~args forks a new process that
executes the program prog with arguments args .
|
create_process_env [Unix] | |
create_with_key [Core_hashtbl_intf.Creators] | |
create_with_key_exn [Core_hashtbl_intf.Creators] | |
critical_section [Nano_mutex] | |
critical_section [Mutex0] | |
critical_section [Lock_file.Nfs] | critical_section ?message path ~f wrap function f (including exceptions escaping
it) by first locking (using Lock_file.Nfs.create_exn ) and then unlocking the given lock
file.
|
critical_section [Mutex] | |
current [Arg] |
Position (in
Sys.argv ) of the argument being processed.
|
current_dir_name [Filename] |
The conventional name for the current directory (e.g.
|
current_string_and_sexp_format [Time] | |
current_thread_has_lock [Nano_mutex] | current_thread_has_lock t returns true iff the current thread has t locked.
|
curry [Tuple.T3] | |
curry [Tuple.T2] | |
D | |
daemonize [Daemon] | daemonize makes the executing process a daemon.
|
daemonize_wait [Daemon] | daemonize_wait makes the executing process a daemon, but delays full detachment
from the calling shell/process until the returned "release" closure is called.
|
data [Core_map_intf.Accessors] |
returns list of data in map
|
data [Core_hashtbl_intf.Accessors] | filter_inplace t ~f removes all the elements from t that don't satisfy f .
|
data [Bounded_int_table] | |
data_segment [Unix.RLimit] | |
date [Command.Spec] | |
dates_between [Date] | |
day [Span] | |
day [Date] | |
day_of_week [Date] | |
deactivate [Timer] | deactivate timer deactives a timer.
|
debug [Unpack_buffer] | debug controls whether invariants are checked at each call.
|
debug [Bounded_int_table] |
set
debug := true to turn on debugging, including potentially slow invariant
checking.
|
decimal_of_sexp [Common] | |
decr [Linux_ext.Priority] | |
decr [Int_intf.S] | |
dedup [List] | dedup (de-duplicate).
|
default [Random.State] | |
default_sys_behavior [Signal] | default_sys_behavior t
Query the default system behavior for a signal.
|
default_utc_offset_deprecated [Zone] | default_utc_offset returns the UTC offset of default regime for timezone t in
seconds.
|
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 .
|
dequeue [Thread_safe_queue] | |
dequeue [Hash_queue.S] | dequeue t returns the front element of the queue.
|
dequeue [Hash_queue.Make] | |
dequeue [Fqueue] |
Like
dequeue_exn , but returns result optionally, without exception.
|
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 t ~f dequeues every element of the queue and applies f to each
one.
|
dequeue_all [Hash_queue.Make] | |
dequeue_exn [Hash_queue.S] | |
dequeue_exn [Hash_queue.Make] | |
dequeue_exn [Fqueue] | dequeue_exn t removes and returns the front of t , raising Empty if t
is empty.
|
dequeue_exn [Queue] | |
dequeue_until_empty [Thread_safe_queue] | |
dequeue_with_key [Hash_queue.S] | dequeue_with_key t returns the front element of the queue and its key
|
dequeue_with_key [Hash_queue.Make] | |
dequeue_with_key_exn [Hash_queue.S] | |
dequeue_with_key_exn [Hash_queue.Make] | |
descending [Comparable.S_common] | |
descending [Comparable.Make_common] | |
descending [Comparable.Poly] | |
descending [Common] | |
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.
|
detuple2 [Type_equal] | tuple2 and detuple2 convert between equality on a 2-tuple and its components.
|
diff [Time_internal.T] | |
diff [Time] | diff t1 t2 returns time t1 minus time t2 .
|
diff [Ofday] | diff t1 t2 returns the difference in time between two ofdays, as if they occurred on
the same day
|
diff [Hash_set_intf.Accessors] | |
diff [Date] | diff t1 t2 returns date t1 minus date t2 in days.
|
diff [Core_set_intf.Accessors] | |
digest [Zone] | digest t return the MD5 digest of the file the t was created from (if any)
|
dir_sep [Filename] |
The directory separator (e.g.
|
dirfd [Unix] | |
dirname [Filename] |
See
Filename.basename .
|
discard_exn [Fqueue] |
Returns version of queue with top element removed.
|
do_intersect [Flags_intf.S] | |
domain_of_sockaddr [Unix] |
Return the socket domain adequate for the given socket address.
|
drop [Unix.IOVec] | drop iovec n drops n characters from iovec .
|
drop [List] | |
drop_back_exn [Dequeue] | |
drop_front_exn [Dequeue] | |
drop_indices_greater_than_exn [Dequeue] | |
drop_indices_less_than_exn [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 drops the longest prefix of l for which f is true .
|
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 [Core_set_intf.Accessors] | |
empty [Univ_map] | |
empty [Int_set] | |
empty [Interval_intf.Gen] | |
empty [Fqueue] |
The empty queue
|
empty [Flags_intf.S] | |
empty [Unix.IOVec] | empty the empty I/O-vector.
|
empty [Unix.Select_fds] | |
empty [Core_set_intf.S] | |
empty [Core_set_intf.Creators] | |
empty [Set.Poly] | |
empty [Core_map_intf.Creators] |
the empty map
|
empty [Map.Poly] | |
empty [Array] | empty () creates an empty array
|
empty [Command.Spec] |
the empty command-line spec
|
empty [Avltree] | |
end_of_day [Ofday] | |
endpwent [Unix.Passwd.Low_level] | |
enqueue [Thread_safe_queue] | |
enqueue [Hash_queue.S] | enqueue t k v adds the key-value pair (k, v) to the end of the queue,
returning `Ok if the pair was added, or `Key_already_present
if there is already a (k, v') in the queue.
|
enqueue [Hash_queue.Make] | |
enqueue [Fqueue] | enqueue t x returns a queue with adds x to the end of t .
|
enqueue [Queue] | enqueue t x adds x to the end of t .
|
enqueue_exn [Hash_queue.S] | |
enqueue_exn [Hash_queue.Make] | |
enqueue_top [Fqueue] |
enqueue a single element on the *top* of the queue.
|
env_of_sexp [Unix] | create_process_env ~prog ~args ~env as create process, but takes an additional
parameter that extends, or replaces the current environment.
|
env_of_sexp__ [Unix] | |
environment [Unix] |
Return the process environment, as an array of strings
with the format ``variable=value''.
|
epoch [Time] | |
eprintf [Printf] | |
epsilon [Span] | |
epsilon [Float_robust_compare.S] | |
epsilon [Float_intf.S] | |
epsilon_float [Float_intf.S] | |
epsilon_float [Common] | |
equal [Tuple.T3] | |
equal [Tuple.T2] | |
equal [Signal] | |
equal [Stable_unit_test_intf.Arg] | |
equal [Polymorphic_compare] | |
equal [Option] | |
equal [No_polymorphic_compare] | |
equal [Nano_mutex] | equal is phys_equal
|
equal [Mutex0] | |
equal [Linux_ext.Priority] | |
equal [Hash_set_intf.Accessors] | |
equal [Flags_intf.S] | |
equal [Equal.S3] | |
equal [Equal.S2] | |
equal [Equal.S1] | |
equal [Equal.S] | |
equal [Doubly_linked.Elt] | |
equal [Doubly_linked] |
predicates
|
equal [String] |
fast equality function on strings, doesn't use compare_val
|
equal [Core_set_intf.Accessors] | subset t1 t2 returns true iff t1 is a subset of t2 .
|
equal [Mutex] | |
equal [Core_map_intf.Accessors] | 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 [List] | |
equal [Core_hashtbl_intf.Accessors] | |
equal [Condition] | |
equal [Array] | |
equal [Polymorphic_compare_intf.S] | |
equal [Comparable.Make_common.Replace_polymorphic_compare] | |
equal [Common] |
toplevel binding for polymorphic equality (=).
|
equal [Bag.Elt] | |
err [Linux_ext.Epoll.Flags] | |
error [Result] | |
error [Or_error] | error message value sexp_of_value constructs an Error.t and returns it as a
Result.Error .
|
error_message [Unix] |
Return a string describing the given error code.
|
error_of_sexp [Unix.Exit_or_signal_or_stop] | |
error_of_sexp [Unix.Exit_or_signal] | |
error_of_sexp [Unix.Exit] | |
error_of_sexp [Unix] | |
error_of_sexp__ [Unix.Exit_or_signal_or_stop] | |
error_of_sexp__ [Unix.Exit_or_signal] | |
error_of_sexp__ [Unix.Exit] | |
error_string [Or_error] | error_string message is Error (Error.of_string message)
|
escape [String.Escaping] | escape ~escapeworthy ~escape_char s is
.
|
escape [Command.Deprecated.Spec] | |
escape [Command.Spec] | escape flags may be passed at most once.
|
escape_gen [String.Escaping] | |
escape_gen_exn [String.Escaping] | escape_gen_exn escapeworthy_map escape_char returns a function that will escape a
string s as follows: if (c1,c2) is in escapeworthy_map , then all occurences of
c1 are replaced by escape_char concatenated to c2 .
|
escaped [String] |
Warning: Only returns a copy if changes are necessary! Special characters are
represented by escape sequences, following the lexical conventions of Objective
Caml.
|
escaped [Char] |
Return a string representing the given character, with special characters escaped
following the lexical conventions of Objective Caml.
|
establish_server [Unix] |
Establish a server on the given address.
|
et [Linux_ext.Epoll.Flags] | |
eval [Blang] | eval t f evaluates the proposition t relative to an environment
f that assigns truth values to base propositions.
|
exec [Unix] | exec ~prog ~args ?search_path ?env execs prog with args .
|
executable_name [Sys] |
The name of the file containing the executable currently running.
|
execution_mode [Sys] | execution_mode tests whether the code being executed was compiled natively
or to bytecode.
|
exists [Hash_queue.Make] | |
exists [Unix.Resource_usage.Fields] | |
exists [Core_map_intf.Accessors] | |
exists [Core_hashtbl_intf.Accessors] | |
exists [Gc.Control.Fields] | |
exists [Gc.Stat.Fields] | |
exists [Container.Generic_phantom] | |
exists [Container.Generic] | |
exists [Container.S1_phantom] | |
exists [Container.S1] | |
exists [Container.S0_phantom] | |
exists [Container.S0] | |
exists [Container.Make] | |
exists [Bounded_int_table] | |
exists2_exn [List] |
Same as
List.exists , but for a two-argument predicate.
|
existsi [Core_hashtbl_intf.Accessors] | |
existsi [Bounded_int_table] | |
exit [Thread] |
Terminate prematurely the currently executing thread.
|
exit_immediately [Unix] | 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] |
print to stderr; exit 1
|
exn_if_dup [List] | exn_if_dup ?compare ?context t ~to_sexp will run find_a_dup on t , and raise
Duplicate_found if a duplicate is found.
|
F | |
fail [Result] | |
failf [Result] |
e.g.
|
failwithf [Printf] |
raises Failure
|
failwithf [Common] | |
failwiths [Error] | failwiths message value sexp_of_value raises an exception with the supplied
message and value , by constructing an Error.t and using Error.raise .
|
failwiths [Common] | |
false_ [Blang] | |
fchmod [Unix] |
Change the permissions of an opened file.
|
fchown [Unix] |
Change the owner uid and owner gid of an opened file.
|
fdatasync [Unix] |
Synchronize the kernel buffers of a given file descriptor with disk,
but do not necessarily write file attributes.
|
feed [Unpack_buffer] | feed t buf ?pos ?len adds the specified substring of buf to t 's buffer.
|
feed_string [Unpack_buffer] | |
fg [Quickcheck] |
float generator (no nan, inf, etc.)
|
file [Command.Spec] | |
file_descr_realpath [Linux_ext] | file_descr_realpath fd
|
file_exists [Sys] | file_exists ~follow_symlinks path
|
file_exists_exn [Sys] |
Same as
file_exists but blows up on `Unknown
|
file_kind_of_sexp [Unix] | |
file_perm_of_sexp [Unix] |
The type of file access rights.
|
file_size [Unix.RLimit] | |
fill [String] | |
fill [Array] | Array.fill a ofs len x modifies the array a in place,
storing x in elements number ofs to ofs + len - 1 .
|
fill [Bucket.S] | |
fill [Bucket.Make] | |
filter [Option] | |
filter [Hash_set_intf.Accessors] | |
filter [String] | filter s ~f:predicate discards characters not satisfying predicate
|
filter [Core_set_intf.Accessors] |
if
res = partition_tf set ~f then fst res are the elements on which f
produced true , and snd res are the elements on which f produces false
|
filter [Core_map_intf.Accessors] | |
filter [List] | filter p l returns all the elements of the list l that satisfy the predicate p .
|
filter [Core_hashtbl_intf.Accessors] | |
filter [Array] | filter ~f array removes the elements for which f returns false.
|
filter_inplace [Hash_set_intf.Accessors] | |
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 [Core_hashtbl_intf.Accessors] | |
filter_map [Core_set_intf.Creators] | |
filter_map [Queue] | |
filter_map [Core_map_intf.Accessors] |
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 [Core_hashtbl_intf.Accessors] |
returns new map with bound values filtered by f applied to the bound
values
|
filter_map [Array] | filter_map ~f array maps f over array and filters None out of the results.
|
filter_map [Bounded_int_table] | |
filter_mapi [Core_map_intf.Accessors] |
like
filter_map , but function takes both key and data as arguments
|
filter_mapi [List] |
filter_mapi is just like filter_map, but it also passes in the index of each
element as the first argument to the mapped function.
|
filter_mapi [Core_hashtbl_intf.Accessors] |
like
filter_map , but function takes both key and data as arguments
|
filter_mapi [Array] |
Same as
filter_map but uses Array.mapi .
|
filter_mapi [Bounded_int_table] | |
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] | |
filteri [Core_hashtbl_intf.Accessors] | |
filteri [Array] |
Like
filter except f also receives the index.
|
filteri_inplace [Core_hashtbl_intf.Accessors] | |
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 [Univ_map.Multi] | |
find [Univ_map.With_fold] | |
find [Univ_map.With_default] | |
find [Univ_map] | |
find [Zone] | find name looks up a t by its name and returns it.
|
find [Linux_ext.Epoll] |
map operations
|
find [Hash_heap.S] | |
find [Hash_heap.Make] | |
find [Hash_queue.Make] | |
find [Core_map_intf.Accessors] |
returns the value bound to the given key, raising
Not_found if none
such exists
|
find [List.Assoc] | |
find [Core_hashtbl_intf.Accessors] | find t k returns Some (the current binding) of k in t, or None if no
such binding exists
|
find [Container.Generic_phantom] | |
find [Container.Generic] | |
find [Container.S1_phantom] | |
find [Container.S1] | |
find [Container.S0_phantom] | |
find [Container.S0] | |
find [Container.Make] | |
find [Bounded_int_table] | |
find [Bigstring] | find ?pos ?len char t returns Some i for the smallest i >= pos such that
t.{i} = char , or None if there is no such i .
|
find [Avltree] |
if the specified key exists in the tree, return the corresponding value.
|
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_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 [Univ_map] | |
find_exn [Zone] | |
find_exn [Linux_ext.Epoll] | |
find_exn [Hash_heap.S] | |
find_exn [Hash_heap.Make] | |
find_exn [Core_set_intf.Accessors] | find_index t i returns the i th smallest element of t in O(log n) time.
|
find_exn [Core_map_intf.Accessors] | |
find_exn [List.Assoc] | |
find_exn [List] | find_exn t ~f returns the first element of t that satisfies f .
|
find_exn [Core_hashtbl_intf.Accessors] | find_exn t k returns the current binding of k in t, or raises Not_found
if no such binding exists.
|
find_exn [Array] | find_exn f t returns the first a in t for which f t.(i) is true.
|
find_exn [Bounded_int_table] | |
find_heap_el_exn [Heap] | find_heap_el_exn heap el
|
find_index [Core_set_intf.Accessors] | |
find_map [Hash_queue.Make] | |
find_map [Container.Generic_phantom] | |
find_map [Container.Generic] | |
find_map [Container.S1_phantom] | |
find_map [Container.S1] | |
find_map [Container.S0_phantom] | |
find_map [Container.S0] | |
find_map [Container.Make] | |
find_office [Zone] | find_office office a more type-safe interface for pulling timezones related to
existing Jane Street offices/locations.
|
find_or_add [Core_hashtbl_intf.Accessors] | find_or_add 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_or_add [Bounded_int_table] | |
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 t f returns the first index i of t for which f i t.(i) is true
|
findi_exn [Array] | findi_exn t f returns the first index i of t for which f i t.(i) is
true.
|
first [Hash_queue.S] | first t returns the front element of the queue, without removing it.
|
first [Hash_queue.Make] | |
first [Doubly_linked] | |
first [Avltree] | |
first_elt [Doubly_linked] |
constant-time extraction of first and last elements.
|
first_some [Option] | |
flag [Command.Spec] | flag name spec ~doc specifies a command that, among other things, takes a flag
named name on its command line.
|
flip [Fn] |
reverse the order of arguments for a binary function
|
float [Command.Spec] | |
float [Random.State] | |
float [Random] | Random.float bound returns a random floating-point number between 0 (inclusive) and
bound (exclusive).
|
float_of_bits [Int64] | |
float_of_bits [Int32] | |
float_of_hh_mm_ss [Time_internal] | |
float_of_int [Common] | |
float_of_sexp [Std_internal] | |
float_of_string [Common] | |
flock [Unix] | flock fd cmd places or releases a lock on the fd as per the flock C call of the same
name.
|
floor [Common] | |
flow_action_of_sexp [Unix.Terminal_io] | |
flush [Out_channel] | |
flush_queue_of_sexp [Unix.Terminal_io] | |
fnmatch [Unix] | |
fold [Hash_queue.Make] | |
fold [Dequeue] | |
fold [Unix.Resource_usage.Fields.Direct] | |
fold [Unix.Resource_usage.Fields] | |
fold [Queue] | |
fold [Core_map_intf.Accessors] |
folds over keys and data in map in increasing order of key.
|
fold [Core_hashtbl_intf.Accessors] | |
fold [Gc.Control.Fields.Direct] | |
fold [Gc.Control.Fields] | |
fold [Gc.Stat.Fields.Direct] | |
fold [Gc.Stat.Fields] | |
fold [Container.Generic_phantom] | |
fold [Container.Generic] | |
fold [Container.S1_phantom] | |
fold [Container.S1] | |
fold [Container.S0_phantom] | |
fold [Container.S0] | |
fold [Container.T] | |
fold [Container.Make] | |
fold [Bounded_int_table] | |
fold [Avltree] |
fold over the tree
|
fold2_exn [List] | List.fold2_exn f a [b1; ...; bn] [c1; ...; cn] is
f (... (f (f a b1 c1) b2 c2) ...) bn cn .
|
fold2_exn [Array] | |
fold_count [Container] | |
fold_dir [Sys] | |
fold_elt [Doubly_linked] | fold_elt t ~init ~f is the same as fold, except f is called with the 'a Elt.t 's
from the list instead of the contained 'a values.
|
fold_elt [Bag] | fold_elt t ~init ~f is the same as fold, except f is called with the
'a Elt.t 's from the bag instead of the contained 'a values.
|
fold_left [List] | |
fold_lines [In_channel] | fold_lines ?fix_win_eol t ~init ~f folds over the lines read from t
using input_line .
|
fold_range_inclusive [Core_map_intf.Accessors] | fold_range_inclusive t ~min ~max ~init ~f
folds f (with initial value ~init) over all keys (and their associated values)
that are in the range min, max (inclusive).
|
fold_ready [Linux_ext.Epoll] | |
fold_right [Doubly_linked] | |
fold_right [Core_set_intf.Accessors] | |
fold_right [Core_map_intf.Accessors] |
folds over keys and data in map in decreasing order of key.
|
fold_right [List] | List.fold_right f [a1; ...; an] b is
f a1 (f a2 (... (f an b) ...)) .
|
fold_right [Array] | Array.fold_right f a ~init computes
f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)) ,
where n is the length of the array a .
|
fold_until [Core_set_intf.Accessors] | |
foldi [Hash_queue.S] | |
foldi [Hash_queue.Make] | |
foldi [Dequeue] | |
foldi [String] | foldi works similarly to fold , but also pass in index of each character to f
|
foldi [List] |
foldi is just like fold, but it also passes in the index of each
element as the first argument to the folded function.
|
foldi [Array] | |
following_weekday [Date] | |
for_all [Hash_queue.Make] | |
for_all [Unix.Resource_usage.Fields] | |
for_all [Core_map_intf.Accessors] |
same semantics as similar functions in List
|
for_all [Gc.Control.Fields] | |
for_all [Gc.Stat.Fields] | |
for_all [Container.Generic_phantom] | |
for_all [Container.Generic] | |
for_all [Container.S1_phantom] | |
for_all [Container.S1] | |
for_all [Container.S0_phantom] | |
for_all [Container.S0] | |
for_all [Container.Make] | |
for_all [Bounded_int_table] | |
for_all2_exn [List] |
Same as
List.for_all , but for a two-argument predicate.
|
for_all2_exn [Array] | for_all2 t1 t2 ~f fails if length t1 <> length t2 .
|
for_alli [Bounded_int_table] | |
forbid_new_string_and_sexp_formats [Time] |
If this is called it asserts that use_new_string_and_sexp_formats has not been called,
and will cause use_new_string_and_sexp_formats to throw an exception if it is called
later
|
force [Only_in_test] | |
force [Force_once] | force t runs the thunk if it hadn't already been forced, else it raises an
exception.
|
force [Lazy] | force x forces the suspension x and returns its result.
|
force [Common] | |
force_val [Lazy] |
Like
force except that if the computation of x raises an exception, it is
unspecified whether force_val x raises the same exception or Undefined .
|
forever [Fn] | forever f runs f () until it throws an exception and returns the
exception.
|
fork [Unix] | fork () forks a new process.
|
fork_exec [Unix] | fork_exec ~prog ~args ?use_path ?env () forks and execs prog with args in the
child process, returning the child pid to the parent.
|
format [Time] | format t fmt formats the given time according to fmt, which follows the formatting
rules given in 'man strftime'.
|
format [Time.Date] | |
formatter_of_buffer [Bigbuffer.Format] | |
fpe [Signal] |
| Dump_core | Arithmetic exception |
|
fprintf [Printf] | |
fractional [Float_intf.S.Parts] | |
fragments [Gc.Stat.Fields] | |
fragments [Gc.Stat] | |
free_blocks [Gc.Stat.Fields] | |
free_blocks [Gc.Stat] | |
free_words [Gc.Stat.Fields] | |
free_words [Gc.Stat] | |
frexp [Float_intf.S] | |
frexp [Common] | |
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] | |
ftruncate [Unix.Native_file] | |
ftruncate [Unix] |
Truncates the file corresponding to the given descriptor
to the given size.
|
full_init [Random] |
Same as
Random.init but takes more data as seed.
|
full_major [Gc] |
Do a minor collection, finish the current major collection cycle,
and perform a complete new cycle.
|
G | |
gather_conjuncts [Blang] | gather_conjuncts t gathers up all toplevel conjuncts in t .
|
gather_disjuncts [Blang] | gather_disjuncts t gathers up all toplevel disjuncts in t .
|
general [Memo] |
Returns memoized version of any function with a single argument.
|
get [Weekday] | |
get [Union_find] | get t returns the value of the class of t .
|
get [Set_once] | |
get [Piecewise_linear.S] | |
get [Linux_ext.Clock] | |
get [Weak] | |
get [Unix.Resource_usage] | |
get [Unix.RLimit] | |
get [String] | |
get [Gc] |
Return the current values of the GC parameters in a
control record.
|
get [Array] | Array.get a n returns the element number n of array a .
|
get [Bigstring] | get t pos returns the character at pos
|
get [Backtrace] | |
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_back_exn [Dequeue] | |
get_backtrace [Printexc] | |
get_cmp [Heap] | get_cmp heap
|
get_digit [Char] |
Return
Some i if is_digit c and None otherwise.
|
get_digit_exn [Char] |
Return
i if is_digit c .
|
get_event_interval [Timer] | get_event_interval event
|
get_event_time [Timer] | get_event_time event
|
get_exn [Set_once] | |
get_exn [Dequeue] | |
get_flag_names [Command.Deprecated] | |
get_front [Dequeue] | |
get_front_exn [Dequeue] | |
get_hostname_and_pid [Lock_file.Nfs] | get_hostname_and_pid path reads the lock file at path and returns the hostname
and path in the file if it can be parsed.
|
get_ipv4_address_for_interface [Linux_ext] | |
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_process_clock [Linux_ext.Clock] | get_process_clock the clock measuring the CPU-time of a process.
|
get_resolution [Linux_ext.Clock] | |
get_sockaddr [Unix] |
Get a sockaddr from a hostname or IP, and a port
|
get_state [Random] |
OCaml's
Random.get_state makes a copy of the default state, which is almost
certainly not what you want.
|
get_terminal_size [Linux_ext] | get_terminal_size ()
|
get_thread_clock [Linux_ext.Clock] | get_thread_clock the clock measuring the CPU-time of the current thread.
|
get_time [Linux_ext.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.
|
getaddrinfo_option_of_sexp [Unix] |
Options to
Unix.getaddrinfo .
|
getbyaddr [Unix.Host] |
Find an entry in
hosts with the given address.
|
getbyaddr_exn [Unix.Host] | |
getbygid [Unix.Group] | |
getbygid_exn [Unix.Group] | |
getbyname [Unix.Service] |
Find an entry in
services with the given name.
|
getbyname [Unix.Protocol] |
Find an entry in
protocols with the given name.
|
getbyname [Unix.Host] |
Find an entry in
hosts with the given name.
|
getbyname [Unix.Group] | |
getbyname [Unix.Passwd] | |
getbyname_exn [Unix.Service] | |
getbyname_exn [Unix.Protocol] | |
getbyname_exn [Unix.Host] | |
getbyname_exn [Unix.Group] | |
getbyname_exn [Unix.Passwd] | |
getbynumber [Unix.Protocol] |
Find an entry in
protocols with the given protocol number.
|
getbynumber_exn [Unix.Protocol] | |
getbyport [Unix.Service] |
Find an entry in
services with the given service number.
|
getbyport_exn [Unix.Service] | |
getbyuid [Unix.Passwd] | |
getbyuid_exn [Unix.Passwd] | |
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 [Sys] |
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.
|
getgrouplist [Unix] | getgrouplist user group returns the list of groups to which user belongs.
|
getgroups [Unix] |
Return the list of groups to which the user executing the process belongs.
|
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 .
|
getnameinfo_option_of_sexp [Unix] |
Options to
Unix.getnameinfo .
|
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.
|
getppid_exn [Unix] |
Return the pid of the parent process, if you're really sure
you're never going to be the init process.
|
getpriority [Linux_ext] |
Get the calling thread's priority in the linux scheduler
|
getpwent [Unix.Passwd.Low_level] | |
getpwent_exn [Unix.Passwd.Low_level] | |
getpwents [Unix.Passwd] | getpwents is a thread-safe wrapper over the low-level passwd database
functions.
|
getsockname [Unix] |
Return the address of the given socket.
|
getsockopt [Unix] | |
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
|
gettid [Linux_ext] | |
gettimeofday [Unix] |
Same as
Unix.time above, 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 [Core_hashtbl_intf.Creators] | |
group [Command] | group ~summary subcommand_alist is a compound command with named
subcommands, as found in subcommand_alist .
|
group_by [Core_set_intf.Accessors] |
if
equiv is an equivalence predicate, then group_by set ~equiv produces a list
of equivalence classes (i.e., a set-theoretic quotient).
|
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 | |
half_open_intervals_are_a_partition [Interval_intf.Gen] | |
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_uncaught_and_exit [Exn] |
behaves as
handle_uncaught ~exit:true and also has a more precise
type in this case
|
handle_unix_error [Unix] | handle_unix_error f runs f () and returns the result.
|
hash [Type_equal.Id] |
accessors
|
hash [Hashable.S_binable] | |
hash [Hashable.S] | |
hash [String] |
slightly faster hash function on strings
|
hash [Core_hashtbl_intf.Key] |
Values returned by
hash must be non-negative.
|
hash [Core_hashtbl_intf.Hashable] | |
hash [Hashtbl] | |
hash_param [Core_hashtbl_intf.Hashable] | |
hash_param [Hashtbl] | |
hashable [Hashable.S_binable] | |
hashable [Hashable.S] | |
hashable [Hashable.Make_binable] | |
hashable [Hashable.Make] | |
hashable [Core_hashtbl_intf.S] | |
hashable [Hashtbl.Poly] | |
have_address_in_common [Unix.Host] | |
hd [List] | |
hd_exn [List] |
Return the first element of the given list.
|
heap_chunks [Gc.Stat.Fields] | |
heap_chunks [Gc.Stat] | |
heap_el_get_el [Heap] | heap_el_get_el heap_el
|
heap_el_get_heap_exn [Heap] | heap_el_get_heap_exn heap_el
|
heap_el_is_valid [Heap] | heap_el_is_valid heap_el
|
heap_el_mem [Heap] | heap_el_mem heap heap_el
|
heap_words [Gc.Stat.Fields] | |
heap_words [Gc.Stat] | |
help [Command.Spec] |
the help text for the command
|
help_recursive [Command.Deprecated] | |
host [Host_and_port] | |
hour [Span] | |
hup [Signal] |
| Terminate | Hangup on controlling terminal |
|
hup [Linux_ext.Epoll.Flags] | |
I | |
id [Fn] |
The identity function
|
id [Thread] |
Return the identifier of the given thread.
|
ident [Common] | |
idrss [Unix.Resource_usage.Fields] | |
idrss [Unix.Resource_usage] | |
if_ [Blang] | |
if_indextoname [Unix] | |
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 () -> ())
|
ignore [Fn] |
*
ignore is the same as Pervasives.ignore .
|
ill [Signal] |
| Dump_core | Invalid hardware instruction |
|
immutable_of_sexp [Common] | |
in_ [Linux_ext.Epoll.Flags] | |
in_channel_length [Common] | |
in_channel_of_descr [Unix] |
Create an input channel reading from the given descriptor.
|
in_channel_realpath [Linux_ext] | in_channel_realpath ic
|
inblock [Unix.Resource_usage.Fields] | |
inblock [Unix.Resource_usage] | |
incr [Linux_ext.Priority] | |
incr [Int_intf.S] | |
incr [Core_hashtbl_intf.Accessors] | |
index [String.Escaping] | index s ~escape_char char find the first literal (not escaped) instance of
char in s starting from 0.
|
index [String] | |
index_exn [String.Escaping] | |
index_exn [String] | |
index_from [String.Escaping] | index_from s ~escape_char pos char find the first literal (not escaped)
instance of char in s starting from pos and proceeding towards the end of s.
|
index_from [String] | |
index_from_exn [String.Escaping] | |
index_from_exn [String] | |
infinity [Float_intf.S] | |
infinity [Common] | |
init [Zone] | init () pre-load all available time zones from disk, this function has no effect if
it is called multiple times.
|
init [Pid] | |
init [String] | |
init [List] | init f n is [(f 0); (f 1); ...; (f (n-1))] .
|
init [Array] | init n ~f creates an array of length n where the i th element is initialized with
f i (starting at zero)
|
init [Bigstring] | init n ~f creates a bigstring t of length n , with t.{i} = f i
|
init [Random] |
Initialize the generator, using the argument as a seed.
|
initgroups [Unix] | |
initialized_zones [Zone] | initialized_zones () returns a sorted list of time zone names 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] |
Completely reads an input channel and returns the results as a list of
strings.
|
insert_after [Doubly_linked] | |
insert_before [Doubly_linked] |
constant-time insertion of a new element.
|
insert_delimiter [Int_conversions] | |
insert_first [Doubly_linked] | |
insert_last [Doubly_linked] | |
insert_underscores [Int_conversions] | |
int [Signal] |
| Terminate | Interactive interrupt (ctrl-C) |
|
int [Command.Spec] | |
int [Random.State] | |
int [Random] | Random.int bound returns a random integer between 0 (inclusive) and bound
(exclusive).
|
int32 [Random.State] | |
int32 [Random] | Random.int32 bound returns a random integer between 0 (inclusive) and bound
(exclusive).
|
int32_of_sexp [Std_internal] | |
int32_to_int [Int_conversions] | |
int32_to_int64 [Int_conversions] | |
int32_to_int_exn [Int_conversions] | |
int32_to_nativeint [Int_conversions] | |
int64 [Random.State] | |
int64 [Random] | Random.int64 bound returns a random integer between 0 (inclusive) and bound
(exclusive).
|
int64_of_sexp [Std_internal] | |
int64_to_int [Int_conversions] | |
int64_to_int32 [Int_conversions] | |
int64_to_int32_exn [Int_conversions] | |
int64_to_int_exn [Int_conversions] | |
int64_to_nativeint [Int_conversions] | |
int64_to_nativeint_exn [Int_conversions] | |
int_of_float [Common] | |
int_of_sexp [Std_internal] | |
int_to_int32 [Int_conversions] | |
int_to_int32_exn [Int_conversions] | |
int_to_int64 [Int_conversions] | |
int_to_nativeint [Int_conversions] | |
integral [Float_intf.S.Parts] | |
inter [Core_set_intf.Accessors] | |
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 .
|
interruptible_pause [Time] | interruptible_pause span sleeps for span time unless interrupted (e.g.
|
intersect [Interval_intf.Gen] | |
intersect [Flags_intf.S] | |
interval_timer_of_sexp [Unix] |
The three kinds of interval timers.
|
interval_timer_status_of_sexp [Unix] |
The type describing the status of an interval timer
|
invalid_argf [Printf] |
raises Invalid_arg
|
invalid_argf [Common] | |
invariant [Weekday] | |
invariant [Unpack_buffer] | |
invariant [Nano_mutex] | |
invariant [Linux_ext.Epoll] | |
invariant [Invariant.S3] | |
invariant [Invariant.S2] | |
invariant [Invariant.S1] | |
invariant [Invariant.S] | |
invariant [Hash_queue.S] | invariant t checks the invariants of the queue.
|
invariant [Hash_queue.Make] | |
invariant [Doubly_linked] | |
invariant [Dequeue] | |
invariant [Stack] | |
invariant [Core_hashtbl_intf.Accessors] | |
invariant [Bounded_int_table] | |
invariant [Blang] | |
invariant [Bag] | |
invariant [Avltree] |
check invariants, raise an exception if any invariants fail
|
invariants [Core_set_intf.Accessors] |
Test if invariants of internal AVL search tree hold.
|
invariants [Core_map_intf.Accessors] |
Test if invariants of internal AVL search tree hold.
|
inverse [List.Assoc] | |
iround [Float_intf.S] | |
iround_down [Float_intf.S] | |
iround_down_exn [Float_intf.S] | |
iround_exn [Float_intf.S] | |
iround_nearest [Float_intf.S] | |
iround_nearest_exn [Float_intf.S] | |
iround_towards_zero [Float_intf.S] | |
iround_towards_zero_exn [Float_intf.S] | |
iround_up [Float_intf.S] | |
iround_up_exn [Float_intf.S] | |
is_absolute [Filename] | |
is_activated [Timer] | is_activated timer
|
is_alpha [Char] |
'a' - 'z' or 'A' - 'Z'
|
is_alphanum [Char] |
'a' - 'z' or 'A' - 'Z' or '0' - '9'
|
is_business_day [Date] | |
is_char_escaped [String.Escaping] | is_char_escaped s ~escape_char pos return true if the char at pos is escaped,
false otherwise.
|
is_char_escaping [String.Escaping] |
Any char in an escaped string is either escaping, escaped or literal.
|
is_char_literal [String.Escaping] | is_literal s ~escape_char pos return true if the char at pos is not escaped or
escaping.
|
is_digit [Char] |
'0' - '9'
|
is_directory [Sys] |
Returns
`Yes if the file exists and is a directory
|
is_directory_exn [Sys] | |
is_empty [Unpack_buffer] | is_empty t returns true if t has no unconsumed bytes, and false if it does.
|
is_empty [Univ_map] | |
is_empty [Interval_intf.Gen] | |
is_empty [Heap] | is_empty heap
|
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 [Core_map_intf.Accessors] |
Test whether a map is empty or not.
|
is_empty [Core_hashtbl_intf.Accessors] | |
is_empty [Container.Generic_phantom] | |
is_empty [Container.Generic] | |
is_empty [Container.S1_phantom] | |
is_empty [Container.S1] | |
is_empty [Container.S0_phantom] | |
is_empty [Container.S0] | |
is_empty [Container.Make] | |
is_empty_or_singleton [Interval_intf.Gen] | |
is_error [Result] | |
is_file [Sys] |
Returns
`Yes if the file exists and is a regular file
|
is_file_exn [Sys] | |
is_finite [Float_intf.S] | |
is_first [Doubly_linked] | |
is_implicit [Filename] |
Return
true if the file name is relative and does not start
with an explicit reference to the current directory (./ or
../ in Unix), false if it starts with an explicit reference
to the root directory or the current directory.
|
is_inf [Float_intf.S] |
includes positive and negative Float.infinity
|
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] |
'a' - 'z'
|
is_mmapped [Bigstring] | is_mmapped bstr
|
is_nan [Float_intf.S] | |
is_none [Option] | is_none t returns true iff t = None.
|
is_none [Common] | |
is_ok [Result] | |
is_posix_pathname_component [Filename] | is_posix_pathname_component f
|
is_prefix [String] | is_prefix s ~prefix returns true if s starts with prefix .
|
is_print [Char] |
' ' - '~'
|
is_relative [Filename] |
Return
true if the file name is relative to the current
directory, false if it is absolute (i.e.
|
is_some [Option] | is_some t returns true iff t = Some x.
|
is_some [Common] | |
is_sorted [List] | |
is_sorted [Array] | |
is_subset [Interval_intf.Gen] | |
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_superset [Interval_intf.Gen] | is_superset i1 of_:i2 is whether i1 contains i2.
|
is_uppercase [Char] |
'A' - 'Z'
|
is_weekday [Date] | |
is_weekend [Date] | |
is_whitespace [Char] |
' ' or '\t' or '\r' or '\n'
|
isatty [Unix] |
Return
true if the given file descriptor refers to a terminal or
console window, false otherwise.
|
isrss [Unix.Resource_usage.Fields] | |
isrss [Unix.Resource_usage] | |
iter [Result] | |
iter [Linux_ext.Epoll] | |
iter [Heap] | |
iter [Hash_heap.S] | |
iter [Hash_heap.Make] | |
iter [Hash_queue.Make] | |
iter [Dequeue] | |
iter [Unix.Resource_usage.Fields.Direct] | |
iter [Unix.Resource_usage.Fields] | |
iter [Core_map_intf.Accessors] |
iterator for map
|
iter [Core_hashtbl_intf.Accessors] | |
iter [Gc.Control.Fields.Direct] | |
iter [Gc.Control.Fields] | |
iter [Gc.Stat.Fields.Direct] | |
iter [Gc.Stat.Fields] | |
iter [Container.Generic_phantom] | |
iter [Container.Generic] | |
iter [Container.S1_phantom] | |
iter [Container.S1] | |
iter [Container.S0_phantom] | |
iter [Container.S0] | |
iter [Container.Make] | |
iter [Bounded_int_table] | |
iter [Avltree] |
iterate over the tree
|
iter2 [Core_set_intf.Accessors] | |
iter2 [Core_map_intf.Accessors] |
Iterate two maps side by side.
|
iter2_exn [List] | List.iter2_exn f [a1; ...; an] [b1; ...; bn] calls in turn
f a1 b1; ...; f an bn .
|
iter2_exn [Array] | |
iter_el [Heap] | iter heap ~f iterate over heap with function f .
|
iter_elt [Doubly_linked] | |
iter_elt [Bag] | |
iter_error [Result] | |
iter_lines [In_channel] | iter_lines ?fix_win_eol t ~f applies f to each line read from t using
input_line .
|
iter_ready [Linux_ext.Epoll] | iter_ready and fold_ready iterate over the ready set computed by the last
call to wait .
|
iter_vals [Hash_heap.S] | |
iter_vals [Hash_heap.Make] | |
iter_vals [Core_hashtbl_intf.Accessors] | iter_vals t ~f is like iter, except it only supplies the value to f,
not the key.
|
iter_vals [Bounded_int_table] | |
iteri [Hash_queue.S] | iter t ~f applies f to each key and element of the queue.
|
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] |
Same as
Array.iter , but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
|
ixrss [Unix.Resource_usage.Fields] | |
ixrss [Unix.Resource_usage] | |
J | |
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.
|
K | |
kbprintf [Printf] | |
keys [Hash_queue.S] | keys t returns the keys in the order of the queue.
|
keys [Hash_queue.Make] | |
keys [Core_map_intf.Accessors] |
returns list of keys in map
|
keys [Core_hashtbl_intf.Accessors] |
Returns the list of all keys for given hashtable.
|
keys [Bounded_int_table] |
Standard hashtbl functions.
|
kfprintf [Printf] | |
kill [Signal] |
| Terminate | Termination (cannot be ignored) |
|
kilobytes [Byte_units] | |
known [Flags_intf.Make_arg] |
An entry
flag, name in known means that the flag bit is called name .
|
ksprintf [Printf] | |
L | |
largest_free [Gc.Stat.Fields] | |
largest_free [Gc.Stat] | |
last [Doubly_linked] | |
last [List] |
The final element of a list.
|
last [Array] | |
last [Avltree] | |
last_elt [Doubly_linked] | |
last_exn [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.
|
laws_exn [Quickcheck] |
Like laws, but throws an exception instead of returning an option.
|
lazy_from_fun [Lazy] | lazy_from_fun f is the same as lazy (f ()) but slightly more
efficient.
|
lazy_from_val [Lazy] | lazy_from_val v returns an already-forced suspension of v
This is for special purposes only and should not be confused with
lazy (v) .
|
lazy_is_val [Lazy] | lazy_is_val x returns true if x has already been forced and
did not raise an exception.
|
lazy_t_of_sexp [Std_internal] | |
lbound [Interval_intf.Gen_set] | |
lbound [Interval_intf.Gen] | |
lbound_exn [Interval_intf.Gen_set] | |
lbound_exn [Interval_intf.Gen] | |
ldexp [Float_intf.S] | |
ldexp [Common] | |
length [Thread_safe_queue] | |
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_heap.S] | |
length [Hash_heap.Make] | |
length [Hash_queue.Make] | |
length [Fqueue] |
complexity: O(1)
|
length [Dequeue] | |
length [Weak] | |
length [String] | |
length [Core_map_intf.Accessors] | length map
|
length [Core_hashtbl_intf.Accessors] | |
length [Container.Generic_phantom] | |
length [Container.Generic] | |
length [Container.S1_phantom] | |
length [Container.S1] | |
length [Container.S0_phantom] | |
length [Container.S0] | |
length [Container.Make] | |
length [Bounded_int_table] | |
length [Bigstring] | length bstr
|
length [Bigbuffer] |
Return the number of characters currently contained in the buffer.
|
level [Bucket.S] | |
level [Bucket.Make] | |
lexicographic [Comparable] | |
lfindi [String] | lfindi ?pos t ~f returns the smallest i >= pos such that f i t.[i] , if there is
such an i .
|
lg [Quickcheck] |
list generator
|
likely_machine_zones [Zone] | likely_machine_zones is a list of zone names that will be searched first when trying
to determine the machine zone of a box.
|
limit_of_sexp [Unix.RLimit] | |
link [Unix] | link ?force ~target ~link_name () creates a hard link named link_name
to the file named target .
|
list_intersect [Interval_intf.Gen] |
Assuming that
ilist1 and ilist2 are lists of (disjoint) intervals,
list_intersect ilist1 ilist2 returns the list of disjoint intervals that correspond
to the intersection of ilist1 with ilist2 .
|
list_of_sexp [Std_internal] | |
listed [Command.Spec] | listed flags may be passed zero or more times
|
listen [Unix] |
Set up a socket for receiving connection requests.
|
live_blocks [Gc.Stat.Fields] | |
live_blocks [Gc.Stat] | |
live_words [Gc.Stat.Fields] | |
live_words [Gc.Stat] | |
localhost [Unix.Inet_addr] |
Special addresses representing the host machine.
|
localhost_inet6 [Unix.Inet_addr] | |
localtime [Unix] |
Convert a time in seconds, as returned by
UnixLabels.time , into a date and
a time.
|
lock [Nano_mutex] | lock t locks the mutex t , blocking until it can be locked.
|
lock [Mutex] | lock mtx locks mtx , possibly waiting for it to be released
first by another thread.
|
lock_command_of_sexp [Unix] |
Commands for
Unix.lockf .
|
lock_exclusive [Unix.Flock_command] | |
lock_exn [Nano_mutex] | |
lock_shared [Unix.Flock_command] | |
lockf [Unix] | |
lookup [Hash_queue.S] | lookup t k returns the value of the key-value pair in the queue with
key k, if there is one.
|
lookup [Hash_queue.Make] | |
lookup_exn [Hash_queue.S] | |
lookup_exn [Hash_queue.Make] | |
lowercase [String] | |
lowercase [Char] |
Convert the given character to its equivalent lowercase character.
|
lpop [Squeue] |
returns the element popped and the length of the queue after
* this element was popped.
|
ls_dir [Sys] |
Same as readder, but return a list rather than an array.
|
lseek [Unix.Native_file] | |
lseek [Unix] | |
lsplit2 [String.Escaping] | |
lsplit2 [String] | lsplit2 line ~on optionally returns line split into two strings around the
* first appearance of on from the left
|
lsplit2_exn [String.Escaping] | |
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 ?drop s returns a string with consecutive chars satisfying drop (by default
white space, e.g.
|
M | |
machine [Unix.Utsname] | |
machine_zone [Zone] | machine_zone ?refresh () returns the machines zone (t).
|
majflt [Unix.Resource_usage.Fields] | |
majflt [Unix.Resource_usage] | |
major [Gc] |
Do a minor collection and finish the current major collection cycle.
|
major_collections [Gc.Stat.Fields] | |
major_collections [Gc.Stat] | |
major_heap_increment [Gc.Control.Fields] | |
major_heap_increment [Gc.Control] | |
major_slice [Gc] |
Do a minor collection and a slice of major collection.
|
major_words [Gc.Stat.Fields] | |
major_words [Gc.Stat] | |
make [String] | |
make [Random.State] |
Create a new state and initialize it with the given seed.
|
make_creator [Unix.Resource_usage.Fields] | |
make_creator [Gc.Control.Fields] | |
make_creator [Gc.Stat.Fields] | |
make_matrix [Array] | Array.make_matrix dimx dimy e returns a two-dimensional array
(an array of arrays) with first dimension dimx and
second dimension dimy .
|
make_self_init [Random.State] |
Create a new state and initialize it with a system-dependent low-entropy seed.
|
map [Unpack_buffer.Unpack_one] | |
map [Result] | |
map [Monad.S2] | |
map [Monad.Make2] | |
map [Monad.Make] | |
map [Interval_intf.Gen] | map t ~f returns create (f l) (f u) if bounds t = Some (l, u) , and empty if
t is empty.
|
map [Monad.S] | map t ~f is t >>| f.
|
map [Unix.Resource_usage.Fields] | |
map [String] | map f s applies f to each character in s , and returns the
resulting string.
|
map [Core_set_intf.Creators] | |
map [Queue] | |
map [Core_map_intf.Accessors] |
returns new map with bound values replaced by f applied to the bound values
|
map [List.Assoc] | |
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 [Core_hashtbl_intf.Accessors] | map t f returns new table with bound values replaced by
f applied to the bound values
|
map [Gc.Control.Fields] | |
map [Gc.Stat.Fields] | |
map [Array] | Array.map ~f a applies function f to all the elements of a ,
and builds an array with the results returned by f :
[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |] .
|
map [Command.Spec] |
parameter transformation
|
map [Bounded_int_table] | |
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_exn [List] | List.map2_exn f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn] .
|
map2_exn [Array] | |
map3 [Tuple.T3] | |
map3_exn [List] | |
map_error [Result] | |
map_file [Bigstring] | map_file shared fd n memory-maps n characters of the data
associated with descriptor fd to a bigstring.
|
map_poly [Unix.Resource_usage.Fields] | |
map_poly [Gc.Control.Fields] | |
map_poly [Gc.Stat.Fields] | |
mapi [String] | mapi f s applies f to each character in s and its index, and returns the
resulting string.
|
mapi [Core_map_intf.Accessors] |
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 [Core_hashtbl_intf.Accessors] |
like
map , but function takes both key and data as arguments
|
mapi [Array] |
Same as
Array.map , but the
function is applied to the index of the element as first argument,
and the element itself as second argument.
|
mapi [Bounded_int_table] | |
marshal [Bigstring_marshal] | marshal ?flags v marshals value v to a bigstring using marshalling
flags flags .
|
marshal_blit [Bigstring_marshal] | marshal_blit ?flags v ?pos ?len buf marshals value v to bigstring
buf starting at position pos and at most len bytes.
|
marshal_data_size [Bigstring_marshal] | marshal_data_size ?pos buf
|
marshal_to_fd [Bigstring_marshal] | marshal_to_fd ?buf fd v marshals data v to file descriptor fd
using marshalling buffer buf , and marshalling flags flags .
|
marshal_to_sock_no_sigpipe [Bigstring_marshal] | marshal_to_sock_no_sigpipe ?buf sock v same as Bigstring_marshal.marshal_to_fd , but
writes to sockets only and uses Bigstring.really_send_no_sigpipe
to avoid SIGPIPE on sockets.
|
match_ [Univ] | match_ t constr does a single constr match on a t for a given constructor.
|
max [Polymorphic_compare] | |
max [No_polymorphic_compare] | |
max [Int_set] | max t the biggest number in the set (if it exists)
|
max [Polymorphic_compare_intf.S] | |
max [Comparable.Make_common.Replace_polymorphic_compare] | |
max_elt [Core_set_intf.Accessors] | |
max_elt [Core_map_intf.Accessors] | max_elt map
|
max_elt_exn [Core_set_intf.Accessors] | |
max_elt_exn [Core_map_intf.Accessors] | |
max_finite_value [Float_intf.S] | |
max_float [Common] | |
max_inan [Float_intf.S] | |
max_int [Common] | |
max_iovecs [Unix.IOVec] | |
max_length [String] |
Maximum length of a string.
|
max_length [Array] |
Maximum length of a normal array.
|
max_overhead [Gc.Control.Fields] | |
max_overhead [Gc.Control] | |
max_value [Int_intf.S] | |
max_value [Float_intf.S] | |
max_value [Char] | |
maxrss [Unix.Resource_usage.Fields] | |
maxrss [Unix.Resource_usage] | |
maybe [Command.Spec] | (maybe anons) indicates that some anonymous arguments are optional
|
maybe_with_default [Command.Spec] | (maybe_with_default default anons) indicates an optional anonymous
argument with a default value
|
mcast_join [Unix] | mcast_join ?ifname sock addr join a multicast group at addr
with socket sock , optionally using network interface ifname .
|
mcast_leave [Unix] | mcast_leave ?ifname sock addr leaves a multicast group at addr
with socket sock , optionally using network interface ifname .
|
megabytes [Byte_units] | |
mem [Univ_map] | |
mem [Int_set] | mem t i test whether i is a member of the set
|
mem [Heap] | mem heap el
|
mem [Hash_set_intf.Accessors] | |
mem [Hash_heap.S] | |
mem [Hash_queue.S] | mem q k returns true iff there is some (k, v) in the queue.
|
mem [Hash_heap.Make] | |
mem [Hash_queue.Make] | |
mem [Core_set_intf.Accessors] | |
mem [Core_map_intf.Accessors] | mem map key tests whether map contains a binding for key
|
mem [List.Assoc] | |
mem [Core_hashtbl_intf.Accessors] | |
mem [Container.Generic_phantom] | |
mem [Container.Generic] | |
mem [Container.S1_phantom] | |
mem [Container.S1] | |
mem [Container.S0_phantom] | |
mem [Container.S0] | |
mem [Container.Make] | |
mem [Bounded_int_table] | |
mem [Avltree] |
return true if key is present in the tree, otherwise return false.
|
merge [Core_map_intf.Accessors] |
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 [Core_hashtbl_intf.Accessors] |
Merge two hashtables.
|
merge_into [Core_hashtbl_intf.Accessors] |
Merge one hashtable into another.
|
microsecond [Span] | |
millisecond [Span] | |
min [Polymorphic_compare] | |
min [No_polymorphic_compare] | |
min [Int_set] | min t the smallest number in the set (if it exists)
|
min [Polymorphic_compare_intf.S] | |
min [Comparable.Make_common.Replace_polymorphic_compare] | |
min_elt [Core_set_intf.Accessors] | |
min_elt [Core_map_intf.Accessors] | min_elt map
|
min_elt_exn [Core_set_intf.Accessors] | |
min_elt_exn [Core_map_intf.Accessors] | |
min_float [Common] | |
min_inan [Float_intf.S] |
min and max that return the other value if one of the values is a
nan .
|
min_int [Common] | |
min_positive_value [Float_intf.S] | |
min_value [Int_intf.S] | |
min_value [Float_intf.S] | |
min_value [Char] | |
minflt [Unix.Resource_usage.Fields] | |
minflt [Unix.Resource_usage] | |
minor [Gc] |
Trigger a minor collection.
|
minor_collections [Gc.Stat.Fields] | |
minor_collections [Gc.Stat] | |
minor_heap_size [Gc.Control.Fields] | |
minor_heap_size [Gc.Control] | |
minor_words [Gc.Stat.Fields] | |
minor_words [Gc.Stat] | |
minus_one [Int_intf.S] | |
minute [Span] | |
mkdir [Unix] |
Create a directory.
|
mkdir_p [Unix] |
Create a directory recursively.
|
mkdtemp [Unix] | 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] | mknod ?file_kind ?perm ?major ?minor path creates a filesystem
entry.
|
mkstemp [Unix] | 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 .
|
mlockall [Unix.Mman] | |
mod_float [Float_intf.S] | mod_float x y returns a result with the same sign as x .
|
mod_float [Common] | |
modf [Float_intf.S] | |
modf [Common] | |
mon [Weekday] | |
month [Date] | |
most_recent [Backtrace.Exn] | most_recent () returns a string containing the stack that was unwound by the
most recently raised exception.
|
msg_flag_of_sexp [Unix] |
The flags for
UnixLabels.recv , UnixLabels.recvfrom ,
UnixLabels.send and UnixLabels.sendto .
|
msgrcv [Unix.Resource_usage.Fields] | |
msgrcv [Unix.Resource_usage] | |
msgsnd [Unix.Resource_usage.Fields] | |
msgsnd [Unix.Resource_usage] | |
munlockall [Unix.Mman] | |
N | |
name [Univ.Constr] | |
name [Type_equal.Id] | |
name [Zone] | name zone returns the name of the time zone
|
name_info_of_sexp [Unix] |
Host and service information returned by
Unix.getnameinfo .
|
names [Unix.Resource_usage.Fields] | |
names [Gc.Control.Fields] | |
names [Gc.Stat.Fields] | |
nan [Float_intf.S] | |
nan [Common] | |
nanosecond [Span] | |
nanosleep [Unix] | nanosleep f delays execution of the program for at least f seconds.
|
nativeint [Random.State] | |
nativeint [Random] | Random.nativeint bound returns a random integer between 0 (inclusive) and bound
(exclusive).
|
nativeint_of_sexp [Std_internal] | |
nativeint_to_int [Int_conversions] | |
nativeint_to_int32 [Int_conversions] | |
nativeint_to_int32_exn [Int_conversions] | |
nativeint_to_int64 [Int_conversions] | |
nativeint_to_int_exn [Int_conversions] | |
neg [Span] |
negation
|
neg [Int_intf.S] | |
neg [Float_intf.S] | |
neg_infinity [Float_intf.S] | |
neg_infinity [Common] | |
never_returns [Never_returns] | |
never_returns [Common] | |
newline [Out_channel] | |
next [Doubly_linked] |
constant-time move to next or previous element.
|
next_key [Core_map_intf.Accessors] | rank t k if k is in t, returns the number of keys strictly less than k in t,
otherwise None
|
next_multiple [Time] | |
nget [String] | nget s i Gets the char at normalized position i in s .
|
nget [Array] |
Array access with
normalize d index.
|
nice [Unix.Priority] | |
nice [Unix.RLimit] | |
nice [Unix] |
Change the process priority.
|
nivcsw [Unix.Resource_usage.Fields] | |
nivcsw [Unix.Resource_usage] | |
nng [Quickcheck] |
natural number generator
|
no_arg [Command.Deprecated.Spec] | |
no_arg [Command.Spec] | no_arg flags may be passed at most once.
|
no_arg_abort [Command.Spec] | no_arg_abort ~exit is like no_arg , but aborts command-line parsing
by calling exit .
|
no_arg_register [Command.Spec] | no_arg_register ~key ~value is like no_arg , but associates value
with key in the in the auto-completion environment
|
no_raise_of_sexp [Sexp] | no_raise is the identity, but by using 'a no_raise in a sexpable type, the
resulting use sexp_of_no_raise protects the conversion of 'a to a sexp so that if
it fails, one gets a sexp with an error message about the failure, rather than an
exception being raised.
|
nodename [Unix.Utsname] | |
non [Fn] |
Negates a function
|
none [Linux_ext.Epoll.Flags] | |
normalize [Ordered_collection_common] | |
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.
|
not_ [Blang] | |
now [Time_internal.T] | |
now [Time] | |
now [Time.Ofday] | |
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.Resource_usage.Fields] | |
nsignals [Unix.Resource_usage] | |
nswap [Unix.Resource_usage.Fields] | |
nswap [Unix.Resource_usage] | |
nth [List] | |
nth [Bigbuffer] |
get the (zero-based) n-th character of the buffer.
|
nth_exn [List] |
Return the
n -th element of the given list.
|
num_bits [Word_size] | |
num_bits [Int_intf.S] | |
num_file_descriptors [Unix.RLimit] | |
num_threads [Thread] | num_threads () attempts to return the number of currently running
threads by parsing /proc.
|
nvcsw [Unix.Resource_usage.Fields] | |
nvcsw [Unix.Resource_usage] | |
O | |
ocaml_version [Sys] | ocaml_version is the version of Objective Caml.
|
occurrence [Time] | occurrence side time ~ofday ~zone returns a Time.t that is the occurrence of ofday
(in the given zone ) that is the latest occurrence (<=) time or the earliest
occurrence (>=) time , according to side .
|
of_alist [Core_map_intf.Creators] |
creates map from association list with unique keys
|
of_alist [Core_hashtbl_intf.Creators] | |
of_alist [Bounded_int_table.With_key] | |
of_alist_exn [Core_map_intf.Creators] |
creates map from association list with unique keys.
|
of_alist_exn [Core_hashtbl_intf.Creators] | |
of_alist_exn [Bounded_int_table.With_key] | |
of_alist_fold [Core_map_intf.Creators] |
combines an association list into a map, folding together bound values with common
keys
|
of_alist_multi [Core_map_intf.Creators] |
creates map from association list with possibly repeated keys.
|
of_alist_multi [Core_hashtbl_intf.Creators] | |
of_alist_report_all_dups [Core_hashtbl_intf.Creators] | |
of_array [Heap] | of_array ?min_size cmp ar
|
of_array [Core_set_intf.Creators] | |
of_array [Queue] | |
of_bigstring [Substring_intf.S] | |
of_bigstring [Make_substring.Base] | |
of_bigstring [Make_substring.F] | |
of_bigstring [Unix.IOVec] | of_bigstring ?pos ?len bstr
|
of_bigstring [Binable0] | |
of_bigstring [Binable] | |
of_caml_int [Signal] | of_caml_int constructs a Signal.t given an O'Caml internal signal number.
|
of_char [String] | |
of_char_list [String] | |
of_code [Unix.Exit] | |
of_date_ofday [Time] | |
of_day [Span] | |
of_exn [Or_error] | of_exn exn is Error (Error.of_exn exn) .
|
of_exn [Info] | |
of_exn_result [Or_error] | of_exn_result (Ok a) = Ok a , of_exn_result (Error exn) = of_exn exn
|
of_filename_string [Time] | of_filename_string s converts s that has format YYYY-MM-DD_HH-MM-SS.mmm into
time
|
of_float [Floatable.S] | |
of_float [Int64] | |
of_hashtbl_keys [Hash_set_intf.Accessors] | |
of_hr [Span] | |
of_int [Weekday] | of_int i returns i'th weekday if i is in 0,1,...,6.
|
of_int [Pid] | |
of_int [Ordering] | of_int n is
|
of_int [Month] | of_int i returns i'th month if i is in 1,2,...,12.
|
of_int [Linux_ext.Priority] | |
of_int [Float_intf.S] | |
of_int [Flags_intf.S] | |
of_int [Unix.File_descr] | |
of_int [Nativeint] | |
of_int [Int64] | |
of_int [Int63] | |
of_int [Int32] | |
of_int [Int] | |
of_int [Char] |
Return the character with the given ASCII code or
None is the argument is outside
the range 0 to 255.
|
of_int32 [Nativeint] | |
of_int32 [Int64] | |
of_int32 [Int32] | |
of_int32 [Int] | |
of_int32_exn [Int_intf.S] | |
of_int64 [Float_intf.S] | |
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 [Intable.S] | |
of_int_exn [Char] |
Return the character with the given ASCII code.
|
of_int_sec [Span] | |
of_int_style [Sexp] | |
of_key [Core_hashtbl_intf.Hashable] | |
of_lazy [Info] |
Be careful that the body of the lazy or thunk does not access mutable data, since it
will only be called at an undetermined later point.
|
of_list [Info] | |
of_list [Hash_set_intf.Creators] | |
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 [Stack] | of_list l returns a stack whose top is the first element of l and
* bottom is the last element of l .
|
of_list [Core_set_intf.Creators] | |
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] | Array.of_list l returns a fresh array containing the elements
of l .
|
of_list [Bag] | |
of_list_map [Array] | of_list_map l ~f is the same as of_list (List.map l ~f)
|
of_list_rev [Array] | of_list_rev l converts from list then reverses in place
|
of_list_rev_map [Array] | of_list_rev_map l ~f is the same as rev_inplace (of_list_map l ~f)
|
of_local_date_ofday [Time] | |
of_localized_string [Time] | of_localized_string zone str read in the given string assuming that it represents
a time in zone and return the appropriate Time.t
|
of_map [Command.Spec.Arg_type] | |
of_min [Span] | |
of_ms [Span] | |
of_nativeint [Nativeint] | |
of_nativeint [Int64] | |
of_nativeint [Int32] | |
of_nativeint [Int] | |
of_nativeint_exn [Int_intf.S] | |
of_ns [Span] | |
of_option [Result] | |
of_sec [Span] | |
of_sorted_array [Core_set_intf.Creators] |
Create set from sorted array.
|
of_sorted_array [Core_map_intf.Creators] |
creates map from sorted array of key-data pairs.
|
of_sorted_array_unchecked [Core_set_intf.Creators] |
Similar to
of_sorted_arary without checking the input array.
|
of_sorted_array_unchecked [Core_map_intf.Creators] |
Like
of_sorted_array except behavior is undefined when an Error would have been
returned.
|
of_span_since_start_of_day [Ofday] | |
of_string [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 [Info] | |
of_string [Unix.IOVec] | of_string ?pos ?len str
|
of_string [Unix.Inet_addr] |
Conversion from the printable representation of an Internet address to its internal
representation.
|
of_string [Binable] | |
of_string [Bigstring] | of_string ?pos ?len str
|
of_string_abs [Time] | |
of_string_fix_proto [Time] | |
of_string_iso8601_basic [Date] | |
of_string_iso8601_extended [Ofday] | |
of_string_or_getbyname [Unix.Inet_addr] |
Call
of_string and if that fails, use Host.getbyname .
|
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_system_int [Unix.Error] | |
of_thunk [Only_in_test] | |
of_thunk [Info] | |
of_time [Time.Date] | |
of_tm [Date] | |
of_tree [Core_set_intf.Creators] | |
of_tree [Core_map_intf.Creators] | |
of_unix [Unix.Exit_or_signal_or_stop] | of_unix assumes that any signal numbers in the incoming value are O'Caml internal
signal numbers.
|
of_unix [Unix.Exit_or_signal] | of_unix assumes that any signal numbers in the incoming value are O'Caml internal
signal numbers.
|
of_us [Span] | |
of_utc_offset [Zone] | of_utc_offset offset returns a timezone with a static UTC offset (given in
hours).
|
ok [Result] | |
ok_exn [Result] | ok_exn t returns x if t = Ok x , and raises exn if t = Error exn
|
ok_exn [Or_error] | ok_exn t throws an exception if t is an Error , and otherwise returns the
contents of the Ok constructor.
|
ok_fst [Result] | ok_fst is useful with List.partition_map .
|
ok_if_true [Result] | |
ok_or_failwith [Result] | |
ok_unit [Result] | ok_unit = Ok () , used to avoid allocation as a performance hack
|
one [Int_intf.S] | |
oneshot [Linux_ext.Epoll.Flags] | |
open_connection [Unix] |
Connect to a server at the given address.
|
open_flag_of_sexp [Unix] | |
open_in_gen [Sys_open_patch] |
Reimplementation of
Pervasives.open_in_gen
|
open_out_gen [Sys_open_patch] |
Reimplementation of
Pervasives.open_out_gen
|
open_process [Unix] |
See
UnixLabels.open_process_in .
|
open_process_full [Unix] | |
open_process_in [Unix] |
High-level pipe and process management.
|
open_process_out [Unix] |
See
UnixLabels.open_process_in .
|
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.
|
option_of_sexp [Std_internal] | |
optional [Command.Spec] |
optional flags may be passed at most once
|
optional_with_default [Command.Spec] | optional_with_default flags may be passed at most once, and
default to a given value
|
or_ [Blang] | |
os_type [Sys] |
Operating system currently executing the Caml program.
|
oublock [Unix.Resource_usage.Fields] | |
oublock [Unix.Resource_usage] | |
ounit_tests [With_return] | |
ounit_tests [Unique_id_intf] | |
ounit_tests [Time_internal] | |
ounit_tests [Time] | |
ounit_tests [Sys_open_patch] | |
ounit_tests [Std_internal] | |
ounit_tests [Word_size] | |
ounit_tests [Weekday] | |
ounit_tests [Uuid] | |
ounit_tests [Unpack_buffer] | |
ounit_tests [Univ_map] | |
ounit_tests [Univ] | |
ounit_tests [Unit] | |
ounit_tests [Unique_id] | |
ounit_tests [Union_find] | |
ounit_tests [Type_equal] | |
ounit_tests [Tuple] | |
ounit_tests [Timer] | |
ounit_tests [Thread_safe_queue] | |
ounit_tests [Substring_intf] | |
ounit_tests [Substring] | |
ounit_tests [String_id] | |
ounit_tests [Stringable] | |
ounit_tests [Zone] | |
ounit_tests [Std] | |
ounit_tests [Staged] | |
ounit_tests [Stable_unit_test_intf] | |
ounit_tests [Stable_unit_test] | |
ounit_tests [Stable_internal] | |
ounit_tests [Stable_containers] | |
ounit_tests [Stable.Unit_tests] | |
ounit_tests [Stable_unit_test_intf.S] | |
ounit_tests [Stable] | |
ounit_tests [Squeue] | |
ounit_tests [Span] | |
ounit_tests [Space_safe_tuple] | |
ounit_tests [Source_code_position0] | |
ounit_tests [Source_code_position] | |
ounit_tests [Signal] | |
ounit_tests [Sexpable] | |
ounit_tests [Set_once] | |
ounit_tests [Robustly_comparable] | |
ounit_tests [Result] | |
ounit_tests [Ref] | |
ounit_tests [Quickcheck] | |
ounit_tests [Pretty_printer] | |
ounit_tests [Polymorphic_compare_intf] | |
ounit_tests [Polymorphic_compare] | |
ounit_tests [Piecewise_linear] | |
ounit_tests [Pid] | |
ounit_tests [Out_channel] | |
ounit_tests [Or_error] | |
ounit_tests [Ordering] | |
ounit_tests [Ordered_collection_common] | |
ounit_tests [Option] | |
ounit_tests [Only_in_test] | |
ounit_tests [Ofday] | |
ounit_tests [No_polymorphic_compare] | |
ounit_tests [Never_returns] | |
ounit_tests [Nano_mutex] | |
ounit_tests [Mutex0] | |
ounit_tests [Month] | |
ounit_tests [Monad] | |
ounit_tests [Memo] | |
ounit_tests [Make_substring] | |
ounit_tests [Lock_file] | |
ounit_tests [Linux_ext] | |
ounit_tests [Invariant] | |
ounit_tests [Int_set] | |
ounit_tests [Int_replace_polymorphic_compare] | |
ounit_tests [Int_intf] | |
ounit_tests [Interval_intf] | |
ounit_tests [Interval] | |
ounit_tests [Interfaces] | |
ounit_tests [Int_conversions] | |
ounit_tests [Intable] | |
ounit_tests [Inline_tests] | |
ounit_tests [Info] | |
ounit_tests [In_channel] | |
ounit_tests [Identifiable] | |
ounit_tests [Host_and_port] | |
ounit_tests [Heap_block] | |
ounit_tests [Heap] | |
ounit_tests [Hash_set_intf] | |
ounit_tests [Hash_set] | |
ounit_tests [Hash_queue] | |
ounit_tests [Hash_heap] | |
ounit_tests [T] | |
ounit_tests [Hashable] | |
ounit_tests [Fqueue] | |
ounit_tests [Force_once] | |
ounit_tests [Fn] | |
ounit_tests [Float_robust_compare] | |
ounit_tests [Float_intf] | |
ounit_tests [Floatable] | |
ounit_tests [Float] | |
ounit_tests [Flags_intf] | |
ounit_tests [Flags] | |
ounit_tests [Exn] | |
ounit_tests [Error] | |
ounit_tests [Equal] | |
ounit_tests [Doubly_linked] | |
ounit_tests [Dequeue] | |
ounit_tests [Date] | |
ounit_tests [Daemon] | |
ounit_tests [Crc] | |
ounit_tests [Weak] | |
ounit_tests [Unix] | |
ounit_tests [Thread] | |
ounit_tests [Sys] | |
ounit_tests [String] | |
ounit_tests [Stack] | |
ounit_tests [Sexp] | |
ounit_tests [Core_set_unit_tests] | |
ounit_tests [Core_set_intf] | |
ounit_tests [Set] | |
ounit_tests [Queue] | |
ounit_tests [Printf] | |
ounit_tests [Printexc] | |
ounit_tests [Nativeint] | |
ounit_tests [Mutex] | |
ounit_tests [Core_map_unit_tests] | |
ounit_tests [Core_map_intf] | |
ounit_tests [Map] | |
ounit_tests [List] | |
ounit_tests [Lazy] | |
ounit_tests [Int64] | |
ounit_tests [Int63] | |
ounit_tests [Int32] | |
ounit_tests [Int] | |
ounit_tests [Core_hashtbl_intf] | |
ounit_tests [Hashtbl] | |
ounit_tests [Gc] | |
ounit_tests [Filename] | |
ounit_tests [Field] | |
ounit_tests [Condition] | |
ounit_tests [Char] | |
ounit_tests [Bin_prot] | |
ounit_tests [Array] | |
ounit_tests [Arg] |
Stop interpreting keywords and call the
function with each remaining argument
|
ounit_tests [Container] | |
ounit_tests [Constrained_float] | |
ounit_tests [Comparator] | |
ounit_tests [Comparable] | |
ounit_tests [Commutative_group] | |
ounit_tests [Common] | |
ounit_tests [Command] | |
ounit_tests [Caml] | |
ounit_tests [Byte_units] | |
ounit_tests [Bucket] | |
ounit_tests [Bounded_int_table] | |
ounit_tests [Bool] | |
ounit_tests [Blang] | |
ounit_tests [Binary_packing] | |
ounit_tests [Binable0] | |
ounit_tests [Binable] | |
ounit_tests [Bigsubstring] | |
ounit_tests [Bigstring_marshal] | |
ounit_tests [Bigstring] | |
ounit_tests [Bigbuffer] |
The abstract type of buffers.
|
ounit_tests [Bag] | |
ounit_tests [Backtrace] | |
ounit_tests [Avltree] | |
ounit_tests [Random] | |
ounit_tests [Array_permute] | |
out [Linux_ext.Epoll.Flags] | |
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
|
outer_of_sexp [Float_intf.S] | |
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] |
Outputs a list of lines, each terminated by a newline character
|
output_string [Out_channel] | |
output_value [Out_channel] | |
P | |
pack_float [Binary_packing] | |
pack_padded_fixed_string [Binary_packing] |
Encode and pack the given string as a padded fixed length string having length
len .
|
pack_signed_16 [Binary_packing] | |
pack_signed_16_big_endian [Binary_packing] | |
pack_signed_16_little_endian [Binary_packing] | |
pack_signed_32 [Binary_packing] | |
pack_signed_32_int [Binary_packing] | |
pack_signed_32_int_big_endian [Binary_packing] | |
pack_signed_32_int_little_endian [Binary_packing] | |
pack_signed_64 [Binary_packing] | |
pack_signed_64_big_endian [Binary_packing] | |
pack_signed_64_int [Binary_packing] | |
pack_signed_64_little_endian [Binary_packing] | |
pack_signed_8 [Binary_packing] | |
pack_unsigned_16 [Binary_packing] | |
pack_unsigned_16_big_endian [Binary_packing] | |
pack_unsigned_16_little_endian [Binary_packing] | |
pack_unsigned_32_int [Binary_packing] | |
pack_unsigned_32_int_big_endian [Binary_packing] | |
pack_unsigned_32_int_little_endian [Binary_packing] | |
pack_unsigned_8 [Binary_packing] | |
parent_dir_name [Filename] |
The conventional name for the parent of the current directory
(e.g.
|
parse [Arg] | Arg.parse speclist anon_fun usage_msg parses the command line.
|
parse_argv [Arg] | Arg.parse_argv ~current args speclist anon_fun usage_msg parses
the array args as if it were the command line.
|
parse_four_digits [Time_internal.Helpers] | |
parse_two_digits [Time_internal.Helpers] | |
partial_iter [Queue] | partial_iter t ~f iterates through t until f returns `Stop
|
partition_map [List] | partition_map t ~f partitions t according to f .
|
partition_map [Core_hashtbl_intf.Accessors] |
returns new maps with bound values partitioned by f applied to the bound values
|
partition_mapi [Core_hashtbl_intf.Accessors] |
like
partition_map , but function takes both key and data as arguments
|
partition_tf [Core_set_intf.Accessors] | |
partition_tf [List] | partition_tf 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_tf [Core_hashtbl_intf.Accessors] | |
partition_tf [Array] | |
partitioni_tf [Core_hashtbl_intf.Accessors] | |
partitioni_tf [Array] | |
parts [Filename] | parts filename returns a list of path components in order.
|
path [Command.Spec] |
the subcommand path of the command
|
pause [Time] | pause span sleeps for span time.
|
pause [Unix] |
Wait until a non-ignored, non-blocked signal is delivered.
|
pause_forever [Time] | pause_forever sleeps indefinitely.
|
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] | |
permute [List] | permute ?random_state t returns a permutation of t .
|
permute [Array] | permute ?random_state t randomly permutes t in place.
|
permute [Array_permute] |
randomly permute an array.
|
pg [Quickcheck] |
pair generator
|
phys_equal [Mutex0] | |
phys_equal [Common] | |
pipe [Signal] |
| Terminate | Broken pipe |
|
pipe [Unix] |
Create a pipe.
|
poly [Core_hashtbl_intf.Hashable] | |
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 [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 [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] | |
port [Host_and_port] | |
pos [Out_channel] | |
pos [Substring_intf.S] | |
pos [Make_substring.F] | |
pos [In_channel] | |
pos_in [Common] | |
pos_out [Common] | |
pp [Time] | |
pp [Zone] | |
pp [Span] | |
pp [Ofday] | |
pp [Identifiable.S] | |
pp [Exn] | |
pp [Date] | |
pp [String] |
This has to be public for interactive top-levels.
|
pr_get_name [Linux_ext] | pr_get_name () gets the name of the executing thread.
|
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_name_first16 [Linux_ext] | pr_set_name_first16 name sets the name of the executing thread to name .
|
pr_set_pdeathsig [Linux_ext] | pr_set_pdeathsig s sets the signal s to be sent to the executing
process when its parent dies.
|
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
|
prev [Doubly_linked] | |
prev_key [Core_map_intf.Accessors] | prev_key t k returns the largest (key, value) pair in t with key less than k
|
previous_weekday [Date] | |
pri [Linux_ext.Epoll.Flags] | |
print [Printexc] | |
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] | |
process_times_of_sexp [Unix] |
The execution times (CPU times) of a process.
|
prof [Signal] |
| Terminate | Profiling interrupt |
|
promoted_words [Gc.Stat.Fields] | |
promoted_words [Gc.Stat] | |
protect [Exn] | |
protect [Common] |
See exn.mli
|
protectx [Exn] |
Executes
f and afterwards executes finally , whether f throws an exception or
not.
|
protectx [Common] | |
pselect [Unix] | 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 [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_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] |
| Dump_core | Interactive termination |
|
quote [Filename] |
Return a quoted version of a file name, suitable for use as
one argument in a command line, escaping all meta-characters.
|
R | |
raise [Error] | |
randomize [Span] | randomize t ~percent returns a span +/- percent * original span.
|
range [List] | range ?stride ?start ?stop start_i stop_i is the list of integers from start_i to
stop_i , stepping by stride .
|
range_to_alist [Core_map_intf.Accessors] | range_to_alist t ~min ~max returns an associative list of the elements whose
keys lie in min, max (inclusive), with the smallest key being at the head of the
list.
|
ranges [Int_set] | ranges t return a list of all ranges that make up the set
|
rank [Core_map_intf.Accessors] | |
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_all [In_channel] | read_all filename Opens filename, reads all input, and closes the file.
|
read_assume_fd_is_nonblocking [Unix] | 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 [In_channel] | read_lines filename Opens filename, reads all lines, and closes the file.
|
read_only_of_sexp [Common] | |
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] | 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 [Filename] | realpath path
|
record_backtrace [Printexc] | |
recv [Unix] |
Receive data from an unconnected socket.
|
recvfrom [Unix] |
Receive data from an unconnected socket.
|
recvfrom_assume_fd_is_nonblocking [Bigstring] | recvfrom_assume_fd_is_nonblocking sock ?pos ?len bstr reads up to
len bytes into bigstring bstr starting at position pos from
socket sock without yielding to other OCaml-threads.
|
reduce [List] | |
reduce [Array] | reduce f [a1; ...; an] is Some (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] | |
refl [Type_equal] | refl , sym , and trans construct proofs that type equality is reflexive,
symmetric, and transitive.
|
register [Pretty_printer] | |
release [Unix.Utsname] | |
rem [Int_intf.S] | |
remove [Timer] | remove event removes event from its associated timer.
|
remove [Linux_ext.Epoll] | |
remove [Heap] | remove heap_el removes heap_el from its associated heap.
|
remove [Hash_set_intf.Accessors] | |
remove [Hash_heap.S] | |
remove [Hash_queue.S] | |
remove [Hash_heap.Make] | |
remove [Hash_queue.Make] | |
remove [Doubly_linked] |
constant-time removal of an element.
|
remove [Sys] |
Remove the given file name from the file system.
|
remove [Core_set_intf.Accessors] | |
remove [Core_map_intf.Accessors] |
returns a new map with any binding for the key in question removed
|
remove [List.Assoc] | |
remove [Core_hashtbl_intf.Accessors] | |
remove [Bounded_int_table] | |
remove [Bag] | remove t elt removes elt from the bag t , raising an exception if elt
is not in the bag.
|
remove [Avltree] |
remove key destructively from the tree if it exists, return the new root node.
|
remove_exn [Hash_queue.S] | |
remove_exn [Hash_queue.Make] | |
remove_first [Doubly_linked] | |
remove_index [Core_set_intf.Accessors] | |
remove_last [Doubly_linked] | |
remove_multi [Core_hashtbl_intf.Accessors] | remove_multi t key updates the table, removing the head of the list bound to
key .
|
remove_one [Core_hashtbl_intf.Accessors] | |
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] | |
replace [Ref] | replace t f is t := f !t
|
replace [Hash_heap.S] | |
replace [Hash_queue.S] | replace q k v changes the value of key k in the queue to v.
|
replace [Hash_heap.Make] | |
replace [Hash_queue.Make] | |
replace [Core_hashtbl_intf.Accessors] | |
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] | |
required [Command.Spec] |
required flags must be passed exactly once
|
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 [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 Bigbuffer.create n .
|
resource_of_sexp [Unix.RLimit] | |
retry_until_no_eintr [Unix] | retry_until_no_eintr f returns f () unless f () fails with EINTR ; in which
case f () is run again until it raises a different error or returns a value.
|
return [Monad.S2] | |
return [Monad.Basic2] | |
return [Monad.Basic] | |
return [Monad.Make2] | |
return [Monad.Make] | |
return [Monad.S] | return v returns the (trivial) computation that returns v.
|
rev [List] |
List reversal.
|
rev_append [List] | List.rev_append l1 l2 reverses l1 and concatenates it to l2 .
|
rev_filter [List] |
Like
filter , but reverses the order of the input 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_filter_mapi [List] |
rev_filter_mapi is just like rev_filter_map, but it also passes in the index of each
element as the first argument to the mapped function.
|
rev_inplace [Array] | rev_inplace t reverses t in place
|
rev_map [List] | List.rev_map f l gives the same result as
List.rev ( ListLabels.map f l) , but is more efficient.
|
rev_map2_exn [List] | List.rev_map2_exn f l1 l2 gives the same result as
List.rev ( List.map2_exn f l1 l2) , but is more efficient.
|
rev_map3_exn [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 .
|
rev_mapi [List] | |
rewinddir [Unix] |
Reposition the descriptor to the beginning of the directory
|
rfindi [String] | rfindi ?pos t ~f returns the largest i <= pos such that f i t.[i] , if there is
such an i .
|
rindex [String.Escaping] | rindex s ~escape_char char find the first literal (not escaped) instance of
char in s starting from the end of s and proceeding towards 0.
|
rindex [String] | |
rindex_exn [String.Escaping] | |
rindex_exn [String] | |
rindex_from [String.Escaping] | rindex_from s ~escape_char pos char find the first literal (not escaped)
instance of char in s starting from pos and towards 0.
|
rindex_from [String] | |
rindex_from_exn [String.Escaping] | |
rindex_from_exn [String] | |
rmdir [Unix] |
Remove an empty directory.
|
robustly_compare [Robustly_comparable.S] | |
root [Filename] |
The path of the root.
|
round [Std_internal] | |
round [Float_intf.S] | |
round_down [Float_intf.S] | |
round_nearest [Float_intf.S] | |
round_towards_zero [Float_intf.S] | |
round_up [Float_intf.S] | |
rsplit2 [String.Escaping] | |
rsplit2 [String] | rsplit2 line ~on optionally returns line split into two strings around the
* first appearance of on from the right
|
rsplit2_exn [String.Escaping] | |
rsplit2_exn [String] |
If the string
s contains the character on , then rsplit2_exn
s ~on returns a pair containing s split around the first
appearance of on (from the right).
|
rstrip [String] | rstrip ?drop s returns a string with consecutive chars satisfying drop (by default
white space, e.g.
|
run [Inline_tests] | |
run [Command.Deprecated] | |
run [Command] |
run a command against
Sys.argv
|
S | |
same [Type_equal.Id] | same_witness t1 t2 and same_witness_exn t1 t2 return a type equality proof iff
the two identifiers are physically equal.
|
same_class [Union_find] | same_class t1 t2 returns true iff t1 and t2 are in the same equivalence class.
|
same_witness [Type_equal.Id] | |
same_witness_exn [Type_equal.Id] | |
sat [Weekday] | |
scale [Span] | |
scale [Float_intf.S] | |
sched_setaffinity [Linux_ext] | |
sched_setaffinity_this_thread [Linux_ext] | |
sec [Std] | |
second [Span] | |
seek [Out_channel] | |
seek [In_channel] | |
seek_command_of_sexp [Unix] |
POSITIONING modes for
UnixLabels.lseek .
|
seek_in [Common] | |
seek_out [Common] | |
segv [Signal] |
| Dump_core | Invalid memory reference |
|
select [Unix] |
Setting restart to true means that we want select to restart automatically
on EINTR (instead of propagating the exception)...
|
self [Thread] |
Return the thread currently executing.
|
self_init [Random] |
Initialize the generator with a more-or-less random seed chosen in a system-dependent
way.
|
send [Signal] | send signal pid sends signal to the process whose process id is pid .
|
send [Unix] |
Send data over an unconnected socket.
|
send_exn [Signal] | send_exn signal ~pid sends signal to the process whose process id is
* pid .
|
send_i [Signal] | send_i signal ~pid sends signal to the process whose process id is pid .
|
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] | sendfile ?pos ?len ~fd sock sends mmap-able data from file
descriptor fd to socket sock using offset pos and length len .
|
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.
|
sendto_nonblocking_no_sigpipe [Bigstring] | sendto_nonblocking_no_sigpipe sock ?pos ?len bstr sockaddr tries
to send len bytes in bigstring bstr starting at position pos
to socket sock using address addr .
|
sequence [Command.Spec] | sequence anons specifies a sequence of anonymous arguments.
|
set [Univ_map.Multi] | |
set [Univ_map.With_fold] | |
set [Univ_map.With_default] | |
set [Univ_map] | |
set [Union_find] | set t v sets the value of the class of t to v .
|
set [Signal] | set t b is ignore (signal t b)
|
set [Set_once] | |
set [Linux_ext.Epoll] | |
set [Weak] | |
set [Unix.Scheduler] | |
set [Unix.RLimit] | |
set [String] | |
set [Core_hashtbl_intf.Accessors] | |
set [Gc] | set r changes the GC parameters according to the control record r .
|
set [Array] | Array.set a n x modifies array a in place, replacing
element number n with x .
|
set [Bounded_int_table] | |
set [Bigstring] | set t pos sets the character at pos
|
set_allocation_policy [Gc.Control] | |
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_exn [Dequeue] | |
set_in_channel_timeout [Unix] |
Set a timeout for a socket associated with an
in_channel
|
set_major_heap_increment [Gc.Control] | |
set_max_overhead [Gc.Control] | |
set_minor_heap_size [Gc.Control] | |
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_recording [Backtrace.Exn] | |
set_space_overhead [Gc.Control] | |
set_stack_limit [Gc.Control] | |
set_state [Random] |
Set the state of the generator used by the basic functions.
|
set_time [Linux_ext.Clock] | |
set_verbose [Gc.Control] | |
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.
|
setpriority [Linux_ext] |
Set the calling thread's priority in the linux scheduler
|
setpwent [Unix.Passwd.Low_level] | |
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] |
Sets the real user id and effective user id for the process.
|
sexp_of___ [Common] | |
sexp_of_addr_info [Unix] | |
sexp_of_array [Std_internal] | |
sexp_of_bool [Std_internal] | |
sexp_of_char [Std_internal] | |
sexp_of_decimal [Common] | |
sexp_of_env [Unix] | |
sexp_of_error [Unix.Exit_or_signal_or_stop] | |
sexp_of_error [Unix.Exit_or_signal] | |
sexp_of_error [Unix.Exit] | |
sexp_of_error [Unix] |
Unknown error
|
sexp_of_exn [Std_internal] | |
sexp_of_file_kind [Unix] |
Socket
|
sexp_of_file_perm [Unix] | |
sexp_of_float [Std_internal] | |
sexp_of_flow_action [Unix.Terminal_io] | |
sexp_of_flush_queue [Unix.Terminal_io] | |
sexp_of_getaddrinfo_option [Unix] | |
sexp_of_getnameinfo_option [Unix] | |
sexp_of_heap_el [Heap] |
Type of heap elements (they can be efficiently removed)
|
sexp_of_immutable [Common] | |
sexp_of_int [Std_internal] | |
sexp_of_int32 [Std_internal] | |
sexp_of_int64 [Std_internal] | |
sexp_of_int_style [Int_conversions] | |
sexp_of_interval_timer [Unix] |
(for profiling) decrements both when the process
is running and when the system is running on behalf of the
process; it sends
SIGPROF when expired.
|
sexp_of_interval_timer_status [Unix] | |
sexp_of_key [Core_hashtbl_intf.Accessors] | |
sexp_of_lazy_t [Std_internal] | |
sexp_of_limit [Unix.RLimit] | |
sexp_of_list [Std_internal] | |
sexp_of_lock_command [Unix] |
Lock a region for reading, or fail if already locked
|
sexp_of_msg_flag [Unix] | |
sexp_of_name_info [Unix] |
Name of service or port number
|
sexp_of_nativeint [Std_internal] | |
sexp_of_never_returns [Never_returns] | |
sexp_of_never_returns [Common] | never_returns should be used as the return type of functions that don't return and
might block forever, rather than 'a or _ .
|
sexp_of_no_raise [Sexp] | |
sexp_of_open_flag [Unix] |
Windows only: allow the file to be deleted while still open
|
sexp_of_option [Std_internal] | |
sexp_of_outer [Float_intf.S] | |
sexp_of_process_times [Unix] | |
sexp_of_read_only [Common] | |
sexp_of_read_write [Common] | |
sexp_of_resource [Unix.RLimit] | |
sexp_of_seek_command [Unix] |
indicates positions relative to the end of the file
|
sexp_of_select_timeout [Unix] | |
sexp_of_setattr_when [Unix.Terminal_io] | |
sexp_of_shutdown_command [Unix] |
Close both
|
sexp_of_sockaddr [Unix] | |
sexp_of_socket_bool_option [Unix] |
Forbid binding an IPv6 socket to an IPv4 address
|
sexp_of_socket_domain [Unix] | |
sexp_of_socket_float_option [Unix] |
Timeout for output operations
|
sexp_of_socket_int_option [Unix] | |
sexp_of_socket_type [Unix] | |
sexp_of_stats [Unix.Native_file] | |
sexp_of_stats [Unix] | |
sexp_of_string [Std_internal] | |
sexp_of_sys_behavior [Signal] | |
sexp_of_sysconf [Unix] | |
sexp_of_t [Time] | |
sexp_of_t [Weekday] | |
sexp_of_t [Uuid] | |
sexp_of_t [Unpack_buffer] | |
sexp_of_t [Univ_map.Key] | create name to_sexp generates a fresh key.
|
sexp_of_t [Univ_map] | |
sexp_of_t [Univ.Constr] | |
sexp_of_t [Univ] | |
sexp_of_t [Unique_id_intf.Id] | |
sexp_of_t [Type_equal.Id] | |
sexp_of_t [Tuple.Hashable_sexpable] | |
sexp_of_t [Tuple.Comparable_sexpable] | |
sexp_of_t [Tuple.T3] | |
sexp_of_t [Tuple.T2] | |
sexp_of_t [Thread_safe_queue] | |
sexp_of_t [Zone] | |
sexp_of_t [Stable_containers.Map.V1] | |
sexp_of_t [Stable_containers.Hash_set.V1] | |
sexp_of_t [Stable_containers.Hashtbl.V1] | |
sexp_of_t [Stable_containers.Set.V1] | |
sexp_of_t [Zone.Stable.V1] | |
sexp_of_t [Weekday.Stable.V1] | |
sexp_of_t [Time.Stable.V1] | |
sexp_of_t [String_id.Stable.V1] | |
sexp_of_t [Squeue] | |
sexp_of_t [Span.Stable.V1] | |
sexp_of_t [Span.Parts] | |
sexp_of_t [Span] | |
sexp_of_t [Source_code_position0] | |
sexp_of_t [Source_code_position] | |
sexp_of_t [Signal] | |
sexp_of_t [Sexpable.S3] | |
sexp_of_t [Sexpable.S2] | |
sexp_of_t [Sexpable.S1] | |
sexp_of_t [Sexpable.Of_stringable] | |
sexp_of_t [Sexpable.Of_sexpable] | |
sexp_of_t [Set_once] | |
sexp_of_t [Stable_unit_test_intf.Arg] | |
sexp_of_t [Result.Stable.V1] | |
sexp_of_t [Result] | |
sexp_of_t [Ref] | |
sexp_of_t [Piecewise_linear.Key] | |
sexp_of_t [Piecewise_linear.S] | |
sexp_of_t [Pid] | |
sexp_of_t [Or_error] | |
sexp_of_t [Ordering] | |
sexp_of_t [Option] | |
sexp_of_t [Ofday.Stable.V1] | |
sexp_of_t [Ofday] | |
sexp_of_t [Nano_mutex] | |
sexp_of_t [Month.Stable.V1] | |
sexp_of_t [Month] | |
sexp_of_t [Linux_ext.Epoll.Flags] | |
sexp_of_t [Linux_ext.Epoll] | |
sexp_of_t [Linux_ext.Priority] | |
sexp_of_t [Linux_ext.Sysinfo] | |
sexp_of_t [Int_intf.S] | |
sexp_of_t [Interval_intf.S.Set] | |
sexp_of_t [Interval_intf.S] | |
sexp_of_t [Interval_intf.S1.Set] | |
sexp_of_t [Interval_intf.S1] | |
sexp_of_t [Interval.Stable.V1.Ofday] | |
sexp_of_t [Interval.Stable.V1.Int] | |
sexp_of_t [Interval.Stable.V1.Float] | |
sexp_of_t [Sexpable.S] | |
sexp_of_t [Int_conversions.Make] | |
sexp_of_t [Info] | |
sexp_of_t [Identifiable.S] | |
sexp_of_t [Heap_block] | |
sexp_of_t [Heap] | |
sexp_of_t [Hash_set_intf.S] | |
sexp_of_t [Hash_set.Poly] | |
sexp_of_t [Hash_set] | |
sexp_of_t [Fqueue] | |
sexp_of_t [Force_once] | |
sexp_of_t [Float_intf.S.Terse] | |
sexp_of_t [Float_intf.S.Sign] | |
sexp_of_t [Float_intf.S.Class] | |
sexp_of_t [Flags_intf.S] | |
sexp_of_t [Exn] | |
sexp_of_t [Doubly_linked.Elt] | |
sexp_of_t [Doubly_linked] | |
sexp_of_t [Dequeue] | |
sexp_of_t [Date.Stable.V1] | |
sexp_of_t [Date] | |
sexp_of_t [Weak] | |
sexp_of_t [Unix.Mman.Mcl_flags] | |
sexp_of_t [Unix.Scheduler.Policy] | |
sexp_of_t [Unix.Utsname] | |
sexp_of_t [Unix.Resource_usage] | |
sexp_of_t [Unix.RLimit] | |
sexp_of_t [Unix.IOVec] | |
sexp_of_t [Unix.Terminal_io] | |
sexp_of_t [Unix.Service] | |
sexp_of_t [Unix.Protocol] | |
sexp_of_t [Unix.Host] | |
sexp_of_t [Unix.Inet_addr] | |
sexp_of_t [Unix.Protocol_family] | |
sexp_of_t [Unix.Group] | |
sexp_of_t [Unix.Passwd] | |
sexp_of_t [Unix.Select_fds] | |
sexp_of_t [Unix.Process_info] | |
sexp_of_t [Unix.Exit_or_signal_or_stop] | |
sexp_of_t [Unix.Exit_or_signal] | |
sexp_of_t [Unix.Exit] | |
sexp_of_t [Unix.File_descr] | |
sexp_of_t [String] | |
sexp_of_t [Stack] | |
sexp_of_t [Sexp.Sexp_maybe] | |
sexp_of_t [Sexp] | |
sexp_of_t [Core_set_intf.S.Tree] | |
sexp_of_t [Core_set_intf.S] | |
sexp_of_t [Set.Tree] | |
sexp_of_t [Set.Poly.Tree] | |
sexp_of_t [Set.Poly] | |
sexp_of_t [Queue] | |
sexp_of_t [Core_map_intf.S.Tree] | |
sexp_of_t [Core_map_intf.S] | |
sexp_of_t [Map.Tree] | |
sexp_of_t [Map.Poly.Tree] | |
sexp_of_t [Map.Poly] | |
sexp_of_t [List.Assoc] | |
sexp_of_t [List] | |
sexp_of_t [Lazy] | |
sexp_of_t [Core_hashtbl_intf.S] | |
sexp_of_t [Core_hashtbl_intf.Key] | |
sexp_of_t [Hashtbl.Poly] | |
sexp_of_t [Hashtbl] | |
sexp_of_t [Gc.Control] | |
sexp_of_t [Gc.Stat] | |
sexp_of_t [Char] | |
sexp_of_t [Array] | |
sexp_of_t [Constrained_float.S] | |
sexp_of_t [Comparator.Pre_binable] | |
sexp_of_t [Comparator.Pre] | |
sexp_of_t [Commutative_group.S] | |
sexp_of_t [Byte_units.Measure] | |
sexp_of_t [Byte_units] | |
sexp_of_t [Bucket.S] | |
sexp_of_t [Bucket.Contents] | |
sexp_of_t [Bucket.Make] | |
sexp_of_t [Bounded_int_table.With_key] | |
sexp_of_t [Bounded_int_table] | |
sexp_of_t [Bool] | |
sexp_of_t [Blang.Stable.V1] | |
sexp_of_t [Blang] | |
sexp_of_t [Bigstring] | |
sexp_of_t [Bag.Elt] | |
sexp_of_t [Bag] | |
sexp_of_t [Backtrace] | |
sexp_of_tcp_bool_option [Linux_ext] | |
sexp_of_tm [Unix] | |
sexp_of_wait_on [Unix] | |
sg [Quickcheck] |
string generator
|
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_epoch_time [Zone] | |
shift_left [Int_intf.S] | |
shift_right [Int_intf.S] | |
shift_right_logical [Int_intf.S] | |
shutdown [Unix] | |
shutdown_command_of_sexp [Unix] |
The type of commands for
shutdown .
|
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_intf.S] | |
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 [Core_set_intf.Creators] | |
singleton [Queue] | |
singleton [Core_map_intf.Creators] |
map with one key, data pair
|
size [Timer] | size timer returns the number of events in a timer's heap.
|
skip [Bigstring_marshal] | skip ?pos buf skips the marshalled data starting at position pos .
|
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 [Ofday] | |
snd3 [Common] | |
sockaddr_of_sexp [Unix] | |
socket [Unix] |
Create a new socket in the given domain, and with the
given kind.
|
socket_bool_option_of_sexp [Unix] |
The socket options that can be consulted with
UnixLabels.getsockopt
and modified with UnixLabels.setsockopt .
|
socket_domain_of_sexp [Unix] | |
socket_float_option_of_sexp [Unix] |
The socket options that can be consulted with
UnixLabels.getsockopt_float
and modified with UnixLabels.setsockopt_float .
|
socket_int_option_of_sexp [Unix] |
The socket options that can be consulted with
UnixLabels.getsockopt_int
and modified with UnixLabels.setsockopt_int .
|
socket_type_of_sexp [Unix] | |
socketpair [Unix] |
Create a pair of unnamed sockets, connected together.
|
some [Option] | |
some_if [Option] | |
sort [List] |
Sort a list in increasing order according to a comparison function.
|
sort [Array] | |
sort_and_align [Arg] |
Like align, except that the specification list is also sorted by key
|
sorted_copy [Array] | sorted_copy ar cmp returns a shallow copy of ar that is sorted.
|
space_overhead [Gc.Control.Fields] | |
space_overhead [Gc.Control] | |
specialize [Blang] | specialize t f partially evaluates t according to a
perhaps-incomplete assignment f of the values of base propositions.
|
split [String.Escaping] | split s ~escape_char ~on
|
split [String] | split s ~on
|
split [Core_set_intf.Accessors] | split x set produces a triple triple where fst3 triple is the set of elements
strictly less than x , snd3 triple = mem set x , and trd3 triple is the set of
elements strictly larger than x .
|
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_extension [Filename] | split_extension fn return the portion of the filename before the
extension and the (optional) extension.
|
split_n [List] | split_n n [e1; ...; em] is ([e1; ...; en], [en+1; ...; em]) .
|
split_on_chars [String.Escaping] | split_on_chars s ~on
|
split_on_chars [String] | split_on_chars s ~on
|
sprintf [Printf] | |
stable_dedup [List] | stable_dedup Same as dedup but maintains the order of the list and doesn't allow
compare function to be specified (otherwise, the implementation in terms of Set.t
would hide a heavyweight functor instantiation at each call).
|
stable_dedup_involving_an_application_of_the_set_functor [List] | |
stable_dedup_list [Core_set_intf.Creators] | |
stable_sort [List] |
Same as sort, but guaranteed to be stable
|
stable_sort [Array] | |
stack [Unix.RLimit] | |
stack_limit [Gc.Control.Fields] | |
stack_limit [Gc.Control] | |
stack_size [Gc.Stat.Fields] | |
stack_size [Gc.Stat] | |
stage [Staged] | |
stage [Common] | |
start_of_day [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.
|
stats_of_sexp [Unix.Native_file] | |
stats_of_sexp [Unix] |
The informations returned by the
UnixLabels.stat calls.
|
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.
|
step [Command.Spec] |
combinator for patching up how parameters are obtained or presented
|
stime [Unix.Resource_usage.Fields] | |
stime [Unix.Resource_usage] | |
stop [Signal] |
| Stop | Stop |
|
strftime [Unix] |
Convert a date and time, specified by the
tm argument, into a formatted string.
|
strict_add [Hash_set_intf.Accessors] | |
strict_add_exn [Hash_set_intf.Accessors] | |
strict_remove [Hash_set_intf.Accessors] | |
strict_remove_exn [Hash_set_intf.Accessors] | |
string [Command.Spec] | |
string_bigstring [Make_substring.Blit] | |
string_kind [Unix.IOVec] | |
string_of_float [Common] | |
string_of_sexp [Std_internal] | |
string_string [Make_substring.Blit] | |
strip [Type_equal.Injective2] | |
strip [Type_equal.Injective] | |
strip [String] | strip ?drop s returns a string with consecutive chars satisfying drop (by default
white space, e.g.
|
strptime [Unix] |
Given a format string, convert a corresponding string to a date and time
See 'man strptime' for format options.
|
sub [Time_internal.T] | |
sub [Time] | sub t s subtracts the span s from time t and returns the
resulting time.
|
sub [Ofday] | |
sub [Float_intf.S] | |
sub [String] | |
sub [List] | sub pos len l is the len -element sublist of l , starting at pos .
|
sub [Array] | Array.sub a start len returns a fresh array of length len ,
containing the elements number start to start + len - 1
of array a .
|
sub [Bigstring] | sub ?pos ?len bstr
|
sub [Bigbuffer] | Bigbuffer.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_shared [Bigstring] | sub_shared ?pos ?len bstr
|
subset [Core_set_intf.Accessors] | |
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
|
summary [Command.Deprecated] | |
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] | |
sym [Type_equal] | |
symlink [Unix] | symlink source dest creates the file dest as a symbolic link
to the file source .
|
symmetric_diff [Core_map_intf.Accessors] | symmetric_diff t1 t2 ~data_equal returns a list of changes between t1 and t2.
|
sync [Unix] |
Synchronize all filesystem buffers with disk.
|
synchronize [Mutex0] | |
synchronize [Mutex] | synchronize f creates a mutex and returns a new function that is identical to f
except that the mutex is held during its execution.
|
sys_behavior_of_sexp [Signal] |
The default behaviour of the system if these signals trickle to the top level of a
program.
|
sys_behavior_of_sexp__ [Signal] | |
sysconf [Unix] | |
sysconf_of_sexp [Unix] |
System configuration
|
sysinfo [Linux_ext.Sysinfo] | |
sysname [Unix.Utsname] | |
system [Unix] |
Execute the given command, wait until it terminates, and return
its termination status.
|
T | |
t2 [Command.Spec] | |
t3 [Command.Spec] | |
t4 [Command.Spec] | |
t_of_sexp [Time] | |
t_of_sexp [Weekday] | |
t_of_sexp [Uuid] | |
t_of_sexp [Unique_id_intf.Id] | |
t_of_sexp [Tuple.Hashable_sexpable] | |
t_of_sexp [Tuple.Comparable_sexpable] | |
t_of_sexp [Tuple.T3] | |
t_of_sexp [Tuple.T2] | |
t_of_sexp [Zone] | |
t_of_sexp [Stable_containers.Map.V1] | |
t_of_sexp [Stable_containers.Hash_set.V1] | |
t_of_sexp [Stable_containers.Hashtbl.V1] | |
t_of_sexp [Stable_containers.Set.V1] | |
t_of_sexp [Zone.Stable.V1] | |
t_of_sexp [Weekday.Stable.V1] | |
t_of_sexp [Time.Stable.V1] | |
t_of_sexp [String_id.Stable.V1] | |
t_of_sexp [Span.Stable.V1] | |
t_of_sexp [Span.Parts] | |
t_of_sexp [Span] | |
t_of_sexp [Source_code_position0] | |
t_of_sexp [Source_code_position] | |
t_of_sexp [Signal] | |
t_of_sexp [Sexpable.S3] | |
t_of_sexp [Sexpable.S2] | |
t_of_sexp [Sexpable.S1] | |
t_of_sexp [Sexpable.Of_stringable] | |
t_of_sexp [Sexpable.Of_sexpable] | |
t_of_sexp [Set_once] | |
t_of_sexp [Stable_unit_test_intf.Arg] | |
t_of_sexp [Result.Stable.V1] | |
t_of_sexp [Result] | |
t_of_sexp [Ref] | |
t_of_sexp [Piecewise_linear.Key] | |
t_of_sexp [Piecewise_linear.S] | |
t_of_sexp [Pid] | |
t_of_sexp [Or_error] | |
t_of_sexp [Ordering] | |
t_of_sexp [Option] | |
t_of_sexp [Ofday.Stable.V1] | |
t_of_sexp [Ofday] | |
t_of_sexp [Month.Stable.V1] | |
t_of_sexp [Month] | |
t_of_sexp [Linux_ext.Priority] | |
t_of_sexp [Linux_ext.Sysinfo] | |
t_of_sexp [Int_intf.S] | |
t_of_sexp [Interval_intf.S.Set] | |
t_of_sexp [Interval_intf.S] | |
t_of_sexp [Interval_intf.S1.Set] | |
t_of_sexp [Interval_intf.S1] | |
t_of_sexp [Interval.Stable.V1.Ofday] | |
t_of_sexp [Interval.Stable.V1.Int] | |
t_of_sexp [Interval.Stable.V1.Float] | |
t_of_sexp [Sexpable.S] | |
t_of_sexp [Info] | |
t_of_sexp [Identifiable.S] | |
t_of_sexp [Hash_set_intf.S] | |
t_of_sexp [Hash_set.Poly] | |
t_of_sexp [Fqueue] | |
t_of_sexp [Float_intf.S.Terse] | |
t_of_sexp [Float_intf.S.Sign] | |
t_of_sexp [Float_intf.S.Class] | |
t_of_sexp [Doubly_linked] | |
t_of_sexp [Dequeue] | |
t_of_sexp [Date.Stable.V1] | |
t_of_sexp [Date] | |
t_of_sexp [Unix.Mman.Mcl_flags] | |
t_of_sexp [Unix.Scheduler.Policy] | |
t_of_sexp [Unix.Utsname] | |
t_of_sexp [Unix.Resource_usage] | |
t_of_sexp [Unix.RLimit] | |
t_of_sexp [Unix.IOVec] | |
t_of_sexp [Unix.Service] | |
t_of_sexp [Unix.Protocol] | |
t_of_sexp [Unix.Inet_addr] | |
t_of_sexp [Unix.Protocol_family] | |
t_of_sexp [Unix.Passwd] | |
t_of_sexp [Unix.Process_info] | |
t_of_sexp [Unix.Exit_or_signal_or_stop] | |
t_of_sexp [Unix.Exit_or_signal] | |
t_of_sexp [Unix.Exit] | |
t_of_sexp [Unix.File_descr] | |
t_of_sexp [String] | |
t_of_sexp [Stack] | |
t_of_sexp [Sexp.Sexp_maybe] | |
t_of_sexp [Sexp] | |
t_of_sexp [Core_set_intf.S.Tree] | |
t_of_sexp [Core_set_intf.S] | |
t_of_sexp [Set.Poly.Tree] | |
t_of_sexp [Set.Poly] | |
t_of_sexp [Queue] | |
t_of_sexp [Core_map_intf.S.Tree] | |
t_of_sexp [Core_map_intf.S] | |
t_of_sexp [Map.Poly.Tree] | |
t_of_sexp [Map.Poly] | |
t_of_sexp [List.Assoc] | |
t_of_sexp [List] | |
t_of_sexp [Lazy] | |
t_of_sexp [Core_hashtbl_intf.S] | |
t_of_sexp [Core_hashtbl_intf.Key] | |
t_of_sexp [Hashtbl.Poly] | |
t_of_sexp [Gc.Control] | |
t_of_sexp [Gc.Stat] | |
t_of_sexp [Char] | |
t_of_sexp [Array] | |
t_of_sexp [Constrained_float.S] | |
t_of_sexp [Comparator.Pre_binable] | |
t_of_sexp [Comparator.Pre] | |
t_of_sexp [Commutative_group.S] | |
t_of_sexp [Byte_units.Measure] | |
t_of_sexp [Byte_units] | |
t_of_sexp [Bucket.S] | |
t_of_sexp [Bucket.Contents] | |
t_of_sexp [Bucket.Make] | |
t_of_sexp [Bounded_int_table.With_key] | |
t_of_sexp [Bool] | |
t_of_sexp [Blang.Stable.V1] | |
t_of_sexp [Blang] | |
t_of_sexp [Bigstring] | |
t_of_sexp__ [Source_code_position0] | |
t_of_sexp__ [Unix.Scheduler.Policy] | |
t_of_sexp__ [Unix.Protocol_family] | |
t_of_sexp__ [Byte_units.Measure] | |
t_of_sexp_abs [Time] | |
tag [Or_error] | tag t string is Result.map_error t ~f:(fun e -> Error.tag e string) .
|
tag [Info] | |
tag_arg [Or_error] | |
tag_arg [Info] | |
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_exn [Dequeue] | |
take_front_exn [Dequeue] | |
take_while [List] | take_while l ~f returns the longest prefix of l for which f is true .
|
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] | |
temp_dir_name [Filename] |
The name of the temporary directory:
|
temp_file [Filename] | |
term [Signal] |
| Terminate | Termination |
|
test [Binary_packing] | |
test_invariants [Fqueue] |
test via asserts whether invariants hold
|
tests [Stable_unit_test_intf.Arg] | |
tests [Inline_tests] | |
tg [Quickcheck] |
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_span [Command.Spec] | |
timedlock [Mutex] | timedlock mtx timeout like lock , but takes a timeout parameter.
|
timedwait [Condition] | timedwait cond mtx timeout waits on condition variable cond
with mutex mtx until either the condition is signalled, or until
timeout expires.
|
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] | |
tl_exn [List] |
Return the given list without its first element.
|
tm_of_sexp [Unix] |
The type representing wallclock time and calendar date.
|
to_alist [Core_map_intf.Accessors] |
creates association list from map.
|
to_alist [Core_hashtbl_intf.Accessors] |
Returns the list of all (key,data) pairs for given hashtable.
|
to_alist [Bounded_int_table] | |
to_array [Hash_queue.Make] | |
to_array [Queue] | |
to_array [Container.Generic_phantom] | |
to_array [Container.Generic] | |
to_array [Container.S1_phantom] | |
to_array [Container.S1] | |
to_array [Container.S0_phantom] | |
to_array [Container.S0] | |
to_array [Container.Make] | |
to_bigstring [Substring_intf.S] | |
to_bigstring [Make_substring.F] | |
to_bigstring [Binable0] | |
to_bigstring [Binable] | |
to_caml_int [Signal] | |
to_date [Time] | |
to_date_ofday [Time] | |
to_day [Span] | |
to_epoch [Time] | to_epoch t returns the number of seconds since Jan 1, 1970 00:00:00 in UTC
|
to_exn [Info] | |
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 [Span] | |
to_int [Weekday] | to_int t returns an int in 0,1,...6.
|
to_int [Pid] | |
to_int [Month] | to_int t returns an int in 1,2,...12.
|
to_int [Linux_ext.Priority] | |
to_int [Float_intf.S] | |
to_int [Unix.File_descr] | |
to_int [Nativeint] | |
to_int [Int64] | |
to_int [Int63] | |
to_int [Int32] | |
to_int [Int] | |
to_int [Char] |
Return the ASCII code of the argument.
|
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_intf.S] | |
to_int_exn [Intable.S] | |
to_int_exn [Flags_intf.S] | |
to_int_exn [Nativeint] | |
to_knots [Piecewise_linear.S] | |
to_list [Hash_queue.Make] | |
to_list [Fqueue] | to_list t returns a list of the elements in t in order from least-recently-added
(at the head) to most-recently added (at the tail).
|
to_list [Unix.Resource_usage.Fields] | |
to_list [Queue] | |
to_list [Gc.Control.Fields] | |
to_list [Gc.Stat.Fields] | |
to_list [Container.Generic_phantom] | |
to_list [Container.Generic] | |
to_list [Container.S1_phantom] | |
to_list [Container.S1] | |
to_list [Container.S0_phantom] | |
to_list [Container.S0] | |
to_list [Container.Make] | |
to_list_rev [String] |
Returns the reversed list of characters contained in a list.
|
to_local_date [Time] | |
to_local_date_ofday [Time] | |
to_local_ofday [Time] | |
to_localized_string [Time] | to_localized_string time zone returns a string representation of time
in the given zone in the form like "2008-11-18 15:34:56.123".
|
to_millisec_string [Ofday] |
with milliseconds
|
to_min [Span] | |
to_ms [Span] | |
to_nativeint [Nativeint] | |
to_nativeint [Int64] | |
to_nativeint [Int32] | |
to_nativeint [Int] | |
to_nativeint_exn [Int_intf.S] | |
to_ns [Span] | |
to_ofday [Time] | |
to_parts [Span] | |
to_parts [Ofday] | |
to_poly [Interval_intf.S.Set] | |
to_poly [Interval_intf.S] | |
to_sec [Span] | |
to_sec_string [Time] | to_sec_string t Same as to_string, but without milliseconds
|
to_sec_string [Ofday] |
trailing milliseconds are trimmed
|
to_sexp_hum [Source_code_position0] | |
to_sexp_hum [Source_code_position] | |
to_short_string [Span] | to_short_string t pretty-prints approximate time span using no more than
five characters if the span is positive, and six if the span is negative.
|
to_span_since_start_of_day [Ofday] | |
to_string [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 [Int_set] | |
to_string [Stringable.S] | |
to_string [Exn] | |
to_string [Unix.Inet_addr] |
Return the printable representation of the given Internet address.
|
to_string [Printexc] | |
to_string [List] | |
to_string [Bin_prot.Writer] | |
to_string [Binable] | |
to_string [Bigstring] | to_string ?pos ?len bstr
|
to_string [Backtrace] | |
to_string_abs [Time] | to_string_abs ?zone t returns a string that represents an absolute time, rather than
a local time with an assumed time zone.
|
to_string_american [Date] | |
to_string_deprecated [Time] | to_string_deprecated returns a string in the old format
|
to_string_fix_proto [Time] | |
to_string_hum [Int_intf.S] | |
to_string_hum [Int_conversions.Make] | |
to_string_hum [Info] |
might be an expensive operation
|
to_string_hum [Float_intf.S] |
Pretty print float, for example
to_string_hum ~decimals:3 1234.1999 = "1_234.200"
to_string_hum ~decimals:3 ~strip_zero:true 1234.1999 = "1_234.2" .
|
to_string_hum [Unix.Exit_or_signal_or_stop] | |
to_string_hum [Unix.Exit_or_signal] | |
to_string_hum [Unix.Exit] | |
to_string_iso8601_basic [Date] | |
to_string_trimmed [Time] | to_string_trimmed t Same as to_string, but removes trailing seconds and
milliseconds if they are 0
|
to_string_trimmed [Ofday] |
trailing seconds and subseconds are trimmed off if they are 0
|
to_system_int [Signal] | |
to_tm [Time_internal] | |
to_tm_utc [Time_internal] | |
to_tree [Core_set_intf.Accessors] | |
to_tree [Core_map_intf.Accessors] | |
to_us [Span] | |
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, Complexity: O(1)
|
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_heap_words [Gc.Stat.Fields] | |
top_heap_words [Gc.Stat] | |
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 .
|
trans [Type_equal] | |
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 [Bag] | transfer ~src ~dst moves all of the elements from src to dst in constant
time.
|
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.
|
transpose [List] | transpose m transposes the rows and columns of the matrix m ,
considered as either a row of column lists or (dually) a column of row lists.
|
transpose_exn [List] | transpose_exn transposes the rows and columns of its argument, throwing exception if
the list is not rectangular.
|
trd3 [Common] | |
true_ [Blang] | |
truncate [Unix.Native_file] | |
truncate [Unix] |
Truncates the named file to the given size.
|
truncate [Common] | |
try_lock [Nano_mutex] | try_lock t locks t if it can immediately do so.
|
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_exn [Nano_mutex] | |
try_with [Result] | |
try_with [Or_error] | try_with f catches exceptions thrown by f and returns them in the Result.t as an
Error.t.
|
try_with [Option] | try_with f returns Some x if f returns x and None if f raises an
exception.
|
try_with_join [Or_error] | |
tstp [Signal] |
| Stop | Interactive stop |
|
ttin [Signal] |
| Stop | Terminal read from background process |
|
ttou [Signal] |
| Stop | Terminal write from background process |
|
tue [Weekday] | |
tune [Gc] |
Adjust the specified GC parameters.
|
tuple [Host_and_port] | |
tuple2 [Type_equal] | |
U | |
ubound [Interval_intf.Gen_set] | |
ubound [Interval_intf.Gen] | |
ubound_exn [Interval_intf.Gen_set] | |
ubound_exn [Interval_intf.Gen] | |
uig [Quickcheck] |
unsigned int generator (uniform random in range min_int, max_int)
|
umask [Unix] |
Set the process creation mask, and return the previous mask.
|
uname [Unix] | |
uncapitalize [String] | |
uncurry [Tuple.T3] | |
uncurry [Tuple.T2] | |
unescape [String.Escaping] | unescape ~escape_char is defined as unescape_gen_exn ~map:[] ~escape_char
|
unescape_gen [String.Escaping] | |
unescape_gen_exn [String.Escaping] | unescape_gen_exn is the inverse operation of escape_gen_exn .
|
unimplemented [Or_error] | unimplemented name returns a standard error value for an unimplemented value.
|
unimplemented [Common] | |
union [Union_find] | union t1 t2 makes the class of t1 and the class of t2 be the same (if they are
already equal, then nothing changes).
|
union [Core_set_intf.Accessors] | |
union_list [Core_set_intf.Creators] | |
unit [Memo] |
efficient special case for argument type
unit
|
unix_error [Unix] | |
unlink [Unix] |
Removes the named file
|
unlock [Nano_mutex] | unlock t unlocks t , if the current thread holds it.
|
unlock [Unix.Flock_command] | |
unlock [Mutex] | unlock mtx unlocks mtx .
|
unlock_exn [Nano_mutex] | |
unmarshal [Bigstring_marshal] | unmarshal ?pos buf unmarshals data contained in buf starting
at position pos .
|
unmarshal_from_sock [Bigstring_marshal] | unmarshal_from_sock ?buf sock unmarshals data from socket sock
using unmarshalling buffer buf .
|
unmarshal_next [Bigstring_marshal] | unmarshal_next ?pos buf unmarshals data contained in buf starting
at position pos .
|
unordered_append [List] | |
unpack [Unpack_buffer] | unpack t unpacks all the values that it can from t .
|
unpack_float [Binary_packing] |
As with integers, floats can be be packed big endian or little endian, depending on
the order in which the bytes of the float are layed out.
|
unpack_padded_fixed_string [Binary_packing] |
Decode the fixed length padded string having length
len from buf starting at
pos .
|
unpack_signed_16 [Binary_packing] |
The functions ending with
_big_endian or _little_endian are faster than the ones
with explicit byte_order argument:
|
unpack_signed_16_big_endian [Binary_packing] | |
unpack_signed_16_little_endian [Binary_packing] | |
unpack_signed_32 [Binary_packing] | |
unpack_signed_32_int [Binary_packing] | |
unpack_signed_32_int_big_endian [Binary_packing] | |
unpack_signed_32_int_little_endian [Binary_packing] | |
unpack_signed_64 [Binary_packing] | |
unpack_signed_64_big_endian [Binary_packing] | |
unpack_signed_64_int [Binary_packing] | |
unpack_signed_64_little_endian [Binary_packing] | |
unpack_signed_8 [Binary_packing] | |
unpack_unsigned_16 [Binary_packing] | |
unpack_unsigned_16_big_endian [Binary_packing] | |
unpack_unsigned_16_little_endian [Binary_packing] | |
unpack_unsigned_32_int [Binary_packing] | |
unpack_unsigned_32_int_big_endian [Binary_packing] | |
unpack_unsigned_32_int_little_endian [Binary_packing] | |
unpack_unsigned_8 [Binary_packing] | |
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 version of
get .
|
unsafe_get_int16_be [Bigstring] | |
unsafe_get_int16_le [Bigstring] | |
unsafe_get_int32_be [Bigstring] | |
unsafe_get_int32_le [Bigstring] | |
unsafe_get_int32_t_be [Bigstring] | |
unsafe_get_int32_t_le [Bigstring] | |
unsafe_get_int64_be_exn [Bigstring] | |
unsafe_get_int64_le_exn [Bigstring] | |
unsafe_get_int64_t_be [Bigstring] | |
unsafe_get_int64_t_le [Bigstring] | |
unsafe_get_uint16_be [Bigstring] | |
unsafe_get_uint16_le [Bigstring] | |
unsafe_input [Bigstring] | unsafe_input ~min_len ic ~pos ~len bstr similar to
Bigstring.input , but does not perform any bounds checks.
|
unsafe_input_value [In_channel] | |
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 version of
set .
|
unsafe_set_int16_be [Bigstring] | |
unsafe_set_int16_le [Bigstring] | |
unsafe_set_int32_be [Bigstring] | |
unsafe_set_int32_le [Bigstring] | |
unsafe_set_int32_t_be [Bigstring] | |
unsafe_set_int32_t_le [Bigstring] | |
unsafe_set_int64_be [Bigstring] | |
unsafe_set_int64_le [Bigstring] | |
unsafe_set_int64_t_be [Bigstring] | |
unsafe_set_int64_t_le [Bigstring] | |
unsafe_set_uint16_be [Bigstring] | |
unsafe_set_uint16_le [Bigstring] | |
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.
|
unsetenv [Unix] | unsetenv name deletes the variable name from the environment.
|
unstage [Staged] | |
unstage [Common] | |
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.
|
unzip [List] |
Transform a list of pairs into a pair of lists:
unzip [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]) .
|
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] |
Convert the given character to its equivalent uppercase character.
|
usage [Arg] | Arg.usage speclist usage_msg prints to standard error
an error message that includes the list of valid options.
|
usage_string [Arg] |
Returns the message that would have been printed by
Arg.usage ,
if provided with the same parameters.
|
usr1 [Signal] |
| Terminate | Application-defined signal 1 |
|
usr2 [Signal] |
| Terminate | Application-defined signal 2 |
|
utc [Zone] | utc the UTC time zone.
|
utc_offset [Time] | |
utime [Unix.Resource_usage.Fields] | |
utime [Unix.Resource_usage] | |
utimes [Unix] |
Set the last access time (second arg) and last modification time
(third arg) for a file.
|
uw [Common] |
Option handling
|
V | |
value [Option] | value None ~default = default
value (Some x) ~default = x
|
value [Heap_block] | value t returns the value that is physically equal to t
|
value [Doubly_linked.Elt] | |
value [Bag.Elt] | |
value_exn [Option] | value_exn (Some x) = x .
|
value_map [Option] | value_map t ~f ~default is equivalent to value (map t ~f) ~default , except that
it is slightly faster since it avoids creating the intermediate option.
|
values [Blang] | values t forms the list containing every v
for which Base v is a subexpression of t
|
verbose [Gc.Control.Fields] | |
verbose [Gc.Control] | |
version [Unix.Utsname] | |
version [Command.Deprecated] | |
virtual_memory [Unix.RLimit] | |
volatile_contents [Bigbuffer] |
Return the actual underlying bigstring used by this bigbuffer.
|
vtalrm [Signal] |
| Terminate | Timeout in virtual time |
|
W | |
wait [Linux_ext.Epoll] | wait t ~timeout blocks until at least one file descriptor in t is ready for one
of the events it is being watched for, or timeout passes.
|
wait [Unix] | |
wait [Condition] | |
wait_nohang [Unix] | |
wait_nohang_untraced [Unix] | |
wait_not_empty [Squeue] | wait_not_empty sq Waits for something to be available.
|
wait_on_of_sexp [Unix] | |
wait_on_of_sexp__ [Unix] | |
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] |
See
Thread.wait_timed_write .
|
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_untraced [Unix] | |
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] | waitpid pid waits for child process pid to terminate, and returns its exit status.
|
waitpid_exn [Unix] | |
wed [Weekday] | |
weekdays_between [Date] | |
with_file [Out_channel] | |
with_file [In_channel] | with_file ~f fname executes ~f on the open channel from
fname , and closes it afterwards.
|
with_file [Unix] | with_file file ~mode ~perm ~f opens file , and applies f to the resulting file
descriptor.
|
with_return [With_return] | |
with_return [Common] | |
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] | |
words [Byte_units] | |
wrap [Command.Spec] |
combinator for defining a class of commands with common behavior
|
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_all [Out_channel] | write_all file data writes all data to the named file.
|
write_assume_fd_is_nonblocking [Unix] | 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 [Out_channel] | write_lines file lines works like output_lines, except that the output is sent to
the named file.
|
write_new_string_and_sexp_formats__read_both [Time] |
If this is ever called then all future calls to to_string and sexp_of_t will produce a
new format sexp/string that includes enough offset information to reproduce the
correct Time.t when of_string/t_of_sexp is called, even if they are called on a
machine with a different timezone than the writing machine.
|
write_new_string_and_sexp_formats__read_only_new [Time] |
This does the same as
write_new_string_and_sexp_formats__read_both and additionally
of_string and t_of_sexp will not accept formats without a timezone.
|
writev [Unix] | writev fd ?count iovecs like Unix.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] | 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 [Date] | |
yield [Thread] |
Re-schedule the calling thread without suspending it.
|
Z | |
zero [Span] | |
zero [Signal] | |
zero [Int_intf.S] | |
zero [Float_intf.S] | |
zero [Commutative_group.S] | |
zero [Bucket.Contents] | |
zip [List] |
Transform a pair of lists into an (optional) list of pairs:
zip [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)] .
|
zip_exn [List] |