Index of values


( * ) [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 registered.
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 nth 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]
Same as Core_set.to_list.
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 ith 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 ith 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 normalized 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 normalized 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_wheels.
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 ith 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.