( * ) [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.Without_squelch] | |
(<.) [Robustly_comparable.S] | |
(</>) [String.Infix] | |
(<=) [Polymorphic_compare] | |
(<=) [No_polymorphic_compare] | |
(<=) [Polymorphic_compare_intf.Infix] | |
(<=) [Comparable.Make_common.Replace_polymorphic_compare.Without_squelch] | |
(<=.) [Robustly_comparable.S] | |
(<>) [Polymorphic_compare] | |
(<>) [No_polymorphic_compare] | |
(<>) [Polymorphic_compare_intf.Infix] | |
(<>) [Comparable.Make_common.Replace_polymorphic_compare.Without_squelch] | |
(<>.) [Robustly_comparable.S] | |
(<|>) [Array.Infix] | |
(=) [Polymorphic_compare] | |
(=) [No_polymorphic_compare] | |
(=) [Polymorphic_compare_intf.Infix] | |
(=) [Comparable.Make_common.Replace_polymorphic_compare.Without_squelch] | |
(=.) [Robustly_comparable.S] | |
(==) [Common] | |
(==>) [Common] | |
(>) [Polymorphic_compare] | |
(>) [No_polymorphic_compare] | |
(>) [Polymorphic_compare_intf.Infix] | |
(>) [Comparable.Make_common.Replace_polymorphic_compare.Without_squelch] | |
(>.) [Robustly_comparable.S] | |
(>=) [Polymorphic_compare] | |
(>=) [No_polymorphic_compare] | |
(>=) [Polymorphic_compare_intf.Infix] | |
(>=) [Comparable.Make_common.Replace_polymorphic_compare.Without_squelch] | |
(>=.) [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 fn.ml
|
(|>) [Fn] |
A pipe operator, equivalent to |!, but this notation is more broadly accepted
|
(|>) [Common] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Unique_id_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Time_internal] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Std_internal] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Substring_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Stringable] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Std] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Stable_unit_test_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Stable_internal] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Stable] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Source_code_position0] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Sexpable] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Robustly_comparable] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Polymorphic_compare_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Never_returns] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Mutex0] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Monad] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Make_substring] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Invariant] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Int_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Interval_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Interfaces] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Intable] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Hash_set_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Hash_queue] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Hash_heap] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [T] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Hashable] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Float_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Floatable] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Flags_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Equal] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Core_set_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Core_map_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Core_hashtbl_intf] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Field] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Bin_prot] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Container] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Constrained_float] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Comparable] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Commutative_group] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Caml] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Bucket] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Binable0] | |
__pa_ounit_275876e34cf609db118f3d84b799a790 [Array_permute] | |
_squelch_unused_module_warning_ [Std] | |
_squelch_unused_module_warning_ [No_polymorphic_compare] | |
_squelch_unused_module_warning_ [Comparable.S_common.Replace_polymorphic_compare] | |
_squelch_unused_module_warning_ [Comparable.Make_common.Replace_polymorphic_compare] | |
_squelch_unused_module_warning_ [Comparable.Poly.Replace_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.
|
ascending [Polymorphic_compare] | ascending is identical to compare .
|
ascending [Comparable.S_common] | ascending is identical to compare .
|
ascending [Comparable.Make_common] | |
ascending [Comparable.Poly] | |
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 [Option] | |
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_ [Option] | |
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__ [Option] | |
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 [Option] | |
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 [Option] | |
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 [Option] | |
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 [Option] | |
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_ [Option] | |
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 [Option] | |
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] |
Note that the sexps are not directly inferred from the type above -- there are lots of
fancy shortcuts.
|
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.
|
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 [Std_internal] | |
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] | |
ceil_pow2 [Int_math] | |
ceil_pow2 [Int] | ceil_pow2 x returns the smallest power of 2 that is greater than or equal to
x .
|
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] | |
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 [Lazy] | |
compare [Core_hashtbl_intf.Key] | |
compare [Comparator.Pre_binable] | |
compare [Comparator.Pre] | |
compare [Polymorphic_compare_intf.S] | |
compare [Comparable.Make_common.Replace_polymorphic_compare.Without_squelch] | |
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] |
Types for use as markers in phantom types.
|
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 [Unique_id_intf.Id] |
Always returns a value that is not equal to any other value created with
create .
|
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 [Polymorphic_compare] | |
descending [Comparable.S_common] | |
descending [Comparable.Make_common] | |
descending [Comparable.Poly] | |
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] | |
does_match [Univ] | does_match t constr returns true iff t was created by create constr v .
|
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 [Std_internal] | |
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.Without_squelch] | |
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 [Common] | Or_error.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_and_remove [Core_hashtbl_intf.Accessors] | find_and_remove t k returns Some (the current binding) of k in t and removes
it, or None is no such binding exists
|
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_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] | |
floor_pow2 [Int_math] | |
floor_pow2 [Int] | floor_pow2 x returns the largest power of 2 that is less than or equal to x .
|
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 [Std_internal] | |
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 [Univ.Constr] | |
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_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_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_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 [Std_internal] | |
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.
|
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 .
|
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 returns Some v if t was created by create constr v , and
returns None otherwise.
|
match_exn [Univ] | |
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.Without_squelch] | |
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.Without_squelch] | |
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_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 [Command.Spec.Arg_type] |
convenience wrapper for
of_map .
|
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 [Interned_string.Make] | |
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] |
an auto-completing Arg_type over a finite set of values
|
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_exn [Common] | Or_error.ok_exn
|
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.
|
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] | |
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] |
We disable
== and != and replace them with the longer and more mnemonic
phys_equal because they too easily lead to mistakes (for example they don't even
work right on Int64 or Float).
|
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 [Info] | |
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 [Std_internal] | |
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_exn 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 [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_addr_info [Unix] | |
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_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_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_limit [Unix.RLimit] | |
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_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_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_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_epoch_time zone [`Local | `UTC] time Takes an epoch (aka "unix") time given
either in local or in UTC (as indicated in the arguments) and shifts it according to
the local time regime in force in 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 [Std_internal] | |
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_list [Core_set_intf.Creators] | |
stable_dedup_staged [List] | |
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] |
See
module : Staged for documentation
|
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_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] | |
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] |
For marking a given value as unimplemented.
|
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] |
Returns the word size of this program, not necessarily of the OS
|
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] |