|
( * ) [Percent] |
|
( * ) [Int_math.T] |
|
( * ) [Int_intf.S.O] |
|
( * ) [Int_intf.S] |
|
( * ) [Float_intf.S.O] |
|
( * ) [Float_intf.S] |
|
( *> ) [Applicative_intf.S2.Applicative_infix] |
|
( *> ) [Applicative_intf.S.Applicative_infix] |
|
( <* ) [Applicative_intf.S2.Applicative_infix] |
|
( <* ) [Applicative_intf.S.Applicative_infix] |
|
(!) [Ref.Permissioned] |
get and (!) are two names for the same function.
|
(!) [Ref] |
|
(!=) [Common] |
|
(%) [Std_internal] |
|
(%) [Int_math.Make] |
|
(%) [Int_intf.S.O] |
|
(%) [Int_intf.S] |
|
(&) [Common] |
|
(+) [Time_ns.Span] |
|
(+) [Int_math.T] |
|
(+) [Int_intf.S.O] |
|
(+) [Int_intf.S] |
|
(+) [Float_intf.S.O] |
|
(+) [Float_intf.S] |
|
(+) [Flags_intf.S] |
set union, bitwise or
|
(+) [Commutative_group.S] |
|
(+) [Byte_units.Infix] |
( / ) t mul scales t by 1/mul
|
(+) [Bucket.Contents] |
|
(-) [Time_ns.Span] |
|
(-) [Int_math.T] |
|
(-) [Int_intf.S.O] |
|
(-) [Int_intf.S] |
|
(-) [Float_intf.S.O] |
|
(-) [Float_intf.S] |
|
(-) [Flags_intf.S] |
set difference
|
(-) [Commutative_group.S] |
|
(-) [Byte_units.Infix] |
|
(-) [Bucket.Contents] |
|
(/%) [Std_internal] |
|
(/%) [Int_math.Make] |
|
(/%) [Int_intf.S.O] |
|
(/%) [Int_intf.S] |
There are two pairs of integer division and remainder functions, /% and % , and
/ and rem .
|
(/) [Time_ns.Span] |
|
(/) [Int_math.T] |
|
(/) [Int_intf.S.O] |
|
(/) [Int_intf.S] |
|
(/) [Float_intf.S.O] |
|
(/) [Float_intf.S] |
|
(/) [Byte_units.Infix] |
|
(//) [Std_internal] |
|
(//) [Time_ns.Span] |
|
(//) [Int_math.Make] |
|
(//) [Int_intf.S.O] |
|
(//) [Int_intf.S] |
float division of integers
|
(//) [Byte_units.Infix] |
( // ) t1 t2 returns the ratio of t1 to t2
|
(:=) [Ref.Permissioned] |
|
(:=) [Ref] |
|
(<) [Polymorphic_compare] |
|
(<) [No_polymorphic_compare] |
|
(<) [Polymorphic_compare_intf.Infix] |
|
(<*>) [Applicative_intf.S2.Applicative_infix] |
|
(<*>) [Applicative_intf.S.Applicative_infix] |
same as apply
|
(<.) [Robustly_comparable.S] |
|
(</>) [Core_string.Infix] |
|
(<=) [Polymorphic_compare] |
|
(<=) [No_polymorphic_compare] |
|
(<=) [Polymorphic_compare_intf.Infix] |
|
(<=.) [Robustly_comparable.S] |
|
(<>) [Polymorphic_compare] |
|
(<>) [No_polymorphic_compare] |
|
(<>) [Polymorphic_compare_intf.Infix] |
|
(<>.) [Robustly_comparable.S] |
|
(<|>) [Core_array.Permissioned.Infix] |
|
(<|>) [Core_array.Infix] |
|
(=) [Polymorphic_compare] |
|
(=) [No_polymorphic_compare] |
|
(=) [Polymorphic_compare_intf.Infix] |
|
(=.) [Robustly_comparable.S] |
|
(==) [Common] |
|
(==>) [Common] |
|
(>) [Polymorphic_compare] |
|
(>) [No_polymorphic_compare] |
|
(>) [Polymorphic_compare_intf.Infix] |
|
(>.) [Robustly_comparable.S] |
|
(>=) [Polymorphic_compare] |
|
(>=) [No_polymorphic_compare] |
|
(>=) [Polymorphic_compare_intf.Infix] |
|
(>=.) [Robustly_comparable.S] |
|
(>>=) [Monad_intf.Infix2] |
|
(>>=) [Monad_intf.Infix] |
t >>= f returns a computation that sequences the computations represented by two
monad elements.
|
(>>|) [Monad_intf.Infix2] |
|
(>>|) [Monad_intf.Infix] |
t >>| f is t >>= (fun a -> return (f a)) .
|
(@) [Sequence.Infix] |
|
(@) [Core_list.Infix] |
|
(@>) [Applicative_intf.Args2] |
|
(@>) [Applicative_intf.Args] |
infix operator for cons
|
(^) [Rope] |
takes O(1) time
|
(^) [Core_string] |
String append.
|
(or) [Common] |
|
(|!) [Fn] |
A 'pipe' operator.
|
(|!) [Common] |
Functions from fn.ml
|
(|>) [Fn] |
A pipe operator, equivalent to |!, but this notation is more broadly accepted
|
(|>) [Common] |
|
(~-) [Int_math.T] |
|
(~-) [Int_intf.S.O] |
|
(~-) [Int_intf.S] |
|
(~-) [Float_intf.S.O] |
|
(~-) [Float_intf.S] |
|
__bin_read_decimal__ [Std_kernel] |
|
__bin_read_immutable__ [Perms.Export] |
|
__bin_read_me__ [Perms.Stable.V1] |
|
__bin_read_me__ [Perms] |
|
__bin_read_no_raise__ [Core_sexp] |
|
__bin_read_nobody__ [Perms.Stable.V1] |
|
__bin_read_nobody__ [Perms] |
|
__bin_read_outer__ [Float_intf.S] |
|
__bin_read_perms__ [Perms.Export] |
|
__bin_read_read__ [Perms.Export] |
|
__bin_read_read_write__ [Perms.Export] |
|
__bin_read_sexp_array__ [Std_internal] |
|
__bin_read_sexp_bool__ [Std_internal] |
|
__bin_read_sexp_list__ [Std_internal] |
|
__bin_read_sexp_list__ [Stable_internal] |
|
__bin_read_sexp_opaque__ [Std_internal] |
|
__bin_read_sexp_option__ [Std_internal] |
|
__bin_read_sexp_option__ [Stable_internal] |
|
__bin_read_t__ [Validated_intf.Raw_binable] |
|
__bin_read_t__ [Timing_wheel_intf.Interval_num.Span] |
|
__bin_read_t__ [Timing_wheel_intf.Interval_num] |
|
__bin_read_t__ [T.T_bin] |
|
__bin_read_t__ [Unique_id_intf.Id] |
|
__bin_read_t__ [Total_map.Key] |
|
__bin_read_t__ [Total_map.S] |
|
__bin_read_t__ [String_id.S.Stable.V1] |
|
__bin_read_t__ [Time_ns.Span] |
|
__bin_read_t__ [Time_ns] |
|
__bin_read_t__ [Stack_unit_tests.Test] |
|
__bin_read_t__ [Stack_unit_tests.Debug] |
|
__bin_read_t__ [Stack_intf.S] |
|
__bin_read_t__ [Stable_unit_test_intf.Unordered_container_arg] |
|
__bin_read_t__ [Stable_internal.Sexp] |
|
__bin_read_t__ [Stable_containers.Hashable.V1.S.Hash_set] |
|
__bin_read_t__ [Stable_containers.Hashable.V1.S.Table] |
|
__bin_read_t__ [Source_code_position0.Stable.V1] |
|
__bin_read_t__ [Source_code_position] |
|
__bin_read_t__ [Set_once] |
|
__bin_read_t__ [Stable_unit_test_intf.Arg] |
|
__bin_read_t__ [Result] |
|
__bin_read_t__ [Ref.Permissioned] |
|
__bin_read_t__ [Ref] |
|
__bin_read_t__ [Pool_intf.S.Pointer.Id] |
|
__bin_read_t__ [Pid] |
|
__bin_read_t__ [Perms.Stable.V1.Upper_bound] |
|
__bin_read_t__ [Perms.Stable.V1.Read_write] |
|
__bin_read_t__ [Perms.Stable.V1.Immutable] |
|
__bin_read_t__ [Perms.Stable.V1.Write] |
|
__bin_read_t__ [Perms.Stable.V1.Read] |
|
__bin_read_t__ [Perms.Upper_bound] |
|
__bin_read_t__ [Perms.Read_write] |
|
__bin_read_t__ [Perms.Immutable] |
|
__bin_read_t__ [Perms.Write] |
|
__bin_read_t__ [Perms.Read] |
|
__bin_read_t__ [Percent.Stable.V1] |
|
__bin_read_t__ [Ordering] |
|
__bin_read_t__ [Or_error] |
|
__bin_read_t__ [Option] |
|
__bin_read_t__ [Nothing0] |
|
__bin_read_t__ [Nothing.Stable.V1] |
|
__bin_read_t__ [Month.Stable.V1] |
|
__bin_read_t__ [Month] |
|
__bin_read_t__ [Linked_queue] |
|
__bin_read_t__ [Stable_module_types.S2] |
|
__bin_read_t__ [Int_intf.S] |
|
__bin_read_t__ [Int_intf.Hexable.Hex] |
|
__bin_read_t__ [Stable_module_types.S0] |
|
__bin_read_t__ [Info] |
|
__bin_read_t__ [Identifiable.S] |
|
__bin_read_t__ [Host_and_port.Stable.V1] |
|
__bin_read_t__ [Fqueue.Stable.V1] |
|
__bin_read_t__ [Fqueue] |
|
__bin_read_t__ [Float_intf.S.Terse] |
|
__bin_read_t__ [Float_intf.S.Class] |
|
__bin_read_t__ [Fdeque.Stable.V1] |
|
__bin_read_t__ [Fdeque] |
|
__bin_read_t__ [Either_intf.S] |
|
__bin_read_t__ [Deque] |
|
__bin_read_t__ [Decimal] |
|
__bin_read_t__ [Day_of_week.Stable.V1] |
|
__bin_read_t__ [Day_of_week] |
|
__bin_read_t__ [Core_string] |
|
__bin_read_t__ [Core_sexp.With_text] |
|
__bin_read_t__ [Core_sexp.Sexp_maybe] |
|
__bin_read_t__ [Core_sexp.Sexp_opaque] |
|
__bin_read_t__ [Core_sexp.Sexp_array] |
|
__bin_read_t__ [Core_sexp.Sexp_list] |
|
__bin_read_t__ [Core_sexp.Sexp_option] |
|
__bin_read_t__ [Core_sexp] |
|
__bin_read_t__ [Core_set_intf.Elt_binable] |
|
__bin_read_t__ [Core_set.Poly] |
|
__bin_read_t__ [Core_queue] |
|
__bin_read_t__ [Core_map_intf.Key_binable] |
|
__bin_read_t__ [Core_map.Poly] |
|
__bin_read_t__ [Core_list.Assoc] |
|
__bin_read_t__ [Core_list] |
|
__bin_read_t__ [Stable_module_types.S1] |
|
__bin_read_t__ [Core_lazy] |
|
__bin_read_t__ [Core_hashtbl_intf.Hashtbl.Poly] |
|
__bin_read_t__ [Core_hashtbl_intf.Key_binable] |
|
__bin_read_t__ [Core_gc.Control] |
|
__bin_read_t__ [Core_gc.Stat] |
|
__bin_read_t__ [Core_char] |
|
__bin_read_t__ [Core_array.Permissioned.Float] |
|
__bin_read_t__ [Core_array.Permissioned.Int] |
|
__bin_read_t__ [Core_array.Permissioned] |
|
__bin_read_t__ [Core_array.Float] |
|
__bin_read_t__ [Core_array.Int] |
|
__bin_read_t__ [Core_array] |
|
__bin_read_t__ [Constrained_float.S] |
|
__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] |
|
__decimal_of_sexp__ [Std_kernel] |
|
__t_of_sexp__ [Source_code_position0.Stable.V1] |
|
__t_of_sexp__ [Perms.Upper_bound] |
|
__t_of_sexp__ [Perms.Read_write] |
|
__t_of_sexp__ [Perms.Immutable] |
|
__t_of_sexp__ [Perms.Write] |
|
__t_of_sexp__ [Perms.Read] |
|
__t_of_sexp__ [Nothing0] |
|
__t_of_sexp__ [Byte_units.Measure] |
|
_squelch_unused_module_warning_ [Std] |
|
_squelch_unused_module_warning_ [No_polymorphic_compare] |
_squelch_unused_module_warning_ helps avoid spurious unused-open warnings in
OCaml 4.0.
|
_squelch_unused_module_warning_ [Comparable_intf.S_common.Replace_polymorphic_compare] |
|
A |
abs [Time_ns.Span] |
|
abs [Percent] |
|
abs [Int_math.T] |
|
abs [Int_intf.S.O] |
|
abs [Int_intf.S] |
Returns the absolute value of the argument.
|
abs [Float_intf.S.O] |
|
abs [Float_intf.S] |
|
abs_diff [Time_ns] |
|
abs_float [Common] |
|
add [Univ_map_intf.S1] |
|
add [Univ_map_intf.S] |
|
add [Timing_wheel_intf.Timing_wheel.Priority_queue] |
add t ~key value adds a new value to t and returns an element that can later
be supplied to remove the element from t .
|
add [Timing_wheel_intf.Timing_wheel] |
add t ~at a adds a new value a to t and returns an alarm that can later be
supplied to remove the alarm from t .
|
add [Timing_wheel_intf.Interval_num] |
|
add [Timing_wheel_intf.Timing_wheel_time] |
|
add [Univ_map.Multi] |
|
add [Univ_map.With_fold] |
fold value into accumulator
|
add [Time_ns] |
|
add [Int_set] |
add t i add i to the set
|
add [Heap_intf.S] |
|
add [Hash_set_intf.Accessors] |
|
add [Float_intf.S] |
Ordinary functions for arithmetic operations
|
add [Fheap] |
add t v returns the new heap after addition.
|
add [Core_set_intf.Accessors2_with_comparator] |
|
add [Core_set_intf.Accessors2] |
|
add [Core_set_intf.Accessors1] |
|
add [Core_set_intf.Accessors0] |
|
add [Core_set_intf.Accessors_generic] |
|
add [Core_set] |
add t a returns a new set with a added to t , or returns t if mem t a .
|
add [Core_map_intf.Accessors3_with_comparator] |
|
add [Core_map_intf.Accessors3] |
|
add [Core_map_intf.Accessors2] |
|
add [Core_map_intf.Accessors1] |
|
add [Core_map_intf.Accessors_generic] |
|
add [Core_map] |
returns a new map with the specified new binding;
if the key was already bound, its previous binding disappears.
|
add [Core_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_at_interval_num [Timing_wheel_intf.Timing_wheel] |
|
add_buffer [Bigbuffer] |
add_buffer b1 b2 appends the current contents of buffer b2
at the end of buffer b1 .
|
add_char [Bigbuffer] |
add_char b c appends the character c at the end of the buffer b .
|
add_exn [Univ_map_intf.S1] |
|
add_exn [Univ_map_intf.S] |
|
add_exn [Core_hashtbl_intf.Accessors] |
|
add_exn [Bounded_int_table] |
|
add_finalizer [Core_gc.Expert] |
add_finalizer b f ensures that f runs after b becomes unreachable.
|
add_finalizer_exn [Core_gc.Expert] |
|
add_multi [Core_map_intf.Accessors3_with_comparator] |
|
add_multi [Core_map_intf.Accessors3] |
|
add_multi [Core_map_intf.Accessors2] |
|
add_multi [Core_map_intf.Accessors1] |
|
add_multi [Core_map_intf.Accessors_generic] |
|
add_multi [Core_map] |
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_or_error [Core_hashtbl_intf.Accessors] |
|
add_range [Int_set] |
add_range t i j add all the numbers between i and j (inclusive) to the set.
|
add_removable [Heap.Removable] |
add_removable t v adds v to t , returning a token that can be used to delete v
from t in lg(n) amortized time.
|
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 .
|
advance_clock [Timing_wheel_intf.Timing_wheel] |
advance_clock t ~to_ ~handle_fired advances t 's clock to to_ .
|
alarm_precision [Timing_wheel_intf.Timing_wheel.Config] |
accessors
|
alarm_precision [Timing_wheel_intf.Timing_wheel] |
Accessors
|
alarm_upper_bound [Timing_wheel_intf.Timing_wheel] |
alarm_upper_bound t returns the upper bound on an at that can be supplied to
add .
|
alist [Validate] |
Validates an association list, naming each element using a user-defined function for
computing the name.
|
all [Validate] |
Combine a list of validation functions into one that does all validations.
|
all [Total_map.Key] |
|
all [Pretty_printer] |
all () returns all pretty printers that have been register ed.
|
all [Month] |
|
all [Monad_intf.S2] |
|
all [Monad_intf.S] |
|
all [Day_of_week] |
|
all [Applicative_intf.S2] |
|
all [Applicative_intf.S] |
|
all_ignore [Monad_intf.S2] |
|
all_ignore [Monad_intf.S] |
|
allocated_bytes [Core_gc] |
Return the total number of bytes allocated since the program was
started.
|
allocation_policy [Core_gc.Control.Fields] |
|
allocation_policy [Core_gc.Control] |
|
allow_intersecting [Flags_intf.Make_arg] |
allow_intersecting says whether to allow intersecting known flags.
|
am_recording [Backtrace.Exn] |
|
and_ [Blang] |
n-ary And
|
append [Sequence] |
append t1 t2 first produces the elements of t1 , then produces the elements of
t2 .
|
append [Core_list] |
E.g.
|
append [Core_array.Permissioned] |
|
append [Core_array] |
Array.append v1 v2 returns a fresh array containing the
concatenation of the arrays v1 and v2 .
|
apply [Percent] |
apply t x multiplies the percent t by x , returning a float
|
apply [Applicative_intf.S2] |
|
apply [Applicative_intf.Basic2] |
|
apply [Applicative_intf.S] |
|
apply [Applicative_intf.Basic] |
The following identities ought to hold for every Applicative (for some value of =):
|
applyN [Applicative_intf.Args2] |
|
applyN [Applicative_intf.Args] |
|
apply_n_times [Fn] |
apply_n_times ~n f x is the n -fold application of f to x .
|
are_disjoint [Flags_intf.S] |
|
array [Type_immediacy.Never] |
|
ascending [Polymorphic_compare] |
ascending is identical to compare .
|
ascending [Comparable_intf.S_common] |
ascending is identical to compare .
|
at [Timing_wheel_intf.Timing_wheel.Alarm] |
All Alarm functions will raise if not (Timing_wheel.mem timing_wheel t) .
|
attempts_used [Raw_quickcheck_generator.Choice] |
attempts_used t reports the number of attempts made to choose a value.
|
B |
back_index [Deque] |
back_index t return the index of the back item in t .
|
back_index_exn [Deque] |
back_index_exn t throws an exception if t is empty, otherwise returns the index
of the back item in t
|
backtrace [Exn] |
The same as Printexc.get_backtrace
|
backtrace_status [Core_printexc] |
|
base [Substring_intf.S] |
The pos refers to the position in the base string, not any other substring that this
substring was generated from.
|
base [Make_substring.F] |
|
base [Blang] |
|
between [Comparable_intf.S_common] |
|
big [Binary_searchable_intf.Indexable.For_test] |
|
big_contents [Bigbuffer] |
Return a copy of the current contents of the buffer as a bigstring.
|
bigstring_bigstring [Make_substring.Blit] |
|
bigstring_string [Make_substring.Blit] |
|
bin_decimal [Std_kernel] |
|
bin_immutable [Perms.Export] |
|
bin_me [Perms.Stable.V1] |
|
bin_me [Perms] |
|
bin_no_raise [Core_sexp] |
|
bin_nobody [Perms.Stable.V1] |
|
bin_nobody [Perms] |
|
bin_outer [Float_intf.S] |
|
bin_perms [Perms.Export] |
|
bin_read [Perms.Export] |
|
bin_read_decimal [Std_kernel] |
|
bin_read_immutable [Perms.Export] |
|
bin_read_me [Perms.Stable.V1] |
|
bin_read_me [Perms] |
|
bin_read_no_raise [Core_sexp] |
|
bin_read_nobody [Perms.Stable.V1] |
|
bin_read_nobody [Perms] |
|
bin_read_outer [Float_intf.S] |
|
bin_read_perms [Perms.Export] |
|
bin_read_read [Perms.Export] |
|
bin_read_read_write [Perms.Export] |
|
bin_read_sexp_array [Std_internal] |
|
bin_read_sexp_bool [Std_internal] |
|
bin_read_sexp_list [Std_internal] |
|
bin_read_sexp_list [Stable_internal] |
|
bin_read_sexp_opaque [Std_internal] |
|
bin_read_sexp_option [Std_internal] |
|
bin_read_sexp_option [Stable_internal] |
|
bin_read_t [Validated_intf.Raw_binable] |
|
bin_read_t [Timing_wheel_intf.Interval_num.Span] |
|
bin_read_t [Timing_wheel_intf.Interval_num] |
|
bin_read_t [T.T_bin] |
|
bin_read_t [Unique_id_intf.Id] |
|
bin_read_t [Total_map.Key] |
|
bin_read_t [Total_map.S] |
|
bin_read_t [String_id.S.Stable.V1] |
|
bin_read_t [Time_ns.Span] |
|
bin_read_t [Time_ns] |
|
bin_read_t [Stack_unit_tests.Test] |
|
bin_read_t [Stack_unit_tests.Debug] |
|
bin_read_t [Stack_intf.S] |
|
bin_read_t [Stable_unit_test_intf.Unordered_container_arg] |
|
bin_read_t [Stable_internal.Sexp] |
|
bin_read_t [Stable_containers.Hashable.V1.S.Hash_set] |
|
bin_read_t [Stable_containers.Hashable.V1.S.Table] |
|
bin_read_t [Source_code_position0.Stable.V1] |
|
bin_read_t [Source_code_position] |
|
bin_read_t [Set_once] |
|
bin_read_t [Stable_unit_test_intf.Arg] |
|
bin_read_t [Result] |
|
bin_read_t [Ref.Permissioned] |
|
bin_read_t [Ref] |
|
bin_read_t [Pool_intf.S.Pointer.Id] |
|
bin_read_t [Pid] |
|
bin_read_t [Perms.Stable.V1.Upper_bound] |
|
bin_read_t [Perms.Stable.V1.Read_write] |
|
bin_read_t [Perms.Stable.V1.Immutable] |
|
bin_read_t [Perms.Stable.V1.Write] |
|
bin_read_t [Perms.Stable.V1.Read] |
|
bin_read_t [Perms.Upper_bound] |
|
bin_read_t [Perms.Read_write] |
|
bin_read_t [Perms.Immutable] |
|
bin_read_t [Perms.Write] |
|
bin_read_t [Perms.Read] |
|
bin_read_t [Percent.Stable.V1] |
|
bin_read_t [Ordering] |
|
bin_read_t [Or_error] |
|
bin_read_t [Option] |
|
bin_read_t [Nothing0] |
|
bin_read_t [Nothing.Stable.V1] |
|
bin_read_t [Month.Stable.V1] |
|
bin_read_t [Month] |
|
bin_read_t [Linked_queue] |
|
bin_read_t [Stable_module_types.S2] |
|
bin_read_t [Int_intf.S] |
|
bin_read_t [Int_intf.Hexable.Hex] |
|
bin_read_t [Stable_module_types.S0] |
|
bin_read_t [Info] |
|
bin_read_t [Identifiable.S] |
|
bin_read_t [Host_and_port.Stable.V1] |
|
bin_read_t [Fqueue.Stable.V1] |
|
bin_read_t [Fqueue] |
|
bin_read_t [Float_intf.S.Terse] |
|
bin_read_t [Float_intf.S.Class] |
|
bin_read_t [Fdeque.Stable.V1] |
|
bin_read_t [Fdeque] |
|
bin_read_t [Either_intf.S] |
|
bin_read_t [Deque] |
|
bin_read_t [Decimal] |
|
bin_read_t [Day_of_week.Stable.V1] |
|
bin_read_t [Day_of_week] |
|
bin_read_t [Core_string] |
|
bin_read_t [Core_sexp.With_text] |
|
bin_read_t [Core_sexp.Sexp_maybe] |
|
bin_read_t [Core_sexp.Sexp_opaque] |
|
bin_read_t [Core_sexp.Sexp_array] |
|
bin_read_t [Core_sexp.Sexp_list] |
|
bin_read_t [Core_sexp.Sexp_option] |
|
bin_read_t [Core_sexp] |
|
bin_read_t [Core_set_intf.Elt_binable] |
|
bin_read_t [Core_set.Poly] |
|
bin_read_t [Core_queue] |
|
bin_read_t [Core_map_intf.Key_binable] |
|
bin_read_t [Core_map.Poly] |
|
bin_read_t [Core_list.Assoc] |
|
bin_read_t [Core_list] |
|
bin_read_t [Stable_module_types.S1] |
|
bin_read_t [Core_lazy] |
|
bin_read_t [Core_hashtbl_intf.Hashtbl.Poly] |
|
bin_read_t [Core_hashtbl_intf.Key_binable] |
|
bin_read_t [Core_gc.Control] |
|
bin_read_t [Core_gc.Stat] |
|
bin_read_t [Core_char] |
|
bin_read_t [Core_array.Permissioned.Float] |
|
bin_read_t [Core_array.Permissioned.Int] |
|
bin_read_t [Core_array.Permissioned] |
|
bin_read_t [Core_array.Float] |
|
bin_read_t [Core_array.Int] |
|
bin_read_t [Core_array] |
|
bin_read_t [Constrained_float.S] |
|
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_write [Perms.Export] |
|
bin_reader_decimal [Std_kernel] |
|
bin_reader_immutable [Perms.Export] |
|
bin_reader_me [Perms.Stable.V1] |
|
bin_reader_me [Perms] |
|
bin_reader_no_raise [Core_sexp] |
|
bin_reader_nobody [Perms.Stable.V1] |
|
bin_reader_nobody [Perms] |
|
bin_reader_outer [Float_intf.S] |
|
bin_reader_perms [Perms.Export] |
|
bin_reader_read [Perms.Export] |
|
bin_reader_read_write [Perms.Export] |
|
bin_reader_sexp_array [Std_internal] |
|
bin_reader_sexp_bool [Std_internal] |
|
bin_reader_sexp_list [Std_internal] |
|
bin_reader_sexp_list [Stable_internal] |
|
bin_reader_sexp_opaque [Std_internal] |
|
bin_reader_sexp_option [Std_internal] |
|
bin_reader_sexp_option [Stable_internal] |
|
bin_reader_t [Validated_intf.Raw_binable] |
|
bin_reader_t [Timing_wheel_intf.Interval_num.Span] |
|
bin_reader_t [Timing_wheel_intf.Interval_num] |
|
bin_reader_t [T.T_bin] |
|
bin_reader_t [Unique_id_intf.Id] |
|
bin_reader_t [Total_map.Key] |
|
bin_reader_t [Total_map.S] |
|
bin_reader_t [String_id.S.Stable.V1] |
|
bin_reader_t [Time_ns.Span] |
|
bin_reader_t [Time_ns] |
|
bin_reader_t [Stack_unit_tests.Test] |
|
bin_reader_t [Stack_unit_tests.Debug] |
|
bin_reader_t [Stack_intf.S] |
|
bin_reader_t [Stable_unit_test_intf.Unordered_container_arg] |
|
bin_reader_t [Stable_internal.Sexp] |
|
bin_reader_t [Stable_containers.Hashable.V1.S.Hash_set] |
|
bin_reader_t [Stable_containers.Hashable.V1.S.Table] |
|
bin_reader_t [Source_code_position0.Stable.V1] |
|
bin_reader_t [Source_code_position] |
|
bin_reader_t [Set_once] |
|
bin_reader_t [Stable_unit_test_intf.Arg] |
|
bin_reader_t [Result] |
|
bin_reader_t [Ref.Permissioned] |
|
bin_reader_t [Ref] |
|
bin_reader_t [Pool_intf.S.Pointer.Id] |
|
bin_reader_t [Pid] |
|
bin_reader_t [Perms.Stable.V1.Upper_bound] |
|
bin_reader_t [Perms.Stable.V1.Read_write] |
|
bin_reader_t [Perms.Stable.V1.Immutable] |
|
bin_reader_t [Perms.Stable.V1.Write] |
|
bin_reader_t [Perms.Stable.V1.Read] |
|
bin_reader_t [Perms.Upper_bound] |
|
bin_reader_t [Perms.Read_write] |
|
bin_reader_t [Perms.Immutable] |
|
bin_reader_t [Perms.Write] |
|
bin_reader_t [Perms.Read] |
|
bin_reader_t [Percent.Stable.V1] |
|
bin_reader_t [Ordering] |
|
bin_reader_t [Or_error] |
|
bin_reader_t [Option] |
|
bin_reader_t [Nothing0] |
|
bin_reader_t [Nothing.Stable.V1] |
|
bin_reader_t [Month.Stable.V1] |
|
bin_reader_t [Month] |
|
bin_reader_t [Linked_queue] |
|
bin_reader_t [Stable_module_types.S2] |
|
bin_reader_t [Int_intf.S] |
|
bin_reader_t [Int_intf.Hexable.Hex] |
|
bin_reader_t [Stable_module_types.S0] |
|
bin_reader_t [Info] |
|
bin_reader_t [Identifiable.S] |
|
bin_reader_t [Host_and_port.Stable.V1] |
|
bin_reader_t [Fqueue.Stable.V1] |
|
bin_reader_t [Fqueue] |
|
bin_reader_t [Float_intf.S.Terse] |
|
bin_reader_t [Float_intf.S.Class] |
|
bin_reader_t [Fdeque.Stable.V1] |
|
bin_reader_t [Fdeque] |
|
bin_reader_t [Either_intf.S] |
|
bin_reader_t [Deque] |
|
bin_reader_t [Decimal] |
|
bin_reader_t [Day_of_week.Stable.V1] |
|
bin_reader_t [Day_of_week] |
|
bin_reader_t [Core_string] |
|
bin_reader_t [Core_sexp.With_text] |
|
bin_reader_t [Core_sexp.Sexp_maybe] |
|
bin_reader_t [Core_sexp.Sexp_opaque] |
|
bin_reader_t [Core_sexp.Sexp_array] |
|
bin_reader_t [Core_sexp.Sexp_list] |
|
bin_reader_t [Core_sexp.Sexp_option] |
|
bin_reader_t [Core_sexp] |
|
bin_reader_t [Core_set_intf.Elt_binable] |
|
bin_reader_t [Core_set.Poly] |
|
bin_reader_t [Core_queue] |
|
bin_reader_t [Core_map_intf.Key_binable] |
|
bin_reader_t [Core_map.Poly] |
|
bin_reader_t [Core_list.Assoc] |
|
bin_reader_t [Core_list] |
|
bin_reader_t [Stable_module_types.S1] |
|
bin_reader_t [Core_lazy] |
|
bin_reader_t [Core_hashtbl_intf.Hashtbl.Poly] |
|
bin_reader_t [Core_hashtbl_intf.Key_binable] |
|
bin_reader_t [Core_gc.Control] |
|
bin_reader_t [Core_gc.Stat] |
|
bin_reader_t [Core_char] |
|
bin_reader_t [Core_array.Permissioned.Float] |
|
bin_reader_t [Core_array.Permissioned.Int] |
|
bin_reader_t [Core_array.Permissioned] |
|
bin_reader_t [Core_array.Float] |
|
bin_reader_t [Core_array.Int] |
|
bin_reader_t [Core_array] |
|
bin_reader_t [Constrained_float.S] |
|
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_sexp_array [Std_internal] |
|
bin_sexp_bool [Std_internal] |
|
bin_sexp_list [Std_internal] |
|
bin_sexp_list [Stable_internal] |
|
bin_sexp_opaque [Std_internal] |
|
bin_sexp_option [Std_internal] |
|
bin_sexp_option [Stable_internal] |
|
bin_size_decimal [Std_kernel] |
|
bin_size_immutable [Perms.Export] |
|
bin_size_me [Perms.Stable.V1] |
|
bin_size_me [Perms] |
|
bin_size_no_raise [Core_sexp] |
|
bin_size_nobody [Perms.Stable.V1] |
|
bin_size_nobody [Perms] |
|
bin_size_outer [Float_intf.S] |
|
bin_size_perms [Perms.Export] |
|
bin_size_read [Perms.Export] |
|
bin_size_read_write [Perms.Export] |
|
bin_size_sexp_array [Std_internal] |
|
bin_size_sexp_bool [Std_internal] |
|
bin_size_sexp_list [Std_internal] |
|
bin_size_sexp_list [Stable_internal] |
|
bin_size_sexp_opaque [Std_internal] |
|
bin_size_sexp_option [Std_internal] |
|
bin_size_sexp_option [Stable_internal] |
|
bin_size_t [Validated_intf.Raw_binable] |
|
bin_size_t [Timing_wheel_intf.Interval_num.Span] |
|
bin_size_t [Timing_wheel_intf.Interval_num] |
|
bin_size_t [T.T_bin] |
|
bin_size_t [Unique_id_intf.Id] |
|
bin_size_t [Total_map.Key] |
|
bin_size_t [Total_map.S] |
|
bin_size_t [String_id.S.Stable.V1] |
|
bin_size_t [Time_ns.Span] |
|
bin_size_t [Time_ns] |
|
bin_size_t [Stack_unit_tests.Test] |
|
bin_size_t [Stack_unit_tests.Debug] |
|
bin_size_t [Stack_intf.S] |
|
bin_size_t [Stable_unit_test_intf.Unordered_container_arg] |
|
bin_size_t [Stable_internal.Sexp] |
|
bin_size_t [Stable_containers.Hashable.V1.S.Hash_set] |
|
bin_size_t [Stable_containers.Hashable.V1.S.Table] |
|
bin_size_t [Source_code_position0.Stable.V1] |
|
bin_size_t [Source_code_position] |
|
bin_size_t [Set_once] |
|
bin_size_t [Stable_unit_test_intf.Arg] |
|
bin_size_t [Result] |
|
bin_size_t [Ref.Permissioned] |
|
bin_size_t [Ref] |
|
bin_size_t [Pool_intf.S.Pointer.Id] |
|
bin_size_t [Pid] |
|
bin_size_t [Perms.Stable.V1.Upper_bound] |
|
bin_size_t [Perms.Stable.V1.Read_write] |
|
bin_size_t [Perms.Stable.V1.Immutable] |
|
bin_size_t [Perms.Stable.V1.Write] |
|
bin_size_t [Perms.Stable.V1.Read] |
|
bin_size_t [Perms.Upper_bound] |
|
bin_size_t [Perms.Read_write] |
|
bin_size_t [Perms.Immutable] |
|
bin_size_t [Perms.Write] |
|
bin_size_t [Perms.Read] |
|
bin_size_t [Percent.Stable.V1] |
|
bin_size_t [Ordering] |
|
bin_size_t [Or_error] |
|
bin_size_t [Option] |
|
bin_size_t [Nothing0] |
|
bin_size_t [Nothing.Stable.V1] |
|
bin_size_t [Month.Stable.V1] |
|
bin_size_t [Month] |
|
bin_size_t [Linked_queue] |
|
bin_size_t [Stable_module_types.S2] |
|
bin_size_t [Int_intf.S] |
|
bin_size_t [Int_intf.Hexable.Hex] |
|
bin_size_t [Stable_module_types.S0] |
|
bin_size_t [Info] |
|
bin_size_t [Identifiable.S] |
|
bin_size_t [Host_and_port.Stable.V1] |
|
bin_size_t [Fqueue.Stable.V1] |
|
bin_size_t [Fqueue] |
|
bin_size_t [Float_intf.S.Terse] |
|
bin_size_t [Float_intf.S.Class] |
|
bin_size_t [Fdeque.Stable.V1] |
|
bin_size_t [Fdeque] |
|
bin_size_t [Either_intf.S] |
|
bin_size_t [Deque] |
|
bin_size_t [Decimal] |
|
bin_size_t [Day_of_week.Stable.V1] |
|
bin_size_t [Day_of_week] |
|
bin_size_t [Core_string] |
|
bin_size_t [Core_sexp.With_text] |
|
bin_size_t [Core_sexp.Sexp_maybe] |
|
bin_size_t [Core_sexp.Sexp_opaque] |
|
bin_size_t [Core_sexp.Sexp_array] |
|
bin_size_t [Core_sexp.Sexp_list] |
|
bin_size_t [Core_sexp.Sexp_option] |
|
bin_size_t [Core_sexp] |
|
bin_size_t [Core_set_intf.Elt_binable] |
|
bin_size_t [Core_set.Poly] |
|
bin_size_t [Core_queue] |
|
bin_size_t [Core_map_intf.Key_binable] |
|
bin_size_t [Core_map.Poly] |
|
bin_size_t [Core_list.Assoc] |
|
bin_size_t [Core_list] |
|
bin_size_t [Stable_module_types.S1] |
|
bin_size_t [Core_lazy] |
|
bin_size_t [Core_hashtbl_intf.Hashtbl.Poly] |
|
bin_size_t [Core_hashtbl_intf.Key_binable] |
|
bin_size_t [Core_gc.Control] |
|
bin_size_t [Core_gc.Stat] |
|
bin_size_t [Core_char] |
|
bin_size_t [Core_array.Permissioned.Float] |
|
bin_size_t [Core_array.Permissioned.Int] |
|
bin_size_t [Core_array.Permissioned] |
|
bin_size_t [Core_array.Float] |
|
bin_size_t [Core_array.Int] |
|
bin_size_t [Core_array] |
|
bin_size_t [Constrained_float.S] |
|
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_t [Validated_intf.Raw_binable] |
|
bin_t [Timing_wheel_intf.Interval_num.Span] |
|
bin_t [Timing_wheel_intf.Interval_num] |
|
bin_t [T.T_bin] |
|
bin_t [Unique_id_intf.Id] |
|
bin_t [Total_map.Key] |
|
bin_t [Total_map.S] |
|
bin_t [String_id.S.Stable.V1] |
|
bin_t [Time_ns.Span] |
|
bin_t [Time_ns] |
|
bin_t [Stack_unit_tests.Test] |
|
bin_t [Stack_unit_tests.Debug] |
|
bin_t [Stack_intf.S] |
|
bin_t [Stable_unit_test_intf.Unordered_container_arg] |
|
bin_t [Stable_internal.Sexp] |
|
bin_t [Stable_containers.Hashable.V1.S.Hash_set] |
|
bin_t [Stable_containers.Hashable.V1.S.Table] |
|
bin_t [Source_code_position0.Stable.V1] |
|
bin_t [Source_code_position] |
|
bin_t [Set_once] |
|
bin_t [Stable_unit_test_intf.Arg] |
|
bin_t [Result] |
|
bin_t [Ref.Permissioned] |
|
bin_t [Ref] |
|
bin_t [Pool_intf.S.Pointer.Id] |
|
bin_t [Pid] |
|
bin_t [Perms.Stable.V1.Upper_bound] |
|
bin_t [Perms.Stable.V1.Read_write] |
|
bin_t [Perms.Stable.V1.Immutable] |
|
bin_t [Perms.Stable.V1.Write] |
|
bin_t [Perms.Stable.V1.Read] |
|
bin_t [Perms.Upper_bound] |
|
bin_t [Perms.Read_write] |
|
bin_t [Perms.Immutable] |
|
bin_t [Perms.Write] |
|
bin_t [Perms.Read] |
|
bin_t [Percent.Stable.V1] |
|
bin_t [Ordering] |
|
bin_t [Or_error] |
|
bin_t [Option] |
|
bin_t [Nothing0] |
|
bin_t [Nothing.Stable.V1] |
|
bin_t [Month.Stable.V1] |
|
bin_t [Month] |
|
bin_t [Linked_queue] |
|
bin_t [Stable_module_types.S2] |
|
bin_t [Int_intf.S] |
|
bin_t [Int_intf.Hexable.Hex] |
|
bin_t [Stable_module_types.S0] |
|
bin_t [Info] |
|
bin_t [Identifiable.S] |
|
bin_t [Host_and_port.Stable.V1] |
|
bin_t [Fqueue.Stable.V1] |
|
bin_t [Fqueue] |
|
bin_t [Float_intf.S.Terse] |
|
bin_t [Float_intf.S.Class] |
|
bin_t [Fdeque.Stable.V1] |
|
bin_t [Fdeque] |
|
bin_t [Either_intf.S] |
|
bin_t [Deque] |
|
bin_t [Decimal] |
|
bin_t [Day_of_week.Stable.V1] |
|
bin_t [Day_of_week] |
|
bin_t [Core_string] |
|
bin_t [Core_sexp.With_text] |
|
bin_t [Core_sexp.Sexp_maybe] |
|
bin_t [Core_sexp.Sexp_opaque] |
|
bin_t [Core_sexp.Sexp_array] |
|
bin_t [Core_sexp.Sexp_list] |
|
bin_t [Core_sexp.Sexp_option] |
|
bin_t [Core_sexp] |
|
bin_t [Core_set_intf.Elt_binable] |
|
bin_t [Core_set.Poly] |
|
bin_t [Core_queue] |
|
bin_t [Core_map_intf.Key_binable] |
|
bin_t [Core_map.Poly] |
|
bin_t [Core_list.Assoc] |
|
bin_t [Core_list] |
|
bin_t [Stable_module_types.S1] |
|
bin_t [Core_lazy] |
|
bin_t [Core_hashtbl_intf.Hashtbl.Poly] |
|
bin_t [Core_hashtbl_intf.Key_binable] |
|
bin_t [Core_gc.Control] |
|
bin_t [Core_gc.Stat] |
|
bin_t [Core_char] |
|
bin_t [Core_array.Permissioned.Float] |
|
bin_t [Core_array.Permissioned.Int] |
|
bin_t [Core_array.Permissioned] |
|
bin_t [Core_array.Float] |
|
bin_t [Core_array.Int] |
|
bin_t [Core_array] |
|
bin_t [Constrained_float.S] |
|
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_write_decimal [Std_kernel] |
|
bin_write_immutable [Perms.Export] |
|
bin_write_me [Perms.Stable.V1] |
|
bin_write_me [Perms] |
|
bin_write_no_raise [Core_sexp] |
|
bin_write_nobody [Perms.Stable.V1] |
|
bin_write_nobody [Perms] |
|
bin_write_outer [Float_intf.S] |
|
bin_write_perms [Perms.Export] |
|
bin_write_read [Perms.Export] |
|
bin_write_read_write [Perms.Export] |
|
bin_write_sexp_array [Std_internal] |
|
bin_write_sexp_bool [Std_internal] |
|
bin_write_sexp_list [Std_internal] |
|
bin_write_sexp_list [Stable_internal] |
|
bin_write_sexp_opaque [Std_internal] |
|
bin_write_sexp_option [Std_internal] |
|
bin_write_sexp_option [Stable_internal] |
|
bin_write_t [Validated_intf.Raw_binable] |
|
bin_write_t [Timing_wheel_intf.Interval_num.Span] |
|
bin_write_t [Timing_wheel_intf.Interval_num] |
|
bin_write_t [T.T_bin] |
|
bin_write_t [Unique_id_intf.Id] |
|
bin_write_t [Total_map.Key] |
|
bin_write_t [Total_map.S] |
|
bin_write_t [String_id.S.Stable.V1] |
|
bin_write_t [Time_ns.Span] |
|
bin_write_t [Time_ns] |
|
bin_write_t [Stack_unit_tests.Test] |
|
bin_write_t [Stack_unit_tests.Debug] |
|
bin_write_t [Stack_intf.S] |
|
bin_write_t [Stable_unit_test_intf.Unordered_container_arg] |
|
bin_write_t [Stable_internal.Sexp] |
|
bin_write_t [Stable_containers.Hashable.V1.S.Hash_set] |
|
bin_write_t [Stable_containers.Hashable.V1.S.Table] |
|
bin_write_t [Source_code_position0.Stable.V1] |
|
bin_write_t [Source_code_position] |
|
bin_write_t [Set_once] |
|
bin_write_t [Stable_unit_test_intf.Arg] |
|
bin_write_t [Result] |
|
bin_write_t [Ref.Permissioned] |
|
bin_write_t [Ref] |
|
bin_write_t [Pool_intf.S.Pointer.Id] |
|
bin_write_t [Pid] |
|
bin_write_t [Perms.Stable.V1.Upper_bound] |
|
bin_write_t [Perms.Stable.V1.Read_write] |
|
bin_write_t [Perms.Stable.V1.Immutable] |
|
bin_write_t [Perms.Stable.V1.Write] |
|
bin_write_t [Perms.Stable.V1.Read] |
|
bin_write_t [Perms.Upper_bound] |
|
bin_write_t [Perms.Read_write] |
|
bin_write_t [Perms.Immutable] |
|
bin_write_t [Perms.Write] |
|
bin_write_t [Perms.Read] |
|
bin_write_t [Percent.Stable.V1] |
|
bin_write_t [Ordering] |
|
bin_write_t [Or_error] |
|
bin_write_t [Option] |
|
bin_write_t [Nothing0] |
|
bin_write_t [Nothing.Stable.V1] |
|
bin_write_t [Month.Stable.V1] |
|
bin_write_t [Month] |
|
bin_write_t [Linked_queue] |
|
bin_write_t [Stable_module_types.S2] |
|
bin_write_t [Int_intf.S] |
|
bin_write_t [Int_intf.Hexable.Hex] |
|
bin_write_t [Stable_module_types.S0] |
|
bin_write_t [Info] |
|
bin_write_t [Identifiable.S] |
|
bin_write_t [Host_and_port.Stable.V1] |
|
bin_write_t [Fqueue.Stable.V1] |
|
bin_write_t [Fqueue] |
|
bin_write_t [Float_intf.S.Terse] |
|
bin_write_t [Float_intf.S.Class] |
|
bin_write_t [Fdeque.Stable.V1] |
|
bin_write_t [Fdeque] |
|
bin_write_t [Either_intf.S] |
|
bin_write_t [Deque] |
|
bin_write_t [Decimal] |
|
bin_write_t [Day_of_week.Stable.V1] |
|
bin_write_t [Day_of_week] |
|
bin_write_t [Core_string] |
|
bin_write_t [Core_sexp.With_text] |
|
bin_write_t [Core_sexp.Sexp_maybe] |
|
bin_write_t [Core_sexp.Sexp_opaque] |
|
bin_write_t [Core_sexp.Sexp_array] |
|
bin_write_t [Core_sexp.Sexp_list] |
|
bin_write_t [Core_sexp.Sexp_option] |
|
bin_write_t [Core_sexp] |
|
bin_write_t [Core_set_intf.Elt_binable] |
|
bin_write_t [Core_set.Poly] |
|
bin_write_t [Core_queue] |
|
bin_write_t [Core_map_intf.Key_binable] |
|
bin_write_t [Core_map.Poly] |
|
bin_write_t [Core_list.Assoc] |
|
bin_write_t [Core_list] |
|
bin_write_t [Stable_module_types.S1] |
|
bin_write_t [Core_lazy] |
|
bin_write_t [Core_hashtbl_intf.Hashtbl.Poly] |
|
bin_write_t [Core_hashtbl_intf.Key_binable] |
|
bin_write_t [Core_gc.Control] |
|
bin_write_t [Core_gc.Stat] |
|
bin_write_t [Core_char] |
|
bin_write_t [Core_array.Permissioned.Float] |
|
bin_write_t [Core_array.Permissioned.Int] |
|
bin_write_t [Core_array.Permissioned] |
|
bin_write_t [Core_array.Float] |
|
bin_write_t [Core_array.Int] |
|
bin_write_t [Core_array] |
|
bin_write_t [Constrained_float.S] |
|
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_writer_decimal [Std_kernel] |
|
bin_writer_immutable [Perms.Export] |
|
bin_writer_me [Perms.Stable.V1] |
|
bin_writer_me [Perms] |
|
bin_writer_no_raise [Core_sexp] |
|
bin_writer_nobody [Perms.Stable.V1] |
|
bin_writer_nobody [Perms] |
|
bin_writer_outer [Float_intf.S] |
|
bin_writer_perms [Perms.Export] |
|
bin_writer_read [Perms.Export] |
|
bin_writer_read_write [Perms.Export] |
|
bin_writer_sexp_array [Std_internal] |
|
bin_writer_sexp_bool [Std_internal] |
|
bin_writer_sexp_list [Std_internal] |
|
bin_writer_sexp_list [Stable_internal] |
|
bin_writer_sexp_opaque [Std_internal] |
|
bin_writer_sexp_option [Std_internal] |
|
bin_writer_sexp_option [Stable_internal] |
|
bin_writer_t [Validated_intf.Raw_binable] |
|
bin_writer_t [Timing_wheel_intf.Interval_num.Span] |
|
bin_writer_t [Timing_wheel_intf.Interval_num] |
|
bin_writer_t [T.T_bin] |
|
bin_writer_t [Unique_id_intf.Id] |
|
bin_writer_t [Total_map.Key] |
|
bin_writer_t [Total_map.S] |
|
bin_writer_t [String_id.S.Stable.V1] |
|
bin_writer_t [Time_ns.Span] |
|
bin_writer_t [Time_ns] |
|
bin_writer_t [Stack_unit_tests.Test] |
|
bin_writer_t [Stack_unit_tests.Debug] |
|
bin_writer_t [Stack_intf.S] |
|
bin_writer_t [Stable_unit_test_intf.Unordered_container_arg] |
|
bin_writer_t [Stable_internal.Sexp] |
|
bin_writer_t [Stable_containers.Hashable.V1.S.Hash_set] |
|
bin_writer_t [Stable_containers.Hashable.V1.S.Table] |
|
bin_writer_t [Source_code_position0.Stable.V1] |
|
bin_writer_t [Source_code_position] |
|
bin_writer_t [Set_once] |
|
bin_writer_t [Stable_unit_test_intf.Arg] |
|
bin_writer_t [Result] |
|
bin_writer_t [Ref.Permissioned] |
|
bin_writer_t [Ref] |
|
bin_writer_t [Pool_intf.S.Pointer.Id] |
|
bin_writer_t [Pid] |
|
bin_writer_t [Perms.Stable.V1.Upper_bound] |
|
bin_writer_t [Perms.Stable.V1.Read_write] |
|
bin_writer_t [Perms.Stable.V1.Immutable] |
|
bin_writer_t [Perms.Stable.V1.Write] |
|
bin_writer_t [Perms.Stable.V1.Read] |
|
bin_writer_t [Perms.Upper_bound] |
|
bin_writer_t [Perms.Read_write] |
|
bin_writer_t [Perms.Immutable] |
|
bin_writer_t [Perms.Write] |
|
bin_writer_t [Perms.Read] |
|
bin_writer_t [Percent.Stable.V1] |
|
bin_writer_t [Ordering] |
|
bin_writer_t [Or_error] |
|
bin_writer_t [Option] |
|
bin_writer_t [Nothing0] |
|
bin_writer_t [Nothing.Stable.V1] |
|
bin_writer_t [Month.Stable.V1] |
|
bin_writer_t [Month] |
|
bin_writer_t [Linked_queue] |
|
bin_writer_t [Stable_module_types.S2] |
|
bin_writer_t [Int_intf.S] |
|
bin_writer_t [Int_intf.Hexable.Hex] |
|
bin_writer_t [Stable_module_types.S0] |
|
bin_writer_t [Info] |
|
bin_writer_t [Identifiable.S] |
|
bin_writer_t [Host_and_port.Stable.V1] |
|
bin_writer_t [Fqueue.Stable.V1] |
|
bin_writer_t [Fqueue] |
|
bin_writer_t [Float_intf.S.Terse] |
|
bin_writer_t [Float_intf.S.Class] |
|
bin_writer_t [Fdeque.Stable.V1] |
|
bin_writer_t [Fdeque] |
|
bin_writer_t [Either_intf.S] |
|
bin_writer_t [Deque] |
|
bin_writer_t [Decimal] |
|
bin_writer_t [Day_of_week.Stable.V1] |
|
bin_writer_t [Day_of_week] |
|
bin_writer_t [Core_string] |
|
bin_writer_t [Core_sexp.With_text] |
|
bin_writer_t [Core_sexp.Sexp_maybe] |
|
bin_writer_t [Core_sexp.Sexp_opaque] |
|
bin_writer_t [Core_sexp.Sexp_array] |
|
bin_writer_t [Core_sexp.Sexp_list] |
|
bin_writer_t [Core_sexp.Sexp_option] |
|
bin_writer_t [Core_sexp] |
|
bin_writer_t [Core_set_intf.Elt_binable] |
|
bin_writer_t [Core_set.Poly] |
|
bin_writer_t [Core_queue] |
|
bin_writer_t [Core_map_intf.Key_binable] |
|
bin_writer_t [Core_map.Poly] |
|
bin_writer_t [Core_list.Assoc] |
|
bin_writer_t [Core_list] |
|
bin_writer_t [Stable_module_types.S1] |
|
bin_writer_t [Core_lazy] |
|
bin_writer_t [Core_hashtbl_intf.Hashtbl.Poly] |
|
bin_writer_t [Core_hashtbl_intf.Key_binable] |
|
bin_writer_t [Core_gc.Control] |
|
bin_writer_t [Core_gc.Stat] |
|
bin_writer_t [Core_char] |
|
bin_writer_t [Core_array.Permissioned.Float] |
|
bin_writer_t [Core_array.Permissioned.Int] |
|
bin_writer_t [Core_array.Permissioned] |
|
bin_writer_t [Core_array.Float] |
|
bin_writer_t [Core_array.Int] |
|
bin_writer_t [Core_array] |
|
bin_writer_t [Constrained_float.S] |
|
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] |
|
binary_search [Binary_searchable_intf.S1_permissions] |
|
binary_search [Binary_searchable_intf.S1] |
|
binary_search [Binary_searchable_intf.S] |
binary_search ?pos ?len t ~compare which elt takes t that is sorted in
nondecreasing order according to compare , where compare and elt divide t
into three (possibly empty) segments:
|
binary_search_segmented [Binary_searchable_intf.S1_permissions] |
|
binary_search_segmented [Binary_searchable_intf.S1] |
|
binary_search_segmented [Binary_searchable_intf.S] |
binary_search_segmented ?pos ?len t ~segment_of which takes an segment_of
function that divides t into two (possibly empty) segments:
|
bind [Raw_quickcheck_generator] |
bind t f is a monadic bind that replaces each value x that has probability p in
t with the probability distribution f x weighted proportionally by p .
|
bind [Monad_intf.S2] |
|
bind [Monad_intf.Basic2] |
|
bind [Monad_intf.S] |
bind t f = t >>= f
|
bind [Monad_intf.Basic] |
|
bind_choice [Raw_quickcheck_generator] |
bind_choice t f is like bind t f , except f is passed an 'a Choice.t and can
thus use subsets of t by using Choice.gen with the ~keep option.
|
bit_and [Int_intf.S] |
|
bit_not [Int_intf.S] |
|
bit_or [Int_intf.S] |
|
bit_xor [Int_intf.S] |
|
bits [Core_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 [Core_random] |
Return 30 random bits in a nonnegative integer.
|
bits_of_float [Core_int64] |
|
bits_of_float [Core_int32] |
|
blit [Make_substring.Base] |
|
blit [Flat_array_debug.Debug] |
|
blit [Blit_intf.S_distinct] |
|
blit [Blit_intf.S1_permissions] |
|
blit [Blit_intf.S1] |
|
blit [Blit_intf.S_permissions] |
|
blit [Blit_intf.S] |
|
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_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] |
|
blit_transfer [Core_queue] |
Transfers up to len elements from the front of src to the end of dst , removing
them from src .
|
blito [Flat_array_debug.Debug] |
|
blito [Blit_intf.S_distinct] |
|
blito [Blit_intf.S1_permissions] |
|
blito [Blit_intf.S1] |
|
blito [Blit_intf.S_permissions] |
|
blito [Blit_intf.S] |
|
bool [Type_immediacy.Always] |
|
bool [Quickcheck_observer] |
|
bool [Quickcheck_generator] |
|
bool [Core_random.State] |
|
bool [Core_random] |
Random.bool () returns true or false with probability 0.5 each.
|
booltest [Validate] |
Create a validation function from a function that produces a bool
|
bot [Fqueue] |
like bot_exn , but returns result optionally, without exception.
|
bot_exn [Fqueue] |
returns the bottom (most-recently enqueued element).
|
both [Option] |
|
both [Applicative_intf.S2] |
|
both [Applicative_intf.S] |
|
bounded_length [Sequence] |
bounded_length ~at_most t returns `Is len if len = length t <= at_most , and
otherwise returns `Greater .
|
bprintf [Std_internal] |
|
bprintf [Core_printf] |
|
bprintf [Bigbuffer.Printf] |
|
bprintf [Bigbuffer.Format] |
|
branching_factor [Raw_quickcheck_observer] |
branching_factor t produces the number of nodes in the decision tree of t , or one
less than the number of buckets in t .
|
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 |
call [Option] |
call x f run optional function on argument
|
capacity [Pool_intf.S] |
capacity returns the maximum number of tuples that the pool can hold.
|
capacity [Flat_queue] |
capacity t returns the length of the array backing t .
|
capacity [Core_stack] |
capacity t returns the length of the array backing t .
|
capacity [Core_queue] |
Returns the current length of the backing array.
|
capitalize [Core_string] |
|
cartesian_product [Sequence] |
Returns a sequence with all possible pairs.
|
cartesian_product [Core_list] |
Returns a list with all possible pairs -- if the input lists have length len1 and
len2, the resulting list will have length len1*len2.
|
cartesian_product [Core_array.Permissioned] |
|
cartesian_product [Core_array] |
|
catch [Core_printexc] |
|
ceil [Common] |
|
ceil_pow2 [Int_pow2] |
|
ceil_pow2 [Core_int] |
ceil_pow2 x returns the smallest power of 2 that is greater than or equal to x .
|
change [Univ_map_intf.S1] |
|
change [Univ_map_intf.S] |
|
change [Univ_map.Multi] |
|
change [Univ_map.With_fold] |
accumulator update
|
change [Univ_map.With_default] |
|
change [Total_map] |
|
change [Core_map_intf.Accessors3_with_comparator] |
|
change [Core_map_intf.Accessors3] |
|
change [Core_map_intf.Accessors2] |
|
change [Core_map_intf.Accessors1] |
|
change [Core_map_intf.Accessors_generic] |
|
change [Core_map] |
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_intf.S1] |
|
change_exn [Univ_map_intf.S] |
|
change_key [Timing_wheel_intf.Timing_wheel.Priority_queue] |
change_key t elt ~key changes the key of elt to key .
|
char [Type_immediacy.Always] |
|
char [Quickcheck_observer] |
|
char [Quickcheck_generator] |
|
char_alpha [Quickcheck_generator] |
|
char_alphanum [Quickcheck_generator] |
|
char_digit [Quickcheck_generator] |
|
char_lowercase [Quickcheck_generator] |
|
char_print [Quickcheck_generator] |
|
char_uppercase [Quickcheck_generator] |
|
char_whitespace [Quickcheck_generator] |
|
check_args [Bigstring] |
check_args ~loc ~pos ~len bstr checks the position and length
arguments pos and len for bigstrings bstr .
|
check_field [Invariant_intf.Invariant] |
check_field is used when checking invariants using Fields.iter .
|
check_invariant [Pool_intf.Pool.Debug] |
|
check_invariant [Flat_queue_debug.Debug] |
|
check_invariant [Debug.Make] |
Whether the invariants are called on each invocation
|
check_invariant [Core_queue_debug.Debug] |
|
check_pos_len_exn [Ordered_collection_common] |
check_pos_len_exn ~pos ~len ~length raises unless
pos >= 0 && len >= 0 && pos + len <= length .
|
choose [Raw_quickcheck_generator] |
choose t ~random_float_between_zero_and_one makes a choice in t at random, using
random_float_between_zero_and_one to produce random floats between 0.
|
choose [Core_set_intf.Accessors2_with_comparator] |
|
choose [Core_set_intf.Accessors2] |
|
choose [Core_set_intf.Accessors1] |
|
choose [Core_set_intf.Accessors0] |
|
choose [Core_set_intf.Accessors_generic] |
|
choose [Core_set] |
returns an arbitrary element, or None if the set is empty.
|
choose [Bag] |
choose t returns some element in the bag.
|
choose_exn [Core_set_intf.Accessors2_with_comparator] |
|
choose_exn [Core_set_intf.Accessors2] |
|
choose_exn [Core_set_intf.Accessors1] |
|
choose_exn [Core_set_intf.Accessors0] |
|
choose_exn [Core_set_intf.Accessors_generic] |
|
choose_exn [Core_set] |
|
chop_prefix [Core_string] |
|
chop_prefix_exn [Core_string] |
chop_prefix s ~pref returns a copy s without the leading pref
|
chop_suffix [Core_string] |
|
chop_suffix_exn [Core_string] |
chop_suffix s ~suf returns a copy s without the trailing suff
|
classify [Float_intf.S] |
return the Class.t.
|
classify_float [Common] |
|
clear [Timing_wheel_intf.Timing_wheel.Priority_queue] |
clear t removes all elts from t .
|
clear [Timing_wheel_intf.Timing_wheel] |
clear t removes all alarms from t .
|
clear [Stack_unit_tests.Test] |
|
clear [Stack_unit_tests.Debug] |
|
clear [Stack_intf.S] |
clear t discards all elements from t .
|
clear [Linked_queue] |
clear t discards all elements from t .
|
clear [Hash_set_intf.Accessors] |
|
clear [Hash_queue.S] |
clear the queue
|
clear [Hash_queue.Make] |
|
clear [Flat_queue] |
clear t removes all elements from t .
|
clear [Doubly_linked] |
clear t removes all elements from the list in constant time.
|
clear [Deque] |
clear t removes all elements from t .
|
clear [Core_queue] |
|
clear [Core_hashtbl_intf.Accessors] |
|
clear [Bounded_int_table] |
|
clear [Bigbuffer] |
Empty the buffer.
|
clear [Bag] |
clear t removes all elements from the bag.
|
clear_internal_pool [Thread_safe_queue] |
The queue maintains an internal pool of unused elements, which are used by enqueue
and returned to the pool by dequeue_exn .
|
close [Out_channel] |
close t flushes and closes t , and may raise an exception.
|
close [In_channel] |
close t closes t, and may raise an exception.
|
close_in [Common] |
we have our own version of these two, the INRIA version doesn't release the runtime
lock.
|
close_out [Common] |
|
closest_key [Core_map_intf.Accessors3_with_comparator] |
|
closest_key [Core_map_intf.Accessors3] |
|
closest_key [Core_map_intf.Accessors2] |
|
closest_key [Core_map_intf.Accessors1] |
|
closest_key [Core_map_intf.Accessors_generic] |
|
closest_key [Core_map] |
closest_key t dir k returns the (key, value) pair in t with key closest to
k , which satisfies the given inequality bound.
|
combine [Result] |
Returns Ok if both are Ok and Error otherwise.
|
combine [Either_intf.Focused] |
|
combine [Core_array.Permissioned] |
|
combine [Core_array] |
combine ar combines two arrays to an array of pairs.
|
combine_all [Either_intf.Focused] |
|
combine_all_unit [Either_intf.Focused] |
|
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 .
|
compact [Core_gc] |
Perform a full major collection and compact the heap.
|
compactions [Core_gc.Stat.Fields] |
|
compactions [Core_gc.Stat] |
|
compactions [Core_gc] |
|
comparator [Core_set] |
|
comparator [Core_map] |
|
comparator [Comparator.S] |
|
comparator [Comparator.S1] |
|
compare [Timing_wheel_intf.Interval_num.Span] |
|
compare [Timing_wheel_intf.Interval_num] |
|
compare [Timing_wheel_intf.Timing_wheel_time.Span] |
|
compare [Timing_wheel_intf.Timing_wheel_time] |
|
compare [Tuple.T3] |
|
compare [Tuple.T2] |
|
compare [Total_map.Key] |
|
compare [Total_map.S] |
|
compare [String_id.S.Stable.V1] |
|
compare [Time_ns.Span] |
|
compare [Time_ns] |
|
compare [Stable_internal.Sexp] |
|
compare [Source_code_position0.Stable.V1] |
|
compare [Sequence] |
|
compare [Result] |
|
compare [Ref] |
|
compare [Polymorphic_compare] |
|
compare [Perms.Stable.V1.Upper_bound] |
|
compare [Perms.Stable.V1.Read_write] |
|
compare [Perms.Stable.V1.Immutable] |
|
compare [Perms.Stable.V1.Write] |
|
compare [Perms.Stable.V1.Read] |
|
compare [Perms.Upper_bound] |
|
compare [Perms.Read_write] |
|
compare [Perms.Immutable] |
|
compare [Perms.Write] |
|
compare [Perms.Read] |
|
compare [Percent.Stable.V1] |
|
compare [Ordering] |
|
compare [Or_error] |
|
compare [Option] |
Compares None as smaller than any Some x
|
compare [Nothing0] |
|
compare [Nothing.Stable.V1] |
|
compare [No_polymorphic_compare] |
|
compare [Month.Stable.V1] |
|
compare [Stable_module_types.S2] |
|
compare [Int_intf.Hexable.Hex] |
|
compare [Stable_module_types.S0] |
|
compare [Info] |
|
compare [Host_and_port.Stable.V1] |
|
compare [Hashable.S] |
|
compare [Fqueue.Stable.V1] |
|
compare [Fqueue] |
|
compare [Fdeque.Stable.V1] |
|
compare [Fdeque] |
|
compare [Either_intf.S] |
|
compare [Decimal] |
|
compare [Day_of_week.Stable.V1] |
|
compare [Day_of_week] |
|
compare [Core_sexp.Sexp_maybe] |
|
compare [Core_sexp.Sexp_opaque] |
|
compare [Core_sexp.Sexp_array] |
|
compare [Core_sexp.Sexp_list] |
|
compare [Core_sexp.Sexp_option] |
|
compare [Core_set_intf.S0.Tree] |
|
compare [Core_set_intf.S0] |
|
compare [Core_set_intf.Elt_binable] |
|
compare [Core_set_intf.Elt] |
|
compare [Core_set.Poly] |
|
compare [Core_set] |
|
compare [Core_queue] |
|
compare [Core_map_intf.S] |
|
compare [Core_map_intf.Key_binable] |
|
compare [Core_map_intf.Key] |
|
compare [Core_map.Poly] |
|
compare [Core_list.Assoc] |
|
compare [Core_list] |
|
compare [Stable_module_types.S1] |
|
compare [Core_lazy] |
|
compare [Core_hashtbl_intf.Key] |
|
compare [Core_array.Permissioned.Float] |
|
compare [Core_array.Permissioned.Int] |
|
compare [Core_array.Permissioned] |
|
compare [Core_array.Float] |
|
compare [Core_array.Int] |
|
compare [Core_array] |
|
compare [Polymorphic_compare_intf.S] |
|
compare [Blang.Stable.V1] |
|
compare [Blang] |
|
compare [Bigstring] |
|
compare_decimal [Std_kernel] |
|
compare_direct [Core_set_intf.Accessors2_with_comparator] |
|
compare_direct [Core_set_intf.Accessors2] |
|
compare_direct [Core_set_intf.Accessors1] |
|
compare_direct [Core_set_intf.Accessors0] |
|
compare_direct [Core_set_intf.Accessors_generic] |
|
compare_direct [Core_set] |
compare_direct t1 t2 compares the sets t1 and t2 .
|
compare_direct [Core_map_intf.Accessors3_with_comparator] |
|
compare_direct [Core_map_intf.Accessors3] |
|
compare_direct [Core_map_intf.Accessors2] |
|
compare_direct [Core_map_intf.Accessors1] |
|
compare_direct [Core_map_intf.Accessors_generic] |
|
compare_direct [Core_map] |
Total ordering between maps.
|
compare_fn [Quickcheck_generator] |
Generator for comparison functions; result is guaranteed to be a partial order.
|
compare_fn_with_sexp [Quickcheck_generator] |
|
compare_immutable [Perms.Export] |
|
compare_me [Perms.Stable.V1] |
|
compare_me [Perms] |
|
compare_nobody [Perms.Stable.V1] |
|
compare_nobody [Perms] |
|
compare_perms [Perms.Export] |
|
compare_read [Perms.Export] |
|
compare_read_write [Perms.Export] |
|
compare_sexp_array [Std_internal] |
|
compare_sexp_bool [Std_internal] |
|
compare_sexp_list [Std_internal] |
|
compare_sexp_list [Stable_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.Stable.V1] |
|
compare_t [Nothing0] |
|
compare_write [Perms.Export] |
|
comparison [Quickcheck_observer] |
comparison ~compare ~eq ~lt ~gt combines observers lt and gt , where lt
observes values less than eq according to compare , and gt observes values
greater than eq according to compare .
|
complement [Flags_intf.S] |
bitwise not
|
compose [Fn] |
compose f g x is f (g x)
|
concat [Sequence] |
concat tt produces the elements of each inner sequence sequentially.
|
concat [Substring_intf.S] |
|
concat [Make_substring.F] |
|
concat [Core_string] |
concatanate all strings in the list using separator sep (default sep "")
|
concat [Core_list] |
Concatenate a list of lists.
|
concat [Core_array.Permissioned] |
|
concat [Core_array] |
Same as Array.append , but concatenates a list of arrays.
|
concat_array [Core_string] |
concat_array sep ar like String.concat , but operates on arrays
|
concat_bigstring [Substring_intf.S] |
|
concat_bigstring [Make_substring.F] |
|
concat_map [Sequence] |
concat_map t ~f is concat (map t ~f) .
|
concat_map [Linked_queue] |
|
concat_map [Core_string] |
Like map , but allows replacement of a single character with zero or two or more
characters.
|
concat_map [Core_queue] |
creates a new queue with elements equal to List.concat_map ~f (to_list t) .
|
concat_map [Core_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 [Core_array.Permissioned] |
|
concat_map [Core_array] |
same as List.concat_map
|
concat_mapi [Sequence] |
concat_mapi t ~f is like concat_map, but passes the index as an argument.
|
concat_mapi [Core_list] |
concat_mapi t ~f is like concat_map, but passes the index as an argument
|
concat_no_order [Core_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] |
|
cons [Core_list] |
|
cons [Applicative_intf.Args2] |
|
cons [Applicative_intf.Args] |
prepend an argument
|
const [Fn] |
produces a function that just returns its first argument
|
const [Common] |
|
constant [Blang] |
function true -> true_ | false -> false_
|
constant_value [Blang] |
constant_value t = Some b iff t = constant b
|
contains [Core_string] |
|
contains_dup [Core_list] |
contains_dup True if there are any two elements in the list which are the same.
|
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 .
|
copy [Stack_unit_tests.Test] |
|
copy [Stack_unit_tests.Debug] |
|
copy [Stack_intf.S] |
copy t returns a copy of t .
|
copy [Obj_array] |
copy t returns a new array with the same elements as t .
|
copy [Linked_queue] |
copy t returns a copy of t .
|
copy [Heap_intf.S] |
copy t returns a shallow copy
|
copy [Hash_set_intf.Accessors] |
preserves the equality function
|
copy [Hash_heap.S] |
|
copy [Hash_heap.Make] |
|
copy [Flat_array_debug.Debug] |
|
copy [Flat_array] |
copy a returns a shallow copy of a , that is, a fresh array containing the same
elements as a .
|
copy [Doubly_linked] |
|
copy [Core_string] |
|
copy [Core_queue] |
|
copy [Core_hashtbl_intf.Accessors] |
|
copy [Core_array.Permissioned] |
|
copy [Core_array] |
Array.copy a returns a copy of a , that is, a fresh array
containing the same elements as a .
|
copy [Core_random.State] |
|
count [Stack_unit_tests.Debug] |
|
count [Hash_queue.Make] |
|
count [Core_set] |
count t returns the number of elements of t for which f returns true .
|
count [Core_list] |
count l ~f is the number of elements in l that satisfy the
predicate f .
|
count [Container_unit_tests.Test_generic] |
|
count [Container_intf.Container] |
|
count [Container_intf.Generic_phantom] |
|
count [Container_intf.Generic] |
|
count [Container_intf.S1_permissions] |
Returns the number of elements for which the provided function evaluates to true.
|
count [Container_intf.S1_phantom_invariant] |
Returns the number of elements for which the provided function evaluates to true.
|
count [Container_intf.S1] |
Returns the number of elements for which the provided function evaluates to true.
|
count [Container_intf.S0_phantom] |
Returns the number of elements for which the provided function evaluates to true.
|
count [Container_intf.S0] |
Returns the number of elements for which the provided function evaluates to true.
|
counters [Core_gc] |
Return (minor_words, promoted_words, major_words) .
|
create [Validated_intf.Validated] |
|
create [Timing_wheel_intf.Timing_wheel.Priority_queue] |
create ?level_bits () creates a new empty timing wheel, t , with length t = 0
and min_allowed_key t = 0 .
|
create [Timing_wheel_intf.Timing_wheel.Config] |
create raises if alarm_precision <= 0 .
|
create [Timing_wheel_intf.Timing_wheel] |
create ~config ~start creates a new timing wheel with current time start .
|
create [Unpack_buffer] |
|
create [Univ_map.Multi.Key] |
|
create [Univ_map.With_fold.Key] |
|
create [Univ_map.With_default.Key] |
|
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 [Total_map.S] |
|
create [Thread_safe_queue] |
create () returns an empty queue.
|
create [Time_ns.Span] |
|
create [Stack_unit_tests.Test] |
|
create [Stack_unit_tests.Debug] |
|
create [Stack_intf.S] |
create () returns an empty stack.
|
create [Set_once] |
|
create [Ref.Permissioned] |
|
create [Ref] |
|
create [Pool_intf.Pool.Unsafe] |
create slots ~capacity creates an empty pool that can hold up to capacity
N-tuples.
|
create [Pool_intf.S] |
create slots ~capacity ~dummy creates an empty pool that can hold up to capacity
N-tuples.
|
create [Out_channel] |
|
create [Obj_array] |
create ~len returns an obj-array of length len , all of whose indices have value
Obj.repr 0 .
|
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 [Linked_queue] |
create () returns an empty queue.
|
create [Info] |
For create message a sexp_of_a , sexp_of_a a is lazily computed, when the info is
converted to a sexp.
|
create [In_channel] |
|
create [Host_and_port] |
|
create [Heap_intf.S] |
create ?min_size ~cmp returns a new min-heap that can store min_size elements
without reallocations, using ordering function cmp .
|
create [Heap_block] |
create v returns Some t if v is a heap block, where t is physically equal
to v
|
create [Hash_set_intf.Creators] |
|
create [Hash_queue.S] |
create () returns an empty queue.
|
create [Hash_queue.Make] |
|
create [Hash_heap.S] |
|
create [Hash_heap.Make] |
|
create [Force_once] |
create f creates a new force_once
|
create [Flat_queue] |
create ?capacity slots creates an empty queue with capacity at least the supplied
capacity .
|
create [Flat_array_debug.Debug] |
|
create [Flat_array] |
create slots ~len init creates an array of flat tuples, whose slots are initialized
to the slots of init , which is an ordinary OCaml tuple.
|
create [Flags_intf.Flags] |
create ~bit:n creates a flag with the n th bit set.
|
create [Fheap] |
create ~cmp returns a new min-heap that uses ordering function cmp .
|
create [Doubly_linked] |
creating doubly-linked lists
|
create [Deque] |
create ?initial_length ?never_shrink () create a new t .
|
create [Core_weak] |
|
create [Core_string.Search_pattern] |
create pattern preprocesses pattern as per KMP, building an int array of
length length pattern .
|
create [Core_string] |
|
create [Core_queue] |
Create an empty queue.
|
create [Core_hashtbl_intf.Creators] |
|
create [Core_gc.Expert.Alarm] |
create f arranges for f to be called at the end of each major GC cycle,
starting with the current cycle or the next one.
|
create [Core_gc.Control.Fields] |
|
create [Core_gc.Stat.Fields] |
|
create [Core_bytes] |
|
create [Core_array.Permissioned] |
|
create [Core_array] |
create ~len x creates an array of length len with the value x populated in
each element
|
create [Byte_units] |
create measure value creates a t from value units of the given measure.
|
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 [Blit_intf.Sequence] |
|
create [Bigstring] |
create length
|
create [Bigbuffer] |
create n returns a fresh buffer, initially empty.
|
create [Bag] |
create () returns an empty bag.
|
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_exn [Validated_intf.Validated] |
|
create_exn [Timing_wheel_intf.Timing_wheel.Level_bits] |
In create_exn bits , it is an error if any of the b_i in bits has b_i <= 0 ,
or if the sum of the b_i in bits is greater than max_num_bits .
|
create_exn [Heap_block] |
|
create_ieee [Float_intf.S] |
These functions construct and destruct 64-bit floating point numbers based on their
IEEE representation with sign bit, 11-bit non-negative (biased) exponent, and 52-bit
non-negative mantissa (or significand).
|
create_ieee_exn [Float_intf.S] |
|
create_mapped [Core_hashtbl_intf.Creators] |
create_mapped get_key get_data [x1,...,xn]
= of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn]
|
create_unit [Timing_wheel_unit_tests.Make] |
create_unit is exposed for use in additional unit tests.
|
create_with_key [Core_hashtbl_intf.Creators] |
create_with_key ~get_key [x1,...,xn]
= of_alist [get_key x1, x1; ...; get_key xn, xn]
|
create_with_key_exn [Core_hashtbl_intf.Creators] |
|
create_with_key_or_error [Core_hashtbl_intf.Creators] |
|
createf [Info] |
Construct a t containing only a string from a format.
|
curry [Tuple.T3] |
|
curry [Tuple.T2] |
|
cycle_list_exn [Sequence] |
cycle_list_exn xs repeats the elements of xs forever.
|
D |
data [Core_map_intf.Accessors3_with_comparator] |
|
data [Core_map_intf.Accessors3] |
|
data [Core_map_intf.Accessors2] |
|
data [Core_map_intf.Accessors1] |
|
data [Core_map_intf.Accessors_generic] |
|
data [Core_map] |
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] |
|
day [Time_ns.Span] |
|
debug [Unpack_buffer] |
debug controls whether invariants are checked at each call.
|
debug [Flat_array_debug.Debug] |
|
debug [Debug.Make] |
We avoid labels so that the applications are more concise -- see example above
|
debug [Bounded_int_table] |
set debug := true to turn on debugging, including potentially slow invariant
checking.
|
debug_get [Flat_array_debug.Debug] |
|
debug_set [Flat_array_debug.Debug] |
|
decimal_of_sexp [Std_kernel] |
|
decr [Int_intf.S] |
|
dedup [Core_list] |
dedup (de-duplicate).
|
default [Timing_wheel_intf.Timing_wheel.Config] |
default is create () .
|
default [Timing_wheel_intf.Timing_wheel.Level_bits] |
default returns the default value of level_bits used by Timing_wheel.create
and Timing_wheel.Priority_queue.create .
|
default [Core_random.State] |
|
default_attempts_per_trial [Quickcheck_intf.Quickcheck_config] |
default_attempts_per_trial determines the maximum number of attempts to generate
inputs for trials, as a multiplier for the number of trials, except in tests that
explicitly override it.
|
default_seed [Quickcheck_intf.Quickcheck_config] |
default_seed is used initialize the pseudo-random generator that chooses random
values from generators, in each test that is not provided its own seed.
|
default_trial_count [Quickcheck_intf.Quickcheck_config] |
default_trial_count determines the number of trials per test, except in tests
that explicitly override it.
|
default_trial_count_for_test_no_duplicates [Quickcheck_intf.Quickcheck_config] |
default_trial_count_for_test_no_duplicates determines the number of trials when
running test_no_duplicates without ~trials , either as a constant or as a factor
of default_trial_count .
|
delayed_fold [Sequence] |
delayed_fold allows to do an on-demand fold, while maintaining a state.
|
delete [Core_gc.Expert.Alarm] |
delete t will stop the calls to the function associated to t .
|
dequeue [Linked_queue] |
dequeue t returns None if t is empty, otherwise it removes and returns the front
of t
|
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 [Fdeque] |
dequeue t side produces Option.both (peek t side) (drop t side) .
|
dequeue [Deque] |
dequeue t back_or_front remove and return the back_or_front of t
|
dequeue [Core_queue] |
|
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_back [Fdeque] |
|
dequeue_back [Deque] |
|
dequeue_back_exn [Fdeque] |
|
dequeue_back_exn [Deque] |
|
dequeue_exn [Thread_safe_queue] |
dequeue_exn t raises if length t = 0 .
|
dequeue_exn [Linked_queue] |
|
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 [Fdeque] |
|
dequeue_exn [Deque] |
|
dequeue_exn [Core_queue] |
|
dequeue_front [Fdeque] |
|
dequeue_front [Deque] |
|
dequeue_front_exn [Fdeque] |
|
dequeue_front_exn [Deque] |
|
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_intf.S_common] |
|
dest [Type_immediacy] |
|
detuple2 [Type_equal] |
tuple2 and detuple2 convert between equality on a 2-tuple and its components.
|
diff [Timing_wheel_intf.Interval_num] |
|
diff [Time_ns] |
|
diff [Hash_set_intf.Accessors] |
|
diff [Core_set_intf.Accessors2_with_comparator] |
|
diff [Core_set_intf.Accessors2] |
|
diff [Core_set_intf.Accessors1] |
|
diff [Core_set_intf.Accessors0] |
|
diff [Core_set_intf.Accessors_generic] |
|
diff [Core_set] |
diff t1 t2 computes the set difference t1 - t2 , i.e., the set containing all
elements in t1 that are not in t2 .
|
disable_compaction [Core_gc] |
|
discard_exn [Fqueue] |
Returns version of queue with top element removed.
|
div [Time_ns.Span] |
|
do_intersect [Flags_intf.S] |
|
does_match [Univ] |
does_match t id returns true iff t was created by create id v .
|
does_raise [Std_kernel] |
|
does_raise [Exn] |
does_raise f returns true iff f () raises, which is often useful in unit
tests.
|
doubleton [Quickcheck_observer] |
doubleton f ~f_sexp maps values to two "buckets" (as described in t above),
depending on whether they satisfy f .
|
doubleton [Quickcheck_generator] |
|
drop [Sequence] |
drop t n produces all elements of t except the first n elements.
|
drop [Fdeque] |
drop t side produces Some of t with the element at its side removed, or
None if t is empty.
|
drop [Deque] |
drop ?n t back_or_front drop n elements (default 1) from the back_or_front of
t .
|
drop [Core_list] |
|
drop_back [Fdeque] |
|
drop_back [Deque] |
|
drop_back_exn [Fdeque] |
|
drop_eagerly [Sequence] |
drop_eagerly t n immediately consumes the first n elements of t and returns the
unevaluated tail of t .
|
drop_exn [Fdeque] |
|
drop_front [Flat_queue] |
drop_front ?n t drops the the first n elements of t .
|
drop_front [Fdeque] |
|
drop_front [Deque] |
|
drop_front_exn [Fdeque] |
|
drop_prefix [Substring_intf.S] |
|
drop_prefix [Make_substring.F] |
|
drop_prefix [Core_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 [Core_string] |
drop_suffix s n drops the longest suffix of s of length less than or equal to n
|
drop_while [Sequence] |
drop_while t ~f produces the suffix of t beginning with the first element of t
for which f is false .
|
drop_while [Core_list] |
drop_while l ~f drops the longest prefix of l for which f is true .
|
drop_while_option [Sequence] |
drop_while_option t ~f immediately consumes the elements from t until the
predicate f fails and returns the first element that failed along with the
unevaluated tail of t .
|
durations [Timing_wheel_intf.Timing_wheel.Config] |
durations t returns the durations of the levels in t
|
E |
either [Quickcheck_observer] |
|
either [Quickcheck_generator] |
|
elements [Core_set_intf.Accessors2_with_comparator] |
|
elements [Core_set_intf.Accessors2] |
|
elements [Core_set_intf.Accessors1] |
|
elements [Core_set_intf.Accessors0] |
|
elements [Core_set_intf.Accessors_generic] |
|
elements [Core_set] |
|
elts [Bag] |
|
empty [Univ_map_intf.S1] |
|
empty [Univ_map_intf.S] |
|
empty [Sequence] |
empty is a sequence with no elements.
|
empty [Obj_array] |
|
empty [Int_set] |
|
empty [Fqueue] |
The empty queue
|
empty [Flags_intf.S] |
|
empty [Fdeque] |
The empty deque.
|
empty [Core_set_intf.Creators2_with_comparator] |
|
empty [Core_set_intf.Creators2] |
|
empty [Core_set_intf.Creators1] |
|
empty [Core_set_intf.Creators0] |
|
empty [Core_set_intf.Creators_generic] |
|
empty [Core_set] |
Creates an empty set based on the provided comparator.
|
empty [Core_map_intf.Creators3_with_comparator] |
|
empty [Core_map_intf.Creators2] |
|
empty [Core_map_intf.Creators1] |
|
empty [Core_map_intf.Creators_generic] |
|
empty [Core_map] |
the empty map
|
empty [Core_array.Permissioned] |
|
empty [Core_array] |
empty () creates an empty array
|
empty [Avltree] |
|
enqueue [Thread_safe_queue] |
|
enqueue [Linked_queue] |
enqueue t x adds x to the end of t .
|
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 [Fdeque] |
enqueue t side x produces t updated with x added to its side .
|
enqueue [Deque] |
enqueue t back_or_front v push v onto the back_or_front of t .
|
enqueue [Core_queue] |
|
enqueue1 [Flat_queue] |
There is an enqueueN function for each possible arity of a flat queue.
|
enqueue2 [Flat_queue] |
|
enqueue3 [Flat_queue] |
|
enqueue4 [Flat_queue] |
|
enqueue5 [Flat_queue] |
|
enqueue6 [Flat_queue] |
|
enqueue7 [Flat_queue] |
|
enqueue8 [Flat_queue] |
|
enqueue9 [Flat_queue] |
|
enqueue_back [Fdeque] |
|
enqueue_back [Deque] |
|
enqueue_exn [Hash_queue.S] |
|
enqueue_exn [Hash_queue.Make] |
|
enqueue_front [Fdeque] |
|
enqueue_front [Deque] |
|
enqueue_top [Fqueue] |
enqueue a single element on the *top* of the queue.
|
enum [Quickcheck_observer] |
enum n ~f maps values to n buckets, where f produces the index for a bucket
from 0 to n-1 for each value.
|
epoch [Timing_wheel_intf.Timing_wheel_time] |
|
epoch [Time_ns] |
Unix epoch (1970-01-01 00:00:00 UTC)
|
eprint [Debug] |
eprint message prints to stderr message , followed by a newline and flush.
|
eprintf [Std_internal] |
|
eprintf [Debug] |
eprintf message arg1 ... argn prints to stderr message , with sprintf-style format
characters instantiated, followed by a newline and flush.
|
eprintf [Core_printf] |
|
eprints [Debug] |
eprints message a sexp_of_a prints to stderr message and a as a sexp, followed
by a newline and flush.
|
epsilon_float [Float_intf.S] |
The difference between 1.0 and the smallest exactly representable floating-point
number greater than 1.0.
|
epsilon_float [Common] |
|
equal [Tuple.T3] |
|
equal [Tuple.T2] |
|
equal [Stable_unit_test_intf.Unordered_container_arg] |
|
equal [Stable_unit_test_intf.Arg] |
tests is a list of (value, sexp-representation, bin-io-representation) triples.
|
equal [Polymorphic_compare] |
|
equal [Option] |
|
equal [No_polymorphic_compare] |
|
equal [Hash_set_intf.Accessors] |
|
equal [Tuple_type_intf.Slot] |
|
equal [Equal.S3] |
|
equal [Equal.S2] |
|
equal [Equal.S1] |
|
equal [Equal.S] |
|
equal [Either_intf.S] |
|
equal [Doubly_linked.Elt] |
pointer equality
|
equal [Doubly_linked] |
predicates
|
equal [Core_string] |
fast equality function on strings, doesn't use compare_val
|
equal [Core_set_intf.Accessors2_with_comparator] |
|
equal [Core_set_intf.Accessors2] |
|
equal [Core_set_intf.Accessors1] |
|
equal [Core_set_intf.Accessors0] |
|
equal [Core_set_intf.Accessors_generic] |
|
equal [Core_set] |
equal t1 t2 returns true iff the two sets have the same elements.
|
equal [Core_map_intf.Accessors3_with_comparator] |
|
equal [Core_map_intf.Accessors3] |
|
equal [Core_map_intf.Accessors2] |
|
equal [Core_map_intf.Accessors1] |
|
equal [Core_map_intf.Accessors_generic] |
|
equal [Core_map] |
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 [Core_list] |
|
equal [Core_hashtbl_intf.Accessors] |
equal t1 t2 f and similar t1 t2 f both return true iff t1 and t2 have the
same keys and for all keys k , f (find_exn t1 k) (find_exn t2 k) .
|
equal [Core_array.Permissioned] |
|
equal [Core_array] |
|
equal [Polymorphic_compare_intf.S] |
|
equal [Blit_intf.Elt] |
of_bool is used to generate two distinct values of type t , used in unit tests.
|
equal [Bag.Elt] |
|
equal_fn [Quickcheck_generator] |
Generator for equality functions; result is guaranteed to be an equivalence
relation.
|
equal_fn_with_sexp [Quickcheck_generator] |
|
error [Result] |
|
error [Or_error] |
error is a wrapper around Error.create :
|
error [Common] |
Or_error.error
|
error_string [Or_error] |
error_string message is Error (Error.of_string message)
|
errorf [Or_error] |
errorf format arg1 arg2 ... is Error (sprintf format arg1 arg2 ...) .
|
errors [Validate] |
Returns a list of formatted error strings, which include both the error message and
the path to the error.
|
escape [Core_string.Escaping] |
escape ~escapeworthy ~escape_char s is
escape_gen_exn ~escapeworthy_map:(List.zip_exn escapeworthy escapeworthy)
~escape_char
.
|
escape_gen [Core_string.Escaping] |
|
escape_gen_exn [Core_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 [Core_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 [Core_char] |
Return a string representing the given character, with special characters escaped
following the lexical conventions of Objective Caml.
|
eval [Blang] |
eval t f evaluates the proposition t relative to an environment
f that assigns truth values to base propositions.
|
exists [Stack_unit_tests.Debug] |
|
exists [Hash_queue.Make] |
|
exists [Core_set] |
exists t ~f returns true iff there exists an a in t for which f a .
|
exists [Core_map_intf.Accessors3_with_comparator] |
|
exists [Core_map_intf.Accessors3] |
|
exists [Core_map_intf.Accessors2] |
|
exists [Core_map_intf.Accessors1] |
|
exists [Core_map_intf.Accessors_generic] |
|
exists [Core_map] |
|
exists [Core_hashtbl_intf.Accessors] |
|
exists [Core_gc.Control.Fields] |
|
exists [Core_gc.Stat.Fields] |
|
exists [Container_unit_tests.Test_generic] |
|
exists [Container_intf.Container] |
|
exists [Container_intf.Generic_phantom] |
|
exists [Container_intf.Generic] |
|
exists [Container_intf.S1_permissions] |
Returns true if and only if there exists an element for which the provided
function evaluates to true .
|
exists [Container_intf.S1_phantom_invariant] |
Returns true if and only if there exists an element for which the provided
function evaluates to true .
|
exists [Container_intf.S1] |
Returns true if and only if there exists an element for which the provided
function evaluates to true .
|
exists [Container_intf.S0_phantom] |
Returns true if and only if there exists an element for which the provided
function evaluates to true .
|
exists [Container_intf.S0] |
Returns true if and only if there exists an element for which the provided
function evaluates to true .
|
exists [Bounded_int_table] |
|
exists2_exn [Core_list] |
Same as List.exists , but for a two-argument predicate.
|
existsi [Core_hashtbl_intf.Accessors] |
|
existsi [Bounded_int_table] |
|
exitf [Core_printf] |
print to stderr; exit 1
|
exn_if_dup [Core_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 [Validate] |
A result containing a single error
|
fail [Result] |
|
fail_fn [Validate] |
fail_fn err returns a function that always returns fail, with err as the error
message.
|
failf [Validate] |
Like sprintf or failwithf but produces a t instead of a string or exception
|
failf [Result] |
e.g.
|
fails [Validate] |
|
failure [Raw_quickcheck_generator] |
Empty generator that is guaranteed to fail to produce a value.
|
failwithf [Core_printf] |
raises Failure
|
failwithf [Common] |
|
failwithp [Error] |
|
failwithp [Common] |
Error.failwithp
|
failwiths [Error] |
failwiths ?strict ?here message a sexp_of_a
= Error.raise (Error.create ?strict ?here s a sexp_of_a)
|
failwiths [Common] |
Error.failwiths
|
false_ [Blang] |
|
feed [Unpack_buffer] |
feed t buf ?pos ?len adds the specified substring of buf to t 's buffer.
|
feed_string [Unpack_buffer] |
|
field [Validate] |
Used for validating an individual field.
|
field_folder [Validate] |
Creates a function for use in a Fields.fold .
|
fill [Core_string] |
|
fill [Core_array.Permissioned] |
|
fill [Core_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 [Sequence] |
|
filter [Quickcheck_generator] |
|
filter [Option] |
|
filter [Linked_queue] |
|
filter [Hash_set_intf.Accessors] |
|
filter [Core_string] |
filter s ~f:predicate discards characters not satisfying predicate
|
filter [Core_set_intf.Accessors2_with_comparator] |
|
filter [Core_set_intf.Accessors2] |
|
filter [Core_set_intf.Accessors1] |
|
filter [Core_set_intf.Accessors0] |
|
filter [Core_set_intf.Accessors_generic] |
|
filter [Core_set] |
filter t ~f returns the subset of t for which f evaluates to true.
|
filter [Core_queue] |
filter is like filter_map , except with List.filter .
|
filter [Core_map_intf.Accessors3_with_comparator] |
|
filter [Core_map_intf.Accessors3] |
|
filter [Core_map_intf.Accessors2] |
|
filter [Core_map_intf.Accessors1] |
|
filter [Core_map_intf.Accessors_generic] |
|
filter [Core_map] |
filter , filter_map , and filter_mapi run in O(n * lg n) time; they simply
accumulate each key & data retained by f into a new map using add .
|
filter [Core_list] |
filter l ~f returns all the elements of the list l that satisfy the predicate p .
|
filter [Core_hashtbl_intf.Accessors] |
|
filter [Core_array.Permissioned] |
|
filter [Core_array] |
filter ~f array removes the elements for which f returns false.
|
filter_inplace [Linked_queue] |
filter_inplace t ~f removes all elements of t that don't satisfy f .
|
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 [Core_queue] |
filter_inplace t ~f removes all elements of t that don't satisfy f .
|
filter_inplace [Core_hashtbl_intf.Accessors] |
|
filter_inplace [Bag] |
filter_inplace t ~f removes all the elements from t that don't satisfy f .
|
filter_map [Sequence] |
filter_map t ~f produce mapped elements of t which are not None .
|
filter_map [Quickcheck_generator] |
filter_map t ~f produces y for every x in t such that f x = Some y .
|
filter_map [Linked_queue] |
|
filter_map [Core_set_intf.Creators2_with_comparator] |
|
filter_map [Core_set_intf.Creators2] |
|
filter_map [Core_set_intf.Creators1] |
|
filter_map [Core_set_intf.Creators0] |
|
filter_map [Core_set_intf.Creators_generic] |
|
filter_map [Core_set] |
Like Core_set.map , except elements for which f returns None will be dropped.
|
filter_map [Core_queue] |
filter_map creates a new queue with elements equal to List.filter_map ~f (to_list
t) .
|
filter_map [Core_map_intf.Accessors3_with_comparator] |
|
filter_map [Core_map_intf.Accessors3] |
|
filter_map [Core_map_intf.Accessors2] |
|
filter_map [Core_map_intf.Accessors1] |
|
filter_map [Core_map_intf.Accessors_generic] |
|
filter_map [Core_map] |
returns new map with bound values filtered by f applied to the bound values
|
filter_map [Core_list] |
filter_map l ~f 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 [Core_array.Permissioned] |
|
filter_map [Core_array] |
filter_map ~f array maps f over array and filters None out of the
results.
|
filter_map [Bounded_int_table] |
|
filter_mapi [Sequence] |
filter_mapi is just like filter_map , but it also passes in the index of each
element to f .
|
filter_mapi [Core_map_intf.Accessors3_with_comparator] |
|
filter_mapi [Core_map_intf.Accessors3] |
|
filter_mapi [Core_map_intf.Accessors2] |
|
filter_mapi [Core_map_intf.Accessors1] |
|
filter_mapi [Core_map_intf.Accessors_generic] |
|
filter_mapi [Core_map] |
like filter_map , but function takes both key and data as arguments
|
filter_mapi [Core_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 [Core_array.Permissioned] |
|
filter_mapi [Core_array] |
Same as filter_map but uses Array.mapi .
|
filter_mapi [Bounded_int_table] |
|
filter_opt [Sequence] |
filter_opt t produces the elements of t which are not None .
|
filter_opt [Core_list] |
filter_opt l is the sublist of l containing only elements
which are Some e .
|
filter_opt [Core_array.Permissioned] |
|
filter_opt [Core_array] |
filter_opt array returns a new array where None entries are omitted and Some x
entries are replaced with x .
|
filteri [Sequence] |
|
filteri [Core_list] |
|
filteri [Core_hashtbl_intf.Accessors] |
|
filteri [Core_array.Permissioned] |
|
filteri [Core_array] |
Like filter except f also receives the index.
|
filteri_inplace [Core_hashtbl_intf.Accessors] |
|
finalize_release [Core_gc.Expert] |
The runtime essentially maintains a bool ref:
|
find [Univ_map_intf.S1] |
|
find [Univ_map_intf.S] |
|
find [Univ_map.Multi] |
|
find [Univ_map.With_fold] |
the current accumulator
|
find [Univ_map.With_default] |
|
find [Total_map] |
|
find [Stack_unit_tests.Debug] |
|
find [Hash_queue.Make] |
|
find [Hash_heap.S] |
|
find [Hash_heap.Make] |
|
find [Core_set] |
find t f returns an element of t for which f returns true, with no guarantee as
to which element is returned.
|
find [Core_map_intf.Accessors3_with_comparator] |
|
find [Core_map_intf.Accessors3] |
|
find [Core_map_intf.Accessors2] |
|
find [Core_map_intf.Accessors1] |
|
find [Core_map_intf.Accessors_generic] |
|
find [Core_map] |
returns the value bound to the given key, raising Not_found if none such exists
|
find [Core_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_unit_tests.Test_generic] |
|
find [Container_intf.Container] |
|
find [Container_intf.Generic_phantom] |
|
find [Container_intf.Generic] |
|
find [Container_intf.S1_permissions] |
Returns as an option the first element for which f evaluates to true.
|
find [Container_intf.S1_phantom_invariant] |
Returns as an option the first element for which f evaluates to true.
|
find [Container_intf.S1] |
Returns as an option the first element for which f evaluates to true.
|
find [Container_intf.S0_phantom] |
Returns as an option the first element for which f evaluates to true.
|
find [Container_intf.S0] |
Returns as an option the first element for which f evaluates to true.
|
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 [Core_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_call [Core_hashtbl_intf.Accessors] |
find_and_call t k ~if_found ~if_not_found
|
find_and_call [Avltree] |
find_and_call t ~compare k ~if_found ~if_not_found
|
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_consecutive_duplicate [Sequence] |
find_consecutive_duplicate t ~equal returns the first pair of consecutive elements
(a1, a2) in t such that equal a1 a2 .
|
find_consecutive_duplicate [Core_list] |
find_consecutive_duplicate t ~equal returns the first pair of consecutive elements
(a1, a2) in t such that equal a1 a2 .
|
find_consecutive_duplicate [Core_array.Permissioned] |
|
find_consecutive_duplicate [Core_array] |
find_consecutive_duplicate t ~equal returns the first pair of consecutive elements
(a1, a2) in t such that equal a1 a2 .
|
find_elt [Heap.Removable] |
find_elt t ~f .
|
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_intf.S1] |
|
find_exn [Univ_map_intf.S] |
|
find_exn [Sequence] |
find_exn t ~f returns the first element of t that satisfies f .
|
find_exn [Hash_heap.S] |
|
find_exn [Hash_heap.Make] |
|
find_exn [Core_set_intf.Accessors2_with_comparator] |
|
find_exn [Core_set_intf.Accessors2] |
|
find_exn [Core_set_intf.Accessors1] |
|
find_exn [Core_set_intf.Accessors0] |
|
find_exn [Core_set_intf.Accessors_generic] |
|
find_exn [Core_set] |
Like find , but throws an exception on failure.
|
find_exn [Core_map_intf.Accessors3_with_comparator] |
|
find_exn [Core_map_intf.Accessors3] |
|
find_exn [Core_map_intf.Accessors2] |
|
find_exn [Core_map_intf.Accessors1] |
|
find_exn [Core_map_intf.Accessors_generic] |
|
find_exn [Core_map] |
|
find_exn [Core_list.Assoc] |
|
find_exn [Core_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 [Core_array.Permissioned] |
|
find_exn [Core_array] |
find_exn f t returns the first a in t for which f t.(i) is true.
|
find_exn [Bounded_int_table] |
|
find_index [Core_set_intf.Accessors2_with_comparator] |
|
find_index [Core_set_intf.Accessors2] |
|
find_index [Core_set_intf.Accessors1] |
|
find_index [Core_set_intf.Accessors0] |
|
find_index [Core_set_intf.Accessors_generic] |
|
find_index [Core_set] |
find_index t i returns the i th smallest element of t , in O(log n) time.
|
find_map [Stack_unit_tests.Debug] |
|
find_map [Hash_queue.Make] |
|
find_map [Core_set] |
find_map t f returns b for some a in t for which f a = Some b .
|
find_map [Container_unit_tests.Test_generic] |
|
find_map [Container_intf.Container] |
|
find_map [Container_intf.Generic_phantom] |
|
find_map [Container_intf.Generic] |
|
find_map [Container_intf.S1_permissions] |
Returns the first evaluation of f that returns Some , and returns None if there
is no such element.
|
find_map [Container_intf.S1_phantom_invariant] |
Returns the first evaluation of f that returns Some , and returns None if there
is no such element.
|
find_map [Container_intf.S1] |
Returns the first evaluation of f that returns Some , and returns None if there
is no such element.
|
find_map [Container_intf.S0_phantom] |
Returns the first evaluation of f that returns Some , and returns None if there
is no such element.
|
find_map [Container_intf.S0] |
Returns the first evaluation of f that returns Some , and returns None if there
is no such element.
|
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] |
Mutation of the heap during iteration is not supported, but there is no check to
prevent it.
|
find_pop_exn [Hash_heap.Make] |
|
findi [Sequence] |
|
findi [Core_list] |
|
findi [Core_array.Permissioned] |
|
findi [Core_array] |
findi t f returns the first index i of t for which f i t.(i) is true
|
findi_exn [Core_array.Permissioned] |
|
findi_exn [Core_array] |
findi_exn t f returns the first index i of t for which f i t.(i) is
true.
|
fire_past_alarms [Timing_wheel_intf.Timing_wheel] |
fire_past_alarms t ~handle_fired fires and removes all alarms a in t with
Time.( <= ) (Alarm.at t a) (now t) , applying handle_fired to each such a .
|
first [Hash_queue.S] |
first t returns the front element of the queue, without removing it.
|
first [Hash_queue.Make] |
|
first [Either_intf.S] |
first and second are First.return and Second.return .
|
first [Doubly_linked] |
|
first [Avltree] |
|
first_elt [Doubly_linked] |
constant-time extraction of first and last elements.
|
first_failure [Validate] |
|
first_some [Option] |
|
first_with_key [Hash_queue.S] |
first_with_key t returns the front element of the queue and its key, without
removing it.
|
first_with_key [Hash_queue.Make] |
|
flip [Fn] |
reverse the order of arguments for a binary function
|
float [Type_immediacy.Never] |
|
float [Quickcheck_observer] |
|
float [Quickcheck_generator] |
|
float [Core_random.State] |
|
float [Core_random] |
Random.float bound returns a random floating-point number between 0 (inclusive) and
bound (exclusive).
|
float_between [Quickcheck_generator] |
float_between ~nan ~lower_bound ~upper_bound produces floating point
numbers within the given bounds.
|
float_finite [Quickcheck_generator] |
float_finite includes finite values, but excludes infinite and NaN values.
|
float_of_bits [Core_int64] |
|
float_of_bits [Core_int32] |
|
float_of_int [Common] |
|
float_of_string [Common] |
|
float_without_nan [Quickcheck_generator] |
float_without_nan includes finite and infinite values, but excludes NaN.
|
floor [Common] |
|
floor_pow2 [Int_pow2] |
|
floor_pow2 [Core_int] |
floor_pow2 x returns the largest power of 2 that is less than or equal to x .
|
flush [Out_channel] |
|
fn [Raw_quickcheck_observer] |
Observer for function type.
|
fn [Quickcheck_generator] |
Generators for functions; take observers for inputs and a generator for outputs.
|
fn2 [Quickcheck_generator] |
|
fn2_with_sexp [Quickcheck_generator] |
|
fn3 [Quickcheck_generator] |
|
fn3_with_sexp [Quickcheck_generator] |
|
fn4 [Quickcheck_generator] |
|
fn4_with_sexp [Quickcheck_generator] |
|
fn5 [Quickcheck_generator] |
|
fn5_with_sexp [Quickcheck_generator] |
|
fn6 [Quickcheck_generator] |
|
fn6_with_sexp [Quickcheck_generator] |
|
fn_sexp [Quickcheck_generator] |
|
fn_with_sexp [Quickcheck_generator] |
|
fold [Stack_unit_tests.Debug] |
|
fold [Linked_queue] |
|
fold [Hash_queue.Make] |
|
fold [Flat_queue] |
In iter t ~f and fold t ~init ~f , if f mutates t , then the iteration will
raise.
|
fold [Core_set] |
fold t ~init ~f folds over the elements of the set from smallest to largest.
|
fold [Core_map_intf.Accessors3_with_comparator] |
|
fold [Core_map_intf.Accessors3] |
|
fold [Core_map_intf.Accessors2] |
|
fold [Core_map_intf.Accessors1] |
|
fold [Core_map_intf.Accessors_generic] |
|
fold [Core_map] |
folds over keys and data in map in increasing order of key.
|
fold [Core_hashtbl_intf.Accessors] |
|
fold [Core_gc.Control.Fields.Direct] |
|
fold [Core_gc.Control.Fields] |
|
fold [Core_gc.Stat.Fields.Direct] |
|
fold [Core_gc.Stat.Fields] |
|
fold [Container_unit_tests.Test_generic] |
|
fold [Container_intf.Make_arg] |
|
fold [Container_intf.Generic_phantom] |
|
fold [Container_intf.Generic] |
|
fold [Container_intf.S1_permissions] |
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en , where e1..en
are the elements of t
|
fold [Container_intf.S1_phantom_invariant] |
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en , where e1..en
are the elements of t
|
fold [Container_intf.S1] |
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en , where e1..en
are the elements of t
|
fold [Container_intf.S0_phantom] |
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en , where e1..en
are the elements of t
|
fold [Container_intf.S0] |
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en , where e1..en
are the elements of t
|
fold [Bounded_int_table] |
|
fold [Avltree] |
fold over the tree
|
fold' [Deque] |
fold' t ~init ~f fold over the elements of t
|
fold2_exn [Core_list] |
List.fold2_exn ~f ~init:a [b1; ...; bn] [c1; ...; cn] is
f (... (f (f a b1 c1) b2 c2) ...) bn cn .
|
fold2_exn [Core_array.Permissioned] |
|
fold2_exn [Core_array] |
|
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_left [Core_list] |
fold_left is the same as fold , and one should always use fold rather than
fold_left , except in functors that are parameterized over a more general signature
where this equivalence does not hold.
|
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.Accessors3_with_comparator] |
|
fold_range_inclusive [Core_map_intf.Accessors3] |
|
fold_range_inclusive [Core_map_intf.Accessors2] |
|
fold_range_inclusive [Core_map_intf.Accessors1] |
|
fold_range_inclusive [Core_map_intf.Accessors_generic] |
|
fold_range_inclusive [Core_map] |
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_right [Doubly_linked] |
|
fold_right [Core_set_intf.Accessors2_with_comparator] |
|
fold_right [Core_set_intf.Accessors2] |
|
fold_right [Core_set_intf.Accessors1] |
|
fold_right [Core_set_intf.Accessors0] |
|
fold_right [Core_set_intf.Accessors_generic] |
|
fold_right [Core_set] |
Like Core_set.fold , except that it goes from the largest to the smallest element.
|
fold_right [Core_map_intf.Accessors3_with_comparator] |
|
fold_right [Core_map_intf.Accessors3] |
|
fold_right [Core_map_intf.Accessors2] |
|
fold_right [Core_map_intf.Accessors1] |
|
fold_right [Core_map_intf.Accessors_generic] |
|
fold_right [Core_map] |
folds over keys and data in map in decreasing order of key.
|
fold_right [Core_list] |
List.fold_right [a1; ...; an] ~f ~init:b is
f a1 (f a2 (... (f an b) ...)) .
|
fold_right [Core_array.Permissioned] |
|
fold_right [Core_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.Accessors2_with_comparator] |
|
fold_until [Core_set_intf.Accessors2] |
|
fold_until [Core_set_intf.Accessors1] |
|
fold_until [Core_set_intf.Accessors0] |
|
fold_until [Core_set_intf.Accessors_generic] |
|
fold_until [Core_set] |
Like Core_set.fold , except that it will terminate early, if f returns `Stop .
|
foldi [Sequence] |
foldi is just like fold , but it also passes in the index of each element to
f .
|
foldi [Hash_queue.S] |
|
foldi [Hash_queue.Make] |
|
foldi [Deque] |
foldi t ~init ~f as fold , but also passes in the index of the current element.
|
foldi [Core_string] |
foldi works similarly to fold , but also pass in index of each character to f
|
foldi [Core_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 [Core_array.Permissioned] |
|
foldi [Core_array] |
|
foldi' [Deque] |
foldi' t ~init ~f as fold' , but also passes in the index of the current element to
f .
|
for_all [Stack_unit_tests.Debug] |
|
for_all [Hash_queue.Make] |
|
for_all [Core_set] |
for_all t ~f returns true iff for all a in t , f a .
|
for_all [Core_map_intf.Accessors3_with_comparator] |
|
for_all [Core_map_intf.Accessors3] |
|
for_all [Core_map_intf.Accessors2] |
|
for_all [Core_map_intf.Accessors1] |
|
for_all [Core_map_intf.Accessors_generic] |
|
for_all [Core_map] |
same semantics as similar functions in List
|
for_all [Core_hashtbl_intf.Accessors] |
|
for_all [Core_gc.Control.Fields] |
|
for_all [Core_gc.Stat.Fields] |
|
for_all [Container_unit_tests.Test_generic] |
|
for_all [Container_intf.Container] |
|
for_all [Container_intf.Generic_phantom] |
|
for_all [Container_intf.Generic] |
|
for_all [Container_intf.S1_permissions] |
Returns true if and only if the provided function evaluates to true for all
elements.
|
for_all [Container_intf.S1_phantom_invariant] |
Returns true if and only if the provided function evaluates to true for all
elements.
|
for_all [Container_intf.S1] |
Returns true if and only if the provided function evaluates to true for all
elements.
|
for_all [Container_intf.S0_phantom] |
Returns true if and only if the provided function evaluates to true for all
elements.
|
for_all [Container_intf.S0] |
Returns true if and only if the provided function evaluates to true for all
elements.
|
for_all [Bounded_int_table] |
|
for_all2_exn [Core_list] |
Same as List.for_all , but for a two-argument predicate.
|
for_all2_exn [Core_array.Permissioned] |
|
for_all2_exn [Core_array] |
for_all2_exn t1 t2 ~f fails if length t1 <> length t2 .
|
for_alli [Core_hashtbl_intf.Accessors] |
|
for_alli [Bounded_int_table] |
|
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 [Core_lazy] |
force x forces the suspension x and returns its result.
|
force [Common] |
|
force_eagerly [Sequence] |
force_eagerly t precomputes the sequence.
|
force_val [Core_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.
|
formatter_of_buffer [Bigbuffer.Format] |
|
fprintf [Std_internal] |
|
fprintf [Core_printf] |
|
fractional [Float_intf.S.Parts] |
|
fragments [Core_gc.Stat.Fields] |
|
fragments [Core_gc.Stat] |
|
free [Pool_intf.S] |
free t pointer frees the tuple pointed to by pointer from t .
|
free_blocks [Core_gc.Stat.Fields] |
|
free_blocks [Core_gc.Stat] |
|
free_words [Core_gc.Stat.Fields] |
|
free_words [Core_gc.Stat] |
|
frexp [Float_intf.S] |
frexp f returns the pair of the significant and the exponent of f.
|
frexp [Common] |
|
from_fun [Core_lazy] |
from_fun f is the same as lazy (f ()) but slightly more efficient.
|
from_val [Core_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) .
|
front_index [Deque] |
front_index t return the index of the front item in t .
|
front_index_exn [Deque] |
front_index_exn t throws an exception if t is empty, otherwise returns the index
of the front item in t
|
fst3 [Common] |
triple handling
|
full_init [Core_random] |
Same as Random.init but takes more data as seed.
|
full_major [Core_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 [Union_find] |
get t returns the value of the class of t .
|
get [Set_once] |
|
get [Ref.Permissioned] |
|
get [Pool_intf.S] |
get t pointer slot gets slot of the tuple pointed to by pointer in
pool t .
|
get [Obj_array] |
get t i and unsafe_get t i return the object at index i .
|
get [Flat_queue] |
These functions get and set individual slots of flat tuple i in queue t .
|
get [Flat_array_debug.Debug] |
|
get [Flat_array] |
These functions get and set individual slots of flat tuple i in array t .
|
get [Deque] |
get t i return the element at index i .
|
get [Core_weak] |
|
get [Core_string] |
|
get [Core_queue] |
get t i returns the i 'th element in t , where the 0'th element is at the front of
t and the length t - 1 element is at the back.
|
get [Core_gc] |
Return the current values of the GC parameters in a control record.
|
get [Core_array.Permissioned] |
|
get [Core_array] |
Array.get a n returns the element number n of array a .
|
get [Blit_intf.Sequence] |
|
get [Binary_searchable_intf.Indexable1] |
|
get [Binary_searchable_intf.Indexable] |
|
get [Bigstring] |
get t pos returns the character at pos
|
get [Backtrace] |
|
get1 [Tuple.T3] |
|
get1 [Tuple.T2] |
|
get2 [Tuple.T3] |
|
get2 [Tuple.T2] |
|
get3 [Tuple.T3] |
|
get_all_slots [Flat_queue] |
get_all_slots t i allocates a new ordinary OCaml tuple whose components are equal to
the slots of the flat tuple at index i of t .
|
get_all_slots [Flat_array_debug.Debug] |
|
get_all_slots [Flat_array] |
get_all_slots t i allocates a new ordinary OCaml tuple whose components are equal to
the slots of the flat tuple at index i of t .
|
get_backtrace [Core_printexc] |
|
get_digit [Core_char] |
Return Some i if is_digit c and None otherwise.
|
get_digit_exn [Core_char] |
Return i if is_digit c .
|
get_exn [Set_once] |
|
get_opt [Deque] |
get_opt t i return the element at index i .
|
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_state [Core_random] |
OCaml's Random.get_state makes a copy of the default state, which is almost
certainly not what you want.
|
get_tail_padded_fixed_string [Bigstring] |
similar to Binary_packing.unpack_tail_padded_fixed_string and
.pack_tail_padded_fixed_string .
|
get_tuple [Pool_intf.S] |
get_tuple t pointer allocates an OCaml tuple isomorphic to the pool t 's tuple
pointed to by pointer .
|
gigabytes [Byte_units] |
|
group [Core_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_by [Core_set_intf.Accessors2_with_comparator] |
|
group_by [Core_set_intf.Accessors2] |
|
group_by [Core_set_intf.Accessors1] |
|
group_by [Core_set_intf.Accessors0] |
|
group_by [Core_set_intf.Accessors_generic] |
|
group_by [Core_set] |
if equiv is an equivalence predicate, then group_by set ~equiv produces a list
of equivalence classes (i.e., a set-theoretic quotient).
|
groupi [Core_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.
|
grow [Pool_intf.S] |
grow t ~capacity returns a new pool t' with the supplied capacity.
|
H |
handle_uncaught [Exn] |
handle_uncaught ~exit f catches an exception escaping f and prints an error
message to stderr.
|
handle_uncaught_and_exit [Exn] |
handle_uncaught_and_exit f returns f () , unless that raises, in which case it
prints the exception and exits nonzero.
|
hash [Type_equal.Id] |
accessors
|
hash [Hashable.S_binable] |
|
hash [Hashable.S] |
|
hash [Core_string] |
slightly faster hash function on strings
|
hash [Core_hashtbl_intf.Hashtbl] |
|
hash [Core_hashtbl_intf.Key] |
Values returned by hash must be non-negative.
|
hash [Core_hashtbl_intf.Hashable] |
|
hash_param [Core_hashtbl_intf.Hashtbl] |
|
hash_param [Core_hashtbl_intf.Hashable] |
|
hashable [Hashable.S_binable] |
|
hashable [Hashable.S] |
|
hashable [Hashable.Make_binable] |
|
hashable [Hashable.Make] |
|
hashable [Core_hashtbl_intf.Hashtbl.Poly] |
|
hashable [Core_hashtbl_intf.S] |
|
hd [Sequence] |
|
hd [Core_list] |
|
hd_exn [Sequence] |
|
hd_exn [Core_list] |
Return the first element of the given list.
|
heap_chunks [Core_gc.Stat.Fields] |
|
heap_chunks [Core_gc.Stat] |
|
heap_chunks [Core_gc] |
|
heap_words [Core_gc.Stat.Fields] |
|
heap_words [Core_gc.Stat] |
|
heap_words [Core_gc] |
|
here [Validated_intf.Raw] |
here will appear in validation-failure error messages.
|
host [Host_and_port] |
|
hour [Time_ns.Span] |
|
I |
id [Fn] |
The identity function
|
id_of_pointer [Pool_intf.S] |
id_of_pointer t pointer returns an id that is unique for the lifetime of
pointer 's tuple.
|
ident [Common] |
|
ieee_exponent [Float_intf.S] |
|
ieee_mantissa [Float_intf.S] |
|
ieee_negative [Float_intf.S] |
|
if_ [Blang] |
if_ if then else
|
ifprintf [Core_printf] |
|
ignore [Result] |
|
ignore [Or_error] |
|
ignore [Force_once] |
ignore () = create (fun () -> ())
|
ignore [Fn] |
ignore is the same as Pervasives.ignore .
|
ignore_m [Monad_intf.S2] |
|
ignore_m [Monad_intf.S] |
ignore_m t is map t ~f:(fun _ -> ()) .
|
immutable_of_sexp [Perms.Export] |
|
in_channel_length [Common] |
|
incr [Int_intf.S] |
|
incr [Core_hashtbl_intf.Accessors] |
|
increase_min_allowed_key [Timing_wheel_intf.Timing_wheel.Priority_queue] |
increase_min_allowed_key t ~key ~handle_removed increases the minimum allowed
key in t to key , and removes all elements with keys less than key , applying
handle_removed to each element that is removed.
|
index [Core_string.Escaping] |
index s ~escape_char char find the first literal (not escaped) instance of
char in s starting from 0.
|
index [Core_string.Search_pattern] |
pos < 0 or pos >= length string result in no match (hence index returns
None and index_exn raises).
|
index [Core_string] |
|
index_all [Core_string.Search_pattern] |
may_overlap determines whether after a successful match, index_all should start
looking for another one at the very next position (~may_overlap:true ), or jump to
the end of that match and continue from there (~may_overlap:false ), e.g.:
|
index_exn [Core_string.Escaping] |
|
index_exn [Core_string.Search_pattern] |
|
index_exn [Core_string] |
|
index_from [Core_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 [Core_string] |
|
index_from_exn [Core_string.Escaping] |
|
index_from_exn [Core_string] |
|
infinity [Float_intf.S] |
|
infinity [Common] |
|
init [Sequence] |
init n ~f is [(f 0); (f 1); ...; (f (n-1))] .
|
init [Pid] |
|
init [Core_string] |
|
init [Core_list] |
init n ~f is [(f 0); (f 1); ...; (f (n-1))] .
|
init [Core_array.Permissioned] |
|
init [Core_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 [Core_random] |
Initialize the generator, using the argument as a seed.
|
input [In_channel] |
|
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_delimiter_every ~chars_per_delimiter:3
|
insert_delimiter_every [Int_conversions] |
utility for defining to_string_hum on numeric types -- takes a string matching
(-|+)?0-9a-fA-F + and puts delimiter every chars_per_delimiter characters
starting from the right.
|
insert_first [Doubly_linked] |
|
insert_last [Doubly_linked] |
|
insert_underscores [Int_conversions] |
insert_delimiter ~delimiter:'_'
|
inspect [Raw_quickcheck_generator] |
inspect t produces a concrete representation of the outermost constructor of t .
|
int [Type_immediacy.Always] |
|
int [Quickcheck_observer] |
|
int [Quickcheck_generator] |
|
int [Core_random.State] |
|
int [Core_random] |
Random.int bound returns a random integer between 0 (inclusive) and bound
(exclusive).
|
int32 [Type_immediacy.Never] |
|
int32 [Core_random.State] |
|
int32 [Core_random] |
Random.int32 bound returns a random integer between 0 (inclusive) and bound
(exclusive).
|
int32_positive_overflow_bounds [Pow_overflow_bounds] |
|
int32_to_int [Int_conversions] |
|
int32_to_int64 [Int_conversions] |
|
int32_to_int_exn [Int_conversions] |
|
int32_to_nativeint [Int_conversions] |
|
int63_round_nearest_exn [Float_intf.S] |
|
int64 [Type_immediacy.Never] |
|
int64 [Core_random.State] |
|
int64 [Core_random] |
Random.int64 bound returns a random integer between 0 (inclusive) and bound
(exclusive).
|
int64_negative_overflow_bounds [Pow_overflow_bounds] |
|
int64_positive_overflow_bounds [Pow_overflow_bounds] |
|
int64_pow [Int_math] |
|
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_as_value [Type_immediacy.Sometimes] |
|
int_as_value [Type_immediacy.Always] |
|
int_as_value [Type_immediacy] |
|
int_as_value_exn [Type_immediacy.Sometimes] |
|
int_as_value_exn [Type_immediacy.Always] |
|
int_as_value_exn [Type_immediacy] |
|
int_between [Quickcheck_observer] |
int_between ~lower_bound ~upper_bound observes integers within the given bounds.
|
int_between [Quickcheck_generator] |
int_between ~lower_bound ~upper_bound produces integers within the given bounds.
|
int_is_value [Type_immediacy.Sometimes] |
|
int_is_value [Type_immediacy.Always] |
|
int_is_value [Type_immediacy] |
|
int_middle_bits [Quickcheck_unit_tests.Test] |
|
int_of_float [Common] |
|
int_positive_overflow_bounds [Pow_overflow_bounds] |
|
int_pow [Int_math] |
|
int_to_int32 [Int_conversions] |
Ocaml has the following integer types, with the following bit widths
on 32-bit and 64-bit architectures.
|
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.Accessors2_with_comparator] |
|
inter [Core_set_intf.Accessors2] |
|
inter [Core_set_intf.Accessors1] |
|
inter [Core_set_intf.Accessors0] |
|
inter [Core_set_intf.Accessors_generic] |
|
inter [Core_set] |
inter t1 t2 computes the intersection of sets t1 and t2 .
|
interleave [Sequence] |
interleave tt produces each element of the inner sequences of tt eventually, even
if any or all of the inner sequences are infinite.
|
interleaved_cartesian_product [Sequence] |
Returns a sequence that eventually reaches every possible pair of elements of the
inputs, even if either or both are infinite.
|
intersect [Flags_intf.S] |
bitwise and
|
intersperse [Sequence] |
intersperse xs ~sep produces sep between adjacent elements of xs .
|
intersperse [Core_list] |
intersperse xs ~sep places sep between adjacent elements of xs .
|
interval_num [Timing_wheel_intf.Timing_wheel.Alarm] |
|
interval_num [Timing_wheel_intf.Timing_wheel] |
interval_num t time returns the number of the interval that time is in, where
0 is the interval that starts at start .
|
interval_num_start [Timing_wheel_intf.Timing_wheel] |
interval_num_start t n is the start of the n 'th interval in t , i.e.:
|
interval_start [Timing_wheel_intf.Timing_wheel] |
|
invalid_argf [Core_printf] |
raises Invalid_arg
|
invalid_argf [Common] |
|
invariant [Univ_map_intf.S1] |
|
invariant [Timing_wheel_intf.Timing_wheel.Priority_queue.Elt] |
|
invariant [Unpack_buffer] |
|
invariant [Stack_unit_tests.Test] |
|
invariant [Stack_unit_tests.Debug] |
|
invariant [Invariant_intf.Invariant] |
invariant here t sexp_of_t f runs f () , and if f raises, wraps the exception
in an Error.t that states "invariant failed" and includes both the exception
raised by f , as well as sexp_of_t t .
|
invariant [Invariant_intf.S3] |
|
invariant [Invariant_intf.S2] |
|
invariant [Invariant_intf.S1] |
|
invariant [Invariant_intf.S] |
|
invariant [Hash_queue.S] |
invariant t checks the invariants of the queue.
|
invariant [Hash_queue.Make] |
|
invariant [Flat_array_debug.Debug] |
|
invariant [Doubly_linked] |
|
invariant [Core_hashtbl_intf.Accessors] |
|
invariant [Blang] |
|
invariant [Bag] |
|
invariant [Avltree] |
check invariants, raise an exception if any invariants fail
|
invariants [Core_set_intf.Accessors2_with_comparator] |
|
invariants [Core_set_intf.Accessors2] |
|
invariants [Core_set_intf.Accessors1] |
|
invariants [Core_set_intf.Accessors0] |
|
invariants [Core_set_intf.Accessors_generic] |
|
invariants [Core_set] |
Tests internal invariants of the set data structure.
|
invariants [Core_map_intf.Accessors3_with_comparator] |
|
invariants [Core_map_intf.Accessors3] |
|
invariants [Core_map_intf.Accessors2] |
|
invariants [Core_map_intf.Accessors1] |
|
invariants [Core_map_intf.Accessors_generic] |
|
invariants [Core_map] |
Test if invariants of internal AVL search tree hold.
|
inverse [Core_list.Assoc] |
|
iround [Float_intf.S] |
|
iround_down [Float_intf.S] |
|
iround_down_exn [Float_intf.S] |
|
iround_exn [Float_intf.S] |
|
iround_lbound [Float_intf.S] |
If f <= iround_lbound || f >= iround_ubound , then iround* functions will refuse
to round f , returning None or raising as appropriate.
|
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_ubound [Float_intf.S] |
|
iround_up [Float_intf.S] |
|
iround_up_exn [Float_intf.S] |
|
is_alpha [Core_char] |
'a' - 'z' or 'A' - 'Z'
|
is_alphanum [Core_char] |
'a' - 'z' or 'A' - 'Z' or '0' - '9'
|
is_char_escaped [Core_string.Escaping] |
is_char_escaped s ~escape_char pos return true if the char at pos is escaped,
false otherwise.
|
is_char_escaping [Core_string.Escaping] |
Any char in an escaped string is either escaping, escaped or literal.
|
is_char_literal [Core_string.Escaping] |
is_literal s ~escape_char pos return true if the char at pos is not escaped or
escaping.
|
is_digit [Core_char] |
'0' - '9'
|
is_empty [Univ_map_intf.S1] |
|
is_empty [Univ_map_intf.S] |
|
is_empty [Timing_wheel_intf.Timing_wheel.Priority_queue] |
is_empty t is length t = 0
|
is_empty [Timing_wheel_intf.Timing_wheel] |
One can think of a timing wheel as a set of alarms.
|
is_empty [Unpack_buffer] |
is_empty t returns true if t has no unconsumed bytes, and false if it does.
|
is_empty [Stack_unit_tests.Test] |
|
is_empty [Stack_unit_tests.Debug] |
|
is_empty [Hash_queue.Make] |
|
is_empty [Fqueue] |
|
is_empty [Flat_queue] |
|
is_empty [Flags_intf.S] |
|
is_empty [Core_string] |
is_empty s returns true iff s is empty (i.e.
|
is_empty [Core_set] |
is_empty t is true iff t is empty.
|
is_empty [Core_map_intf.Accessors3_with_comparator] |
|
is_empty [Core_map_intf.Accessors3] |
|
is_empty [Core_map_intf.Accessors2] |
|
is_empty [Core_map_intf.Accessors1] |
|
is_empty [Core_map_intf.Accessors_generic] |
|
is_empty [Core_map] |
Test whether a map is empty or not.
|
is_empty [Core_hashtbl_intf.Accessors] |
|
is_empty [Core_array.Permissioned] |
|
is_empty [Container_unit_tests.Test_generic] |
|
is_empty [Container_intf.Container] |
Generic definitions of container operations in terms of iter .
|
is_empty [Container_intf.Generic_phantom] |
|
is_empty [Container_intf.Generic] |
|
is_empty [Container_intf.S1_permissions] |
|
is_empty [Container_intf.S1_phantom_invariant] |
|
is_empty [Container_intf.S1] |
|
is_empty [Container_intf.S0_phantom] |
|
is_empty [Container_intf.S0] |
|
is_error [Stack_unit_tests] |
|
is_error [Result.Export] |
|
is_error [Result] |
|
is_finite [Float_intf.S] |
is_finite t returns true iff classify t is in Normal; Subnormal; Zero; .
|
is_first [Either_intf.S] |
|
is_first [Doubly_linked] |
|
is_full [Pool_intf.S] |
is_full t returns true if no more tuples can be allocated in t .
|
is_inf [Percent] |
|
is_inf [Float_intf.S] |
includes positive and negative Float.infinity
|
is_init [Flat_array_debug.Debug] |
|
is_init [Flat_array] |
is_init t i returns true iff flat tuple i 's slots are identical to those of
the init supplied to create .
|
is_last [Doubly_linked] |
|
is_lowercase [Core_char] |
'a' - 'z'
|
is_mmapped [Bigstring] |
is_mmapped bstr
|
is_nan [Percent] |
|
is_nan [Float_intf.S] |
|
is_negative [Comparable_intf.With_zero] |
|
is_non_negative [Comparable_intf.With_zero] |
|
is_non_positive [Comparable_intf.With_zero] |
|
is_none [Option] |
is_none t returns true iff t = None.
|
is_none [Core_weak] |
|
is_none [Common] |
|
is_null [Pool_intf.S.Pointer] |
|
is_ok [Stack_unit_tests] |
|
is_ok [Result.Export] |
|
is_ok [Result] |
|
is_positive [Comparable_intf.With_zero] |
|
is_pow2 [Int_pow2] |
|
is_pow2 [Core_int] |
is_pow2 x returns true iff x is a power of 2.
|
is_prefix [Core_string] |
is_prefix s ~prefix returns true if s starts with prefix .
|
is_prefix [Core_list] |
is_prefix xs ~prefix returns true if xs starts with prefix .
|
is_print [Core_char] |
' ' - '~'
|
is_second [Either_intf.S] |
|
is_some [Option] |
is_some t returns true iff t = Some x.
|
is_some [Core_weak] |
|
is_some [Common] |
|
is_sorted [Core_list] |
is_sorted t ~compare returns true iff forall adjacent a1; a2 in t , compare a1
a2 <= 0 .
|
is_sorted [Core_array.Permissioned] |
|
is_sorted [Core_array] |
|
is_sorted_strictly [Core_list] |
|
is_sorted_strictly [Core_array.Permissioned] |
|
is_sorted_strictly [Core_array] |
is_sorted_strictly xs ~cmp iff is_sorted xs ~cmp and no two consecutive elements
in xs are equal according to cmp
|
is_substring [Core_string] |
is_substring ~substring:"bar" "foo bar baz" is true
|
is_suffix [Core_string] |
is_suffix s ~suffix returns true if s ends with suffix .
|
is_sun_or_sat [Day_of_week] |
|
is_uppercase [Core_char] |
'A' - 'Z'
|
is_val [Core_lazy] |
is_val x returns true if x has already been forced and
did not raise an exception.
|
is_whitespace [Core_char] |
' ' or '\t' or '\r' or '\n'
|
is_zero [Percent] |
|
iso_8601_weekday_number [Day_of_week] |
As per ISO 8601, Mon->1, Tue->2, ...
|
iter [Timing_wheel_intf.Timing_wheel.Priority_queue] |
|
iter [Timing_wheel_intf.Timing_wheel] |
|
iter [Total_map] |
|
iter [Stack_unit_tests.Debug] |
|
iter [Result] |
|
iter [Quickcheck_intf.Quickcheck] |
iter ~seed ~trials ~attempts gen ~f runs f on up to trials different values
generated by gen .
|
iter [Hash_queue.Make] |
|
iter [Hash_heap.S] |
|
iter [Hash_heap.Make] |
|
iter [Flat_queue] |
|
iter [Either_intf.S] |
|
iter [Core_set] |
iter t ~f calls f on every element of t , going in order from the smallest to
largest.
|
iter [Core_map_intf.Accessors3_with_comparator] |
|
iter [Core_map_intf.Accessors3] |
|
iter [Core_map_intf.Accessors2] |
|
iter [Core_map_intf.Accessors1] |
|
iter [Core_map_intf.Accessors_generic] |
|
iter [Core_map] |
iterator for map
|
iter [Core_hashtbl_intf.Accessors] |
|
iter [Core_gc.Control.Fields.Direct] |
|
iter [Core_gc.Control.Fields] |
|
iter [Core_gc.Stat.Fields.Direct] |
|
iter [Core_gc.Stat.Fields] |
|
iter [Container_unit_tests.Test_generic] |
|
iter [Container_intf.Container] |
|
iter [Container_intf.Make_arg] |
The iter argument to Container.Make says how to implement the container's iter
function.
|
iter [Container_intf.Generic_phantom] |
|
iter [Container_intf.Generic] |
|
iter [Container_intf.S1_permissions] |
|
iter [Container_intf.S1_phantom_invariant] |
|
iter [Container_intf.S1] |
|
iter [Container_intf.S0_phantom] |
|
iter [Container_intf.S0] |
iter must allow exceptions raised in f to escape, terminating the iteration
cleanly.
|
iter [Bounded_int_table] |
|
iter [Avltree] |
iterate over the tree
|
iter' [Deque] |
iter' t ~f iter over the elements of t .
|
iter2 [Total_map] |
|
iter2 [Core_set_intf.Accessors2_with_comparator] |
|
iter2 [Core_set_intf.Accessors2] |
|
iter2 [Core_set_intf.Accessors1] |
|
iter2 [Core_set_intf.Accessors0] |
|
iter2 [Core_set_intf.Accessors_generic] |
|
iter2 [Core_set] |
Iterate two sets side by side.
|
iter2 [Core_map_intf.Accessors3_with_comparator] |
|
iter2 [Core_map_intf.Accessors3] |
|
iter2 [Core_map_intf.Accessors2] |
|
iter2 [Core_map_intf.Accessors1] |
|
iter2 [Core_map_intf.Accessors_generic] |
|
iter2 [Core_map] |
Iterate two maps side by side.
|
iter2_exn [Core_list] |
List.iter2_exn [a1; ...; an] [b1; ...; bn] ~f calls in turn
f a1 b1; ...; f an bn .
|
iter2_exn [Core_array.Permissioned] |
|
iter2_exn [Core_array] |
Functions with 2 suffix raise an exception if the lengths aren't the same.
|
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_vals [Hash_heap.S] |
Returns the list of all (key, value) pairs for given Hash_heap .
|
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 [Sequence] |
iteri is just like iter , but it also passes in the index of each element to
f .
|
iteri [Hash_queue.S] |
iter t ~f applies f to each key and element of the queue.
|
iteri [Hash_queue.Make] |
|
iteri [Deque] |
iteri t ~f iter over the elements of t `front_to_back passing in the index.
|
iteri [Core_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 [Core_array.Permissioned] |
|
iteri [Core_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.
|
iteri' [Deque] |
iteri' t ~f as iter , but also passes in the index of the current element.
|
J |
join [Monad_intf.S2] |
|
join [Monad_intf.S] |
join t is t >>= (fun t' -> t') .
|
K |
kbprintf [Core_printf] |
|
keep_alive [Core_gc] |
|
key [Timing_wheel_intf.Timing_wheel.Priority_queue.Elt] |
|
keys [Hash_queue.S] |
keys t returns the keys in the order of the queue.
|
keys [Hash_queue.Make] |
|
keys [Core_map_intf.Accessors3_with_comparator] |
|
keys [Core_map_intf.Accessors3] |
|
keys [Core_map_intf.Accessors2] |
|
keys [Core_map_intf.Accessors1] |
|
keys [Core_map_intf.Accessors_generic] |
|
keys [Core_map] |
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 [Core_printf] |
|
kilobytes [Byte_units] |
|
known [Flags_intf.Make_arg] |
An entry flag, name in known means that the bit(s) in flag is (are) called
name ; i.e.
|
ksprintf [Std_internal] |
|
ksprintf [Core_printf] |
|
L |
largest_free [Core_gc.Stat.Fields] |
|
largest_free [Core_gc.Stat] |
|
last [Doubly_linked] |
|
last [Core_list] |
The final element of a list.
|
last [Core_array.Permissioned] |
|
last [Core_array] |
|
last [Avltree] |
|
last_elt [Doubly_linked] |
|
last_exn [Core_list] |
|
ldexp [Float_intf.S] |
ldexp x n returns x *. 2 ** n
|
ldexp [Common] |
|
length [Timing_wheel_intf.Timing_wheel.Priority_queue] |
length t returns the number of elements in the timing wheel.
|
length [Timing_wheel_intf.Timing_wheel] |
|
length [Thread_safe_queue] |
|
length [Stack_unit_tests.Debug] |
|
length [Pool_intf.S] |
length returns the number of tuples currently in the pool.
|
length [Out_channel] |
|
length [Obj_array] |
|
length [Substring_intf.S] |
|
length [Make_substring.Base] |
|
length [Make_substring.F] |
|
length [In_channel] |
|
length [Hash_queue.Make] |
|
length [Hash_heap.S] |
|
length [Hash_heap.Make] |
|
length [Fqueue] |
complexity: O(1)
|
length [Flat_queue] |
|
length [Flat_array_debug.Debug] |
|
length [Flat_array] |
accessors
|
length [Core_weak] |
|
length [Core_string] |
|
length [Core_set] |
Returns the number of elements in the set.
|
length [Core_map_intf.Accessors3_with_comparator] |
|
length [Core_map_intf.Accessors3] |
|
length [Core_map_intf.Accessors2] |
|
length [Core_map_intf.Accessors1] |
|
length [Core_map_intf.Accessors_generic] |
|
length [Core_map] |
length map
|
length [Core_hashtbl_intf.Accessors] |
|
length [Core_bytes] |
|
length [Core_array.Permissioned] |
|
length [Container_unit_tests.Test_generic] |
|
length [Container_intf.Container] |
|
length [Container_intf.Generic_phantom] |
|
length [Container_intf.Generic] |
|
length [Container_intf.S1_permissions] |
|
length [Container_intf.S1_phantom_invariant] |
|
length [Container_intf.S1] |
|
length [Container_intf.S0_phantom] |
|
length [Container_intf.S0] |
|
length [Bounded_int_table] |
|
length [Blit_intf.Sequence] |
|
length [Binary_searchable_intf.Indexable1] |
|
length [Binary_searchable_intf.Indexable] |
|
length [Bigstring] |
length bstr
|
length [Bigbuffer] |
Return the number of characters currently contained in the buffer.
|
length_is_bounded_by [Sequence] |
length_is_bounded_by ~min ~max t returns true if min <= length t and length t <=
max When min or max are not provided, the check for that bound is omitted.
|
level [Bucket.S] |
|
level [Bucket.Make] |
|
level_bits [Timing_wheel_intf.Timing_wheel.Config] |
|
lexicographic [Comparable] |
lexicographic cmps x y compares x and y lexicographically using functions in the
list cmps .
|
lfindi [Core_string] |
lfindi ?pos t ~f returns the smallest i >= pos such that f i t.[i] , if there is
such an i .
|
lift [Type_equal.Lift3] |
|
lift [Type_equal.Lift2] |
|
lift [Type_equal.Lift] |
|
list [Validate] |
Validates a list, naming each element using a user-defined function for computing the
name
|
list [Type_immediacy.Sometimes] |
|
list [Quickcheck_observer] |
|
list [Quickcheck_generator] |
Generator for lists of a given type.
|
list_indexed [Validate] |
Validates a list, naming each element by its position in the list (where the first
position is 1, not 0)
|
live_blocks [Core_gc.Stat.Fields] |
|
live_blocks [Core_gc.Stat] |
|
live_words [Core_gc.Stat.Fields] |
|
live_words [Core_gc.Stat] |
|
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 [Core_string] |
|
lowercase [Core_char] |
Convert the given character to its equivalent lowercase character.
|
lsplit2 [Core_string.Escaping] |
lsplit2 s on escape_char splits s into a pair on the first literal instance of
on (meaning the first unescaped instance) starting from the left.
|
lsplit2 [Core_string] |
lsplit2 line ~on optionally returns line split into two strings around the
first appearance of on from the left
|
lsplit2_exn [Core_string.Escaping] |
|
lsplit2_exn [Core_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).
|
lstrip [Core_string] |
lstrip ?drop s returns a string with consecutive chars satisfying drop (by default
white space, e.g.
|
M |
major [Core_gc] |
Do a minor collection and finish the current major collection cycle.
|
major_collections [Core_gc.Stat.Fields] |
|
major_collections [Core_gc.Stat] |
|
major_collections [Core_gc] |
|
major_heap_increment [Core_gc.Control.Fields] |
|
major_heap_increment [Core_gc.Control] |
|
major_plus_minor_words [Core_gc] |
This function returns major_words () + minor_words () .
|
major_slice [Core_gc] |
Do a minor collection and a slice of major collection.
|
major_words [Core_gc.Stat.Fields] |
|
major_words [Core_gc.Stat] |
|
major_words [Core_gc] |
|
make [Core_string] |
|
make [Core_random.State] |
Create a new state and initialize it with the given seed.
|
make_creator [Core_gc.Control.Fields] |
|
make_creator [Core_gc.Stat.Fields] |
|
make_matrix [Core_array.Permissioned] |
|
make_matrix [Core_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 [Core_random.State] |
Create a new state and initialize it with a system-dependent low-entropy seed.
|
map [Unpack_buffer.Unpack_one] |
|
map [Total_map] |
|
map [Result] |
|
map [Monad_intf.S2] |
|
map [Monad_intf.Basic2] |
|
map [Monad_intf.S] |
map t ~f is t >>| f.
|
map [Monad_intf.Basic] |
The map argument to Monad.Make says how to implement the monad's map function.
|
map [Linked_queue] |
|
map [Stable_module_types.S2] |
|
map [Either_intf.S] |
|
map [Core_string] |
map f s applies f to each character in s , and returns the
resulting string.
|
map [Core_set_intf.Creators2_with_comparator] |
|
map [Core_set_intf.Creators2] |
|
map [Core_set_intf.Creators1] |
|
map [Core_set_intf.Creators0] |
|
map [Core_set_intf.Creators_generic] |
The types of map and filter_map are subtle.
|
map [Core_set] |
map ~comparator t ~f returns a new set created by applying f to every element in
t .
|
map [Core_queue] |
|
map [Core_map_intf.Accessors3_with_comparator] |
|
map [Core_map_intf.Accessors3] |
|
map [Core_map_intf.Accessors2] |
|
map [Core_map_intf.Accessors1] |
|
map [Core_map_intf.Accessors_generic] |
|
map [Core_map] |
returns new map with bound values replaced by f applied to the bound values
|
map [Core_list.Assoc] |
Bijectivity is not guaranteed because we allow a key to appear more than once.
|
map [Core_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 [Stable_module_types.S1] |
|
map [Core_hashtbl_intf.Accessors] |
map t f returns new table with bound values replaced by
f applied to the bound values
|
map [Core_gc.Control.Fields] |
|
map [Core_gc.Stat.Fields] |
|
map [Core_array.Permissioned] |
|
map [Core_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 [Bounded_int_table] |
|
map [Applicative_intf.S2] |
|
map [Applicative_intf.Basic2] |
|
map [Applicative_intf.S] |
|
map [Applicative_intf.Basic] |
The map argument to Applicative.Make says how to implement the applicative's
map function.
|
map1 [Tuple.T3] |
|
map1 [Tuple.T2] |
|
map2 [Tuple.T3] |
|
map2 [Tuple.T2] |
|
map2 [Total_map] |
|
map2 [Option] |
map2 o f map 'a option and 'b option to a 'c option using ~f
|
map2 [Applicative_intf.S2] |
|
map2 [Applicative_intf.S] |
|
map2_exn [Core_list] |
List.map2_exn [a1; ...; an] [b1; ...; bn] ~f is [f a1 b1; ...; f an bn] .
|
map2_exn [Core_array.Permissioned] |
|
map2_exn [Core_array] |
|
map3 [Tuple.T3] |
|
map3 [Applicative_intf.S2] |
|
map3 [Applicative_intf.S] |
|
map3_exn [Core_list] |
|
mapN [Applicative_intf.Args2] |
|
mapN [Applicative_intf.Args] |
|
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 [Core_gc.Control.Fields] |
|
map_poly [Core_gc.Stat.Fields] |
|
mapi [Total_map] |
|
mapi [Sequence] |
|
mapi [Core_string] |
mapi f s applies f to each character in s and its index, and returns the
resulting string.
|
mapi [Core_map_intf.Accessors3_with_comparator] |
|
mapi [Core_map_intf.Accessors3] |
|
mapi [Core_map_intf.Accessors2] |
|
mapi [Core_map_intf.Accessors1] |
|
mapi [Core_map_intf.Accessors_generic] |
|
mapi [Core_map] |
like map , but function takes both key and data as arguments
|
mapi [Core_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 [Core_array.Permissioned] |
|
mapi [Core_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] |
marshals value _ to a new bigstring.
|
marshal_blit [Bigstring_marshal] |
marshals value _ to the bigstring at most len bytes.
|
marshal_data_size [Bigstring_marshal] |
the length of marshalled data in the bigstring
|
match_ [Univ] |
match_ t id returns Some v if t was created by create id v , and returns None
otherwise.
|
match_exn [Univ] |
|
max [Timing_wheel_intf.Interval_num.Span] |
|
max [Timing_wheel_intf.Interval_num] |
|
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_allowed_key [Timing_wheel_intf.Timing_wheel.Priority_queue] |
max_allowed_key t is the maximum allowed key that can be stored in t .
|
max_capacity [Pool_intf.S] |
max_capacity returns the maximum capacity allowed when creating a pool.
|
max_elt [Stack_unit_tests.Test] |
|
max_elt [Stack_unit_tests.Debug] |
|
max_elt [Heap_intf.S] |
|
max_elt [Hash_queue.Make] |
|
max_elt [Fheap] |
|
max_elt [Core_set_intf.Accessors2_with_comparator] |
|
max_elt [Core_set_intf.Accessors2] |
|
max_elt [Core_set_intf.Accessors1] |
|
max_elt [Core_set_intf.Accessors0] |
|
max_elt [Core_set_intf.Accessors_generic] |
|
max_elt [Core_set] |
Returns the largest element of the set.
|
max_elt [Core_map_intf.Accessors3_with_comparator] |
|
max_elt [Core_map_intf.Accessors3] |
|
max_elt [Core_map_intf.Accessors2] |
|
max_elt [Core_map_intf.Accessors1] |
|
max_elt [Core_map_intf.Accessors_generic] |
|
max_elt [Core_map] |
max_elt map
|
max_elt [Container_unit_tests.Test_generic] |
|
max_elt [Container_intf.Container] |
|
max_elt [Container_intf.Generic_phantom] |
|
max_elt [Container_intf.Generic] |
|
max_elt [Container_intf.S1_permissions] |
|
max_elt [Container_intf.S1_phantom_invariant] |
|
max_elt [Container_intf.S1] |
|
max_elt [Container_intf.S0_phantom] |
|
max_elt [Container_intf.S0] |
|
max_elt_exn [Core_set_intf.Accessors2_with_comparator] |
|
max_elt_exn [Core_set_intf.Accessors2] |
|
max_elt_exn [Core_set_intf.Accessors1] |
|
max_elt_exn [Core_set_intf.Accessors0] |
|
max_elt_exn [Core_set_intf.Accessors_generic] |
|
max_elt_exn [Core_set] |
|
max_elt_exn [Core_map_intf.Accessors3_with_comparator] |
|
max_elt_exn [Core_map_intf.Accessors3] |
|
max_elt_exn [Core_map_intf.Accessors2] |
|
max_elt_exn [Core_map_intf.Accessors1] |
|
max_elt_exn [Core_map_intf.Accessors_generic] |
|
max_elt_exn [Core_map] |
|
max_finite_value [Float_intf.S] |
|
max_float [Common] |
|
max_inan [Float_intf.S] |
|
max_int [Common] |
|
max_length [Core_string] |
Maximum length of a string.
|
max_length [Core_array] |
Maximum length of a normal array.
|
max_num_bits [Timing_wheel_intf.Timing_wheel.Level_bits] |
max_num_bits is how many bits in a key the timing wheel can use, i.e.
|
max_overhead [Core_gc.Control.Fields] |
|
max_overhead [Core_gc.Control] |
|
max_representable [Timing_wheel_intf.Interval_num] |
To avoid issues with arithmetic overflow, the implementation restricts interval
numbers to be <= max_representable , where:
|
max_value [Timing_wheel_intf.Interval_num] |
|
max_value [Time_ns.Span] |
|
max_value [Time_ns] |
|
max_value [Int_intf.S] |
The largest representable integer
|
max_value [Float_intf.S] |
equal to infinity
|
max_value [Core_char] |
|
maybe_raise [Validate] |
If the result contains any errors, then raises an exception with a formatted error
message containing a message for every error.
|
me_of_sexp [Perms.Stable.V1] |
|
me_of_sexp [Perms] |
|
megabytes [Byte_units] |
|
mem [Univ_map_intf.S1] |
|
mem [Univ_map_intf.S] |
|
mem [Timing_wheel_intf.Timing_wheel.Priority_queue] |
|
mem [Timing_wheel_intf.Timing_wheel] |
|
mem [Stack_unit_tests.Debug] |
|
mem [Int_set] |
mem t i test whether i is a member of the set
|
mem [Hash_set_intf.Accessors] |
override Container.Generic.mem
|
mem [Hash_queue.S] |
mem q k returns true iff there is some (k, v) in the queue.
|
mem [Hash_queue.Make] |
|
mem [Hash_heap.S] |
|
mem [Hash_heap.Make] |
|
mem [Core_set_intf.Accessors2_with_comparator] |
|
mem [Core_set_intf.Accessors2] |
|
mem [Core_set_intf.Accessors1] |
|
mem [Core_set_intf.Accessors0] |
|
mem [Core_set_intf.Accessors_generic] |
override Container 's mem
|
mem [Core_set] |
mem t a returns true iff a is in t .
|
mem [Core_map_intf.Accessors3_with_comparator] |
|
mem [Core_map_intf.Accessors3] |
|
mem [Core_map_intf.Accessors2] |
|
mem [Core_map_intf.Accessors1] |
|
mem [Core_map_intf.Accessors_generic] |
|
mem [Core_map] |
mem map key tests whether map contains a binding for key
|
mem [Core_list.Assoc] |
|
mem [Core_hashtbl_intf.Accessors] |
|
mem [Container_unit_tests.Test_generic] |
|
mem [Container_intf.Generic_phantom] |
|
mem [Container_intf.Generic] |
|
mem [Container_intf.S1_permissions] |
Checks whether the provided element is there, using polymorphic compare if equal
is not provided
|
mem [Container_intf.S1_phantom_invariant] |
Checks whether the provided element is there, using polymorphic compare if equal
is not provided
|
mem [Container_intf.S1] |
Checks whether the provided element is there, using polymorphic compare if equal
is not provided
|
mem [Container_intf.S0_phantom] |
Checks whether the provided element is there using the default equality test, using
the provided equal function if it is not
|
mem [Container_intf.S0] |
Checks whether the provided element is there using the default equality test, using
the provided equal function if it is not
|
mem [Bounded_int_table] |
|
mem [Avltree] |
return true if key is present in the tree, otherwise return false.
|
memoize [Sequence] |
memoize t produces each element of t , but also memoizes them so that if you
consume the same element multiple times it is only computed once.
|
merge [Sequence] |
merge t1 t2 ~cmp produces the interleaved elements of t1 and t2 , always picking
the smallest of the two available elements from t1 and t2 , according to cmp .
|
merge [Option] |
merge a b ~f merges together the values from a and b using f .
|
merge [Core_map_intf.Accessors3_with_comparator] |
|
merge [Core_map_intf.Accessors3] |
|
merge [Core_map_intf.Accessors2] |
|
merge [Core_map_intf.Accessors1] |
|
merge [Core_map_intf.Accessors_generic] |
|
merge [Core_map] |
merges two maps
|
merge [Core_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 containing 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 [Time_ns.Span] |
|
millisecond [Time_ns.Span] |
|
min [Timing_wheel_intf.Interval_num] |
|
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_allowed_key [Timing_wheel_intf.Timing_wheel.Priority_queue] |
min_allowed_key t is the minimum key that can be stored in t .
|
min_elt [Timing_wheel_intf.Timing_wheel.Priority_queue] |
min_elt t returns an element in t that has the minimum key, if t is
nonempty.
|
min_elt [Stack_unit_tests.Test] |
|
min_elt [Stack_unit_tests.Debug] |
|
min_elt [Heap_intf.S] |
Even though these two functions are part of Container.S1, they are documented
separately to make sure there is no confusion.
|
min_elt [Hash_queue.Make] |
|
min_elt [Fheap] |
The comparison function in min_elt and max_elt are independent of that used to
order the heap.
|
min_elt [Core_set_intf.Accessors2_with_comparator] |
|
min_elt [Core_set_intf.Accessors2] |
|
min_elt [Core_set_intf.Accessors1] |
|
min_elt [Core_set_intf.Accessors0] |
|
min_elt [Core_set_intf.Accessors_generic] |
|
min_elt [Core_set] |
Returns the smallest element of the set.
|
min_elt [Core_map_intf.Accessors3_with_comparator] |
|
min_elt [Core_map_intf.Accessors3] |
|
min_elt [Core_map_intf.Accessors2] |
|
min_elt [Core_map_intf.Accessors1] |
|
min_elt [Core_map_intf.Accessors_generic] |
|
min_elt [Core_map] |
min_elt map
|
min_elt [Container_unit_tests.Test_generic] |
|
min_elt [Container_intf.Container] |
|
min_elt [Container_intf.Generic_phantom] |
|
min_elt [Container_intf.Generic] |
|
min_elt [Container_intf.S1_permissions] |
Returns a min (resp max) element from the collection using the provided cmp
function.
|
min_elt [Container_intf.S1_phantom_invariant] |
Returns a min (resp max) element from the collection using the provided cmp
function.
|
min_elt [Container_intf.S1] |
Returns a minimum (resp maximum) element from the collection using the provided
cmp function, or None if the collection is empty.
|
min_elt [Container_intf.S0_phantom] |
Returns a min (resp max) element from the collection using the provided cmp
function, or None if the collection is empty.
|
min_elt [Container_intf.S0] |
Returns a min (resp max) element from the collection using the provided cmp
function.
|
min_elt_exn [Core_set_intf.Accessors2_with_comparator] |
|
min_elt_exn [Core_set_intf.Accessors2] |
|
min_elt_exn [Core_set_intf.Accessors1] |
|
min_elt_exn [Core_set_intf.Accessors0] |
|
min_elt_exn [Core_set_intf.Accessors_generic] |
|
min_elt_exn [Core_set] |
|
min_elt_exn [Core_map_intf.Accessors3_with_comparator] |
|
min_elt_exn [Core_map_intf.Accessors3] |
|
min_elt_exn [Core_map_intf.Accessors2] |
|
min_elt_exn [Core_map_intf.Accessors1] |
|
min_elt_exn [Core_map_intf.Accessors_generic] |
|
min_elt_exn [Core_map] |
|
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_key [Timing_wheel_intf.Timing_wheel.Priority_queue] |
|
min_positive_normal_value [Float_intf.S] |
|
min_positive_subnormal_value [Float_intf.S] |
min_positive_subnormal_value = 2 ** -1074
min_positive_normal_value = 2 ** -1022
|
min_value [Timing_wheel_intf.Interval_num] |
|
min_value [Time_ns.Span] |
The limits of t are chosen to allow conversion to and from float spans with
microsecond precision.
|
min_value [Time_ns] |
|
min_value [Int_intf.S] |
|
min_value [Float_intf.S] |
equal to neg_infinity
|
min_value [Core_char] |
|
minor [Core_gc] |
Trigger a minor collection.
|
minor_collections [Core_gc.Stat.Fields] |
|
minor_collections [Core_gc.Stat] |
|
minor_collections [Core_gc] |
|
minor_heap_size [Core_gc.Control.Fields] |
|
minor_heap_size [Core_gc.Control] |
|
minor_words [Core_gc.Stat.Fields] |
|
minor_words [Core_gc.Stat] |
|
minor_words [Core_gc] |
The following functions return the same as (Gc.quick_stat ()).Stat.f , avoiding any
allocation (of the stat record or a float).
|
minus_one [Int_intf.S] |
|
minus_one [Float_intf.S] |
|
minute [Time_ns.Span] |
|
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] |
|
most_recent [Backtrace.Exn] |
most_recent () returns a string containing the stack that was unwound by the
most recently raised exception.
|
move_after [Doubly_linked] |
|
move_before [Doubly_linked] |
|
move_to_back [Doubly_linked] |
|
move_to_front [Doubly_linked] |
constant-time move of an element from and to positions in the same list.
|
N |
name [Validate] |
extend location path by one name
|
name [Type_equal.Id] |
|
name_list [Validate] |
|
names [Core_gc.Control.Fields] |
|
names [Core_gc.Stat.Fields] |
|
nan [Float_intf.S] |
|
nan [Common] |
|
nanosecond [Time_ns.Span] |
|
nativeint [Type_immediacy.Never] |
|
nativeint [Core_random.State] |
|
nativeint [Core_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 [Time_ns.Span] |
|
neg [Percent] |
|
neg [Int_math.T] |
|
neg [Int_intf.S.O] |
|
neg [Int_intf.S] |
Negation
|
neg [Float_intf.S.O] |
|
neg [Float_intf.S] |
|
neg_infinity [Float_intf.S] |
|
neg_infinity [Common] |
|
never_returns [Never_returns] |
|
never_returns [Common] |
|
new1 [Pool_intf.S] |
new<N> t a0 ... a<N-1> returns a new tuple from the pool, with the tuple's
slots initialized to a0 ...
|
new10 [Pool_intf.S] |
|
new11 [Pool_intf.S] |
|
new12 [Pool_intf.S] |
|
new2 [Pool_intf.S] |
|
new3 [Pool_intf.S] |
|
new4 [Pool_intf.S] |
|
new5 [Pool_intf.S] |
|
new6 [Pool_intf.S] |
|
new7 [Pool_intf.S] |
|
new8 [Pool_intf.S] |
|
new9 [Pool_intf.S] |
|
newline [Out_channel] |
|
next [Sequence] |
next returns the next element of a sequence and the next tail if the sequence is not
finished.
|
next [Doubly_linked] |
constant-time retrieval of next or previous element.
|
next_alarm_fires_at [Timing_wheel_intf.Timing_wheel] |
next_alarm_fires_at t returns the minimum time to which the clock can be advanced
such that an alarm will fire, or None if t has no alarms.
|
next_multiple [Time_ns] |
next_multiple ~base ~after ~interval returns the smallest time of the form:
|
nget [Core_string] |
nget s i Gets the char at normalized position i in s .
|
nget [Core_array.Permissioned] |
|
nget [Core_array] |
Array access with normalize d index.
|
nil [Applicative_intf.Args2] |
|
nil [Applicative_intf.Args] |
the empty argument list *
|
no_raise_of_sexp [Core_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.
|
nobody_of_sexp [Perms.Stable.V1] |
|
nobody_of_sexp [Perms] |
|
non [Fn] |
Negates a function
|
normalize [Ordered_collection_common] |
|
normalize [Core_array.Permissioned] |
|
normalize [Core_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 [Timing_wheel_intf.Timing_wheel] |
|
now [Time_ns] |
|
now_interval_num [Timing_wheel_intf.Timing_wheel] |
|
nset [Core_string] |
nset s i c Sets the char at normalized position i to c .
|
nset [Core_array.Permissioned] |
|
nset [Core_array] |
Array modification with normalize d index.
|
nth [Sequence] |
return the nth element
|
nth [Core_map_intf.Accessors3_with_comparator] |
|
nth [Core_map_intf.Accessors3] |
|
nth [Core_map_intf.Accessors2] |
|
nth [Core_map_intf.Accessors1] |
|
nth [Core_map_intf.Accessors_generic] |
|
nth [Core_map] |
nth t n finds the (key, value) pair of rank n (i.e.
|
nth [Core_list] |
|
nth [Bigbuffer] |
get the (zero-based) n-th character of the buffer.
|
nth_exn [Sequence] |
|
nth_exn [Core_list] |
Return the n -th element of the given list.
|
null [Timing_wheel_intf.Timing_wheel.Alarm] |
null () returns an alarm t such that not (mem timing_wheel t) for all
timing_wheel s.
|
null [Pool_intf.S.Pointer] |
The null pointer is a distinct pointer that does not correspond to a tuple in
the pool.
|
num_bits [Timing_wheel_intf.Timing_wheel.Level_bits] |
num_bits t is the sum of the b_i in t .
|
num_bits [Word_size] |
|
num_bits [Int_intf.S] |
The number of bits available in this integer type.
|
num_bits_int [Int_conversions] |
|
num_bits_int32 [Int_conversions] |
|
num_bits_int64 [Int_conversions] |
|
num_bits_nativeint [Int_conversions] |
|
num_days [Day_of_week] |
num_days ~from ~to_ gives the number of days that must elapse from a from to get
to a to_ , i.e.
|
O |
observe [Raw_quickcheck_observer] |
observe t gen ~sexp_of_rng ~branching_factor constructs a generator for a function
type using t to observe the domain and gen to generate the range.
|
of_alist [Core_map_intf.Creators3_with_comparator] |
|
of_alist [Core_map_intf.Creators2] |
|
of_alist [Core_map_intf.Creators1] |
|
of_alist [Core_map_intf.Creators_generic] |
|
of_alist [Core_map] |
creates map from association list with unique keys
|
of_alist [Core_hashtbl_intf.Creators] |
|
of_alist [Bounded_int_table.With_key] |
of_alist returns a table whose maximum allowed key is the maximum key in the input
list.
|
of_alist_exn [Core_map_intf.Creators3_with_comparator] |
|
of_alist_exn [Core_map_intf.Creators2] |
|
of_alist_exn [Core_map_intf.Creators1] |
|
of_alist_exn [Core_map_intf.Creators_generic] |
|
of_alist_exn [Core_map] |
creates map from association list with unique keys.
|
of_alist_exn [Core_hashtbl_intf.Creators] |
|
of_alist_exn [Bounded_int_table.With_key] |
|
of_alist_fold [Core_map_intf.Creators3_with_comparator] |
|
of_alist_fold [Core_map_intf.Creators2] |
|
of_alist_fold [Core_map_intf.Creators1] |
|
of_alist_fold [Core_map_intf.Creators_generic] |
|
of_alist_fold [Core_map] |
combines an association list into a map, folding together bound values with common
keys
|
of_alist_multi [Core_map_intf.Creators3_with_comparator] |
|
of_alist_multi [Core_map_intf.Creators2] |
|
of_alist_multi [Core_map_intf.Creators1] |
|
of_alist_multi [Core_map_intf.Creators_generic] |
|
of_alist_multi [Core_map] |
creates map from association list with possibly repeated keys.
|
of_alist_multi [Core_hashtbl_intf.Creators] |
|
of_alist_or_error [Core_map_intf.Creators3_with_comparator] |
|
of_alist_or_error [Core_map_intf.Creators2] |
|
of_alist_or_error [Core_map_intf.Creators1] |
|
of_alist_or_error [Core_map_intf.Creators_generic] |
|
of_alist_or_error [Core_map] |
creates map from association list with unique keys.
|
of_alist_or_error [Core_hashtbl_intf.Creators] |
|
of_alist_reduce [Core_map_intf.Creators3_with_comparator] |
|
of_alist_reduce [Core_map_intf.Creators2] |
|
of_alist_reduce [Core_map_intf.Creators1] |
|
of_alist_reduce [Core_map_intf.Creators_generic] |
|
of_alist_reduce [Core_map] |
combines an association list into a map, reducing together bound values with common
keys
|
of_alist_report_all_dups [Core_hashtbl_intf.Creators] |
|
of_array [Linked_queue] |
|
of_array [Heap_intf.S] |
min_size (see create ) will be set to the size of the input array or list.
|
of_array [Fheap] |
|
of_array [Core_set_intf.Creators2_with_comparator] |
|
of_array [Core_set_intf.Creators2] |
|
of_array [Core_set_intf.Creators1] |
|
of_array [Core_set_intf.Creators0] |
|
of_array [Core_set_intf.Creators_generic] |
|
of_array [Core_set] |
|
of_array [Core_queue] |
|
of_array [Binary_searchable_intf.Indexable1.For_test] |
|
of_array [Binary_searchable_intf.Indexable.For_test] |
|
of_array_id [Core_array.Permissioned] |
of_array_id and to_array_id return the same underlying array.
|
of_bigstring [Substring_intf.S] |
Conversion to substrings.
|
of_bigstring [Make_substring.Base] |
|
of_bigstring [Make_substring.F] |
|
of_bigstring [Binable0] |
|
of_bigstring [Binable] |
|
of_bool [Blit_intf.Elt] |
|
of_bp [Percent] |
of_bp 5. is 5bp = 0.05% = 0.0005x
|
of_bp_int [Percent] |
|
of_char [Core_string] |
|
of_char_list [Core_string] |
|
of_day [Time_ns.Span] |
|
of_error [Validate] |
|
of_error_opt [Validate] |
|
of_exn [Or_error] |
of_exn exn is Error (Error.of_exn exn) .
|
of_exn [Info] |
of_exn and to_exn are primarily used with Error , but their definitions have to
be here because they refer to the underlying representation.
|
of_exn_result [Or_error] |
of_exn_result (Ok a) = Ok a , of_exn_result (Error exn) = of_exn exn
|
of_float [Floatable.S] |
|
of_float [Float_intf.S.O] |
|
of_float [Core_int64] |
|
of_fun [Raw_quickcheck_observer] |
of_fun f produces an observer that lazily applies f .
|
of_fun [Raw_quickcheck_generator] |
of_fun f produces a generator that lazily applies f .
|
of_hashtbl_keys [Hash_set_intf.Accessors] |
|
of_hr [Time_ns.Span] |
|
of_info [Error] |
|
of_int [Timing_wheel_intf.Interval_num.Span] |
|
of_int [Timing_wheel_intf.Interval_num] |
|
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 [Float_intf.S.O] |
|
of_int [Float_intf.S] |
|
of_int [Flags_intf.S] |
|
of_int [Day_of_week] |
|
of_int [Core_nativeint] |
|
of_int [Core_int64] |
|
of_int [Core_int63] |
|
of_int [Core_int32] |
|
of_int [Core_int] |
|
of_int [Core_char] |
Return the character with the given ASCII code or None is the argument is outside
the range 0 to 255.
|
of_int32 [Core_nativeint] |
|
of_int32 [Core_int64] |
|
of_int32 [Core_int32] |
|
of_int32 [Core_int] |
|
of_int32_exn [Int_intf.S] |
|
of_int63 [Timing_wheel_intf.Interval_num.Span] |
|
of_int63 [Timing_wheel_intf.Interval_num] |
|
of_int63 [Pool_intf.S.Pointer.Id] |
|
of_int63_ns [Time_ns.Span] |
|
of_int63_ns_since_epoch [Time_ns] |
|
of_int64 [Float_intf.S] |
|
of_int64 [Core_nativeint] |
|
of_int64 [Core_int64] |
|
of_int64 [Core_int32] |
|
of_int64 [Core_int] |
|
of_int64_exn [Int_intf.S] |
|
of_int64_exn [Core_int] |
|
of_int64_preserve_order [Float_intf.S] |
|
of_int_exn [Month] |
|
of_int_exn [Intable.S] |
|
of_int_exn [Int_math.T] |
|
of_int_exn [Int_intf.S.O] |
|
of_int_exn [Day_of_week] |
These use the same mapping as Unix.tm_wday : 0 <-> Sun, ...
|
of_int_exn [Core_char] |
Return the character with the given ASCII code.
|
of_int_ns [Time_ns.Span] |
|
of_int_ns_since_epoch [Time_ns] |
|
of_int_sec [Time_ns.Span] |
|
of_int_style [Core_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 [Validate] |
combine multiple results, merging errors
|
of_list [Stack_unit_tests.Test] |
|
of_list [Stack_unit_tests.Debug] |
|
of_list [Stack_intf.S] |
of_list l returns a stack whose top is the first element of l and bottom is the
last element of l .
|
of_list [Sequence] |
|
of_list [Quickcheck_observer] |
of_list list ~equal maps values in list to separate buckets, and compares
observed values to the elements of list using equal .
|
of_list [Quickcheck_generator] |
Produce any of the given values, weighted equally.
|
of_list [Linked_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 [Info] |
Combine multiple infos into one
|
of_list [Heap_intf.S] |
|
of_list [Hash_set_intf.Creators] |
|
of_list [Fheap] |
|
of_list [Fdeque.Back_to_front] |
|
of_list [Fdeque.Front_to_back] |
|
of_list [Fdeque] |
of_list returns a deque with elements in the same front-to-back order as the
list.
|
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 [Core_set_intf.Creators2_with_comparator] |
|
of_list [Core_set_intf.Creators2] |
|
of_list [Core_set_intf.Creators1] |
|
of_list [Core_set_intf.Creators0] |
|
of_list [Core_set_intf.Creators_generic] |
|
of_list [Core_set] |
The list or array given to of_list and of_array need not be sorted.
|
of_list [Core_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 [Core_list] |
of_list is the identity function.
|
of_list [Core_array.Permissioned] |
|
of_list [Core_array] |
Array.of_list l returns a fresh array containing the elements of l .
|
of_list [Bag] |
|
of_list_map [Core_array.Permissioned] |
|
of_list_map [Core_array] |
of_list_map l ~f is the same as of_list (List.map l ~f)
|
of_list_rev [Core_array.Permissioned] |
|
of_list_rev [Core_array] |
of_list_rev l converts from list then reverses in place
|
of_list_rev_map [Core_array.Permissioned] |
|
of_list_rev_map [Core_array] |
of_list_rev_map l ~f is the same as rev_inplace (of_list_map l ~f)
|
of_map_keys [Core_set_intf.Creators2_with_comparator] |
|
of_map_keys [Core_set_intf.Creators2] |
|
of_map_keys [Core_set_intf.Creators1] |
|
of_map_keys [Core_set_intf.Creators0] |
|
of_map_keys [Core_set_intf.Creators_generic] |
never requires a comparator because it can get one from the input Map.t
|
of_map_keys [Core_set] |
|
of_min [Time_ns.Span] |
|
of_ms [Time_ns.Span] |
|
of_mult [Percent] |
of_mult 5. is 5x = 500% = 50_000bp
|
of_nativeint [Core_nativeint] |
|
of_nativeint [Core_int64] |
|
of_nativeint [Core_int32] |
|
of_nativeint [Core_int] |
|
of_nativeint_exn [Int_intf.S] |
|
of_ns [Time_ns.Span] |
|
of_option [Result] |
|
of_parts [Time_ns.Span] |
|
of_percentage [Percent] |
of_percentage 5. is 5% = 0.05x = 500bp
|
of_predicate [Quickcheck_observer] |
of_predicate t1 t2 ~f combines t1 and t2 , where t1 observes values that
satisfy f and t2 observes values that do not satisfy f .
|
of_ref [Ref.Permissioned] |
|
of_result [Validate] |
Create a validation function from a function that produces a Result.t
|
of_sec [Timing_wheel_intf.Timing_wheel_time.Span] |
|
of_sec [Time_ns.Span] |
|
of_sec_with_microsecond_precision [Time_ns.Span] |
|
of_sequence [Quickcheck_generator] |
Generator for the values from a potentially infinite sequence.
|
of_sexp_allow_extra_fields [Core_sexp] |
of_sexp_allow_extra_fields of_sexp sexp uses of_sexp to convert sexp to a
value, but will not fail if there are any extra fields in a record (even deeply
nested records).
|
of_sorted_array [Core_set_intf.Creators2_with_comparator] |
|
of_sorted_array [Core_set_intf.Creators2] |
|
of_sorted_array [Core_set_intf.Creators1] |
|
of_sorted_array [Core_set_intf.Creators0] |
|
of_sorted_array [Core_set_intf.Creators_generic] |
|
of_sorted_array [Core_set] |
Create set from sorted array.
|
of_sorted_array [Core_map_intf.Creators3_with_comparator] |
|
of_sorted_array [Core_map_intf.Creators2] |
|
of_sorted_array [Core_map_intf.Creators1] |
|
of_sorted_array [Core_map_intf.Creators_generic] |
|
of_sorted_array [Core_map] |
creates map from sorted array of key-data pairs.
|
of_sorted_array_unchecked [Core_set_intf.Creators2_with_comparator] |
|
of_sorted_array_unchecked [Core_set_intf.Creators2] |
|
of_sorted_array_unchecked [Core_set_intf.Creators1] |
|
of_sorted_array_unchecked [Core_set_intf.Creators0] |
|
of_sorted_array_unchecked [Core_set_intf.Creators_generic] |
|
of_sorted_array_unchecked [Core_set] |
Similar to of_sorted_array , but without checking the input array.
|
of_sorted_array_unchecked [Core_map_intf.Creators3_with_comparator] |
|
of_sorted_array_unchecked [Core_map_intf.Creators2] |
|
of_sorted_array_unchecked [Core_map_intf.Creators1] |
|
of_sorted_array_unchecked [Core_map_intf.Creators_generic] |
|
of_sorted_array_unchecked [Core_map] |
Like of_sorted_array except behavior is undefined when an Error would have been
returned.
|
of_span_since_epoch [Time_ns] |
|
of_string [Sexpable.To_stringable] |
|
of_string [Rope] |
takes O(1) time
|
of_string [Substring_intf.S] |
|
of_string [Make_substring.Base] |
|
of_string [Make_substring.F] |
|
of_string [Stringable.S] |
|
of_string [Info] |
|
of_string [Binable] |
|
of_string [Bigstring] |
of_string ?pos ?len str
|
of_string_allow_nan_and_inf [Percent] |
|
of_text [Core_sexp.With_text] |
Creates a t from the text, by first converting the text to an s-expression, and
then parsing the s-expression with the provided converter.
|
of_thunk [Only_in_test] |
|
of_thunk [Info] |
|
of_tree [Core_set_intf.Creators2_with_comparator] |
|
of_tree [Core_set_intf.Creators2] |
|
of_tree [Core_set_intf.Creators1] |
|
of_tree [Core_set_intf.Creators0] |
|
of_tree [Core_set_intf.Creators_generic] |
|
of_tree [Core_set] |
|
of_tree [Core_map_intf.Creators3_with_comparator] |
|
of_tree [Core_map_intf.Creators2] |
|
of_tree [Core_map_intf.Creators1] |
|
of_tree [Core_map_intf.Creators_generic] |
|
of_tree [Core_map] |
Creates a t from a Tree.t and a Comparator.t .
|
of_typerep [Type_immediacy.Never] |
|
of_typerep [Type_immediacy.Sometimes] |
|
of_typerep [Type_immediacy.Always] |
|
of_typerep [Type_immediacy] |
|
of_us [Time_ns.Span] |
|
of_value [Core_sexp.With_text] |
Generates a t from the value by creating the text automatically using the provided
s-expression converter.
|
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_if_true returns Ok () if bool is true, and Error error if it is false
|
ok_or_failwith [Result] |
raises Failure in the Error case
|
ok_unit [Result] |
ok_unit = Ok () , used to avoid allocation as a performance hack
|
on_grow [Pooled_hashtbl] |
on_grow ~before ~after allows you to connect higher level loggers to the point where
these hashtbls grow.
|
one [Timing_wheel_intf.Interval_num.Span] |
|
one [Timing_wheel_intf.Interval_num] |
|
one [Int_intf.S] |
|
one [Float_intf.S] |
|
one_ulp [Float_intf.S] |
The next or previous representable float.
|
option [Type_immediacy.Sometimes] |
|
option [Quickcheck_observer] |
|
option [Quickcheck_generator] |
|
or_ [Blang] |
n-ary Or
|
original_gen [Raw_quickcheck_generator.Choice] |
original_gen t produces the original generator from which t was constructed,
unmodified.
|
out_channel_length [Common] |
|
outer_of_sexp [Float_intf.S] |
|
output [Out_channel] |
|
output_binary_int [Out_channel] |
|
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] |
|
overflow_bound_max_int32_value [Pow_overflow_bounds] |
|
overflow_bound_max_int64_value [Pow_overflow_bounds] |
|
overflow_bound_max_int_value [Pow_overflow_bounds] |
|
P |
pack_float [Binary_packing] |
|
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_int_big_endian [Binary_packing] |
|
pack_signed_64_int_little_endian [Binary_packing] |
|
pack_signed_64_little_endian [Binary_packing] |
|
pack_signed_8 [Binary_packing] |
|
pack_tail_padded_fixed_string [Binary_packing] |
Encode and pack the given string as a tail padded fixed length string having length
len .
|
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] |
|
pair [Validate] |
Validation functions for particular data types.
|
partial_iter [Linked_queue] |
partial_iter t ~f iterates through t until f returns `Stop
|
partition_map [Core_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.Accessors2_with_comparator] |
|
partition_tf [Core_set_intf.Accessors2] |
|
partition_tf [Core_set_intf.Accessors1] |
|
partition_tf [Core_set_intf.Accessors0] |
|
partition_tf [Core_set_intf.Accessors_generic] |
|
partition_tf [Core_set] |
if a, b = partition_tf set ~f then a is the elements on which f produced true ,
and b is the elements on which f produces false .
|
partition_tf [Core_list] |
partition_tf l ~f 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 [Core_array.Permissioned] |
|
partition_tf [Core_array] |
|
partitioni_tf [Core_hashtbl_intf.Accessors] |
|
partitioni_tf [Core_array.Permissioned] |
|
partitioni_tf [Core_array] |
|
pass [Validate] |
A result containing no errors
|
pass_bool [Validate] |
Check for unconditionally passing a bool
|
pass_unit [Validate] |
Check for unconditionally passing a unit
|
peek [Linked_queue] |
peek t returns None if t is empty, otherwise it returns Some x where x is
the front of t .
|
peek [Fdeque] |
peek t side produces Some of the element at the side of t , or None if t is
empty.
|
peek [Deque] |
peek t back_or_front return the value at the back or front of the dequeue without
removing it.
|
peek [Core_queue] |
|
peek_back [Fdeque] |
|
peek_back [Deque] |
|
peek_back_exn [Fdeque] |
|
peek_back_exn [Deque] |
|
peek_exn [Linked_queue] |
|
peek_exn [Fdeque] |
|
peek_exn [Core_queue] |
|
peek_front [Fdeque] |
|
peek_front [Deque] |
|
peek_front_exn [Fdeque] |
|
peek_front_exn [Deque] |
|
perms_of_sexp [Perms.Export] |
|
permute [Quickcheck_generator] |
permute list generates all permutations of list .
|
permute [Core_list] |
permute ?random_state t returns a permutation of t .
|
permute [Core_array.Permissioned] |
|
permute [Core_array] |
permute ?random_state t randomly permutes t in place.
|
permute [Array_permute] |
randomly permute an array.
|
phys_compare [Pool_intf.S.Pointer] |
|
phys_equal [Pool_intf.S.Pointer] |
|
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).
|
phys_same [Common] |
phys_same is like phys_equal , but with a more general type.
|
pointer_is_valid [Pool_intf.S] |
pointer_is_valid t pointer returns true iff pointer points to a live tuple in
t , i.e.
|
pointer_of_id_exn [Pool_intf.S] |
pointer_of_id_exn t id returns the pointer corresponding to id .
|
poly [Core_hashtbl_intf.Hashable] |
|
pop [Stack_unit_tests.Test] |
|
pop [Stack_unit_tests.Debug] |
|
pop [Stack_intf.S] |
pop t removes and returns the top element of t as Some a , or returns None if
t is empty.
|
pop [Heap_intf.S] |
This removes and returns the top (i.e.
|
pop [Hash_heap.S] |
|
pop [Hash_heap.Make] |
|
pop [Fheap] |
This removes and returns the top (i.e.
|
pop_exn [Stack_unit_tests.Test] |
|
pop_exn [Stack_unit_tests.Debug] |
|
pop_exn [Stack_intf.S] |
|
pop_exn [Heap_intf.S] |
|
pop_exn [Hash_heap.S] |
|
pop_exn [Hash_heap.Make] |
|
pop_exn [Fheap] |
|
pop_if [Heap_intf.S] |
pop_if t cond returns Some top_element of t if it satisfies condition
cond , removing it, or None in any other case.
|
pop_if [Hash_heap.S] |
|
pop_if [Hash_heap.Make] |
|
pop_if [Fheap] |
pop_if t cond returns Some (top_element, rest_of_heap) if t is not empty and its
top element satisfies condition cond , or None in any other case.
|
pop_if_with_key [Hash_heap.S] |
|
pop_if_with_key [Hash_heap.Make] |
|
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] |
|
pow [Int_intf.S] |
pow base exponent returns base raised to the power of exponent .
|
pp [Pretty_printer.S] |
|
pp [Info] |
|
pred [Timing_wheel_intf.Interval_num.Span] |
|
pred [Timing_wheel_intf.Interval_num] |
|
pred [Int_intf.S] |
|
prefix [Substring_intf.S] |
|
prefix [Make_substring.F] |
|
prefix [Core_string] |
prefix s n returns the longest prefix of s of length less than or equal to n
|
prepend [With_return] |
prepend a ~f returns a value x such that each call to x.return first applies f
before applying a.return .
|
prev [Doubly_linked] |
|
print [Core_printexc] |
|
print_backtrace [Core_printexc] |
|
print_stat [Core_gc] |
Print the current values of the memory management counters (in
human-readable form) into the channel argument.
|
printf [Std_internal] |
|
printf [Core_printf] |
|
promoted_words [Core_gc.Stat.Fields] |
|
promoted_words [Core_gc.Stat] |
|
promoted_words [Core_gc] |
|
protect [Validate] |
protect f x applies the validation f to x , catching any exceptions and returning
them as errors.
|
protect [Exn] |
|
protect [Common] |
See exn.mli
|
protectx [Exn] |
Executes f and afterwards executes finally , whether f throws an exception or
not.
|
protectx [Common] |
|
push [Stack_unit_tests.Test] |
|
push [Stack_unit_tests.Debug] |
|
push [Stack_intf.S] |
push t a adds a to the top of stack t .
|
push [Hash_heap.S] |
|
push [Hash_heap.Make] |
|
push_exn [Hash_heap.S] |
|
push_exn [Hash_heap.Make] |
|
Q |
quick_stat [Core_gc] |
Same as stat except that live_words , live_blocks , free_words ,
free_blocks , largest_free , and fragments are set to 0.
|
R |
raise [Error] |
Note that the exception raised by this function maintains a reference to the t
passed in.
|
raise_without_backtrace [Exn] |
Same as raise , except that the backtrace is not recorded.
|
random [Core_int63] |
random ~state bound returns a random integer between 0 (inclusive) and bound
(exclusive).
|
random_sequence [Quickcheck_intf.Quickcheck] |
random_sequence ~seed gen produces a sequence of values chosen from gen .
|
random_state_of_seed [Quickcheck_intf.Quickcheck] |
random_state_of_seed constructs initial random states for a given seed.
|
random_value [Quickcheck_intf.Quickcheck] |
random_value ~seed gen produces a single value chosen from gen using seed .
|
range [Sequence] |
range ?stride ?start ?stop start_i stop_i is the sequence of integers from start_i
to stop_i , stepping by stride .
|
range [Core_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.Accessors3_with_comparator] |
|
range_to_alist [Core_map_intf.Accessors3] |
|
range_to_alist [Core_map_intf.Accessors2] |
|
range_to_alist [Core_map_intf.Accessors1] |
|
range_to_alist [Core_map_intf.Accessors_generic] |
|
range_to_alist [Core_map] |
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.Accessors3_with_comparator] |
|
rank [Core_map_intf.Accessors3] |
|
rank [Core_map_intf.Accessors2] |
|
rank [Core_map_intf.Accessors1] |
|
rank [Core_map_intf.Accessors_generic] |
|
rank [Core_map] |
rank t k if k is in t, returns the number of keys strictly less than k in t,
otherwise None
|
raw [Validated_intf.S] |
|
raw [Validated_intf.Validated] |
|
read_all [In_channel] |
read_all filename Opens filename, reads all input, and closes the file.
|
read_bin_prot [Bigstring] |
The read_bin_prot* functions read from the region of t starting at pos of length
len .
|
read_bin_prot_verbose_errors [Bigstring] |
|
read_lines [In_channel] |
read_lines filename Opens filename, reads all lines, and closes the file.
|
read_of_sexp [Perms.Export] |
|
read_only [Ref.Permissioned] |
|
read_write_of_sexp [Perms.Export] |
|
really_input [In_channel] |
|
record_backtrace [Core_printexc] |
|
recursive [Quickcheck_observer] |
Fixed point observer; use recursive to create observers for recursive types.
|
recursive [Quickcheck_generator] |
Fixed-point generator.
|
reduce [Sequence] |
|
reduce [Core_list] |
|
reduce [Core_array.Permissioned] |
|
reduce [Core_array] |
reduce f [a1; ...; an] is Some (f (... (f (f a1 a2) a3) ...) an) .
|
reduce_balanced [Core_list] |
reduce_balanced returns the same value as reduce when f is associative, but
differs in that the tree of nested applications of f has logarithmic depth.
|
reduce_balanced_exn [Core_list] |
|
reduce_exn [Sequence] |
reduce_exn f [a1; ...; an] is f (... (f (f a1 a2) a3) ...) an .
|
reduce_exn [Core_list] |
reduce_exn [a1; ...; an] ~f is f (... (f (f a1 a2) a3) ...) an .
|
reduce_exn [Core_array.Permissioned] |
|
reduce_exn [Core_array] |
|
ref_ [Type_immediacy.Never] |
|
refl [Type_equal] |
refl , sym , and trans construct proofs that type equality is reflexive,
symmetric, and transitive.
|
register [Pretty_printer] |
register name adds name to the list of pretty printers.
|
rem [Timing_wheel_intf.Interval_num] |
|
rem [Int_math.T] |
|
rem [Int_intf.S] |
|
remove [Timing_wheel_intf.Timing_wheel.Priority_queue] |
remove t elt removes elt from t .
|
remove [Timing_wheel_intf.Timing_wheel] |
remove t alarm removes alarm from t .
|
remove [Hash_set_intf.Accessors] |
|
remove [Hash_queue.S] |
|
remove [Hash_queue.Make] |
|
remove [Hash_heap.S] |
|
remove [Hash_heap.Make] |
|
remove [Heap.Removable] |
If t and token are mismatched then behavior is undefined.
|
remove [Doubly_linked] |
constant-time removal of an element.
|
remove [Core_set_intf.Accessors2_with_comparator] |
|
remove [Core_set_intf.Accessors2] |
|
remove [Core_set_intf.Accessors1] |
|
remove [Core_set_intf.Accessors0] |
|
remove [Core_set_intf.Accessors_generic] |
|
remove [Core_set] |
remove t a returns a new set with a removed from t if mem t a , or returns t
otherwise.
|
remove [Core_map_intf.Accessors3_with_comparator] |
|
remove [Core_map_intf.Accessors3] |
|
remove [Core_map_intf.Accessors2] |
|
remove [Core_map_intf.Accessors1] |
|
remove [Core_map_intf.Accessors_generic] |
|
remove [Core_map] |
returns a new map with any binding for the key in question removed
|
remove [Core_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_consecutive_duplicates [Sequence] |
The same sequence with consecutive duplicates removed.
|
remove_consecutive_duplicates [Core_list] |
remove_consecutive_duplicates .
|
remove_exn [Hash_queue.S] |
|
remove_exn [Hash_queue.Make] |
|
remove_first [Doubly_linked] |
|
remove_index [Core_set_intf.Accessors2_with_comparator] |
|
remove_index [Core_set_intf.Accessors2] |
|
remove_index [Core_set_intf.Accessors1] |
|
remove_index [Core_set_intf.Accessors0] |
|
remove_index [Core_set_intf.Accessors_generic] |
|
remove_index [Core_set] |
remove_index t i returns a version of t with the i th smallest element removed,
in O(log n) time.
|
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.
|
remove_top [Heap_intf.S] |
remove_top t does nothing if t is empty
|
remove_top [Fheap] |
remove_top t returns the new heap after a remove.
|
remove_zero_flags [Flags_intf.Make_arg] |
If remove_zero_flags , then all flags with value zero will be automatically removed
from known .
|
repeat [Sequence] |
repeat a repeats a forever.
|
replace [Ref.Permissioned] |
|
replace [Ref] |
replace t f is t := f !t
|
replace [Hash_queue.S] |
replace q k v changes the value of key k in the queue to v.
|
replace [Hash_queue.Make] |
|
replace [Hash_heap.S] |
|
replace [Hash_heap.Make] |
|
replace [Core_hashtbl_intf.Accessors] |
|
replace [Core_array.Permissioned] |
|
replace [Core_array] |
replace t i ~f = t.(i) <- f (t.(i)) .
|
replace_all [Core_string.Search_pattern] |
|
replace_all [Core_array.Permissioned] |
|
replace_all [Core_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] |
|
replace_first [Core_string.Search_pattern] |
Note that the result of replace_all pattern ~in_:text ~with_:r may still
contain pattern , e.g.
|
reraise [Exn] |
|
reraise_uncaught [Exn] |
Traces exceptions passing through.
|
reraisef [Exn] |
Types with format4 are hard to read, so here's an example.
|
reschedule [Timing_wheel_intf.Timing_wheel] |
reschedule t alarm ~at mutates alarm so that it will fire at at , i.e.
|
reschedule_at_interval_num [Timing_wheel_intf.Timing_wheel] |
|
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 .
|
resize [Pooled_hashtbl] |
resize t size ensures that t can hold at least size entries without resizing
(again), provided that t has growth enabled.
|
resize [Bigbuffer_internal] |
|
result [Validate] |
|
return [Monad_intf.S2] |
|
return [Monad_intf.Basic2] |
|
return [Monad_intf.S] |
return v returns the (trivial) computation that returns v.
|
return [Monad_intf.Basic] |
The following identities ought to hold (for some value of =):
|
return [Applicative_intf.S2] |
|
return [Applicative_intf.Basic2] |
|
return [Applicative_intf.S] |
|
return [Applicative_intf.Basic] |
|
rev [Fdeque] |
rev t returns t , reversed.
|
rev [Core_string] |
rev t returns t in reverse order.
|
rev [Core_list] |
List reversal.
|
rev_append [Core_list] |
List.rev_append l1 l2 reverses l1 and concatenates it to l2 .
|
rev_filter [Core_list] |
Like filter , but reverses the order of the input list
|
rev_filter_map [Core_list] |
rev_filter_map l ~f is the reversed sublist of l containing
only elements for which f returns Some e .
|
rev_filter_mapi [Core_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 [Core_array.Permissioned] |
|
rev_inplace [Core_array] |
rev_inplace t reverses t in place
|
rev_map [Core_list] |
List.rev_map l ~f gives the same result as
List.rev ( ListLabels.map f l) , but is more efficient.
|
rev_map2_exn [Core_list] |
List.rev_map2_exn l1 l2 ~f gives the same result as
List.rev (List.map2_exn l1 l2 ~f) , but is more efficient.
|
rev_map3_exn [Core_list] |
|
rev_map_append [Core_list] |
rev_map_append l1 l2 ~f reverses l1 mapping f over each
element, and appends the result to the front of l2 .
|
rev_mapi [Core_list] |
|
rfindi [Core_string] |
rfindi ?pos t ~f returns the largest i <= pos such that f i t.[i] , if there is
such an i .
|
rindex [Core_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 [Core_string] |
|
rindex_exn [Core_string.Escaping] |
|
rindex_exn [Core_string] |
|
rindex_from [Core_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 [Core_string] |
|
rindex_from_exn [Core_string.Escaping] |
|
rindex_from_exn [Core_string] |
|
robust_comparison_tolerance [Float_robust_compare.S] |
intended to be a tolerance on human-entered floats
|
robust_comparison_tolerance [Float_intf.S] |
See Robust_compare
|
robustly_compare [Robustly_comparable.S] |
|
round [Std_internal] |
|
round [Int_intf.Round] |
|
round [Float_intf.S] |
round rounds a float to an integer float.
|
round_down [Int_intf.Round] |
|
round_down [Float_intf.S] |
|
round_nearest [Int_intf.Round] |
|
round_nearest [Float_intf.S] |
|
round_towards_zero [Int_intf.Round] |
|
round_towards_zero [Float_intf.S] |
|
round_up [Int_intf.Round] |
|
round_up [Float_intf.S] |
|
rsplit2 [Core_string.Escaping] |
rsplit2 s on escape_char splits s into a pair on the first literal instance of
on (meaning the first unescaped instance) starting from the right.
|
rsplit2 [Core_string] |
rsplit2 line ~on optionally returns line split into two strings around the
first appearance of on from the right
|
rsplit2_exn [Core_string.Escaping] |
|
rsplit2_exn [Core_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 [Core_string] |
rstrip ?drop s returns a string with consecutive chars satisfying drop (by default
white space, e.g.
|
run [Sequence.Generator] |
|
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 the same (i.e.
|
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] |
|
scale [Timing_wheel_intf.Timing_wheel_time.Span] |
|
scale [Time_ns.Span] |
|
scale [Percent] |
scale t x scales the percent t by x , returning a new t
|
scale [Float_intf.S] |
|
scale [Byte_units] |
scale t mul scale the measure t by mul
|
scale_int [Timing_wheel_intf.Interval_num.Span] |
|
scale_int [Time_ns.Span] |
|
scale_int63 [Time_ns.Span] |
|
second [Time_ns.Span] |
|
second [Either_intf.S] |
|
seek [Out_channel] |
|
seek [In_channel] |
|
seek_in [Common] |
|
seek_out [Common] |
|
self_init [Core_random] |
Initialize the generator with a more-or-less random seed chosen in a system-dependent
way.
|
set [Univ_map_intf.S1] |
|
set [Univ_map_intf.S] |
|
set [Univ_map.Multi] |
|
set [Univ_map.With_fold] |
reset the accumulator
|
set [Univ_map.With_default] |
|
set [Union_find] |
set t v sets the value of the class of t to v .
|
set [Total_map] |
|
set [Set_once] |
|
set [Ref.Permissioned] |
set and (:=) are two names for the same function.
|
set [Pool_intf.S] |
|
set [Obj_array] |
|
set [Flat_queue] |
|
set [Flat_array_debug.Debug] |
|
set [Flat_array] |
|
set [Core_weak] |
|
set [Core_string] |
|
set [Core_queue] |
|
set [Core_hashtbl_intf.Accessors] |
|
set [Core_gc] |
set r changes the GC parameters according to the control record r .
|
set [Core_array.Permissioned] |
|
set [Core_array] |
Array.set a n x modifies array a in place, replacing
element number n with x .
|
set [Bounded_int_table] |
|
set [Blit_intf.Sequence] |
|
set [Bigstring] |
set t pos sets the character at pos
|
set_all_mutable_fields [Core_gc.Control.Fields.Direct] |
|
set_all_mutable_fields [Core_gc.Stat.Fields.Direct] |
|
set_all_slots [Flat_queue] |
|
set_all_slots [Flat_array_debug.Debug] |
|
set_all_slots [Flat_array] |
|
set_allocation_policy [Core_gc.Control] |
|
set_binary_mode [Out_channel] |
|
set_binary_mode [In_channel] |
|
set_capacity [Flat_queue] |
set_capacity t capacity sets the length of the array backing t to as small as
value as possible that is not less than max capacity (length t) .
|
set_capacity [Core_stack] |
set_capacity t capacity sets the length of the array backing t to max capacity
(length t) .
|
set_capacity [Core_queue] |
set_capacity t capacity sets the capacity of t 's backing array to at least
max capacity (length t) .
|
set_exn [Set_once] |
|
set_exn [Deque] |
set_exn t i v mutate the element at i .
|
set_major_heap_increment [Core_gc.Control] |
|
set_max_overhead [Core_gc.Control] |
|
set_minor_heap_size [Core_gc.Control] |
|
set_recording [Backtrace.Exn] |
|
set_space_overhead [Core_gc.Control] |
|
set_stack_limit [Core_gc.Control] |
|
set_state [Core_random] |
Set the state of the generator used by the basic functions.
|
set_tail_padded_fixed_string [Bigstring] |
|
set_to_init [Flat_array_debug.Debug] |
|
set_to_init [Flat_array] |
set_to_init t i sets flat tuple i to the init that was supplied to create .
|
set_verbose [Core_gc.Control] |
|
sexp [Unpack_buffer.Unpack_one] |
|
sexp [Quickcheck_observer] |
|
sexp [Quickcheck_generator] |
|
sexp_of_decimal [Std_kernel] |
|
sexp_of_exn [Std_internal] |
|
sexp_of_fn_with_sexp [Quickcheck_generator] |
|
sexp_of_immutable [Perms.Export] |
|
sexp_of_int_style [Int_conversions] |
global ref affecting whether the sexp_of_t returned by Make
is consistent with the to_string input or the to_string_hum output
|
sexp_of_key [Core_hashtbl_intf.Accessors] |
|
sexp_of_me [Perms.Stable.V1] |
|
sexp_of_me [Perms] |
|
sexp_of_never_returns [Never_returns] |
|
sexp_of_never_returns [Common] |
|
sexp_of_no_raise [Core_sexp] |
|
sexp_of_nobody [Perms.Stable.V1] |
|
sexp_of_nobody [Perms] |
|
sexp_of_outer [Float_intf.S] |
|
sexp_of_perms [Perms.Export] |
|
sexp_of_read [Perms.Export] |
|
sexp_of_read_write [Perms.Export] |
|
sexp_of_t [Validated_intf.Validated] |
|
sexp_of_t [Validated_intf.Raw] |
|
sexp_of_t [Univ_map_intf.S1] |
|
sexp_of_t [Univ_map_intf.S] |
|
sexp_of_t [Timing_wheel_intf.Timing_wheel.Priority_queue.Elt] |
|
sexp_of_t [Timing_wheel_intf.Timing_wheel.Priority_queue] |
|
sexp_of_t [Timing_wheel_intf.Timing_wheel.Config] |
|
sexp_of_t [Timing_wheel_intf.Timing_wheel.Level_bits] |
|
sexp_of_t [Timing_wheel_intf.Timing_wheel.Alarm] |
|
sexp_of_t [Timing_wheel_intf.Timing_wheel] |
|
sexp_of_t [Timing_wheel_intf.Interval_num.Span] |
|
sexp_of_t [Timing_wheel_intf.Interval_num] |
|
sexp_of_t [Timing_wheel_intf.Timing_wheel_time.Span] |
|
sexp_of_t [Timing_wheel_intf.Timing_wheel_time] |
|
sexp_of_t [Unpack_buffer] |
|
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 [Total_map.Key] |
|
sexp_of_t [Total_map.S] |
|
sexp_of_t [Thread_safe_queue] |
|
sexp_of_t [String_id.S.Stable.V1] |
|
sexp_of_t [Time_ns.Alternate_sexp] |
|
sexp_of_t [Time_ns.Span.Alternate_sexp] |
|
sexp_of_t [Time_ns.Span.Parts] |
|
sexp_of_t [Stack_unit_tests.Debug] |
|
sexp_of_t [Stack_intf.S] |
|
sexp_of_t [Stable_unit_test_intf.Unordered_container_arg] |
|
sexp_of_t [Stable_containers.Hashable.V1.S.Hash_set] |
|
sexp_of_t [Stable_containers.Hashable.V1.S.Table] |
|
sexp_of_t [Source_code_position0.Stable.V1] |
|
sexp_of_t [Source_code_position] |
|
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_sexpable1] |
|
sexp_of_t [Sexpable.Of_sexpable] |
|
sexp_of_t [Set_once] |
|
sexp_of_t [Sequence.Step] |
|
sexp_of_t [Sequence] |
|
sexp_of_t [Stable_unit_test_intf.Arg] |
tests is a list of (value, sexp-representation, bin-io-representation) triples.
|
sexp_of_t [Result] |
|
sexp_of_t [Ref.Permissioned] |
|
sexp_of_t [Ref] |
|
sexp_of_t [Pool_intf.S.Pointer.Id] |
|
sexp_of_t [Pool_intf.S.Pointer] |
|
sexp_of_t [Pool_intf.S] |
|
sexp_of_t [Pid] |
|
sexp_of_t [Perms.Stable.V1.Upper_bound] |
|
sexp_of_t [Perms.Stable.V1.Read_write] |
|
sexp_of_t [Perms.Stable.V1.Immutable] |
|
sexp_of_t [Perms.Stable.V1.Write] |
|
sexp_of_t [Perms.Stable.V1.Read] |
|
sexp_of_t [Perms.Upper_bound] |
|
sexp_of_t [Perms.Read_write] |
|
sexp_of_t [Perms.Immutable] |
|
sexp_of_t [Perms.Write] |
|
sexp_of_t [Perms.Read] |
|
sexp_of_t [Percent.Stable.V1] |
|
sexp_of_t [Ordering] |
|
sexp_of_t [Or_error] |
|
sexp_of_t [Option] |
|
sexp_of_t [Obj_array] |
|
sexp_of_t [Nothing0] |
|
sexp_of_t [Nothing.Stable.V1] |
|
sexp_of_t [Month.Stable.V1] |
|
sexp_of_t [Month] |
|
sexp_of_t [Linked_queue] |
|
sexp_of_t [Stable_module_types.S2] |
|
sexp_of_t [Sexpable.S] |
|
sexp_of_t [Int_intf.S] |
|
sexp_of_t [Int_intf.Hexable.Hex] |
|
sexp_of_t [Int_conversions.Make] |
|
sexp_of_t [Stable_module_types.S0] |
|
sexp_of_t [Info] |
|
sexp_of_t [Identifiable.S] |
|
sexp_of_t [Host_and_port.Stable.V1] |
|
sexp_of_t [Heap_intf.S] |
|
sexp_of_t [Heap_block] |
|
sexp_of_t [Hash_set_intf.S] |
|
sexp_of_t [Hash_set.Poly] |
|
sexp_of_t [Hash_set] |
|
sexp_of_t [Hash_queue.S] |
|
sexp_of_t [Hash_queue.Make] |
|
sexp_of_t [Heap.Removable.Elt] |
|
sexp_of_t [Fqueue.Stable.V1] |
|
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 [Flat_queue] |
|
sexp_of_t [Flat_array_debug.Debug] |
|
sexp_of_t [Tuple_type_intf.Slot] |
|
sexp_of_t [Tuple_type_intf.Slots] |
|
sexp_of_t [Flat_array] |
|
sexp_of_t [Flags_intf.S] |
|
sexp_of_t [Fheap] |
|
sexp_of_t [Fdeque.Stable.V1] |
|
sexp_of_t [Fdeque] |
|
sexp_of_t [Exn] |
|
sexp_of_t [Either_intf.S] |
|
sexp_of_t [Doubly_linked.Elt] |
|
sexp_of_t [Doubly_linked] |
|
sexp_of_t [Deque] |
|
sexp_of_t [Decimal] |
|
sexp_of_t [Day_of_week.Stable.V1] |
|
sexp_of_t [Day_of_week] |
|
sexp_of_t [Core_weak] |
|
sexp_of_t [Core_string.Search_pattern] |
|
sexp_of_t [Core_string] |
|
sexp_of_t [Core_sexp.With_text] |
|
sexp_of_t [Core_sexp.Sexp_maybe] |
|
sexp_of_t [Core_sexp] |
|
sexp_of_t [Core_set_intf.S0.Tree] |
|
sexp_of_t [Core_set_intf.S0.Elt] |
|
sexp_of_t [Core_set_intf.S0] |
|
sexp_of_t [Core_set_intf.Elt_binable] |
|
sexp_of_t [Core_set_intf.Elt] |
|
sexp_of_t [Core_set.Poly.Tree] |
|
sexp_of_t [Core_set.Poly] |
|
sexp_of_t [Core_set.Tree] |
|
sexp_of_t [Core_queue] |
|
sexp_of_t [Core_map_intf.S.Tree] |
|
sexp_of_t [Core_map_intf.S] |
|
sexp_of_t [Core_map_intf.Key_binable] |
|
sexp_of_t [Core_map_intf.Key] |
|
sexp_of_t [Core_map.Poly.Tree] |
|
sexp_of_t [Core_map.Poly] |
|
sexp_of_t [Core_map.Tree] |
|
sexp_of_t [Core_list.Assoc] |
|
sexp_of_t [Core_list] |
|
sexp_of_t [Stable_module_types.S1] |
|
sexp_of_t [Core_lazy.T_unforcing] |
|
sexp_of_t [Core_lazy] |
|
sexp_of_t [Core_hashtbl_intf.Hashtbl.Poly] |
|
sexp_of_t [Core_hashtbl_intf.Hashtbl] |
|
sexp_of_t [Core_hashtbl_intf.S] |
|
sexp_of_t [Core_hashtbl_intf.Key] |
|
sexp_of_t [Core_gc.Expert.Alarm] |
|
sexp_of_t [Core_gc.Control] |
|
sexp_of_t [Core_gc.Stat] |
|
sexp_of_t [Core_char] |
|
sexp_of_t [Core_array.Permissioned.Float] |
|
sexp_of_t [Core_array.Permissioned.Int] |
|
sexp_of_t [Core_array.Permissioned] |
|
sexp_of_t [Core_array.Float] |
|
sexp_of_t [Core_array.Int] |
|
sexp_of_t [Core_array] |
|
sexp_of_t [Container_unit_tests.Test_generic] |
|
sexp_of_t [Constrained_float.S] |
|
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 [Blit_intf.Sequence] |
|
sexp_of_t [Blang.Stable.V1] |
|
sexp_of_t [Blang] |
|
sexp_of_t [Bigstring] |
|
sexp_of_t [Bigbuffer_internal] |
|
sexp_of_t [Bag.Elt] |
|
sexp_of_t [Bag] |
|
sexp_of_t [Backtrace] |
|
sexp_of_t1 [Tuple_type_intf.Slots] |
|
sexp_of_t10 [Tuple_type_intf.Slots] |
|
sexp_of_t11 [Tuple_type_intf.Slots] |
|
sexp_of_t12 [Tuple_type_intf.Slots] |
|
sexp_of_t2 [Tuple_type_intf.Slots] |
|
sexp_of_t3 [Tuple_type_intf.Slots] |
|
sexp_of_t4 [Tuple_type_intf.Slots] |
|
sexp_of_t5 [Tuple_type_intf.Slots] |
|
sexp_of_t6 [Tuple_type_intf.Slots] |
|
sexp_of_t7 [Tuple_type_intf.Slots] |
|
sexp_of_t8 [Tuple_type_intf.Slots] |
|
sexp_of_t9 [Tuple_type_intf.Slots] |
|
sexp_of_t_hum [Source_code_position0] |
|
sexp_of_t_hum [Source_code_position] |
|
sexp_of_t_now [Timing_wheel_intf.Timing_wheel] |
<:sexp_of< _ t_now >> displays only now t , not all the alarms.
|
sexp_of_write [Perms.Export] |
|
shift [Month] |
shift t i goes forward (or backward) the specified number of months
|
shift [Day_of_week] |
This goes forward (or backward) the specified number of weekdays
|
shift_left [Sequence] |
shift_left t n is a synonym for drop t n .
|
shift_left [Int_intf.S] |
shifts left, filling in with zeroes
|
shift_right [Sequence] |
shift_right t a produces a and then produces each element of t .
|
shift_right [Int_intf.S] |
shifts right, filling in with zeroes, which will not preserve the sign of the
input
|
shift_right_logical [Int_intf.S] |
|
shift_right_with_list [Sequence] |
shift_right_with_list t l produces the elements of l , then produces the elements
of t .
|
should_print_error [Flags_intf.Make_arg] |
should_print_error says whether to print an error message if there is an error in
the known flags.
|
show_messages [Pool_intf.Pool.Debug] |
|
show_messages [Flat_queue_debug.Debug] |
|
show_messages [Debug.Make] |
If true, you get a message on stderr every time debug is called
|
show_messages [Core_queue_debug.Debug] |
|
sign [Float_intf.S] |
|
similar [Core_hashtbl_intf.Accessors] |
|
since_unix_epoch [Time_ns.Span] |
|
singleton [Sequence] |
singleton a produces a exactly once.
|
singleton [Raw_quickcheck_observer] |
maps all values to a single bucket.
|
singleton [Raw_quickcheck_generator] |
Constant generator.
|
singleton [Quickcheck_generator] |
|
singleton [Obj_array] |
|
singleton [Linked_queue] |
|
singleton [Fqueue] |
|
singleton [Fdeque] |
A one-element deque.
|
singleton [Core_set_intf.Creators2_with_comparator] |
|
singleton [Core_set_intf.Creators2] |
|
singleton [Core_set_intf.Creators1] |
|
singleton [Core_set_intf.Creators0] |
|
singleton [Core_set_intf.Creators_generic] |
|
singleton [Core_set] |
Creates a set based on the provided comparator that contains only the provided
element.
|
singleton [Core_queue] |
|
singleton [Core_map_intf.Creators3_with_comparator] |
|
singleton [Core_map_intf.Creators2] |
|
singleton [Core_map_intf.Creators1] |
|
singleton [Core_map_intf.Creators_generic] |
|
singleton [Core_map] |
map with one key, data pair
|
size [Quickcheck_generator] |
size produces a geometric distribution (think "radioactive decay") starting at 0
and increasing with probability 0.25.
|
size [Bucket.S] |
|
size [Bucket.Make] |
|
skip [Bigstring_marshal] |
|
slice [Ordered_collection_common] |
|
slice [Core_string] |
slice s start stop gets a slice of s between start and stop .
|
slice [Core_list] |
slice l start stop returns a new list including elements l.(start) through
l.(stop-1) , normalized python-style.
|
slice [Core_array.Permissioned] |
|
slice [Core_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 .
|
slots [Flat_array_debug.Debug] |
|
slots [Flat_array] |
|
slots_per_tuple [Tuple_type_intf.Slots] |
|
small [Binary_searchable_intf.Indexable.For_test] |
|
snd3 [Common] |
|
some [Option] |
|
some_if [Option] |
|
sort [Core_list] |
Sort a list in increasing order according to a comparison function.
|
sort [Core_array.Permissioned] |
|
sort [Core_array] |
sort uses constant heap space.
|
sort_and_align [Core_arg] |
Like align , except that the specification list is also sorted by key
|
sorted_copy [Core_array.Permissioned] |
|
sorted_copy [Core_array] |
sorted_copy ar cmp returns a shallow copy of ar that is sorted.
|
space_overhead [Core_gc.Control.Fields] |
|
space_overhead [Core_gc.Control] |
|
specialize [Blang] |
specialize t f partially evaluates t according to a
perhaps-incomplete assignment f of the values of base propositions.
|
split [Core_string.Escaping] |
split s ~escape_char ~on
|
split [Core_string] |
split s ~on
|
split [Core_set_intf.Accessors2_with_comparator] |
|
split [Core_set_intf.Accessors2] |
|
split [Core_set_intf.Accessors1] |
|
split [Core_set_intf.Accessors0] |
|
split [Core_set_intf.Accessors_generic] |
|
split [Core_set] |
split t x produces a triple (t1, maybe_x, t2) where t1 is the set of elements
strictly less than x , maybe_x is the member (if any) of t which compares equal
to x , and t2 is the set of elements strictly larger than x .
|
split [Core_map_intf.Accessors3_with_comparator] |
|
split [Core_map_intf.Accessors3] |
|
split [Core_map_intf.Accessors2] |
|
split [Core_map_intf.Accessors1] |
|
split [Core_map_intf.Accessors_generic] |
|
split [Core_map] |
split t key returns a map of keys strictly less than key , the mapping of key if
any, and a map of keys strictly greater than key .
|
split [Core_array.Permissioned] |
|
split [Core_array] |
split ar splits an array of pairs into two arrays of single elements.
|
split_lines [Core_string] |
split_lines t returns the list of lines that comprise t .
|
split_n [Core_list] |
split_n n [e1; ...; em] is ([e1; ...; en], [en+1; ...; em]) .
|
split_n_eagerly [Sequence] |
split_n_eagerly t n immediately consumes the first n elements of t and returns
the consumed prefix, as a new stream, along with the unevaluated tail of t .
|
split_on_chars [Core_string.Escaping] |
split_on_chars s ~on
|
split_on_chars [Core_string] |
split_on_chars s ~on
|
split_while [Core_list] |
split_while xs ~f = (take_while xs ~f, drop_while xs ~f)
|
sprintf [Std_internal] |
|
sprintf [Core_printf] |
|
stable_dedup [Std_internal.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.Creators2_with_comparator] |
|
stable_dedup_list [Core_set_intf.Creators2] |
|
stable_dedup_list [Core_set_intf.Creators1] |
|
stable_dedup_list [Core_set_intf.Creators0] |
|
stable_dedup_list [Core_set_intf.Creators_generic] |
|
stable_dedup_list [Core_set] |
stable_dedup_list is here rather than in the List module because the
implementation relies crucially on sets, and because doing so allows one to avoid uses
of polymorphic comparison by instantiating the functor at a different implementation
of Comparator and using the resulting stable_dedup_list .
|
stable_dedup_staged [Std_internal.List] |
|
stable_sort [Core_list] |
Same as sort, but guaranteed to be stable
|
stable_sort [Core_array.Permissioned] |
|
stable_sort [Core_array] |
|
stack_limit [Core_gc.Control.Fields] |
|
stack_limit [Core_gc.Control] |
|
stack_size [Core_gc.Stat.Fields] |
|
stack_size [Core_gc.Stat] |
|
stage [Staged] |
|
stage [Common] |
See module : Staged for documentation
|
start [Timing_wheel_intf.Timing_wheel] |
|
stat [Core_gc] |
Return the current values of the memory management counters in a
stat record.
|
stderr [Out_channel] |
|
stdin [In_channel] |
|
stdout [Out_channel] |
|
step [Applicative_intf.Args2] |
|
step [Applicative_intf.Args] |
Transform argument values in some way.
|
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 [Type_immediacy.Never] |
|
string [Quickcheck_observer] |
|
string [Quickcheck_generator] |
|
string_bigstring [Make_substring.Blit] |
|
string_of [Quickcheck_generator] |
|
string_of_float [Common] |
|
string_string [Make_substring.Blit] |
|
strip [Type_equal.Injective2] |
|
strip [Type_equal.Injective] |
|
strip [Core_string] |
strip ?drop s returns a string with consecutive chars satisfying drop (by default
white space, e.g.
|
sub [Timing_wheel_intf.Interval_num] |
|
sub [Timing_wheel_intf.Timing_wheel_time] |
|
sub [Time_ns] |
|
sub [Sequence] |
sub t ~pos ~len is the len -element subsequence of t , starting at pos .
|
sub [Float_intf.S] |
|
sub [Flat_array_debug.Debug] |
|
sub [Core_list] |
sub pos len l is the len -element sublist of l , starting at pos .
|
sub [Blit_intf.S_distinct] |
|
sub [Blit_intf.S1_permissions] |
|
sub [Blit_intf.S1] |
|
sub [Blit_intf.S_permissions] |
|
sub [Blit_intf.S] |
|
sub_shared [Bigstring] |
sub_shared ?pos ?len bstr
|
subo [Flat_array_debug.Debug] |
|
subo [Blit_intf.S_distinct] |
|
subo [Blit_intf.S1_permissions] |
|
subo [Blit_intf.S1] |
|
subo [Blit_intf.S_permissions] |
|
subo [Blit_intf.S] |
|
subset [Core_set_intf.Accessors2_with_comparator] |
|
subset [Core_set_intf.Accessors2] |
|
subset [Core_set_intf.Accessors1] |
|
subset [Core_set_intf.Accessors0] |
|
subset [Core_set_intf.Accessors_generic] |
|
subset [Core_set] |
subset t1 t2 returns true iff t1 is a subset of t2 .
|
substr_index [Core_string] |
Substring search and replace convenience functions.
|
substr_index_all [Core_string] |
|
substr_index_exn [Core_string] |
|
substr_replace_all [Core_string] |
|
substr_replace_first [Core_string] |
As with Search_pattern.replace_all , the result may still contain pattern .
|
succ [Timing_wheel_intf.Interval_num.Span] |
|
succ [Timing_wheel_intf.Interval_num] |
|
succ [Int_intf.S] |
|
suffix [Substring_intf.S] |
|
suffix [Make_substring.F] |
|
suffix [Core_string] |
suffix s n returns the longest suffix of s of length less than or equal to n
|
sum [Stack_unit_tests.Debug] |
|
sum [Hash_queue.Make] |
|
sum [Core_set] |
sum t returns the sum of f t for each t in the set.
|
sum [Container_unit_tests.Test_generic] |
|
sum [Container_intf.Container] |
|
sum [Container_intf.Generic_phantom] |
|
sum [Container_intf.Generic] |
|
sum [Container_intf.S1_permissions] |
Returns the sum of f i for i in the container
|
sum [Container_intf.S1_phantom_invariant] |
Returns the sum of f i for i in the container
|
sum [Container_intf.S1] |
Returns the sum of f i for i in the container
|
sum [Container_intf.S0_phantom] |
Returns the sum of f i for i in the container
|
sum [Container_intf.S0] |
Returns the sum of f i for i in the container
|
swap [Tuple.T2] |
|
swap [Ref.Permissioned] |
|
swap [Ref] |
swap t1 t2 swaps the values in t1 and t2 .
|
swap [Either_intf.S] |
|
swap [Core_array.Permissioned] |
|
swap [Core_array] |
swap arr i j swaps the value at index i with that at index j .
|
swap [Array_permute] |
|
sym [Type_equal] |
|
symmetric_diff [Core_set_intf.Accessors2_with_comparator] |
|
symmetric_diff [Core_set_intf.Accessors2] |
|
symmetric_diff [Core_set_intf.Accessors1] |
|
symmetric_diff [Core_set_intf.Accessors0] |
|
symmetric_diff [Core_set_intf.Accessors_generic] |
|
symmetric_diff [Core_set] |
symmetric_diff t1 t2 returns a sequence of changes between t1 and t2 .
|
symmetric_diff [Core_map_intf.Accessors3_with_comparator] |
|
symmetric_diff [Core_map_intf.Accessors3] |
|
symmetric_diff [Core_map_intf.Accessors2] |
|
symmetric_diff [Core_map_intf.Accessors1] |
|
symmetric_diff [Core_map_intf.Accessors_generic] |
|
symmetric_diff [Core_map] |
symmetric_diff t1 t2 ~data_equal returns a list of changes between t1 and t2 .
|
T |
t0 [Tuple_type_intf.Slot] |
|
t1 [Tuple_type_intf.Slot] |
|
t1 [Tuple_type_intf.Slots] |
|
t10 [Tuple_type_intf.Slot] |
|
t10 [Tuple_type_intf.Slots] |
|
t11 [Tuple_type_intf.Slot] |
|
t11 [Tuple_type_intf.Slots] |
|
t12 [Tuple_type_intf.Slots] |
|
t2 [Tuple_type_intf.Slot] |
|
t2 [Tuple_type_intf.Slots] |
|
t3 [Tuple_type_intf.Slot] |
|
t3 [Tuple_type_intf.Slots] |
|
t4 [Tuple_type_intf.Slot] |
|
t4 [Tuple_type_intf.Slots] |
|
t5 [Tuple_type_intf.Slot] |
|
t5 [Tuple_type_intf.Slots] |
|
t6 [Tuple_type_intf.Slot] |
|
t6 [Tuple_type_intf.Slots] |
|
t7 [Tuple_type_intf.Slot] |
|
t7 [Tuple_type_intf.Slots] |
|
t8 [Tuple_type_intf.Slot] |
|
t8 [Tuple_type_intf.Slots] |
|
t9 [Tuple_type_intf.Slot] |
|
t9 [Tuple_type_intf.Slots] |
|
t_of_sexp [Validated_intf.Validated] |
|
t_of_sexp [Validated_intf.Raw] |
|
t_of_sexp [Timing_wheel_intf.Timing_wheel.Config] |
|
t_of_sexp [Timing_wheel_intf.Timing_wheel.Level_bits] |
|
t_of_sexp [Timing_wheel_intf.Interval_num.Span] |
|
t_of_sexp [Timing_wheel_intf.Interval_num] |
|
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 [Total_map.Key] |
|
t_of_sexp [Total_map.S] |
|
t_of_sexp [String_id.S.Stable.V1] |
|
t_of_sexp [Time_ns.Alternate_sexp] |
|
t_of_sexp [Time_ns.Span.Alternate_sexp] |
|
t_of_sexp [Time_ns.Span.Parts] |
|
t_of_sexp [Stack_unit_tests.Debug] |
|
t_of_sexp [Stack_intf.S] |
|
t_of_sexp [Stable_unit_test_intf.Unordered_container_arg] |
|
t_of_sexp [Stable_containers.Hashable.V1.S.Hash_set] |
|
t_of_sexp [Stable_containers.Hashable.V1.S.Table] |
|
t_of_sexp [Source_code_position0.Stable.V1] |
|
t_of_sexp [Source_code_position] |
|
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_sexpable1] |
|
t_of_sexp [Sexpable.Of_sexpable] |
|
t_of_sexp [Set_once] |
|
t_of_sexp [Stable_unit_test_intf.Arg] |
|
t_of_sexp [Result] |
|
t_of_sexp [Ref.Permissioned] |
|
t_of_sexp [Ref] |
|
t_of_sexp [Pool_intf.S.Pointer.Id] |
|
t_of_sexp [Pid] |
|
t_of_sexp [Perms.Stable.V1.Upper_bound] |
|
t_of_sexp [Perms.Stable.V1.Read_write] |
|
t_of_sexp [Perms.Stable.V1.Immutable] |
|
t_of_sexp [Perms.Stable.V1.Write] |
|
t_of_sexp [Perms.Stable.V1.Read] |
|
t_of_sexp [Perms.Upper_bound] |
|
t_of_sexp [Perms.Read_write] |
|
t_of_sexp [Perms.Immutable] |
|
t_of_sexp [Perms.Write] |
|
t_of_sexp [Perms.Read] |
|
t_of_sexp [Percent.Stable.V1] |
|
t_of_sexp [Ordering] |
|
t_of_sexp [Or_error] |
|
t_of_sexp [Option] |
|
t_of_sexp [Nothing0] |
|
t_of_sexp [Nothing.Stable.V1] |
|
t_of_sexp [Month.Stable.V1] |
|
t_of_sexp [Month] |
|
t_of_sexp [Linked_queue] |
|
t_of_sexp [Stable_module_types.S2] |
|
t_of_sexp [Sexpable.S] |
|
t_of_sexp [Int_intf.S] |
|
t_of_sexp [Int_intf.Hexable.Hex] |
|
t_of_sexp [Stable_module_types.S0] |
|
t_of_sexp [Info] |
|
t_of_sexp [Identifiable.S] |
|
t_of_sexp [Host_and_port.Stable.V1] |
|
t_of_sexp [Hash_set_intf.S] |
|
t_of_sexp [Hash_set.Poly] |
|
t_of_sexp [Fqueue.Stable.V1] |
|
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 [Flags_intf.S] |
|
t_of_sexp [Fdeque.Stable.V1] |
|
t_of_sexp [Fdeque] |
|
t_of_sexp [Either_intf.S] |
|
t_of_sexp [Doubly_linked] |
|
t_of_sexp [Deque] |
|
t_of_sexp [Decimal] |
|
t_of_sexp [Day_of_week.Stable.V1] |
|
t_of_sexp [Day_of_week] |
|
t_of_sexp [Core_string] |
|
t_of_sexp [Core_sexp.With_text] |
|
t_of_sexp [Core_sexp.Sexp_maybe] |
|
t_of_sexp [Core_sexp] |
|
t_of_sexp [Core_set_intf.S0.Tree] |
|
t_of_sexp [Core_set_intf.S0.Elt] |
|
t_of_sexp [Core_set_intf.S0] |
|
t_of_sexp [Core_set_intf.Elt_binable] |
|
t_of_sexp [Core_set_intf.Elt] |
|
t_of_sexp [Core_set.Poly.Tree] |
|
t_of_sexp [Core_set.Poly] |
|
t_of_sexp [Core_queue] |
|
t_of_sexp [Core_map_intf.S.Tree] |
|
t_of_sexp [Core_map_intf.S] |
|
t_of_sexp [Core_map_intf.Key_binable] |
|
t_of_sexp [Core_map_intf.Key] |
|
t_of_sexp [Core_map.Poly.Tree] |
|
t_of_sexp [Core_map.Poly] |
|
t_of_sexp [Core_list.Assoc] |
|
t_of_sexp [Core_list] |
|
t_of_sexp [Stable_module_types.S1] |
|
t_of_sexp [Core_lazy] |
|
t_of_sexp [Core_hashtbl_intf.Hashtbl.Poly] |
|
t_of_sexp [Core_hashtbl_intf.S] |
|
t_of_sexp [Core_hashtbl_intf.Key] |
|
t_of_sexp [Core_gc.Control] |
|
t_of_sexp [Core_gc.Stat] |
|
t_of_sexp [Core_char] |
|
t_of_sexp [Core_array.Permissioned.Float] |
|
t_of_sexp [Core_array.Permissioned.Int] |
|
t_of_sexp [Core_array.Permissioned] |
|
t_of_sexp [Core_array.Float] |
|
t_of_sexp [Core_array.Int] |
|
t_of_sexp [Core_array] |
|
t_of_sexp [Container_unit_tests.Test_generic] |
|
t_of_sexp [Constrained_float.S] |
|
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 [Bag] |
|
t_of_sexp_allow_nan_and_inf [Percent] |
|
tag [Or_error] |
tag t string is Result.map_error t ~f:(fun e -> Error.tag e string) .
|
tag [Info] |
Add a string to the front.
|
tag_arg [Or_error] |
|
tag_arg [Info] |
Add a string and some other data in the form of an s-expression at the front.
|
take [Sequence] |
take t n produces the first n elements of t .
|
take [Core_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_while [Sequence] |
take_while t ~f produces the longest prefix of t for which f applied to each
element is true .
|
take_while [Core_list] |
take_while l ~f returns the longest prefix of l for which f is true .
|
test [Quickcheck_intf.Quickcheck] |
test ~seed ~trials ~attempts ~sexp_of ~examples gen ~f is like iter , with
optional concrete examples that are tested before values from gen , and
additional information provided on failure.
|
test [Binary_packing] |
|
test_can_generate [Quickcheck_intf.Quickcheck] |
test_can_generate ~seed ~trials ~attempts ~sexp_of gen ~f is useful for testing
Generator.t values, to make sure they can generate useful examples.
|
test_no_duplicates [Quickcheck_intf.Quickcheck] |
test_no_duplicates ~seed ~trials ~attempts ~sexp_of gen ~by is useful for testing
Generator.t values, to make sure they do not create duplicate values.
|
tests [Stable_unit_test_intf.Unordered_container_arg] |
|
tests [Stable_unit_test_intf.Arg] |
|
text [Core_sexp.With_text] |
|
tl [Sequence] |
tl t and tl_eagerly_exn t immediately evaluate the first element of t and return
the unevaluated tail.
|
tl [Core_list] |
|
tl_eagerly_exn [Sequence] |
|
tl_exn [Core_list] |
Return the given list without its first element.
|
to_alist [Univ_map_intf.S1] |
|
to_alist [Univ_map_intf.S] |
|
to_alist [Total_map] |
|
to_alist [Hash_heap.S] |
|
to_alist [Hash_heap.Make] |
|
to_alist [Core_map_intf.Accessors3_with_comparator] |
|
to_alist [Core_map_intf.Accessors3] |
|
to_alist [Core_map_intf.Accessors2] |
|
to_alist [Core_map_intf.Accessors1] |
|
to_alist [Core_map_intf.Accessors_generic] |
|
to_alist [Core_map] |
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 [Stack_unit_tests.Debug] |
|
to_array [Linked_queue] |
|
to_array [Hash_queue.Make] |
|
to_array [Core_set] |
|
to_array [Container_unit_tests.Test_generic] |
|
to_array [Container_intf.Container] |
|
to_array [Container_intf.Generic_phantom] |
|
to_array [Container_intf.Generic] |
|
to_array [Container_intf.S1_permissions] |
|
to_array [Container_intf.S1_phantom_invariant] |
|
to_array [Container_intf.S1] |
|
to_array [Container_intf.S0_phantom] |
|
to_array [Container_intf.S0] |
|
to_array_id [Core_array.Permissioned] |
|
to_bigstring [Substring_intf.S] |
these two functions perform a copy
|
to_bigstring [Make_substring.F] |
|
to_bigstring [Binable0] |
|
to_bigstring [Binable] |
|
to_bp [Percent] |
|
to_bp_int [Percent] |
rounds down
|
to_day [Time_ns.Span] |
|
to_exn [Info] |
|
to_float [Floatable.S] |
|
to_float [Core_int64] |
|
to_hr [Time_ns.Span] |
|
to_info [Error] |
|
to_int [Pid] |
|
to_int [Month] |
to_int t returns an int in 1,2,...12.
|
to_int [Float_intf.S] |
|
to_int [Day_of_week] |
|
to_int [Core_nativeint] |
|
to_int [Core_int64] |
|
to_int [Core_int63] |
|
to_int [Core_int32] |
|
to_int [Core_int] |
|
to_int [Core_char] |
Return the ASCII code of the argument.
|
to_int32 [Core_nativeint] |
|
to_int32 [Core_int64] |
|
to_int32 [Core_int32] |
|
to_int32 [Core_int] |
|
to_int32_exn [Int_intf.S] |
|
to_int32_exn [Core_nativeint] |
|
to_int63 [Timing_wheel_intf.Interval_num.Span] |
|
to_int63 [Timing_wheel_intf.Interval_num] |
|
to_int63 [Pool_intf.S.Pointer.Id] |
|
to_int63_ns [Time_ns.Span] |
Fast, implemented as the identity function.
|
to_int63_ns_since_epoch [Time_ns] |
|
to_int64 [Int_intf.S] |
|
to_int64 [Float_intf.S] |
|
to_int64_preserve_order [Float_intf.S] |
An order-preserving bijection between all floats except for nans, and all int64s
with absolute value smaller than or equal to 2**63 - 2**52 .
|
to_int64_preserve_order_exn [Float_intf.S] |
returns nan if the absolute value of the argument is too large
|
to_int_exn [Timing_wheel_intf.Interval_num.Span] |
|
to_int_exn [Timing_wheel_intf.Interval_num] |
|
to_int_exn [Intable.S] |
|
to_int_exn [Flags_intf.S] |
|
to_int_exn [Core_nativeint] |
|
to_int_ns [Time_ns.Span] |
Will raise on 32-bit platforms.
|
to_int_ns_since_epoch [Time_ns] |
Will raise on 32-bit platforms.
|
to_int_sec [Time_ns.Span] |
|
to_list [Stack_unit_tests.Debug] |
|
to_list [Sequence] |
|
to_list [Linked_queue] |
|
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 [Fheap] |
The elements of to_list t are not in any particular order.
|
to_list [Core_set] |
to_list and to_array produce sequences sorted in ascending order according to the
comparator.
|
to_list [Core_gc.Control.Fields] |
|
to_list [Core_gc.Stat.Fields] |
|
to_list [Container_unit_tests.Test_generic] |
|
to_list [Container_intf.Container] |
|
to_list [Container_intf.Generic_phantom] |
|
to_list [Container_intf.Generic] |
|
to_list [Container_intf.S1_permissions] |
|
to_list [Container_intf.S1_phantom_invariant] |
|
to_list [Container_intf.S1] |
|
to_list [Container_intf.S0_phantom] |
|
to_list [Container_intf.S0] |
|
to_list_rev [Sequence] |
to_list_rev t returns a list of the elements of t , in reverse order.
|
to_list_rev [Core_string] |
Returns the reversed list of characters contained in a list.
|
to_map [Total_map] |
|
to_map [Core_set_intf.Accessors2_with_comparator] |
|
to_map [Core_set_intf.Accessors2] |
|
to_map [Core_set_intf.Accessors1] |
|
to_map [Core_set_intf.Accessors0] |
|
to_map [Core_set_intf.Accessors_generic] |
|
to_map [Core_set] |
Convert a set to or from a map.
|
to_min [Time_ns.Span] |
|
to_ms [Time_ns.Span] |
|
to_mult [Percent] |
|
to_nativeint [Core_nativeint] |
|
to_nativeint [Core_int64] |
|
to_nativeint [Core_int32] |
|
to_nativeint [Core_int] |
|
to_nativeint_exn [Int_intf.S] |
|
to_ns [Time_ns.Span] |
|
to_option [Either_intf.Focused] |
|
to_padded_compact_string [Float_intf.S] |
Produce a lossy compact string representation of the float.
|
to_parts [Time_ns.Span] |
|
to_percentage [Percent] |
|
to_ref [Ref.Permissioned] |
|
to_sec [Time_ns.Span] |
|
to_sequence [Fheap] |
to_sequence t is a sequence of the elements of t in ascending order.
|
to_sequence [Doubly_linked] |
|
to_sequence [Core_set_intf.Accessors2_with_comparator] |
|
to_sequence [Core_set_intf.Accessors2] |
|
to_sequence [Core_set_intf.Accessors1] |
|
to_sequence [Core_set_intf.Accessors0] |
|
to_sequence [Core_set_intf.Accessors_generic] |
|
to_sequence [Core_set] |
to_sequence t converts the set t to a sequence of the elements between
greater_or_equal_to and less_or_equal_to inclusive in the order indicated by
order .
|
to_sequence [Core_map_intf.Accessors3_with_comparator] |
|
to_sequence [Core_map_intf.Accessors3] |
|
to_sequence [Core_map_intf.Accessors2] |
|
to_sequence [Core_map_intf.Accessors1] |
|
to_sequence [Core_map_intf.Accessors_generic] |
|
to_sequence [Core_map] |
to_sequence ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t gives a
sequence of key-value pairs between keys_less_or_equal_to and
keys_greater_or_equal_to inclusive, presented in order .
|
to_sequence [Core_array.Permissioned] |
|
to_sequence [Core_array] |
to_sequence t converts t to a sequence.
|
to_sequence_immutable [Core_array.Permissioned] |
to_sequence_immutable t converts t to a sequence.
|
to_sequence_mutable [Core_array.Permissioned] |
|
to_sequence_mutable [Core_array] |
to_sequence_mutable t converts t to a sequence.
|
to_sexp [Type_equal.Id] |
|
to_span_since_epoch [Time_ns] |
|
to_string [Source_code_position0] |
|
to_string [Source_code_position] |
to_string t converts t to the form "FILE:LINE:COL" .
|
to_string [Sexpable.To_stringable] |
|
to_string [Rope] |
takes time proportional to n+m where n is the total size of the result and m
is the number of strings being concatenated
|
to_string [Substring_intf.S] |
|
to_string [Make_substring.F] |
|
to_string [Stringable.S] |
|
to_string [Int_set] |
|
to_string [Exn] |
|
to_string [Core_printexc] |
|
to_string [Core_list] |
|
to_string [Core_bin_prot.Writer] |
|
to_string [Binable] |
|
to_string [Bigstring] |
to_string ?pos ?len bstr
|
to_string [Backtrace] |
|
to_string_hum [Int_intf.S] |
delimiter is underscore by default
|
to_string_hum [Int_intf.Hexable.Hex] |
|
to_string_hum [Int_conversions.Make] |
|
to_string_hum [Info] |
to_string_hum forces the lazy message, which 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 [Byte_units] |
to_string_hum ?measure t returns a string representation of t .
|
to_string_hum_deprecated [Info] |
old version (pre 109.61) of to_string_hum that some applications rely on.
|
to_string_long [Day_of_week] |
Capitalized full day names rather than all-caps 3-letter abbreviations
|
to_string_mach [Info] |
to_string_mach t outputs t as a sexp on a single-line.
|
to_string_mach [Exn] |
|
to_string_round_trippable [Float_intf.S] |
Like to_string , but guaranteed to be round-trippable.
|
to_tree [Core_set_intf.Accessors2_with_comparator] |
|
to_tree [Core_set_intf.Accessors2] |
|
to_tree [Core_set_intf.Accessors1] |
|
to_tree [Core_set_intf.Accessors0] |
|
to_tree [Core_set_intf.Accessors_generic] |
|
to_tree [Core_set] |
|
to_tree [Core_map_intf.Accessors3_with_comparator] |
|
to_tree [Core_map_intf.Accessors3] |
|
to_tree [Core_map_intf.Accessors2] |
|
to_tree [Core_map_intf.Accessors1] |
|
to_tree [Core_map_intf.Accessors_generic] |
|
to_tree [Core_map] |
|
to_us [Time_ns.Span] |
|
top [Stack_unit_tests.Test] |
|
top [Stack_unit_tests.Debug] |
|
top [Stack_intf.S] |
top t returns Some a , where a is the top of t , unless is_empty t , in which
case top returns None .
|
top [Heap_intf.S] |
returns the top (i.e., smallest) element of the heap
|
top [Hash_heap.S] |
|
top [Hash_heap.Make] |
|
top [Fqueue] |
like top_exn , but returns result optionally, without exception, Complexity: O(1)
|
top [Fheap] |
This returns the top (i.e.
|
top_exn [Stack_unit_tests.Test] |
|
top_exn [Stack_unit_tests.Debug] |
|
top_exn [Stack_intf.S] |
|
top_exn [Heap_intf.S] |
|
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 [Fheap] |
|
top_heap_words [Core_gc.Stat.Fields] |
|
top_heap_words [Core_gc.Stat] |
|
top_heap_words [Core_gc] |
|
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 [Core_string] |
tr target replacement s replaces every instance of target in s with
replacement .
|
tr_inplace [Core_string] |
tr_inplace target replacement s destructively modifies s (in place!)
replacing every instance of target in s with replacement .
|
trans [Type_equal] |
|
transfer [Linked_queue] |
transfer ~src ~dst adds all of the elements of src to the end of dst , then
clears src .
|
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 [Bag] |
transfer ~src ~dst moves all of the elements from src to dst in constant
time.
|
transpose [Core_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 [Core_list] |
transpose_exn transposes the rows and columns of its argument, throwing an exception
if the list is not rectangular.
|
trd3 [Common] |
|
true_ [Blang] |
|
truncate [Obj_array] |
truncate t ~len shortens t 's length to len .
|
truncate [Core_array.Permissioned] |
|
truncate [Core_array] |
truncate t ~len drops length t - len elements from the end of t , changing t
so that length t = len afterwards.
|
truncate [Common] |
|
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] |
|
tune [Core_gc] |
Adjust the specified GC parameters.
|
tuple [Host_and_port] |
|
tuple2 [Type_immediacy.Never] |
|
tuple2 [Type_equal] |
|
tuple2 [Raw_quickcheck_observer] |
|
tuple2 [Quickcheck_generator] |
|
tuple3 [Type_immediacy.Never] |
|
tuple3 [Raw_quickcheck_observer] |
|
tuple3 [Quickcheck_generator] |
|
tuple4 [Type_immediacy.Never] |
|
tuple4 [Raw_quickcheck_observer] |
|
tuple4 [Quickcheck_generator] |
|
tuple5 [Type_immediacy.Never] |
|
tuple5 [Raw_quickcheck_observer] |
|
tuple5 [Quickcheck_generator] |
|
tuple6 [Raw_quickcheck_observer] |
|
tuple6 [Quickcheck_generator] |
|
type_id_name [Univ] |
|
type_id_uid [Univ] |
|
typename_of_outer [Float_intf.S] |
|
typename_of_sexp_array [Std_internal] |
|
typename_of_sexp_bool [Std_internal] |
|
typename_of_sexp_list [Std_internal] |
|
typename_of_sexp_opaque [Std_internal] |
|
typename_of_sexp_option [Std_internal] |
|
typename_of_t [Unit] |
|
typename_of_t [Tuple.T3] |
|
typename_of_t [Tuple.T2] |
|
typename_of_t [Time_ns.Span] |
|
typename_of_t [Time_ns] |
|
typename_of_t [Ref] |
|
typename_of_t [Option] |
|
typename_of_t [Int_intf.S] |
|
typename_of_t [Int_intf.Hexable.Hex] |
|
typename_of_t [Float_intf.S] |
|
typename_of_t [Flags_intf.S] |
|
typename_of_t [Either_intf.S] |
|
typename_of_t [Core_string] |
|
typename_of_t [Core_list] |
|
typename_of_t [Core_lazy] |
|
typename_of_t [Core_char] |
|
typename_of_t [Core_array] |
|
typename_of_t [Bool] |
|
typerep_of_outer [Float_intf.S] |
|
typerep_of_sexp_array [Std_internal] |
|
typerep_of_sexp_bool [Std_internal] |
|
typerep_of_sexp_list [Std_internal] |
|
typerep_of_sexp_opaque [Std_internal] |
|
typerep_of_sexp_option [Std_internal] |
|
typerep_of_t [Unit] |
|
typerep_of_t [Tuple.T3] |
|
typerep_of_t [Tuple.T2] |
|
typerep_of_t [Time_ns.Span] |
|
typerep_of_t [Time_ns] |
|
typerep_of_t [Ref] |
|
typerep_of_t [Option] |
|
typerep_of_t [Int_intf.S] |
|
typerep_of_t [Int_intf.Hexable.Hex] |
|
typerep_of_t [Float_intf.S] |
|
typerep_of_t [Flags_intf.S] |
|
typerep_of_t [Either_intf.S] |
|
typerep_of_t [Core_string] |
|
typerep_of_t [Core_list] |
|
typerep_of_t [Core_lazy] |
|
typerep_of_t [Core_char] |
|
typerep_of_t [Core_array] |
|
typerep_of_t [Bool] |
|
U |
uid [Type_equal.Id] |
|
uncapitalize [Core_string] |
|
unchecked_iter [Doubly_linked] |
unchecked_iter t ~f behaves like iter t ~f except that f is allowed to modify
t .
|
unchecked_iter [Bag] |
unchecked_iter t ~f behaves like iter t ~f except that f is allowed to modify
t .
|
uncurry [Tuple.T3] |
|
uncurry [Tuple.T2] |
|
unescape [Core_string.Escaping] |
unescape ~escape_char is defined as unescape_gen_exn ~map:[] ~escape_char
|
unescape_gen [Core_string.Escaping] |
|
unescape_gen_exn [Core_string.Escaping] |
unescape_gen_exn is the inverse operation of escape_gen_exn .
|
unfold [Sequence] |
unfold ~init f is a simplified version of unfold_step that does not allow
Skip .
|
unfold_step [Sequence] |
unfold_step ~init ~f constructs a sequence by giving an initial state init and a
function f explaining how to continue the next step from a given state.
|
unfold_with [Sequence] |
unfold_with t ~init ~f folds a state through the sequence t to create a new
sequence
|
unfold_with_and_finish [Sequence] |
unfold_with_and_finish t ~init ~running_step ~inner_finished ~finishing_step folds a
state through the sequence t to create a new sequence.
|
unimplemented [Or_error] |
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 [Quickcheck_generator] |
Combine arbitary generators, weighted equally.
|
union [Core_set_intf.Accessors2_with_comparator] |
|
union [Core_set_intf.Accessors2] |
|
union [Core_set_intf.Accessors1] |
|
union [Core_set_intf.Accessors0] |
|
union [Core_set_intf.Accessors_generic] |
|
union [Core_set] |
union t1 t2 returns the union of the two sets.
|
union_list [Core_set_intf.Creators2_with_comparator] |
|
union_list [Core_set_intf.Creators2] |
|
union_list [Core_set_intf.Creators1] |
|
union_list [Core_set_intf.Creators0] |
|
union_list [Core_set_intf.Creators_generic] |
|
union_list [Core_set] |
union ~comparator list returns the union of all the sets in list .
|
unit [Type_immediacy.Always] |
|
unit [Quickcheck_observer] |
Observers for basic types.
|
unit [Quickcheck_generator] |
|
unit [Memo] |
efficient special case for argument type unit
|
unmap [Raw_quickcheck_observer] |
unmap t ~f ~f_sexp applies f to values before observing them using t .
|
unmarshal [Bigstring_marshal] |
unmarshals a value from the bigstring and/or returns the index of the byte in the
bigstring right after the unmarshalled value.
|
unmarshal_next [Bigstring_marshal] |
|
unordered_append [Core_list] |
List.unordered_append l1 l2 has the same elements as l1 @ l2 , but in some
unspecified order.
|
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_into [Unpack_buffer] |
unpack_into t q unpacks all the values that it can from t and enqueues them in
q .
|
unpack_iter [Unpack_buffer] |
unpack_iter t ~f unpacks all the values that it can from t , calling f on each
value as it's unpacked.
|
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_int_big_endian [Binary_packing] |
|
unpack_signed_64_int_little_endian [Binary_packing] |
|
unpack_signed_64_little_endian [Binary_packing] |
|
unpack_signed_8 [Binary_packing] |
|
unpack_tail_padded_fixed_string [Binary_packing] |
Decode the fixed length tail padded string having length len from buf starting at
pos .
|
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] |
|
unreachable_code [Nothing] |
Because there are no values of type Nothing.t , a piece of code that has a value of
type Nothing.t must be unreachable.
|
unsafe_blit [Flat_array_debug.Debug] |
|
unsafe_blit [Core_array.Permissioned.Float] |
|
unsafe_blit [Core_array.Permissioned.Int] |
|
unsafe_blit [Core_array.Float] |
|
unsafe_blit [Core_array.Int] |
|
unsafe_blit [Blit_intf.S_distinct] |
|
unsafe_blit [Blit_intf.S1_permissions] |
|
unsafe_blit [Blit_intf.S1] |
|
unsafe_blit [Blit_intf.S_permissions] |
|
unsafe_blit [Blit_intf.S] |
|
unsafe_clear_if_pointer [Obj_array] |
unsafe_clear_if_pointer t i prevents t.(i) from pointing to anything to prevent
space leaks.
|
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_free [Pool_intf.S] |
unsafe_free t pointer frees the tuple pointed to by pointer without checking
pointer_is_valid
|
unsafe_get [Pool_intf.S] |
|
unsafe_get [Obj_array] |
|
unsafe_get [Flat_queue] |
|
unsafe_get [Flat_array_debug.Debug] |
|
unsafe_get [Flat_array] |
|
unsafe_get [Core_string] |
|
unsafe_get [Core_array.Permissioned] |
|
unsafe_get [Core_array] |
Unsafe version of get .
|
unsafe_get_int16_be [Bigstring] |
|
unsafe_get_int16_le [Bigstring] |
16 bit methods
|
unsafe_get_int32_be [Bigstring] |
|
unsafe_get_int32_le [Bigstring] |
32 bit methods
|
unsafe_get_int32_t_be [Bigstring] |
|
unsafe_get_int32_t_le [Bigstring] |
32 bit methods w/ full precision
|
unsafe_get_int64_be_exn [Bigstring] |
|
unsafe_get_int64_be_trunc [Bigstring] |
|
unsafe_get_int64_le_exn [Bigstring] |
|
unsafe_get_int64_le_trunc [Bigstring] |
|
unsafe_get_int64_t_be [Bigstring] |
|
unsafe_get_int64_t_le [Bigstring] |
64 bit methods w/ full precision
|
unsafe_get_int8 [Bigstring] |
|
unsafe_get_uint16_be [Bigstring] |
|
unsafe_get_uint16_le [Bigstring] |
|
unsafe_get_uint32_be [Bigstring] |
|
unsafe_get_uint32_le [Bigstring] |
|
unsafe_get_uint8 [Bigstring] |
|
unsafe_input_value [In_channel] |
|
unsafe_of_int [Core_char] |
|
unsafe_set [Pool_intf.S] |
|
unsafe_set [Obj_array] |
|
unsafe_set [Flat_queue] |
|
unsafe_set [Flat_array_debug.Debug] |
|
unsafe_set [Flat_array] |
|
unsafe_set [Core_string] |
|
unsafe_set [Core_array.Permissioned] |
|
unsafe_set [Core_array] |
Unsafe version of set .
|
unsafe_set_assuming_currently_int [Obj_array] |
unsafe_set_assuming_currently_int t i obj sets index i of t to obj , but only
works correctly if Obj.is_int (get t i) .
|
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_int8 [Bigstring] |
|
unsafe_set_int_assuming_currently_int [Obj_array] |
|
unsafe_set_uint16_be [Bigstring] |
|
unsafe_set_uint16_le [Bigstring] |
|
unsafe_set_uint32_be [Bigstring] |
|
unsafe_set_uint32_le [Bigstring] |
|
unsafe_set_uint8 [Bigstring] |
|
unstage [Staged] |
|
unstage [Common] |
|
until_empty [Stack_unit_tests.Test] |
|
until_empty [Stack_unit_tests.Debug] |
|
until_empty [Stack_intf.S] |
until_empty t f repeatedly pops an element a off of t and runs f a , 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 [Core_list] |
Transform a list of pairs into a pair of lists:
unzip [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]) .
|
update [Heap.Removable] |
update t token v is shorthand for remove t token; add_removable t v
|
updated_gen [Raw_quickcheck_generator.Choice] |
updated_gen t ~keep produces a generator representing a subset of the probability
distribution from which t was constructed.
|
uppercase [Core_string] |
|
uppercase [Core_char] |
Convert the given character to its equivalent uppercase character.
|
uw [Common] |
Option handling
|
V |
valid_or_error [Validate] |
Returns an error if validation fails.
|
validate [Validated_intf.Raw] |
|
validate [Percent] |
|
validate [Option] |
|
validate [Core_map_intf.Accessors3_with_comparator] |
|
validate [Core_map_intf.Accessors3] |
|
validate [Core_map_intf.Accessors2] |
|
validate [Core_map_intf.Accessors1] |
|
validate [Core_map_intf.Accessors_generic] |
|
validate [Core_map] |
|
validate [Core_hashtbl_intf.Accessors] |
|
validate_binio_deserialization [Validated_intf.Raw_binable] |
validate_binio_deserialization controls whether when the binio representation of a
value is deserialized, the resulting value is validated.
|
validate_bound [Comparable_intf.Validate] |
|
validate_lbound [Comparable_intf.Validate] |
|
validate_negative [Comparable_intf.With_zero] |
|
validate_non_negative [Comparable_intf.With_zero] |
|
validate_non_positive [Comparable_intf.With_zero] |
|
validate_ordinary [Float_intf.S] |
validate_ordinary fails if class is Nan or Infinite .
|
validate_positive [Comparable_intf.With_zero] |
|
validate_ubound [Comparable_intf.Validate] |
|
value [Timing_wheel_intf.Timing_wheel.Priority_queue.Elt] |
|
value [Timing_wheel_intf.Timing_wheel.Alarm] |
|
value [Raw_quickcheck_generator.Choice] |
value t produces the value chosen from original_gen t .
|
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 [Either_intf.S] |
|
value [Either_intf.Focused] |
|
value [Doubly_linked.Elt] |
|
value [Core_sexp.With_text] |
|
value [Bag.Elt] |
|
value_as_int [Type_immediacy.Sometimes] |
|
value_as_int [Type_immediacy.Always] |
|
value_as_int [Type_immediacy] |
|
value_as_int_exn [Type_immediacy.Sometimes] |
|
value_as_int_exn [Type_immediacy] |
|
value_exn [Option] |
value_exn (Some x) = x .
|
value_exn [Heap.Removable.Elt] |
value_exn t return the value in the heap controlled by this token if the value
is still in the heap.
|
value_is_int [Type_immediacy.Sometimes] |
|
value_is_int [Type_immediacy] |
|
value_map [Option] |
value_map ~default ~f is the same as function Some x -> f x | None -> default
|
value_map [Either_intf.S] |
|
values [Blang] |
values t forms the list containing every v
for which Base v is a subexpression of t
|
variant2 [Raw_quickcheck_observer] |
|
variant2 [Quickcheck_generator] |
|
variant3 [Quickcheck_observer] |
|
variant3 [Quickcheck_generator] |
|
variant4 [Quickcheck_observer] |
|
variant4 [Quickcheck_generator] |
|
variant5 [Quickcheck_observer] |
|
variant5 [Quickcheck_generator] |
|
variant6 [Quickcheck_observer] |
|
variant6 [Quickcheck_generator] |
|
verbose [Core_gc.Control.Fields] |
|
verbose [Core_gc.Control] |
|
view [Univ] |
view t provides access to the GADT representation of t .
|
volatile_contents [Bigbuffer] |
Return the actual underlying bigstring used by this bigbuffer.
|
W |
weekdays [Day_of_week] |
Mon; Tue; Wed; Thu; Fri
|
weekends [Day_of_week] |
Sat; Sun
|
weighted_union [Raw_quickcheck_observer] |
Nondeterministic observer.
|
weighted_union [Raw_quickcheck_generator] |
weighted_union alist produces a generator that combines the distributions of each
t in alist with the associated weights, which must be finite positive floating
point values.
|
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_return [With_return] |
|
with_return [Either_intf.Focused] |
|
with_return [Common] |
|
with_return_option [With_return] |
Note that with_return_option allocates ~5 words more than equivalent with_return
call
|
with_return_option [Common] |
|
witness [Type_immediacy.Never.For_all_parameters_S5] |
|
witness [Type_immediacy.Never.For_all_parameters_S4] |
|
witness [Type_immediacy.Never.For_all_parameters_S3] |
|
witness [Type_immediacy.Never.For_all_parameters_S2] |
|
witness [Type_immediacy.Never.For_all_parameters_S1] |
|
witness [Type_immediacy.Sometimes.For_all_parameters_S5] |
|
witness [Type_immediacy.Sometimes.For_all_parameters_S4] |
|
witness [Type_immediacy.Sometimes.For_all_parameters_S3] |
|
witness [Type_immediacy.Sometimes.For_all_parameters_S2] |
|
witness [Type_immediacy.Sometimes.For_all_parameters_S1] |
|
witness [Type_immediacy.Always.For_all_parameters_S5] |
|
witness [Type_immediacy.Always.For_all_parameters_S4] |
|
witness [Type_immediacy.Always.For_all_parameters_S3] |
|
witness [Type_immediacy.Always.For_all_parameters_S2] |
|
witness [Type_immediacy.Always.For_all_parameters_S1] |
|
word_size [Word_size] |
Returns the word size of this program, not necessarily of the OS
|
words [Byte_units] |
|
write_all [Out_channel] |
|
write_bin_prot [Bigstring] |
write_bin_prot t writer a writes a to t starting at pos , and returns the index
in t immediately after the last byte written.
|
write_lines [Out_channel] |
The first argument of these is the file name to write to.
|
write_of_sexp [Perms.Export] |
|
Y |
yield [Sequence.Generator] |
|
Z |
zero [Timing_wheel_intf.Interval_num.Span] |
|
zero [Timing_wheel_intf.Interval_num] |
|
zero [Time_ns.Span] |
|
zero [Int_math.T] |
|
zero [Int_intf.S.O] |
|
zero [Int_intf.S] |
|
zero [Float_intf.S.O] |
|
zero [Float_intf.S] |
|
zero [Commutative_group.S] |
|
zero [Bucket.Contents] |
|
zip [Sequence] |
Transforms a pair of sequences into a sequence of pairs.
|
zip [Core_list] |
Transform a pair of lists into an (optional) list of pairs:
zip [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)] .
|
zip_exn [Core_list] |
|
zip_full [Sequence] |
zip_full is like zip , but if one sequence ends before the other, then it keeps
producing elements from the other sequence until it has ended as well.
|