Index of values


( * ) [Int_intf.S]
( * ) [Float_intf.S]
(!) [Ref.Permissioned]
get and (!) are two names for the same function.
(!) [Ref]
(!=) [Common]
(%) [Core_int.Infix]
mod and div operators that have the right behavior on negative numbers, that is, x % y always returns a value between 0 and y-1.
(&) [Common]
(+) [Int_intf.S]
(+) [Float_intf.S]
(+) [Flags_intf.S]
(+) [Commutative_group.S]
(+) [Byte_units.Infix]
( / ) t mul scales t by 1/mul
(+) [Bucket.Contents]
(-) [Int_intf.S]
(-) [Float_intf.S]
(-) [Flags_intf.S]
(-) [Commutative_group.S]
(-) [Byte_units.Infix]
(-) [Bucket.Contents]
(/%) [Core_int.Infix]
(/) [Int_intf.S]
(/) [Float_intf.S]
(/) [Byte_units.Infix]
(//) [Core_int.Infix]
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]
(<.) [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.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.Infix2]
(>>=) [Monad.Infix]
t >>= f returns a computation that sequences the computations represented by two monad elements.
(>>|) [Monad.Infix2]
(>>|) [Monad.Infix]
t >>| f is t >>= (fun a -> return (f a)).
(@) [Core_list.Infix]
(|!) [Fn]
A 'pipe' operator.
(|!) [Common]
Functions from fn.ml
(|>) [Fn]
A pipe operator, equivalent to |!, but this notation is more broadly accepted
(|>) [Common]
__bin_read_decimal__ [Std_kernel]
__bin_read_immutable__ [Common]
__bin_read_no_raise__ [Core_sexp]
__bin_read_outer__ [Float_intf.S]
__bin_read_read_only__ [Common]
__bin_read_read_write__ [Common]
__bin_read_sexp_array__ [Std_internal]
__bin_read_sexp_bool__ [Std_internal]
__bin_read_sexp_list__ [Std_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__ [Unique_id_intf.Id]
__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__ [String_id.Stable.V1]
__bin_read_t__ [Stable_internal.Sexp]
__bin_read_t__ [Stable_containers.Map.V1]
__bin_read_t__ [Stable_containers.Hash_set.V1]
__bin_read_t__ [Stable_containers.Hashtbl.V1]
__bin_read_t__ [Stable_containers.Set.V1]
__bin_read_t__ [Source_code_position]
__bin_read_t__ [Source_code_position0]
__bin_read_t__ [Set_once]
__bin_read_t__ [Stable_unit_test_intf.Arg]
__bin_read_t__ [Result.Stable.V1]
__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__ [Or_error]
__bin_read_t__ [Ordering]
__bin_read_t__ [Option]
__bin_read_t__ [Nothing.Stable.V1]
__bin_read_t__ [Nothing0]
__bin_read_t__ [Month.Stable.V1]
__bin_read_t__ [Month]
__bin_read_t__ [Int_intf.S]
__bin_read_t__ [Info]
__bin_read_t__ [Identifiable.S]
__bin_read_t__ [Host_and_port.Stable.V1]
__bin_read_t__ [T.T_bin]
__bin_read_t__ [Fqueue]
__bin_read_t__ [Float_intf.S.Terse]
__bin_read_t__ [Float_intf.S.Class]
__bin_read_t__ [Dequeue]
__bin_read_t__ [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.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.Poly]
__bin_read_t__ [Core_queue]
__bin_read_t__ [Core_map.Poly]
__bin_read_t__ [Core_list.Assoc]
__bin_read_t__ [Core_list]
__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.Float]
__bin_read_t__ [Core_array.Int]
__bin_read_t__ [Core_array]
__bin_read_t__ [Constrained_float.S]
__bin_read_t__ [Comparator.Pre_binable]
__bin_read_t__ [Byte_units.Measure]
__bin_read_t__ [Byte_units]
__bin_read_t__ [Bucket.S]
__bin_read_t__ [Bucket.Contents]
__bin_read_t__ [Bucket.Make]
__bin_read_t__ [Bounded_int_table.With_key]
__bin_read_t__ [Bool]
__bin_read_t__ [Blang.Stable.V1]
__bin_read_t__ [Blang]
__bin_read_t__ [Bigstring]
__bin_read_t_hum__ [Source_code_position]
__bin_read_t_hum__ [Source_code_position0]
__decimal_of_sexp__ [Std_kernel]
__t_of_sexp__ [Source_code_position0]
__t_of_sexp__ [Nothing0]
__t_of_sexp__ [Byte_units.Measure]
_make_sure_pool_pointer_is_an_int [Std_kernel]
_squelch_unused_module_warning_ [Std]
_squelch_unused_module_warning_ [No_polymorphic_compare]
_squelch_unused_module_warning_ [Comparable_intf.S_common.Replace_polymorphic_compare]

A
abs [Int_intf.S]
abs [Float_intf.S]
abs_float [Common]
add [Univ_map.Multi]
add [Univ_map.With_fold]
add [Univ_map]
add [Int_set]
add t i add i to the set
add [Heap_intf.S]
add [Hash_set_intf.Accessors]
add [Float_intf.S]
add [Core_set]
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_map]
returns a new map with the specified new binding; if the key was already bound, its previous binding disappears.
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_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_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]
add_exn [Core_hashtbl_intf.Accessors]
add_exn [Bounded_int_table]
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_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_hashtbl_intf.Accessors]
add_multi t ~key ~data if key is present in the table then cons data on the list, otherwise add key with a single element list.
add_range [Int_set]
add_range t i j add all the numbers between i and j (inclusive) to the set.
add_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.
align [Core_arg]
Align the documentation strings by inserting spaces at the first space, according to the length of the keyword.
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 [Pretty_printer]
all () returns all pretty printers that have been registered.
all [Month]
all [Monad.S2]
all [Monad.Make2]
all [Monad.Make]
all [Monad.S]
all_ignore [Monad.S2]
all_ignore [Monad.Make2]
all_ignore [Monad.Make]
all_ignore [Monad.S]
allocated_bytes [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.
always [Quickcheck]
generator that always returns given value
and_ [Blang]
append [Core_list]
E.g.
append [Core_array]
Array.append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.
apply [Result]
apply [Option]
apply x f run optional function on argument and return an option
apply_n_times [Fn]
apply_n_times ~n f x is the n-fold application of f to x.
are_disjoint [Flags_intf.S]
ascending [Polymorphic_compare]
ascending is identical to compare.
ascending [Comparable_intf.S_common]
ascending is identical to compare.

B
back_index [Dequeue]
back_index t return the index of the back item in t.
back_index_exn [Dequeue]
back_index_exn t throws an exception if t is empty, otherwise returns the index of the back item in t
backtrace [Exn]
Printexc.get_backtrace
backtrace_status [Core_printexc]
base [Substring_intf.S]
base [Make_substring.F]
base [Blang]
between [Comparable_intf.S_common]
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 [Common]
bin_no_raise [Core_sexp]
bin_outer [Float_intf.S]
bin_read_decimal [Std_kernel]
bin_read_immutable [Common]
bin_read_no_raise [Core_sexp]
bin_read_only [Common]
bin_read_outer [Float_intf.S]
bin_read_read_only [Common]
bin_read_read_write [Common]
bin_read_sexp_array [Std_internal]
bin_read_sexp_bool [Std_internal]
bin_read_sexp_list [Std_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 [Unique_id_intf.Id]
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 [String_id.Stable.V1]
bin_read_t [Stable_internal.Sexp]
bin_read_t [Stable_containers.Map.V1]
bin_read_t [Stable_containers.Hash_set.V1]
bin_read_t [Stable_containers.Hashtbl.V1]
bin_read_t [Stable_containers.Set.V1]
bin_read_t [Source_code_position]
bin_read_t [Source_code_position0]
bin_read_t [Set_once]
bin_read_t [Stable_unit_test_intf.Arg]
bin_read_t [Result.Stable.V1]
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 [Or_error]
bin_read_t [Ordering]
bin_read_t [Option]
bin_read_t [Nothing.Stable.V1]
bin_read_t [Nothing0]
bin_read_t [Month.Stable.V1]
bin_read_t [Month]
bin_read_t [Int_intf.S]
bin_read_t [Info]
bin_read_t [Identifiable.S]
bin_read_t [Host_and_port.Stable.V1]
bin_read_t [T.T_bin]
bin_read_t [Fqueue]
bin_read_t [Float_intf.S.Terse]
bin_read_t [Float_intf.S.Class]
bin_read_t [Dequeue]
bin_read_t [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.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.Poly]
bin_read_t [Core_queue]
bin_read_t [Core_map.Poly]
bin_read_t [Core_list.Assoc]
bin_read_t [Core_list]
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.Float]
bin_read_t [Core_array.Int]
bin_read_t [Core_array]
bin_read_t [Constrained_float.S]
bin_read_t [Comparator.Pre_binable]
bin_read_t [Byte_units.Measure]
bin_read_t [Byte_units]
bin_read_t [Bucket.S]
bin_read_t [Bucket.Contents]
bin_read_t [Bucket.Make]
bin_read_t [Bounded_int_table.With_key]
bin_read_t [Bool]
bin_read_t [Blang.Stable.V1]
bin_read_t [Blang]
bin_read_t [Bigstring]
bin_read_t_hum [Source_code_position]
bin_read_t_hum [Source_code_position0]
bin_read_write [Common]
bin_reader_decimal [Std_kernel]
bin_reader_immutable [Common]
bin_reader_no_raise [Core_sexp]
bin_reader_outer [Float_intf.S]
bin_reader_read_only [Common]
bin_reader_read_write [Common]
bin_reader_sexp_array [Std_internal]
bin_reader_sexp_bool [Std_internal]
bin_reader_sexp_list [Std_internal]
bin_reader_sexp_opaque [Std_internal]
bin_reader_sexp_option [Std_internal]
bin_reader_sexp_option [Stable_internal]
bin_reader_t [Validated_intf.Raw_binable]
bin_reader_t [Unique_id_intf.Id]
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 [String_id.Stable.V1]
bin_reader_t [Stable_internal.Sexp]
bin_reader_t [Stable_containers.Map.V1]
bin_reader_t [Stable_containers.Hash_set.V1]
bin_reader_t [Stable_containers.Hashtbl.V1]
bin_reader_t [Stable_containers.Set.V1]
bin_reader_t [Source_code_position]
bin_reader_t [Source_code_position0]
bin_reader_t [Set_once]
bin_reader_t [Stable_unit_test_intf.Arg]
bin_reader_t [Result.Stable.V1]
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 [Or_error]
bin_reader_t [Ordering]
bin_reader_t [Option]
bin_reader_t [Nothing.Stable.V1]
bin_reader_t [Nothing0]
bin_reader_t [Month.Stable.V1]
bin_reader_t [Month]
bin_reader_t [Int_intf.S]
bin_reader_t [Info]
bin_reader_t [Identifiable.S]
bin_reader_t [Host_and_port.Stable.V1]
bin_reader_t [T.T_bin]
bin_reader_t [Fqueue]
bin_reader_t [Float_intf.S.Terse]
bin_reader_t [Float_intf.S.Class]
bin_reader_t [Dequeue]
bin_reader_t [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.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.Poly]
bin_reader_t [Core_queue]
bin_reader_t [Core_map.Poly]
bin_reader_t [Core_list.Assoc]
bin_reader_t [Core_list]
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.Float]
bin_reader_t [Core_array.Int]
bin_reader_t [Core_array]
bin_reader_t [Constrained_float.S]
bin_reader_t [Comparator.Pre_binable]
bin_reader_t [Byte_units.Measure]
bin_reader_t [Byte_units]
bin_reader_t [Bucket.S]
bin_reader_t [Bucket.Contents]
bin_reader_t [Bucket.Make]
bin_reader_t [Bounded_int_table.With_key]
bin_reader_t [Bool]
bin_reader_t [Blang.Stable.V1]
bin_reader_t [Blang]
bin_reader_t [Bigstring]
bin_reader_t_hum [Source_code_position]
bin_reader_t_hum [Source_code_position0]
bin_sexp_array [Std_internal]
bin_sexp_bool [Std_internal]
bin_sexp_list [Std_internal]
bin_sexp_opaque [Std_internal]
bin_sexp_option [Std_internal]
bin_sexp_option [Stable_internal]
bin_size_decimal [Std_kernel]
bin_size_immutable [Common]
bin_size_no_raise [Core_sexp]
bin_size_outer [Float_intf.S]
bin_size_read_only [Common]
bin_size_read_write [Common]
bin_size_sexp_array [Std_internal]
bin_size_sexp_bool [Std_internal]
bin_size_sexp_list [Std_internal]
bin_size_sexp_opaque [Std_internal]
bin_size_sexp_option [Std_internal]
bin_size_sexp_option [Stable_internal]
bin_size_t [Validated_intf.Raw_binable]
bin_size_t [Unique_id_intf.Id]
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 [String_id.Stable.V1]
bin_size_t [Stable_internal.Sexp]
bin_size_t [Stable_containers.Map.V1]
bin_size_t [Stable_containers.Hash_set.V1]
bin_size_t [Stable_containers.Hashtbl.V1]
bin_size_t [Stable_containers.Set.V1]
bin_size_t [Source_code_position]
bin_size_t [Source_code_position0]
bin_size_t [Set_once]
bin_size_t [Stable_unit_test_intf.Arg]
bin_size_t [Result.Stable.V1]
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 [Or_error]
bin_size_t [Ordering]
bin_size_t [Option]
bin_size_t [Nothing.Stable.V1]
bin_size_t [Nothing0]
bin_size_t [Month.Stable.V1]
bin_size_t [Month]
bin_size_t [Int_intf.S]
bin_size_t [Info]
bin_size_t [Identifiable.S]
bin_size_t [Host_and_port.Stable.V1]
bin_size_t [T.T_bin]
bin_size_t [Fqueue]
bin_size_t [Float_intf.S.Terse]
bin_size_t [Float_intf.S.Class]
bin_size_t [Dequeue]
bin_size_t [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.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.Poly]
bin_size_t [Core_queue]
bin_size_t [Core_map.Poly]
bin_size_t [Core_list.Assoc]
bin_size_t [Core_list]
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.Float]
bin_size_t [Core_array.Int]
bin_size_t [Core_array]
bin_size_t [Constrained_float.S]
bin_size_t [Comparator.Pre_binable]
bin_size_t [Byte_units.Measure]
bin_size_t [Byte_units]
bin_size_t [Bucket.S]
bin_size_t [Bucket.Contents]
bin_size_t [Bucket.Make]
bin_size_t [Bounded_int_table.With_key]
bin_size_t [Bool]
bin_size_t [Blang.Stable.V1]
bin_size_t [Blang]
bin_size_t [Bigstring]
bin_size_t_hum [Source_code_position]
bin_size_t_hum [Source_code_position0]
bin_t [Validated_intf.Raw_binable]
bin_t [Unique_id_intf.Id]
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 [String_id.Stable.V1]
bin_t [Stable_internal.Sexp]
bin_t [Stable_containers.Map.V1]
bin_t [Stable_containers.Hash_set.V1]
bin_t [Stable_containers.Hashtbl.V1]
bin_t [Stable_containers.Set.V1]
bin_t [Source_code_position]
bin_t [Source_code_position0]
bin_t [Set_once]
bin_t [Stable_unit_test_intf.Arg]
bin_t [Result.Stable.V1]
bin_t [Result]
bin_t [Ref.Permissioned]
bin_t [Ref]
bin_t [Pool_intf.S.Pointer.Id]
bin_t [Pid]
bin_t [Or_error]
bin_t [Ordering]
bin_t [Option]
bin_t [Nothing.Stable.V1]
bin_t [Nothing0]
bin_t [Month.Stable.V1]
bin_t [Month]
bin_t [Int_intf.S]
bin_t [Info]
bin_t [Identifiable.S]
bin_t [Host_and_port.Stable.V1]
bin_t [T.T_bin]
bin_t [Fqueue]
bin_t [Float_intf.S.Terse]
bin_t [Float_intf.S.Class]
bin_t [Dequeue]
bin_t [Decimal]
bin_t [Day_of_week.Stable.V1]
bin_t [Day_of_week]
bin_t [Core_string]
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.Poly]
bin_t [Core_queue]
bin_t [Core_map.Poly]
bin_t [Core_list.Assoc]
bin_t [Core_list]
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.Float]
bin_t [Core_array.Int]
bin_t [Core_array]
bin_t [Constrained_float.S]
bin_t [Comparator.Pre_binable]
bin_t [Byte_units.Measure]
bin_t [Byte_units]
bin_t [Bucket.S]
bin_t [Bucket.Contents]
bin_t [Bucket.Make]
bin_t [Bounded_int_table.With_key]
bin_t [Bool]
bin_t [Blang.Stable.V1]
bin_t [Blang]
bin_t [Bigstring]
bin_t_hum [Source_code_position]
bin_t_hum [Source_code_position0]
bin_write_decimal [Std_kernel]
bin_write_immutable [Common]
bin_write_no_raise [Core_sexp]
bin_write_outer [Float_intf.S]
bin_write_read_only [Common]
bin_write_read_write [Common]
bin_write_sexp_array [Std_internal]
bin_write_sexp_bool [Std_internal]
bin_write_sexp_list [Std_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 [Unique_id_intf.Id]
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 [String_id.Stable.V1]
bin_write_t [Stable_internal.Sexp]
bin_write_t [Stable_containers.Map.V1]
bin_write_t [Stable_containers.Hash_set.V1]
bin_write_t [Stable_containers.Hashtbl.V1]
bin_write_t [Stable_containers.Set.V1]
bin_write_t [Source_code_position]
bin_write_t [Source_code_position0]
bin_write_t [Set_once]
bin_write_t [Stable_unit_test_intf.Arg]
bin_write_t [Result.Stable.V1]
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 [Or_error]
bin_write_t [Ordering]
bin_write_t [Option]
bin_write_t [Nothing.Stable.V1]
bin_write_t [Nothing0]
bin_write_t [Month.Stable.V1]
bin_write_t [Month]
bin_write_t [Int_intf.S]
bin_write_t [Info]
bin_write_t [Identifiable.S]
bin_write_t [Host_and_port.Stable.V1]
bin_write_t [T.T_bin]
bin_write_t [Fqueue]
bin_write_t [Float_intf.S.Terse]
bin_write_t [Float_intf.S.Class]
bin_write_t [Dequeue]
bin_write_t [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.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.Poly]
bin_write_t [Core_queue]
bin_write_t [Core_map.Poly]
bin_write_t [Core_list.Assoc]
bin_write_t [Core_list]
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.Float]
bin_write_t [Core_array.Int]
bin_write_t [Core_array]
bin_write_t [Constrained_float.S]
bin_write_t [Comparator.Pre_binable]
bin_write_t [Byte_units.Measure]
bin_write_t [Byte_units]
bin_write_t [Bucket.S]
bin_write_t [Bucket.Contents]
bin_write_t [Bucket.Make]
bin_write_t [Bounded_int_table.With_key]
bin_write_t [Bool]
bin_write_t [Blang.Stable.V1]
bin_write_t [Blang]
bin_write_t [Bigstring]
bin_write_t_hum [Source_code_position]
bin_write_t_hum [Source_code_position0]
bin_writer_decimal [Std_kernel]
bin_writer_immutable [Common]
bin_writer_no_raise [Core_sexp]
bin_writer_outer [Float_intf.S]
bin_writer_read_only [Common]
bin_writer_read_write [Common]
bin_writer_sexp_array [Std_internal]
bin_writer_sexp_bool [Std_internal]
bin_writer_sexp_list [Std_internal]
bin_writer_sexp_opaque [Std_internal]
bin_writer_sexp_option [Std_internal]
bin_writer_sexp_option [Stable_internal]
bin_writer_t [Validated_intf.Raw_binable]
bin_writer_t [Unique_id_intf.Id]
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 [String_id.Stable.V1]
bin_writer_t [Stable_internal.Sexp]
bin_writer_t [Stable_containers.Map.V1]
bin_writer_t [Stable_containers.Hash_set.V1]
bin_writer_t [Stable_containers.Hashtbl.V1]
bin_writer_t [Stable_containers.Set.V1]
bin_writer_t [Source_code_position]
bin_writer_t [Source_code_position0]
bin_writer_t [Set_once]
bin_writer_t [Stable_unit_test_intf.Arg]
bin_writer_t [Result.Stable.V1]
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 [Or_error]
bin_writer_t [Ordering]
bin_writer_t [Option]
bin_writer_t [Nothing.Stable.V1]
bin_writer_t [Nothing0]
bin_writer_t [Month.Stable.V1]
bin_writer_t [Month]
bin_writer_t [Int_intf.S]
bin_writer_t [Info]
bin_writer_t [Identifiable.S]
bin_writer_t [Host_and_port.Stable.V1]
bin_writer_t [T.T_bin]
bin_writer_t [Fqueue]
bin_writer_t [Float_intf.S.Terse]
bin_writer_t [Float_intf.S.Class]
bin_writer_t [Dequeue]
bin_writer_t [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.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.Poly]
bin_writer_t [Core_queue]
bin_writer_t [Core_map.Poly]
bin_writer_t [Core_list.Assoc]
bin_writer_t [Core_list]
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.Float]
bin_writer_t [Core_array.Int]
bin_writer_t [Core_array]
bin_writer_t [Constrained_float.S]
bin_writer_t [Comparator.Pre_binable]
bin_writer_t [Byte_units.Measure]
bin_writer_t [Byte_units]
bin_writer_t [Bucket.S]
bin_writer_t [Bucket.Contents]
bin_writer_t [Bucket.Make]
bin_writer_t [Bounded_int_table.With_key]
bin_writer_t [Bool]
bin_writer_t [Blang.Stable.V1]
bin_writer_t [Blang]
Note that the sexps are not directly inferred from the type above -- there are lots of fancy shortcuts.
bin_writer_t [Bigstring]
bin_writer_t_hum [Source_code_position]
bin_writer_t_hum [Source_code_position0]
binary_search [Binary_searchable_intf.S1]
binary_search [Binary_searchable_intf.S]
binary_search ?pos ?len t ~compare v returns the index in t holding a value equal to v according to compare.
bind [Monad.S2]
bind [Monad.Basic2]
bind [Monad.Basic]
bind [Monad.Make2]
bind [Monad.Make]
bind [Monad.S]
bind t f = t >>= f
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]
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]
blito [Flat_array_debug.Debug]
blito [Blit_intf.S_distinct]
blito [Blit_intf.S1]
blito [Blit_intf.S]
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]
bprintf [Std_internal]
bprintf [Core_printf]
bprintf [Bigbuffer.Printf]
bprintf [Bigbuffer.Format]
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 [Result]
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.
capitalize [Core_string]
cartesian_product [Core_list]
cartesian_product [Core_array]
catch [Core_printexc]
ceil [Common]
ceil_pow2 [Int_math]
ceil_pow2 [Core_int]
ceil_pow2 x returns the smallest power of 2 that is greater than or equal to x.
cg [Quickcheck]
character generator
change [Univ_map.Multi]
change [Univ_map.With_fold]
change [Univ_map.With_default]
change [Univ_map]
change [Core_map]
change map key f updates the given map by changing the value stored under key according to f.
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_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]
check_and_return [Stack_unit_tests.Debug]
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]
check_pos_len_exn [Ordered_collection_common]
check_pos_len_exn ~pos ~len ~length raises unless pos >= 0 && len >= 0 && pos + len <= length.
choose [Core_set]
returns an arbitrary element, or None if the set is empty.
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 [Bag]
choose t returns some element in the bag.
choose_exn [Core_set]
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]
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]
classify_float [Common]
clear [Stack_unit_tests.Test]
clear [Stack_unit_tests.Debug]
clear [Stack_intf.S]
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 [Dequeue]
clear t removes all elements from t.
clear [Core_queue]
clear t discards all elements from t.
clear [Core_hashtbl_intf.Accessors]
clear [Bigbuffer]
Empty the buffer.
clear [Bag]
clear t removes all elements from the bag.
close [Out_channel]
close [In_channel]
close_in [Common]
we have our own version of these two, the INRIA version doesn't release the runtime lock.
close_out [Common]
combine [Result]
combine [Core_array]
combine ar combines two arrays to an array of pairs.
combine_errors [Or_error]
combine_errors ts returns Ok if every element in ts is Ok, else it returns Error with all the errors in ts.
combine_errors_unit [Or_error]
combine_errors_unit returns Ok if every element in ts is Ok (), else it returns Error with all the errors in ts, like combine_errors.
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.S1]
comparator [Comparator.S_binable]
comparator [Comparator.S]
comparator [Comparable_intf.S_common]
compare [Tuple.T3]
compare [Tuple.T2]
compare [String_id.Stable.V1]
compare [Stable_internal.Sexp]
compare [Source_code_position0]
compare [Result.Stable.V1]
compare [Result]
compare [Polymorphic_compare]
compare [Ordering]
compare [Option]
compare [Nothing.Stable.V1]
compare [Nothing0]
compare [No_polymorphic_compare]
compare [Month.Stable.V1]
compare [Host_and_port.Stable.V1]
compare [Hashable.S]
compare [Fqueue]
compare [Decimal]
compare [Day_of_week.Stable.V1]
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.Poly]
compare [Core_set]
compare [Core_set_intf.S0.Tree]
compare [Core_set_intf.S0]
compare [Core_map.Poly]
compare [Core_map_intf.S]
compare [Core_list.Assoc]
compare [Core_list]
lexicographic
compare [Core_lazy]
compare [Core_hashtbl_intf.Key]
compare [Core_array.Float]
compare [Core_array.Int]
compare [Comparator.Pre_binable]
compare [Comparator.Pre]
compare [Polymorphic_compare_intf.S]
compare [Blang.Stable.V1]
compare [Blang]
compare_decimal [Std_kernel]
compare_direct [Core_set]
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_map]
Total ordering between maps.
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_immutable [Common]
compare_read_only [Common]
compare_read_write [Common]
compare_sexp_array [Std_internal]
compare_sexp_bool [Std_internal]
compare_sexp_list [Std_internal]
compare_sexp_opaque [Std_internal]
compare_sexp_option [Std_internal]
compare_sexp_option [Stable_internal]
compare_t [Stable_internal.Sexp]
compare_t [Source_code_position0]
compare_t [Nothing0]
compare_t_hum [Source_code_position]
compare_t_hum [Source_code_position0]
complement [Flags_intf.S]
compose [Fn]
compose f g x is f (g x)
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]
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 [Core_string]
Like map, but allows replacement of a single character with zero or two or more characters.
concat_map [Core_queue]
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]
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]
const [Fn]
produces a function that just returns its first argument
const [Common]
constant [Blang]
constant_value [Blang]
constr_name [Univ]
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 [Heap_intf.S]
copy t returns a shallow copy
copy [Hash_set_intf.Accessors]
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 t returns a copy of t.
copy [Core_string]
copy [Core_queue]
copy t returns a copy of t.
copy [Core_hashtbl_intf.Accessors]
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 [Core_list]
count f l is the number of elements in l that satisfy the predicate f.
count [Container_unit_tests.Test_generic]
count [Container.Generic_phantom]
count [Container.Generic]
count [Container.S1_phantom_invariant]
count [Container.S1_phantom]
count [Container.S1]
count [Container.S0_phantom]
count [Container.S0]
count [Container.Make]
counters [Core_gc]
Return (minor_words, promoted_words, major_words).
create [Validated_intf.Validated]
create [Unpack_buffer]
create [Univ_map.Multi.Key]
create [Univ_map.With_fold.Key]
create [Univ_map.With_default.Key]
create [Univ_map.Key]
create [Univ.Constr]
create name to_sexp if the type 'a doesn't support sexp conversion, then a good practice is to use sexp_of_opaque as the converter.
create [Univ]
create [Union_find]
create v returns a new object in its own equivalence class that has value v.
create [Unique_id_intf.Id]
Always returns a value that is not equal to any other value created with create.
create [Type_equal.Id]
create ~name defines a new type identity.
create [Tuple.T3]
create [Tuple.T2]
create [Thread_safe_queue]
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 [Info]
For create msg z sexp_of_z, be careful to use only immutable values for z, or be aware that z will be lazily converted to a sexp at a later point in time, which will pick up the then-current state of z.
create [In_channel]
create [Host_and_port]
create [Heap_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_heap.S]
create [Hash_heap.Make]
create [Hash_queue.S]
create () returns an empty queue.
create [Hash_queue.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 [Doubly_linked]
creating doubly-linked lists
create [Dequeue]
create ?initial_length ?never_shrink () create a new t.
create [Day_of_week]
create [Core_weak]
create [Core_string]
create [Core_queue]
create () returns an empty queue.
create [Core_hashtbl_intf.Creators]
create [Core_gc.Control.Fields]
create [Core_gc.Stat.Fields]
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' [Thread_safe_queue]
create_alarm [Core_gc]
create_alarm f will arrange for f to be called at the end of each major GC cycle, starting with the current cycle or the next one.
create_bigstring [Binable0]
create_bin_prot [Unpack_buffer.Unpack_one]
create_bin_prot reader returns an unpacker that reads the "size-prefixed" bin_prot encoding, in which a value is encoded by first writing the length of the bin_prot data as a 64-bit int, and then writing the data itself.
create_bin_prot [Unpack_buffer]
create_bin_prot reader returns an unpack buffer that unpacks the "size-prefixed" bin_prot encoding, in which a value is encoded by first writing the length of the bin_prot data as a 64-bit int, and then writing the bin_prot data itself.
create_exn [Validated_intf.Validated]
create_exn [Heap_block]
create_mapped [Core_hashtbl_intf.Creators]
create_with_key [Core_hashtbl_intf.Creators]
create_with_key_exn [Core_hashtbl_intf.Creators]
current [Core_arg]
Position (in Sys.argv) of the argument being processed.
curry [Tuple.T3]
curry [Tuple.T2]

D
data [Core_map]
returns list of data in map
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_hashtbl_intf.Accessors]
filter_inplace t ~f removes all the elements from t that don't satisfy f.
data [Bounded_int_table]
debug [Unpack_buffer]
debug controls whether invariants are checked at each call.
debug [Stack_unit_tests.Debug]
debug [Flat_array_debug.Debug]
debug [Debug.Make]
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 [Core_random.State]
delete_alarm [Core_gc]
delete_alarm a will stop the calls to the function associated to a.
dequeue [Thread_safe_queue]
dequeue [Hash_queue.S]
dequeue t returns the front element of the queue.
dequeue [Hash_queue.Make]
dequeue [Fqueue]
Like dequeue_exn, but returns result optionally, without exception.
dequeue [Dequeue]
dequeue t back_or_front remove and return the back_or_front of t
dequeue [Core_queue]
dequeue t returns None if t is empty, otherwise it removes and returns the front of t
dequeue_all [Hash_queue.S]
dequeue_all t ~f dequeues every element of the queue and applies f to each one.
dequeue_all [Hash_queue.Make]
dequeue_back [Dequeue]
dequeue_back_exn [Dequeue]
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 [Dequeue]
dequeue_exn [Core_queue]
dequeue_front [Dequeue]
dequeue_front_exn [Dequeue]
dequeue_until_empty [Thread_safe_queue]
dequeue_with_key [Hash_queue.S]
dequeue_with_key t returns the front element of the queue and its key
dequeue_with_key [Hash_queue.Make]
dequeue_with_key_exn [Hash_queue.S]
dequeue_with_key_exn [Hash_queue.Make]
descending [Polymorphic_compare]
descending [Comparable_intf.S_common]
detuple2 [Type_equal]
tuple2 and detuple2 convert between equality on a 2-tuple and its components.
diff [Hash_set_intf.Accessors]
diff [Core_set]
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]
discard_exn [Fqueue]
Returns version of queue with top element removed.
do_intersect [Flags_intf.S]
does_match [Univ]
does_match t constr returns true iff t was created by create constr v.
does_raise [Common]
does_raise f returns true iff f () raises.
drop [Dequeue]
drop ?n t back_or_front drop n elements (default 1) from the back_or_front of t.
drop [Core_list]
drop_back [Dequeue]
drop_front [Flat_queue]
drop_front ?n t drops the the first n elements of t.
drop_front [Dequeue]
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 [Core_list]
drop_while l ~f drops the longest prefix of l for which f is true.

E
elements [Core_set]
Same as Core_set.to_list.
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]
empty [Univ_map]
empty [Obj_array]
empty [Int_set]
empty [Fqueue]
The empty queue
empty [Flags_intf.S]
empty [Core_set]
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_map]
the empty map
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_array]
empty () creates an empty array
empty [Avltree]
enqueue [Thread_safe_queue]
enqueue [Hash_queue.S]
enqueue t k v adds the key-value pair (k, v) to the end of the queue, returning `Ok if the pair was added, or `Key_already_present if there is already a (k, v') in the queue.
enqueue [Hash_queue.Make]
enqueue [Fqueue]
enqueue t x returns a queue with adds x to the end of t.
enqueue [Dequeue]
enqueue t back_or_front v push v onto the back_or_front of t.
enqueue [Core_queue]
enqueue t x adds x to the end of t.
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 [Dequeue]
enqueue_exn [Hash_queue.S]
enqueue_exn [Hash_queue.Make]
enqueue_front [Dequeue]
enqueue_top [Fqueue]
enqueue a single element on the *top* of the queue.
eprint [Debug]
synonym for prerr_endline, meaning it prints to stderr, followed by a newline
eprintf [Std_internal]
eprintf [Core_printf]
eprints [Debug]
log message a sexp_of_a prints to stderr message and a as a sexp, followed by a newline.
epsilon [Float_robust_compare.S]
epsilon [Float_intf.S]
epsilon_float [Float_intf.S]
epsilon_float [Common]
equal [Tuple.T3]
equal [Tuple.T2]
equal [Stable_unit_test_intf.Unordered_container_arg]
equal [Stable_unit_test_intf.Arg]
equal [Polymorphic_compare]
equal [Option]
equal [No_polymorphic_compare]
equal [Hash_set_intf.Accessors]
equal [Tuple_type_intf.Slot]
equal [Flags_intf.S]
equal [Equal.S3]
equal [Equal.S2]
equal [Equal.S1]
equal [Equal.S]
equal [Doubly_linked.Elt]
equal [Doubly_linked]
predicates
equal [Core_string]
fast equality function on strings, doesn't use compare_val
equal [Core_set]
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_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_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_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]
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]
error [Result]
error [Or_error]
error message value sexp_of_value constructs an Error.t and returns it as a Result.Error.
error [Common]
Or_error.error
error_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 [Core_map]
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_hashtbl_intf.Accessors]
exists [Core_gc.Control.Fields]
exists [Core_gc.Stat.Fields]
exists [Container_unit_tests.Test_generic]
exists [Container.Generic_phantom]
exists [Container.Generic]
exists [Container.S1_phantom_invariant]
exists [Container.S1_phantom]
exists [Container.S1]
exists [Container.S0_phantom]
exists [Container.S0]
exists [Container.Make]
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]
failwithf [Core_printf]
raises Failure
failwithf [Common]
failwithp [Error]
failwithp [Common]
failwiths [Error]
failwiths message value sexp_of_value raises an exception with the supplied message and value, by constructing an Error.t and using Error.raise.
failwiths [Common]
false_ [Blang]
feed [Unpack_buffer]
feed t buf ?pos ?len adds the specified substring of buf to t's buffer.
feed_string [Unpack_buffer]
fg [Quickcheck]
float generator (no nan, inf, etc.)
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]
Array.fill a ofs len x modifies the array a in place, storing x in elements number ofs to ofs + len - 1.
fill [Bucket.S]
fill [Bucket.Make]
filter [Option]
filter [Hash_set_intf.Accessors]
filter [Core_string]
filter s ~f:predicate discards characters not satisfying predicate
filter [Core_set]
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_map]
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_list]
filter p l returns all the elements of the list l that satisfy the predicate p.
filter [Core_hashtbl_intf.Accessors]
filter [Core_array]
filter ~f array removes the elements for which f returns false.
filter_inplace [Hash_set_intf.Accessors]
filter_inplace [Doubly_linked]
filter_inplace t ~f removes all elements of t that don't satisfy f.
filter_inplace [Core_queue]
filter_inplace t ~f removes all elements of t that don't satisfy f.
filter_inplace [Core_hashtbl_intf.Accessors]
filter_map [Core_set]
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_queue]
filter_map [Core_map]
returns new map with bound values filtered by f applied to the bound values
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_list]
filter_map f l is the sublist of l containing only elements for which f returns Some e.
filter_map [Core_hashtbl_intf.Accessors]
returns new map with bound values filtered by f applied to the bound values
filter_map [Core_array]
filter_map ~f array maps f over array and filters None out of the results.
filter_map [Bounded_int_table]
filter_mapi [Core_map]
like filter_map, but function takes both key and data as arguments
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_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]
Same as filter_map but uses Array.mapi.
filter_mapi [Bounded_int_table]
filter_opt [Core_list]
filter_opt l is the sublist of l containing only elements which are Some e.
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 [Core_list]
filteri [Core_hashtbl_intf.Accessors]
filteri [Core_array]
Like filter except f also receives the index.
filteri_inplace [Core_hashtbl_intf.Accessors]
find [Univ_map.Multi]
find [Univ_map.With_fold]
find [Univ_map.With_default]
find [Univ_map]
find [Stack_unit_tests.Debug]
find [Hash_heap.S]
find [Hash_heap.Make]
find [Hash_queue.Make]
find [Core_set]
find [Core_map]
returns the value bound to the given key, raising Not_found if none such exists
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_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.Generic_phantom]
find [Container.Generic]
find [Container.S1_phantom_invariant]
find [Container.S1_phantom]
find [Container.S1]
find [Container.S0_phantom]
find [Container.S0]
find [Container.Make]
find [Bounded_int_table]
find [Bigstring]
find ?pos ?len char t returns Some i for the smallest i >= pos such that t.{i} = char, or None if there is no such i.
find [Avltree]
if the specified key exists in the tree, return the corresponding value.
find_a_dup [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_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 [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]
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]
find_exn [Hash_heap.S]
find_exn [Hash_heap.Make]
find_exn [Core_set]
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_map]
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_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]
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]
find_index t i returns the ith smallest element of t in O(log n) time.
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_map [Stack_unit_tests.Debug]
find_map [Hash_queue.Make]
find_map [Core_set]
find_map [Container_unit_tests.Test_generic]
find_map [Container.Generic_phantom]
find_map [Container.Generic]
find_map [Container.S1_phantom_invariant]
find_map [Container.S1_phantom]
find_map [Container.S1]
find_map [Container.S0_phantom]
find_map [Container.S0]
find_map [Container.Make]
find_or_add [Core_hashtbl_intf.Accessors]
find_or_add t k ~default returns the data associated with key k if it is in the table t, otherwise it lets d = default() and adds it to the table.
find_or_add [Bounded_int_table]
find_pop [Hash_heap.S]
find_pop [Hash_heap.Make]
find_pop_exn [Hash_heap.S]
find_pop_exn [Hash_heap.Make]
findi [Core_list]
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]
findi_exn t f returns the first index i of t for which f i t.(i) is true.
first [Hash_queue.S]
first t returns the front element of the queue, without removing it.
first [Hash_queue.Make]
first [Doubly_linked]
first [Avltree]
first_elt [Doubly_linked]
constant-time extraction of first and last elements.
first_failure [Validate]
first_some [Option]
flip [Fn]
reverse the order of arguments for a binary function
float [Core_random.State]
float [Core_random]
Random.float bound returns a random floating-point number between 0 (inclusive) and bound (exclusive).
float_of_bits [Core_int64]
float_of_bits [Core_int32]
float_of_int [Common]
float_of_string [Common]
floor [Common]
floor_pow2 [Int_math]
floor_pow2 [Core_int]
floor_pow2 x returns the largest power of 2 that is less than or equal to x.
flush [Out_channel]
fold [Stack_unit_tests.Debug]
fold [Hash_queue.Make]
fold [Flat_queue]
fold [Core_set]
fold [Core_queue]
fold [Core_map]
folds over keys and data in map in increasing order of key.
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_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.Generic_phantom]
fold [Container.Generic]
fold [Container.S1_phantom_invariant]
fold [Container.S1_phantom]
fold [Container.S1]
fold [Container.S0_phantom]
fold [Container.S0]
fold [Container.T]
fold [Container.Make]
fold [Bounded_int_table]
fold [Avltree]
fold over the tree
fold' [Dequeue]
fold' t ~init ~f fold over the elements of t
fold2_exn [Core_list]
List.fold2_exn f a [b1; ...; bn] [c1; ...; cn] is f (... (f (f a b1 c1) b2 c2) ...) bn cn.
fold2_exn [Core_array]
fold_count [Container]
fold_elt [Doubly_linked]
fold_elt t ~init ~f is the same as fold, except f is called with the 'a Elt.t's from the list instead of the contained 'a values.
fold_elt [Bag]
fold_elt t ~init ~f is the same as fold, except f is called with the 'a Elt.t's from the bag instead of the contained 'a values.
fold_left [Core_list]
fold_lines [In_channel]
fold_lines ?fix_win_eol t ~init ~f folds over the lines read from t using input_line.
fold_range_inclusive [Core_map]
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_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_right [Doubly_linked]
fold_right [Core_set]
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_map]
folds over keys and data in map in decreasing order of key.
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_list]
List.fold_right f [a1; ...; an] b is f a1 (f a2 (... (f an b) ...)).
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]
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]
foldi [Hash_queue.S]
foldi [Hash_queue.Make]
foldi [Dequeue]
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]
foldi' [Dequeue]
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 [Core_map]
same semantics as similar functions in List
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_gc.Control.Fields]
for_all [Core_gc.Stat.Fields]
for_all [Container_unit_tests.Test_generic]
for_all [Container.Generic_phantom]
for_all [Container.Generic]
for_all [Container.S1_phantom_invariant]
for_all [Container.S1_phantom]
for_all [Container.S1]
for_all [Container.S0_phantom]
for_all [Container.S0]
for_all [Container.Make]
for_all [Bounded_int_table]
for_all2_exn [Core_list]
Same as List.for_all, but for a two-argument predicate.
for_all2_exn [Core_array]
for_all2_exn t1 t2 ~f fails if length t1 <> length t2.
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_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 [Common]
fri [Day_of_week]
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 [Dequeue]
front_index t return the index of the front item in t.
front_index_exn [Dequeue]
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 [Dequeue]
get t i return the element at index i.
get [Day_of_week]
get [Core_weak]
get [Core_string]
get [Core_gc]
Return the current values of the GC parameters in a control record.
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
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 [Dequeue]
get_opt t i return the element at index i.
get_opt_len [Bigstring]
get_opt_len bstr ~pos opt_len
get_padded_fixed_string [Bigstring]
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_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]
if equiv is an equivalence predicate, then group_by set ~equiv produces a list of equivalence classes (i.e., a set-theoretic quotient).
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]
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]
behaves as handle_uncaught ~exit:true and also has a more precise type in this case
hash [Univ.Constr]
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 [Core_list]
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]

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]
if_ [Blang]
ifprintf [Core_printf]
ignore [Monad.S2]
ignore [Monad.Make2]
ignore [Monad.Make]
ignore [Monad.S]
ignore t = map t ~f:(fun _ -> ()).
ignore [Force_once]
ignore () = create (fun () -> ())
ignore [Fn]
* ignore is the same as Pervasives.ignore.
immutable_of_sexp [Common]
in_channel_length [Common]
incr [Int_intf.S]
incr [Core_hashtbl_intf.Accessors]
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]
index_exn [Core_string.Escaping]
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 [Pid]
init [Core_string]
init [Core_list]
init f n is [(f 0); (f 1); ...; (f (n-1))].
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_first [Doubly_linked]
insert_last [Doubly_linked]
insert_underscores [Int_conversions]
int [Core_random.State]
int [Core_random]
Random.int bound returns a random integer between 0 (inclusive) and bound (exclusive).
int32 [Core_random.State]
int32 [Core_random]
Random.int32 bound returns a random integer between 0 (inclusive) and bound (exclusive).
int32_to_int [Int_conversions]
int32_to_int64 [Int_conversions]
int32_to_int_exn [Int_conversions]
int32_to_nativeint [Int_conversions]
int64 [Core_random.State]
int64 [Core_random]
Random.int64 bound returns a random integer between 0 (inclusive) and bound (exclusive).
int64_to_int [Int_conversions]
int64_to_int32 [Int_conversions]
int64_to_int32_exn [Int_conversions]
int64_to_int_exn [Int_conversions]
int64_to_nativeint [Int_conversions]
int64_to_nativeint_exn [Int_conversions]
int_of_float [Common]
int_to_int32 [Int_conversions]
int_to_int32_exn [Int_conversions]
int_to_int64 [Int_conversions]
int_to_nativeint [Int_conversions]
integral [Float_intf.S.Parts]
inter [Core_set]
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]
intersect [Flags_intf.S]
intersperse [Core_list]
intersperse xs ~sep places sep between adjacent elements of xs.
invalid_argf [Core_printf]
raises Invalid_arg
invalid_argf [Common]
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 [Day_of_week]
invariant [Core_hashtbl_intf.Accessors]
invariant [Blang]
invariant [Bag]
invariant [Avltree]
check invariants, raise an exception if any invariants fail
invariants [Core_set]
Test if invariants of internal AVL search tree hold.
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_map]
Test if invariants of internal AVL search tree hold.
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]
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 [Unpack_buffer]
is_empty t returns true if t has no unconsumed bytes, and false if it does.
is_empty [Univ_map]
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 [Core_map]
Test whether a map is empty or not.
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_hashtbl_intf.Accessors]
is_empty [Container_unit_tests.Test_generic]
is_empty [Container.Generic_phantom]
is_empty [Container.Generic]
is_empty [Container.S1_phantom_invariant]
is_empty [Container.S1_phantom]
is_empty [Container.S1]
is_empty [Container.S0_phantom]
is_empty [Container.S0]
is_empty [Container.Make]
is_error [Stack_unit_tests]
is_error [Result.Export]
is_error [Result]
is_finite [Float_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 [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 [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 [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_math]
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_print [Core_char]
' ' - '~'
is_some [Option]
is_some t returns true iff t = Some x.
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]
is_sorted_strictly [Core_list]
is_sorted_strictly [Core_array]
is_suffix [Core_string]
is_suffix s ~suffix returns true if s ends with suffix.
is_sun_or_sat [Day_of_week]
is_sun_or_sat returns true if t is Sunday or Saturday
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'
iter [Stack_unit_tests.Debug]
iter [Result]
iter [Hash_heap.S]
iter [Hash_heap.Make]
iter [Hash_queue.Make]
iter [Flat_queue]
iter [Core_set]
iter [Core_map]
iterator for map
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_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.Generic_phantom]
iter [Container.Generic]
iter [Container.S1_phantom_invariant]
iter [Container.S1_phantom]
iter [Container.S1]
iter [Container.S0_phantom]
iter [Container.S0]
iter [Container.Make]
iter [Bounded_int_table]
iter [Avltree]
iterate over the tree
iter' [Dequeue]
iter' t ~f iter over the elements of t.
iter2 [Core_set]
Iterate two sets side by side.
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_map]
Iterate two maps 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_exn [Core_list]
List.iter2_exn f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.
iter2_exn [Core_array]
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]
iter_vals [Hash_heap.Make]
iter_vals [Core_hashtbl_intf.Accessors]
iter_vals t ~f is like iter, except it only supplies the value to f, not the key.
iter_vals [Bounded_int_table]
iteri [Hash_queue.S]
iter t ~f applies f to each key and element of the queue.
iteri [Hash_queue.Make]
iteri [Dequeue]
iteri 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]
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' [Dequeue]
iteri' t ~f as iter, but also passes in the index of the current element.

J
join [Monad.S2]
join [Monad.Make2]
join [Monad.Make]
join [Monad.S]
join t is t >>= (fun t' -> t').

K
kbprintf [Core_printf]
keys [Hash_queue.S]
keys t returns the keys in the order of the queue.
keys [Hash_queue.Make]
keys [Core_map]
returns list of keys in map
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_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]
last [Avltree]
last_elt [Doubly_linked]
last_exn [Core_list]
laws [Quickcheck]
laws iter gen func applies func repeatedly (iter times) on output of gen, and if func ever returns false, then the input that caused the failure is returned optionally.
laws_exn [Quickcheck]
Like laws, but throws an exception instead of returning an option.
ldexp [Float_intf.S]
ldexp [Common]
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_heap.S]
length [Hash_heap.Make]
length [Hash_queue.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]
length [Core_map]
length map
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_hashtbl_intf.Accessors]
length [Container_unit_tests.Test_generic]
length [Container.Generic_phantom]
length [Container.Generic]
length [Container.S1_phantom_invariant]
length [Container.S1_phantom]
length [Container.S1]
length [Container.S0_phantom]
length [Container.S0]
length [Container.Make]
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.
level [Bucket.S]
level [Bucket.Make]
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.
lg [Quickcheck]
list generator
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_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 [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_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]
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 [Result]
map [Monad.S2]
map [Monad.Make2]
map [Monad.Make]
map [Monad.S]
map t ~f is t >>| f.
map [Core_string]
map f s applies f to each character in s, and returns the resulting string.
map [Core_set]
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_queue]
map [Core_map]
returns new map with bound values replaced by f applied to the bound values
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_list.Assoc]
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 [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]
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]
map1 [Tuple.T3]
map1 [Tuple.T2]
map2 [Tuple.T3]
map2 [Tuple.T2]
map2 [Option]
map2 o f map 'a option and 'b option to a 'c option using ~f
map2_exn [Core_list]
List.map2_exn f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn].
map2_exn [Core_array]
map3 [Tuple.T3]
map3_exn [Core_list]
map_error [Result]
map_file [Bigstring]
map_file shared fd n memory-maps n characters of the data associated with descriptor fd to a bigstring.
map_poly [Core_gc.Control.Fields]
map_poly [Core_gc.Stat.Fields]
mapi [Core_string]
mapi f s applies f to each character in s and its index, and returns the resulting string.
mapi [Core_map]
like map, but function takes both key and data as arguments
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_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]
Same as Array.map, but the function is applied to the index of the element as first argument, and the element itself as second argument.
mapi [Bounded_int_table]
marshal [Bigstring_marshal]
marshal ?flags v marshals value v to a bigstring using marshalling flags flags.
marshal_blit [Bigstring_marshal]
marshal_blit ?flags v ?pos ?len buf marshals value v to bigstring buf starting at position pos and at most len bytes.
marshal_data_size [Bigstring_marshal]
marshal_data_size ?pos buf
match_ [Univ]
match_ t constr returns Some v if t was created by create constr v, and returns None otherwise.
match_exn [Univ]
max [Polymorphic_compare]
max [No_polymorphic_compare]
max [Int_set]
max t the biggest number in the set (if it exists)
max [Polymorphic_compare_intf.S]
max_elt [Core_set]
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_map]
max_elt map
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_exn [Core_set]
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_map]
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_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_overhead [Core_gc.Control.Fields]
max_overhead [Core_gc.Control]
max_value [Int_intf.S]
max_value [Float_intf.S]
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.
megabytes [Byte_units]
mem [Univ_map]
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]
mem [Hash_heap.S]
mem [Hash_heap.Make]
mem [Hash_queue.S]
mem q k returns true iff there is some (k, v) in the queue.
mem [Hash_queue.Make]
mem [Core_set]
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]
mem [Core_map]
mem map key tests whether map contains a binding for key
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_list.Assoc]
mem [Core_hashtbl_intf.Accessors]
mem [Container_unit_tests.Test_generic]
mem [Container.Generic_phantom]
mem [Container.Generic]
mem [Container.S1_phantom_invariant]
mem [Container.S1_phantom]
mem [Container.S1]
mem [Container.S0_phantom]
mem [Container.S0]
mem [Container.Make]
mem [Bounded_int_table]
mem [Avltree]
return true if key is present in the tree, otherwise return false.
merge [Option]
merge a b ~f merges together the values from a and b using f.
merge [Core_map]
merges two maps
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_list]
Merge two lists: assuming that l1 and l2 are sorted according to the comparison function cmp, merge cmp l1 l2 will return a sorted list containting all the elements of l1 and l2.
merge [Core_hashtbl_intf.Accessors]
Merge two hashtables.
merge_into [Core_hashtbl_intf.Accessors]
Merge one hashtable into another.
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_elt [Core_set]
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_map]
min_elt map
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_exn [Core_set]
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_map]
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_float [Common]
min_inan [Float_intf.S]
min and max that return the other value if one of the values is a nan.
min_int [Common]
min_positive_value [Float_intf.S]
min_value [Int_intf.S]
min_value [Float_intf.S]
min_value [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]
mod_float [Float_intf.S]
mod_float x y returns a result with the same sign as x.
mod_float [Common]
modf [Float_intf.S]
modf [Common]
mon [Day_of_week]

N
name [Validate]
extend location path by one name
name [Univ.Constr]
name [Type_equal.Id]
name_list [Validate]
names [Core_gc.Control.Fields]
names [Core_gc.Stat.Fields]
nan [Float_intf.S]
nan [Common]
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 [Int_intf.S]
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 [Doubly_linked]
constant-time move to next or previous element.
next_key [Core_map]
next_key t k returns the smallest (key, value) pair in t with key greater than k
next_key [Core_map_intf.Accessors3_with_comparator]
next_key [Core_map_intf.Accessors3]
next_key [Core_map_intf.Accessors2]
next_key [Core_map_intf.Accessors1]
next_key [Core_map_intf.Accessors_generic]
nget [Core_string]
nget s i Gets the char at normalized position i in s.
nget [Core_array]
Array access with normalized index.
nng [Quickcheck]
natural number generator
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.
non [Fn]
Negates a function
normalize [Ordered_collection_common]
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]
nset [Core_string]
nset s i c Sets the char at normalized position i to c.
nset [Core_array]
Array modification with normalized index.
nth [Core_list]
nth [Bigbuffer]
get the (zero-based) n-th character of the buffer.
nth_exn [Core_list]
Return the n-th element of the given list.
null [Pool_intf.S.Pointer]
The null pointer is a distinct pointer that does not correspond to a tuple in the pool.
num_bits [Word_size]
num_bits [Int_intf.S]
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
of_alist [Core_map]
creates map from association list with unique keys
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_hashtbl_intf.Creators]
of_alist [Bounded_int_table.With_key]
of_alist_exn [Core_map]
creates map from association list with unique keys.
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_hashtbl_intf.Creators]
of_alist_exn [Bounded_int_table.With_key]
of_alist_fold [Core_map]
combines an association list into a map, folding together bound values with common keys
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_multi [Core_map]
creates map from association list with possibly repeated 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_hashtbl_intf.Creators]
of_alist_reduce [Core_map]
combines an association list into a map, reducing together bound values with common keys
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_report_all_dups [Core_hashtbl_intf.Creators]
of_array [Heap_intf.S]
min_size (see create) will be set to the size of the input array or list.
of_array [Core_set]
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_queue]
of_bigstring [Substring_intf.S]
of_bigstring [Make_substring.Base]
of_bigstring [Make_substring.F]
of_bigstring [Interned_string.Make]
of_bigstring [Binable]
of_bigstring [Binable0]
of_bool [Blit_intf.Elt]
of_char [Core_string]
of_char_list [Core_string]
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_result [Or_error]
of_exn_result (Ok a) = Ok a, of_exn_result (Error exn) = of_exn exn
of_float [Floatable.S]
of_float [Core_int64]
of_hashtbl_keys [Hash_set_intf.Accessors]
of_info [Error]
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]
of_int [Flags_intf.S]
of_int [Day_of_week]
of_int i returns i'th weekday if i is in 0,1,...,6.
of_int [Core_nativeint]
of_int [Core_int]
of_int [Core_int64]
of_int [Core_int63]
of_int [Core_int32]
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_int]
of_int32 [Core_int64]
of_int32 [Core_int32]
of_int32_exn [Int_intf.S]
of_int64 [Float_intf.S]
of_int64 [Core_nativeint]
of_int64 [Core_int]
of_int64 [Core_int64]
of_int64 [Core_int32]
of_int64_exn [Int_intf.S]
of_int64_exn [Core_int]
of_int_exn [Month]
of_int_exn [Intable.S]
of_int_exn [Day_of_week]
of_int_exn i should have i in 0,1,...,6 and returns the i'th weekday.
of_int_exn [Core_char]
Return the character with the given ASCII code.
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 [Info]
of_list [Heap_intf.S]
of_list [Hash_set_intf.Creators]
of_list [Doubly_linked]
of_list l returns a doubly-linked list t with the same elements as l and in the same order (i.e.
of_list [Core_set]
The list or array given to of_list and of_array need not be sorted.
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_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]
Array.of_list l returns a fresh array containing the elements of l.
of_list [Bag]
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]
of_list_rev l converts from list then reverses in place
of_list_rev_map [Core_array]
of_list_rev_map l ~f is the same as rev_inplace (of_list_map l ~f)
of_nativeint [Core_nativeint]
of_nativeint [Core_int]
of_nativeint [Core_int64]
of_nativeint [Core_int32]
of_nativeint_exn [Int_intf.S]
of_option [Result]
of_ref [Ref.Permissioned]
of_result [Validate]
Create a validation function from a function that produces a Result.t
of_sorted_array [Core_set]
Create set from sorted array.
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_map]
creates map from sorted array of key-data pairs.
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_unchecked [Core_set]
Similar to of_sorted_array, but without checking the input array.
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_map]
Like of_sorted_array except behavior is undefined when an Error would have been returned.
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_string [Sexpable.To_stringable]
of_string [Substring_intf.S]
of_string [Make_substring.Base]
of_string [Make_substring.F]
of_string [Stringable.S]
of_string [Info]
of_string [Binable]
of_string [Bigstring]
of_string ?pos ?len str
of_thunk [Only_in_test]
of_thunk [Info]
of_tree [Core_set]
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_map]
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]
ok [Result]
ok_exn [Result]
ok_exn t returns x if t = Ok x, and raises exn if t = Error exn
ok_exn [Or_error]
ok_exn t throws an exception if t is an Error, and otherwise returns the contents of the Ok constructor.
ok_exn [Common]
Or_error.ok_exn
ok_fst [Result]
ok_fst is useful with List.partition_map.
ok_if_true [Result]
ok_or_failwith [Result]
ok_unit [Result]
ok_unit = Ok (), used to avoid allocation as a performance hack
one [Int_intf.S]
or_ [Blang]
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]

P
pack_float [Binary_packing]
pack_padded_fixed_string [Binary_packing]
Encode and pack the given string as a padded fixed length string having length len.
pack_signed_16 [Binary_packing]
pack_signed_16_big_endian [Binary_packing]
pack_signed_16_little_endian [Binary_packing]
pack_signed_32 [Binary_packing]
pack_signed_32_int [Binary_packing]
pack_signed_32_int_big_endian [Binary_packing]
pack_signed_32_int_little_endian [Binary_packing]
pack_signed_64 [Binary_packing]
pack_signed_64_big_endian [Binary_packing]
pack_signed_64_int [Binary_packing]
pack_signed_64_little_endian [Binary_packing]
pack_signed_8 [Binary_packing]
pack_unsigned_16 [Binary_packing]
pack_unsigned_16_big_endian [Binary_packing]
pack_unsigned_16_little_endian [Binary_packing]
pack_unsigned_32_int [Binary_packing]
pack_unsigned_32_int_big_endian [Binary_packing]
pack_unsigned_32_int_little_endian [Binary_packing]
pack_unsigned_8 [Binary_packing]
pair [Validate]
Validation functions for particular data types.
parse [Core_arg]
Arg.parse speclist anon_fun usage_msg parses the command line.
parse_argv [Core_arg]
Arg.parse_argv ~current args speclist anon_fun usage_msg parses the array args as if it were the command line.
partial_iter [Core_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]
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_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_list]
partition_tf p l returns a pair of lists (l1, l2), where l1 is the list of all the elements of l that satisfy the predicate p, and l2 is the list of all the elements of l that do not satisfy p.
partition_tf [Core_hashtbl_intf.Accessors]
partition_tf [Core_array]
partitioni_tf [Core_hashtbl_intf.Accessors]
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 [Dequeue]
peek t back_or_front return the value at the back or front of the dequeue without removing it.
peek [Core_queue]
peek t returns None if t is empty, otherwise it returns Some x where x is the front of t.
peek_back [Dequeue]
peek_back_exn [Dequeue]
peek_exn [Core_queue]
peek_front [Dequeue]
peek_front_exn [Dequeue]
permute [Core_list]
permute ?random_state t returns a permutation of t.
permute [Core_array]
permute ?random_state t randomly permutes t in place.
permute [Array_permute]
randomly permute an array.
pg [Quickcheck]
pair generator
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.
pointer_of_id_exn_is_supported [Pool_intf.S]
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_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_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_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]
pp [Pretty_printer.S]
pp [Info]
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
prev [Doubly_linked]
prev_key [Core_map]
prev_key t k returns the largest (key, value) pair in t with key less than k
prev_key [Core_map_intf.Accessors3_with_comparator]
prev_key [Core_map_intf.Accessors3]
prev_key [Core_map_intf.Accessors2]
prev_key [Core_map_intf.Accessors1]
prev_key [Core_map_intf.Accessors_generic]
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]
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]
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.
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]
ranges [Int_set]
ranges t return a list of all ranges that make up the set
rank [Core_map]
rank t k if k is in t, returns the number of keys strictly less than k in t, otherwise None
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]
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_lines [In_channel]
read_lines filename Opens filename, reads all lines, and closes the file.
read_only [Ref.Permissioned]
read_only_of_sexp [Common]
read_write_of_sexp [Common]
really_input [In_channel]
record_backtrace [Core_printexc]
reduce [Core_list]
reduce [Core_array]
reduce f [a1; ...; an] is Some (f (... (f (f a1 a2) a3) ...) an).
reduce_exn [Core_list]
reduce_exn f [a1; ...; an] is f (... (f (f a1 a2) a3) ...) an.
reduce_exn [Core_array]
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 [Int_intf.S]
remove [Hash_set_intf.Accessors]
remove [Hash_heap.S]
remove [Hash_heap.Make]
remove [Heap.Removable]
If t and token are mismatched then behavior is undefined.
remove [Hash_queue.S]
remove [Hash_queue.Make]
remove [Doubly_linked]
constant-time removal of an element.
remove [Core_set]
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_map]
returns a new map with any binding for the key in question removed
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_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 [Core_list]
remove_consecutive_duplicates.
remove_exn [Hash_queue.S]
remove_exn [Hash_queue.Make]
remove_first [Doubly_linked]
remove_index [Core_set]
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_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_zero_flags [Flags_intf.Make_arg]
repeat [Quickcheck]
replace [Ref.Permissioned]
replace [Ref]
replace t f is t := f !t
replace [Hash_heap.S]
replace [Hash_heap.Make]
replace [Hash_queue.S]
replace q k v changes the value of key k in the queue to v.
replace [Hash_queue.Make]
replace [Core_hashtbl_intf.Accessors]
replace [Core_array]
replace t i ~f = t.(i) <- f (t.(i)).
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]
reraise [Exn]
reraise_uncaught [Exn]
reraisef [Exn]
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 [Bigbuffer_internal]
result [Validate]
return [Monad.S2]
return [Monad.Basic2]
return [Monad.Basic]
return [Monad.Make2]
return [Monad.Make]
return [Monad.S]
return v returns the (trivial) computation that returns v.
rev [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 f l 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]
rev_inplace t reverses t in place
rev_map [Core_list]
List.rev_map f l gives the same result as List.rev (ListLabels.map f l), but is more efficient.
rev_map2_exn [Core_list]
List.rev_map2_exn f l1 l2 gives the same result as List.rev (List.map2_exn f l1 l2), but is more efficient.
rev_map3_exn [Core_list]
rev_map_append [Core_list]
rev_map_append ~f l1 l2 reverses l1 mapping f over each element, and appends the result to the front of l2.
rev_mapi [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]
robustly_compare [Robustly_comparable.S]
round [Std_internal]
round [Float_intf.S]
round_down [Float_intf.S]
round_nearest [Float_intf.S]
round_towards_zero [Float_intf.S]
round_up [Float_intf.S]
rsplit2 [Core_string.Escaping]
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.

S
same [Type_equal.Id]
same_witness t1 t2 and same_witness_exn t1 t2 return a type equality proof iff the two identifiers are physically equal.
same_class [Union_find]
same_class t1 t2 returns true iff t1 and t2 are in the same equivalence class.
same_witness [Type_equal.Id]
same_witness_exn [Type_equal.Id]
sat [Day_of_week]
scale [Float_intf.S]
scale [Byte_units]
scale t mul scale the measure t by mul
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.Multi]
set [Univ_map.With_fold]
set [Univ_map.With_default]
set [Univ_map]
set [Union_find]
set t v sets the value of the class of t to v.
set [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_hashtbl_intf.Accessors]
set [Core_gc]
set r changes the GC parameters according to the control record r.
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_slots [Flat_queue]
set_all_slots [Flat_array_debug.Debug]
set_all_slots [Flat_array]
set_allocation_policy [Core_gc.Control]
set_auto_shrink [Core_stack]
set_auto_shrink t controls whether t's array will automatically shrink when the number of elements on the stack falls below 1/4 of the array size.
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 capacity.
set_exn [Set_once]
set_exn [Dequeue]
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_padded_fixed_string [Bigstring]
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_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_of_decimal [Std_kernel]
sexp_of_exn [Std_internal]
sexp_of_immutable [Common]
sexp_of_int_style [Int_conversions]
sexp_of_key [Core_hashtbl_intf.Accessors]
sexp_of_never_returns [Never_returns]
sexp_of_never_returns [Common]
never_returns should be used as the return type of functions that don't return and might block forever, rather than 'a or _.
sexp_of_no_raise [Core_sexp]
sexp_of_outer [Float_intf.S]
sexp_of_read_only [Common]
sexp_of_read_write [Common]
sexp_of_t [Validated_intf.Validated]
sexp_of_t [Validated_intf.Raw]
sexp_of_t [Unpack_buffer]
sexp_of_t [Univ_map.Key]
create name to_sexp generates a fresh key.
sexp_of_t [Univ_map]
sexp_of_t [Univ.Constr]
sexp_of_t [Univ]
sexp_of_t [Unique_id_intf.Id]
sexp_of_t [Type_equal.Id]
sexp_of_t [Tuple.Hashable_sexpable]
sexp_of_t [Tuple.Comparable_sexpable]
sexp_of_t [Tuple.T3]
sexp_of_t [Tuple.T2]
sexp_of_t [Thread_safe_queue]
sexp_of_t [Stack_unit_tests.Debug]
sexp_of_t [Stack_intf.S]
sexp_of_t [Stable_unit_test_intf.Unordered_container_arg]
sexp_of_t [String_id.Stable.V1]
sexp_of_t [Stable_containers.Map.V1]
sexp_of_t [Stable_containers.Hash_set.V1]
sexp_of_t [Stable_containers.Hashtbl.V1]
sexp_of_t [Stable_containers.Set.V1]
sexp_of_t [Source_code_position]
sexp_of_t [Source_code_position0]
sexp_of_t [Sexpable.S3]
sexp_of_t [Sexpable.S2]
sexp_of_t [Sexpable.S1]
sexp_of_t [Sexpable.Of_stringable]
sexp_of_t [Sexpable.Of_sexpable]
sexp_of_t [Set_once]
sexp_of_t [Stable_unit_test_intf.Arg]
sexp_of_t [Result.Stable.V1]
sexp_of_t [Result]
sexp_of_t [Ref.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 [Or_error]
sexp_of_t [Ordering]
sexp_of_t [Option]
sexp_of_t [Obj_array]
sexp_of_t [Nothing.Stable.V1]
sexp_of_t [Nothing0]
sexp_of_t [Month.Stable.V1]
sexp_of_t [Month]
sexp_of_t [Int_intf.S]
sexp_of_t [Sexpable.S]
sexp_of_t [Int_conversions.Make]
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.Poly]
sexp_of_t [Hash_set]
sexp_of_t [Hash_set_intf.S]
sexp_of_t [Heap.Removable.Elt]
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 [Exn]
sexp_of_t [Doubly_linked.Elt]
sexp_of_t [Doubly_linked]
sexp_of_t [Dequeue]
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]
sexp_of_t [Core_sexp.Sexp_maybe]
sexp_of_t [Core_sexp]
sexp_of_t [Core_set.Poly.Tree]
sexp_of_t [Core_set.Poly]
sexp_of_t [Core_set.Tree]
sexp_of_t [Core_set_intf.S0.Tree]
sexp_of_t [Core_set_intf.S0]
sexp_of_t [Core_queue]
sexp_of_t [Core_map.Poly.Tree]
sexp_of_t [Core_map.Poly]
sexp_of_t [Core_map.Tree]
sexp_of_t [Core_map_intf.S.Tree]
sexp_of_t [Core_map_intf.S]
sexp_of_t [Core_list.Assoc]
sexp_of_t [Core_list]
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.Control]
sexp_of_t [Core_gc.Stat]
sexp_of_t [Core_char]
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 [Comparator.Pre_binable]
sexp_of_t [Comparator.Pre]
sexp_of_t [Commutative_group.S]
sexp_of_t [Byte_units.Measure]
sexp_of_t [Byte_units]
sexp_of_t [Bucket.S]
sexp_of_t [Bucket.Contents]
sexp_of_t [Bucket.Make]
sexp_of_t [Bounded_int_table.With_key]
sexp_of_t [Bounded_int_table]
sexp_of_t [Bool]
sexp_of_t [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_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_position]
sexp_of_t_hum [Source_code_position0]
sg [Quickcheck]
string generator
shift [Month]
shift t i goes forward (or backward) the specified number of months
shift [Day_of_week]
shift t i goes forward (or backward) the specified number of weekdays
shift_left [Int_intf.S]
shift_right [Int_intf.S]
shift_right_logical [Int_intf.S]
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]
sign [Float_intf.S]
similar [Core_hashtbl_intf.Accessors]
singleton [Obj_array]
singleton [Core_set]
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_queue]
singleton [Core_map]
map with one key, data pair
singleton [Core_map_intf.Creators3_with_comparator]
singleton [Core_map_intf.Creators2]
singleton [Core_map_intf.Creators1]
singleton [Core_map_intf.Creators_generic]
skip [Bigstring_marshal]
skip ?pos buf skips the marshalled data starting at position pos.
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]
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]
snd3 [Common]
some [Option]
some_if [Option]
sort [Core_list]
Sort a list in increasing order according to a comparison function.
sort [Core_array]
sort_and_align [Core_arg]
Like align, except that the specification list is also sorted by key
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]
split t x produces a triple (t1, b, t2) where t1 is the set of elements strictly less than x, b = mem set x, and t2 is the set of elements strictly larger than x.
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_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_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 [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]
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_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_staged [List]
stable_sort [Core_list]
Same as sort, but guaranteed to be stable
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
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]
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_bigstring [Make_substring.Blit]
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 [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]
sub [Blit_intf.S]
sub [Bigstring]
sub ?pos ?len bstr
sub_shared [Bigstring]
sub_shared ?pos ?len bstr
subo [Flat_array_debug.Debug]
subo [Blit_intf.S_distinct]
subo [Blit_intf.S1]
subo [Blit_intf.S]
subset [Core_set]
subset t1 t2 returns true iff t1 is a subset of t2.
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]
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
sun [Day_of_week]
swap [Tuple.T2]
swap [Ref.Permissioned]
swap [Ref]
swap t1 t2 swaps the values in t1 and t2.
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_map]
symmetric_diff t1 t2 ~data_equal returns a list 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]

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 [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 [Stack_unit_tests.Debug]
t_of_sexp [Stack_intf.S]
t_of_sexp [Stable_unit_test_intf.Unordered_container_arg]
t_of_sexp [String_id.Stable.V1]
t_of_sexp [Stable_containers.Map.V1]
t_of_sexp [Stable_containers.Hash_set.V1]
t_of_sexp [Stable_containers.Hashtbl.V1]
t_of_sexp [Stable_containers.Set.V1]
t_of_sexp [Source_code_position]
t_of_sexp [Source_code_position0]
t_of_sexp [Sexpable.S3]
t_of_sexp [Sexpable.S2]
t_of_sexp [Sexpable.S1]
t_of_sexp [Sexpable.Of_stringable]
t_of_sexp [Sexpable.Of_sexpable]
t_of_sexp [Set_once]
t_of_sexp [Stable_unit_test_intf.Arg]
t_of_sexp [Result.Stable.V1]
t_of_sexp [Result]
t_of_sexp [Ref.Permissioned]
t_of_sexp [Ref]
t_of_sexp [Pool_intf.S.Pointer.Id]
t_of_sexp [Pid]
t_of_sexp [Or_error]
t_of_sexp [Ordering]
t_of_sexp [Option]
t_of_sexp [Nothing.Stable.V1]
t_of_sexp [Nothing0]
t_of_sexp [Month.Stable.V1]
t_of_sexp [Month]
t_of_sexp [Int_intf.S]
t_of_sexp [Sexpable.S]
t_of_sexp [Info]
t_of_sexp [Identifiable.S]
t_of_sexp [Host_and_port.Stable.V1]
t_of_sexp [Hash_set.Poly]
t_of_sexp [Hash_set_intf.S]
t_of_sexp [Fqueue]
t_of_sexp [Float_intf.S.Terse]
t_of_sexp [Float_intf.S.Sign]
t_of_sexp [Float_intf.S.Class]
t_of_sexp [Doubly_linked]
t_of_sexp [Dequeue]
t_of_sexp [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.Sexp_maybe]
t_of_sexp [Core_sexp]
t_of_sexp [Core_set.Poly.Tree]
t_of_sexp [Core_set.Poly]
t_of_sexp [Core_set_intf.S0.Tree]
t_of_sexp [Core_set_intf.S0]
t_of_sexp [Core_queue]
t_of_sexp [Core_map.Poly.Tree]
t_of_sexp [Core_map.Poly]
t_of_sexp [Core_map_intf.S.Tree]
t_of_sexp [Core_map_intf.S]
t_of_sexp [Core_list.Assoc]
t_of_sexp [Core_list]
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.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 [Comparator.Pre_binable]
t_of_sexp [Comparator.Pre]
t_of_sexp [Commutative_group.S]
t_of_sexp [Byte_units.Measure]
t_of_sexp [Byte_units]
t_of_sexp [Bucket.S]
t_of_sexp [Bucket.Contents]
t_of_sexp [Bucket.Make]
t_of_sexp [Bounded_int_table.With_key]
t_of_sexp [Bool]
t_of_sexp [Blang.Stable.V1]
t_of_sexp [Blang]
t_of_sexp [Bigstring]
t_of_sexp [Bag]
tag [Or_error]
tag t string is Result.map_error t ~f:(fun e -> Error.tag e string).
tag [Info]
tag_arg [Or_error]
tag_arg [Info]
take [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 [Core_list]
take_while l ~f returns the longest prefix of l for which f is true.
test [Binary_packing]
test_invariants [Fqueue]
test via asserts whether invariants hold
tests [Stable_unit_test_intf.Unordered_container_arg]
tests [Stable_unit_test_intf.Arg]
tg [Quickcheck]
triple generator
thu [Day_of_week]
tl [Core_list]
tl_exn [Core_list]
Return the given list without its first element.
to_alist [Core_map]
creates association list from map.
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_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 [Hash_queue.Make]
to_array [Core_set]
to_array [Core_queue]
to_array [Container_unit_tests.Test_generic]
to_array [Container.Generic_phantom]
to_array [Container.Generic]
to_array [Container.S1_phantom_invariant]
to_array [Container.S1_phantom]
to_array [Container.S1]
to_array [Container.S0_phantom]
to_array [Container.S0]
to_array [Container.Make]
to_bigstring [Substring_intf.S]
to_bigstring [Make_substring.F]
to_bigstring [Binable]
to_bigstring [Binable0]
to_exn [Info]
to_float [Floatable.S]
to_float [Core_int64]
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 t returns an int in 0,1,...6.
to_int [Core_nativeint]
to_int [Core_int]
to_int [Core_int64]
to_int [Core_int63]
to_int [Core_int32]
to_int [Core_char]
Return the ASCII code of the argument.
to_int32 [Core_nativeint]
to_int32 [Core_int]
to_int32 [Core_int64]
to_int32 [Core_int32]
to_int32_exn [Int_intf.S]
to_int32_exn [Core_nativeint]
to_int64 [Int_intf.S]
to_int64 [Float_intf.S]
to_int_exn [Intable.S]
to_int_exn [Flags_intf.S]
to_int_exn [Core_nativeint]
to_list [Stack_unit_tests.Debug]
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 [Core_set]
to_list and to_array produce sequences sorted in ascending order according to the comparator.
to_list [Core_queue]
to_list [Core_gc.Control.Fields]
to_list [Core_gc.Stat.Fields]
to_list [Container_unit_tests.Test_generic]
to_list [Container.Generic_phantom]
to_list [Container.Generic]
to_list [Container.S1_phantom_invariant]
to_list [Container.S1_phantom]
to_list [Container.S1]
to_list [Container.S0_phantom]
to_list [Container.S0]
to_list [Container.Make]
to_list_rev [Core_string]
Returns the reversed list of characters contained in a list.
to_nativeint [Core_nativeint]
to_nativeint [Core_int]
to_nativeint [Core_int64]
to_nativeint [Core_int32]
to_nativeint_exn [Int_intf.S]
to_ref [Ref.Permissioned]
to_string [Source_code_position]
to_string [Source_code_position0]
to_string [Sexpable.To_stringable]
to_string [Substring_intf.S]
to_string [Make_substring.F]
to_string [Int_set]
to_string [Stringable.S]
to_string [Exn]
to_string [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_hum [Int_intf.S]
to_string_hum [Int_conversions.Make]
to_string_hum [Info]
might be an expensive operation
to_string_hum [Float_intf.S]
Pretty print float, for example to_string_hum ~decimals:3 1234.1999 = "1_234.200" to_string_hum ~decimals:3 ~strip_zero:true 1234.1999 = "1_234.2" .
to_string_hum [Byte_units]
to_string_hum ?measure t returns a string representation of t.
to_string_mach [Exn]
to_tree [Core_set]
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_map]
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]
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_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_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 [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 [Core_queue]
transfer ~src ~dst adds all of the elements of src to the end of dst, then clears src.
transfer [Bag]
transfer ~src ~dst moves all of the elements from src to dst in constant time.
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 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]
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]
tue [Day_of_week]
tune [Core_gc]
Adjust the specified GC parameters.
tuple [Host_and_port]
tuple2 [Type_equal]

U
uid [Type_equal.Id]
uig [Quickcheck]
unsigned int generator (uniform random in range min_int, max_int)
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.
unimplemented [Or_error]
unimplemented name returns a standard error value for an unimplemented value.
unimplemented [Common]
For marking a given value as unimplemented.
union [Union_find]
union t1 t2 makes the class of t1 and the class of t2 be the same (if they are already equal, then nothing changes).
union [Core_set]
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_list [Core_set]
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]
unit [Memo]
efficient special case for argument type unit
unmarshal [Bigstring_marshal]
unmarshal ?pos buf unmarshals data contained in buf starting at position pos.
unmarshal_next [Bigstring_marshal]
unmarshal_next ?pos buf unmarshals data contained in buf starting at position pos.
unordered_append [Core_list]
List.unordered_append l1 l2 has the same elements as l1 @ l2, but in some unspecified order.
unpack [Unpack_buffer]
unpack t unpacks all the values that it can from t.
unpack_float [Binary_packing]
As with integers, floats can be be packed big endian or little endian, depending on the order in which the bytes of the float are layed out.
unpack_padded_fixed_string [Binary_packing]
Decode the fixed length padded string having length len from buf starting at pos.
unpack_signed_16 [Binary_packing]
The functions ending with _big_endian or _little_endian are faster than the ones with explicit byte_order argument:
unpack_signed_16_big_endian [Binary_packing]
unpack_signed_16_little_endian [Binary_packing]
unpack_signed_32 [Binary_packing]
unpack_signed_32_int [Binary_packing]
unpack_signed_32_int_big_endian [Binary_packing]
unpack_signed_32_int_little_endian [Binary_packing]
unpack_signed_64 [Binary_packing]
unpack_signed_64_big_endian [Binary_packing]
unpack_signed_64_int [Binary_packing]
unpack_signed_64_little_endian [Binary_packing]
unpack_signed_8 [Binary_packing]
unpack_unsigned_16 [Binary_packing]
unpack_unsigned_16_big_endian [Binary_packing]
unpack_unsigned_16_little_endian [Binary_packing]
unpack_unsigned_32_int [Binary_packing]
unpack_unsigned_32_int_big_endian [Binary_packing]
unpack_unsigned_32_int_little_endian [Binary_packing]
unpack_unsigned_8 [Binary_packing]
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.Float]
unsafe_blit [Core_array.Int]
unsafe_blit [Blit_intf.S_distinct]
unsafe_blit [Blit_intf.S1]
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_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]
Unsafe version of get.
unsafe_get_int16_be [Bigstring]
unsafe_get_int16_le [Bigstring]
unsafe_get_int32_be [Bigstring]
unsafe_get_int32_le [Bigstring]
unsafe_get_int32_t_be [Bigstring]
unsafe_get_int32_t_le [Bigstring]
unsafe_get_int64_be_exn [Bigstring]
unsafe_get_int64_le_exn [Bigstring]
unsafe_get_int64_t_be [Bigstring]
unsafe_get_int64_t_le [Bigstring]
unsafe_get_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]
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
uppercase [Core_string]
uppercase [Core_char]
Convert the given character to its equivalent uppercase character.
usage [Core_arg]
Arg.usage speclist usage_msg prints to standard error an error message that includes the list of valid options.
usage_string [Core_arg]
Returns the message that would have been printed by Arg.usage, if provided with the same parameters.
uw [Common]
Option handling

V
valid_or_error [Validate]
validate [Validated_intf.Raw]
validate [Option]
validate [Core_map]
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_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 [Option]
value None ~default = default value (Some x) ~default = x
value [Heap_block]
value t returns the value that is physically equal to t
value [Doubly_linked.Elt]
value [Bag.Elt]
value_exn [Option]
value_exn (Some x) = x.
value_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_map [Option]
value_map ~default ~f is the same as function Some x -> f x | None -> default
values [Blang]
values t forms the list containing every v for which Base v is a subexpression of t
verbose [Core_gc.Control.Fields]
verbose [Core_gc.Control]
volatile_contents [Bigbuffer]
Return the actual underlying bigstring used by this bigbuffer.

W
wed [Day_of_week]
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 [Common]
word_size [Word_size]
Returns the word size of this program, not necessarily of the OS
words [Byte_units]
write_all [Out_channel]
write_all file data writes all data to the named file.
write_lines [Out_channel]
write_lines file lines works like output_lines, except that the output is sent to the named file.

Z
zero [Int_intf.S]
zero [Float_intf.S]
zero [Commutative_group.S]
zero [Bucket.Contents]
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]