|
( * ) [Percent] |
|
( * ) [Int_intf.S.O] |
|
( * ) [Int_intf.S] |
|
( * ) [Float_intf.S.O] |
|
( * ) [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.O] |
|
(+) [Int_intf.S] |
|
(+) [Float_intf.S.O] |
|
(+) [Float_intf.S] |
|
(+) [Flags_intf.S] |
|
(+) [Commutative_group.S] |
|
(+) [Byte_units.Infix] |
( / ) t mul scales t by 1/mul
|
(+) [Bucket.Contents] |
|
(-) [Int_intf.S.O] |
|
(-) [Int_intf.S] |
|
(-) [Float_intf.S.O] |
|
(-) [Float_intf.S] |
|
(-) [Flags_intf.S] |
|
(-) [Commutative_group.S] |
|
(-) [Byte_units.Infix] |
|
(-) [Bucket.Contents] |
|
(/%) [Core_int.Infix] |
|
(/) [Int_intf.S.O] |
|
(/) [Int_intf.S] |
|
(/) [Float_intf.S.O] |
|
(/) [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] |
|
(~-) [Int_intf.S.O] |
|
(~-) [Int_intf.S] |
|
(~-) [Float_intf.S.O] |
|
__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__ [Percent.Stable.V1] |
|
__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_set_intf.Elt_binable] |
|
__bin_read_t__ [Core_queue] |
|
__bin_read_t__ [Core_map.Poly] |
|
__bin_read_t__ [Core_map_intf.Key_binable] |
|
__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__ [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 [Percent] |
|
abs [Int_intf.S.O] |
|
abs [Int_intf.S] |
Returns the absolute value of the argument.
|
abs [Float_intf.S.O] |
|
abs [Float_intf.S] |
|
abs_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 t a returns a new set with a added to t , or returns t if mem t a .
|
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 register ed.
|
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 [Percent] |
|
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 [Percent.Stable.V1] |
|
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_set_intf.Elt_binable] |
|
bin_read_t [Core_queue] |
|
bin_read_t [Core_map.Poly] |
|
bin_read_t [Core_map_intf.Key_binable] |
|
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 [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 [Percent.Stable.V1] |
|
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_set_intf.Elt_binable] |
|
bin_reader_t [Core_queue] |
|
bin_reader_t [Core_map.Poly] |
|
bin_reader_t [Core_map_intf.Key_binable] |
|
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 [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 [Percent.Stable.V1] |
|
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_set_intf.Elt_binable] |
|
bin_size_t [Core_queue] |
|
bin_size_t [Core_map.Poly] |
|
bin_size_t [Core_map_intf.Key_binable] |
|
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 [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 [Percent.Stable.V1] |
|
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_set_intf.Elt_binable] |
|
bin_t [Core_queue] |
|
bin_t [Core_map.Poly] |
|
bin_t [Core_map_intf.Key_binable] |
|
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 [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 [Percent.Stable.V1] |
|
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_set_intf.Elt_binable] |
|
bin_write_t [Core_queue] |
|
bin_write_t [Core_map.Poly] |
|
bin_write_t [Core_map_intf.Key_binable] |
|
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 [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 [Percent.Stable.V1] |
|
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_set_intf.Elt_binable] |
|
bin_writer_t [Core_queue] |
|
bin_writer_t [Core_map.Poly] |
|
bin_writer_t [Core_map_intf.Key_binable] |
|
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 [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 .
|
capacity [Core_stack] |
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_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.S] |
|
comparator [Comparator.S1] |
|
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 [Ref] |
|
compare [Polymorphic_compare] |
|
compare [Percent.Stable.V1] |
|
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_set_intf.Elt_binable] |
|
compare [Core_set_intf.Elt] |
|
compare [Core_map.Poly] |
|
compare [Core_map_intf.S] |
|
compare [Core_map_intf.Key_binable] |
|
compare [Core_map_intf.Key] |
|
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 [Polymorphic_compare_intf.S] |
|
compare [Blang.Stable.V1] |
|
compare [Blang] |
|
compare_decimal [Std_kernel] |
|
compare_direct [Core_set] |
compare_direct t1 t2 compares the sets t1 and t2 .
|
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] |
|
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 t returns the number of elements of t for which f returns true .
|
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] |
Returns the number of elements for which the provided function evaluates to true.
|
count [Container.S1_phantom] |
Returns the number of elements for which the provided function evaluates to true.
|
count [Container.S1] |
Returns the number of elements for which the provided function evaluates to true.
|
count [Container.S0_phantom] |
Returns the number of elements for which the provided function evaluates to true.
|
count [Container.S0] |
Returns the number of elements for which the provided function evaluates to true.
|
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] |
|
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 [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 n th 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 [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 t1 t2 computes the set difference t1 - t2 , i.e., the set containing all
elements in t1 that are not in t2 .
|
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 id returns true iff t was created by create id 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] |
|
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] |
Creates an empty set based on the provided comparator.
|
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] |
eprint message prints to stderr message , followed by a newline and flush.
|
eprintf [Std_internal] |
|
eprintf [Debug] |
eprintf message arg1 ... argn prints to stderr message , with sprintf-style format
characters instantiated, followed by a newline and flush.
|
eprintf [Core_printf] |
|
eprints [Debug] |
eprints message a sexp_of_a prints to stderr message and a as a sexp, followed
by a newline and flush.
|
epsilon [Float_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 [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 t1 t2 returns true iff the two sets have the same elements.
|
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 t ~f returns true iff there exists an a in t for which f a .
|
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] |
Returns true if and only if there exists an element for which the provided
function evaluates to true .
|
exists [Container.S1_phantom] |
Returns true if and only if there exists an element for which the provided
function evaluates to true .
|
exists [Container.S1] |
Returns true if and only if there exists an element for which the provided
function evaluates to true .
|
exists [Container.S0_phantom] |
Returns true if and only if there exists an element for which the provided
function evaluates to true .
|
exists [Container.S0] |
Returns true if and only if there exists an element for which the provided
function evaluates to true .
|
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 t ~f returns the subset of t for which f evaluates to true.
|
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] |
Like Core_set.map , except elements for which f returns None will be dropped.
|
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 t f returns an element of t for which f returns true, with no guarantee as
to which element is returned.
|
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] |
Returns as an option the first element for which f evaluates to true.
|
find [Container.S1_phantom] |
Returns as an option the first element for which f evaluates to true.
|
find [Container.S1] |
Returns as an option the first element for which f evaluates to true.
|
find [Container.S0_phantom] |
Returns as an option the first element for which f evaluates to true.
|
find [Container.S0] |
Returns as an option the first element for which f evaluates to true.
|
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] |
Like find , but throws an exception on failure.
|
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 i th 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 t f returns b for some a in t for which f a = Some b .
|
find_map [Container_unit_tests.Test_generic] |
|
find_map [Container.Generic_phantom] |
|
find_map [Container.Generic] |
|
find_map [Container.S1_phantom_invariant] |
Returns the first evaluation of f that returns Some , and returns None if there
is no such element.
|
find_map [Container.S1_phantom] |
Returns the first evaluation of f that returns Some , and returns None if there
is no such element.
|
find_map [Container.S1] |
Returns the first evaluation of f that returns Some , and returns None if there
is no such element.
|
find_map [Container.S0_phantom] |
Returns the first evaluation of f that returns Some , and returns None if there
is no such element.
|
find_map [Container.S0] |
Returns the first evaluation of f that returns Some , and returns None if there
is no such element.
|
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] |
In iter t ~f and fold t ~init ~f , if f mutates t , then the iteration will
raise.
|
fold [Core_set] |
fold t ~init ~f folds over the elements of the set from smallest to largest.
|
fold [Core_map] |
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 t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en , where e1..en
are the elements of t
|
fold [Container.S1_phantom] |
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en , where e1..en
are the elements of t
|
fold [Container.S1] |
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en , where e1..en
are the elements of t
|
fold [Container.S0_phantom] |
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en , where e1..en
are the elements of t
|
fold [Container.S0] |
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en , where e1..en
are the elements of t
|
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] |
Like Core_set.fold , except that it goes from the largest to the smallest element.
|
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 [a1; ...; an] ~f ~init: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] |
Like Core_set.fold , except that it will terminate early, if f returns `Stop .
|
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 t ~f returns true iff for all a in t , f a .
|
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] |
Returns true if and only if the provided function evaluates to true for all
elements.
|
for_all [Container.S1_phantom] |
Returns true if and only if the provided function evaluates to true for all
elements.
|
for_all [Container.S1] |
Returns true if and only if the provided function evaluates to true for all
elements.
|
for_all [Container.S0_phantom] |
Returns true if and only if the provided function evaluates to true for all
elements.
|
for_all [Container.S0] |
Returns true if and only if the provided function evaluates to true for all
elements.
|
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 [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 i th element is initialized with
f i (starting at zero)
|
init [Bigstring] |
init n ~f creates a bigstring t of length n , with t.{i} = f i
|
init [Core_random] |
Initialize the generator, using the argument as a seed.
|
input [In_channel] |
|
input_all [In_channel] |
|
input_binary_int [In_channel] |
|
input_byte [In_channel] |
|
input_char [In_channel] |
|
input_line [In_channel] |
input_line ?fix_win_eol t reads a line from t and returns it, without
the newline ("\n") character at the end, and, if fix_win_eol the trailing
"\r\n" is dropped.
|
input_lines [In_channel] |
Completely reads an input channel and returns the results as a list of
strings.
|
insert_after [Doubly_linked] |
|
insert_before [Doubly_linked] |
constant-time insertion of a new element.
|
insert_delimiter [Int_conversions] |
|
insert_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 t1 t2 computes the intersection of sets t1 and t2 .
|
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] |
Tests internal invariants of the set data structure.
|
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 t is true iff t is empty.
|
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 [Percent] |
|
is_inf [Float_intf.S] |
includes positive and negative Float.infinity
|
is_init [Flat_array_debug.Debug] |
|
is_init [Flat_array] |
is_init t i returns true iff flat tuple i 's slots are identical to those of
the init supplied to create .
|
is_last [Doubly_linked] |
|
is_lowercase [Core_char] |
'a' - 'z'
|
is_mmapped [Bigstring] |
is_mmapped bstr
|
is_nan [Percent] |
|
is_nan [Float_intf.S] |
|
is_negative [Comparable_intf.With_zero] |
|
is_non_negative [Comparable_intf.With_zero] |
|
is_non_positive [Comparable_intf.With_zero] |
|
is_none [Option] |
is_none t returns true iff t = None.
|
is_none [Core_weak] |
|
is_none [Common] |
|
is_null [Pool_intf.S.Pointer] |
|
is_ok [Stack_unit_tests] |
|
is_ok [Result.Export] |
|
is_ok [Result] |
|
is_positive [Comparable_intf.With_zero] |
|
is_pow2 [Int_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 [Core_weak] |
|
is_some [Common] |
|
is_sorted [Core_list] |
is_sorted t ~compare returns true iff forall adjacent a1; a2 in t , compare a1
a2 <= 0 .
|
is_sorted [Core_array] |
|
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'
|
is_zero [Percent] |
|
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 t ~f calls f on every element of t , going in order from the smallest to
largest.
|
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] |
Returns the number of elements in the 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.Basic2] |
|
map [Monad.Basic] |
Although map can be defined in terms of bind and return , it is almost always
better to define it directly.
|
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 ~comparator t ~f returns a new set created by applying f to every element in
t .
|
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] |
|
map_via_bind [Monad] |
|
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 id returns Some v if t was created by create id 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] |
Returns the largest element of the 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] |
The largest representable integer
|
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 t a returns true iff a is in t .
|
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] |
Checks whether the provided element is there, using polymorphic compare if equal
is not provided
|
mem [Container.S1_phantom] |
Checks whether the provided element is there, using polymorphic compare if equal
is not provided
|
mem [Container.S1] |
Checks whether the provided element is there, using polymorphic compare if equal
is not provided
|
mem [Container.S0_phantom] |
Checks whether the provided element is there using the default equality test, using
the provided equal function if it is not
|
mem [Container.S0] |
Checks whether the provided element is there using the default equality test, using
the provided equal function if it is not
|
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] |
Returns the smallest element of the 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_normal_value [Float_intf.S] |
|
min_positive_subnormal_value [Float_intf.S] |
min_positive_subnormal_value = 2 ** -1074
min_positive_normal_value = 2 ** -1022
|
min_value [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 [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 [Percent] |
|
neg [Int_intf.S.O] |
|
neg [Int_intf.S] |
Negation
|
neg [Float_intf.S.O] |
|
neg [Float_intf.S] |
|
neg_infinity [Float_intf.S] |
|
neg_infinity [Common] |
|
never_returns [Never_returns] |
|
never_returns [Common] |
|
new1 [Pool_intf.S] |
new<N> t a0 ... a<N-1> returns a new tuple from the pool, with the tuple's
slots initialized to a0 ...
|
new10 [Pool_intf.S] |
|
new11 [Pool_intf.S] |
|
new12 [Pool_intf.S] |
|
new2 [Pool_intf.S] |
|
new3 [Pool_intf.S] |
|
new4 [Pool_intf.S] |
|
new5 [Pool_intf.S] |
|
new6 [Pool_intf.S] |
|
new7 [Pool_intf.S] |
|
new8 [Pool_intf.S] |
|
new9 [Pool_intf.S] |
|
newline [Out_channel] |
|
next [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 normalize d 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 normalize d 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] |
The number of bits available in this integer type.
|
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_bp [Percent] |
|
of_bp_int [Percent] |
|
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 [Float_intf.S.O] |
|
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.O] |
|
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 [Int_intf.S.O] |
|
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_mult [Percent] |
|
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_percentage [Percent] |
|
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_string_allow_nan_and_inf [Percent] |
|
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_int_big_endian [Binary_packing] |
|
pack_signed_64_int_little_endian [Binary_packing] |
|
pack_signed_64_little_endian [Binary_packing] |
|
pack_signed_8 [Binary_packing] |
|
pack_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] |
Integer remainder, with the semantics of mod in Pervasives or rem in
Int32/64 , i.e.
|
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 t a returns a new set with a removed from t if mem t a , or returns t
otherwise.
|
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 t i returns a version of t with the i th smallest element removed,
in O(log n) time.
|
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 [Percent] |
|
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_binary_mode [Out_channel] |
|
set_binary_mode [In_channel] |
|
set_capacity [Flat_queue] |
set_capacity t capacity sets the length of the array backing t to as small as
value as possible that is not less than max capacity (length t) .
|
set_capacity [Core_stack] |
set_capacity t capacity sets the length of the array backing t to max capacity
(length t) .
|
set_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] |
|
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 [Percent.Stable.V1] |
|
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.Elt] |
|
sexp_of_t [Core_set_intf.S0] |
|
sexp_of_t [Core_set_intf.Elt_binable] |
|
sexp_of_t [Core_set_intf.Elt] |
|
sexp_of_t [Core_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_map_intf.Key_binable] |
|
sexp_of_t [Core_map_intf.Key] |
|
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 [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] |
shifts left, filling in with zeroes
|
shift_right [Int_intf.S] |
shifts right, filling in with zeroes, which will not preserve the sign of the
input
|
shift_right_logical [Int_intf.S] |
|
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] |
Creates a set based on the provided comparator that contains only the provided
element.
|
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 [Percent.Stable.V1] |
|
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 [Flags_intf.S] |
|
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.Elt] |
|
t_of_sexp [Core_set_intf.S0] |
|
t_of_sexp [Core_set_intf.Elt_binable] |
|
t_of_sexp [Core_set_intf.Elt] |
|
t_of_sexp [Core_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_map_intf.Key_binable] |
|
t_of_sexp [Core_map_intf.Key] |
|
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 [Commutative_group.S] |
|
t_of_sexp [Byte_units.Measure] |
|
t_of_sexp [Byte_units] |
|
t_of_sexp [Bucket.S] |
|
t_of_sexp [Bucket.Contents] |
|
t_of_sexp [Bucket.Make] |
|
t_of_sexp [Bounded_int_table.With_key] |
|
t_of_sexp [Bool] |
|
t_of_sexp [Blang.Stable.V1] |
|
t_of_sexp [Blang] |
|
t_of_sexp [Bigstring] |
|
t_of_sexp [Bag] |
|
t_of_sexp_allow_nan_and_inf [Percent] |
|
tag [Or_error] |
tag t string is Result.map_error t ~f:(fun e -> Error.tag e string) .
|
tag [Info] |
|
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_bp [Percent] |
|
to_bp_int [Percent] |
|
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_mult [Percent] |
|
to_nativeint [Core_nativeint] |
|
to_nativeint [Core_int] |
|
to_nativeint [Core_int64] |
|
to_nativeint [Core_int32] |
|
to_nativeint_exn [Int_intf.S] |
|
to_percentage [Percent] |
|
to_ref [Ref.Permissioned] |
|
to_sexp [Type_equal.Id] |
|
to_string [Source_code_position] |
to_string t converts t to the form "FILE:LINE:COL" .
|
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] |
delimiter is underscore by default
|
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_string_round_trippable [Float_intf.S] |
Like to_string , but guaranteed to be round-trippable.
|
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] |
|
type_id_name [Univ] |
|
typename_of_outer [Float_intf.S] |
|
typename_of_sexp_array [Std_internal] |
|
typename_of_sexp_bool [Std_internal] |
|
typename_of_sexp_list [Std_internal] |
|
typename_of_sexp_opaque [Std_internal] |
|
typename_of_sexp_option [Std_internal] |
|
typename_of_t [Unit] |
|
typename_of_t [Tuple.T3] |
|
typename_of_t [Tuple.T2] |
|
typename_of_t [Ref] |
|
typename_of_t [Option] |
|
typename_of_t [Int_intf.S] |
|
typename_of_t [Float_intf.S] |
|
typename_of_t [Core_string] |
|
typename_of_t [Core_list] |
|
typename_of_t [Core_lazy] |
|
typename_of_t [Core_char] |
|
typename_of_t [Core_array] |
|
typename_of_t [Bool] |
|
typerep_of_outer [Float_intf.S] |
|
typerep_of_sexp_array [Std_internal] |
|
typerep_of_sexp_bool [Std_internal] |
|
typerep_of_sexp_list [Std_internal] |
|
typerep_of_sexp_opaque [Std_internal] |
|
typerep_of_sexp_option [Std_internal] |
|
typerep_of_t [Unit] |
|
typerep_of_t [Tuple.T3] |
|
typerep_of_t [Tuple.T2] |
|
typerep_of_t [Ref] |
|
typerep_of_t [Option] |
|
typerep_of_t [Int_intf.S] |
|
typerep_of_t [Float_intf.S] |
|
typerep_of_t [Core_string] |
|
typerep_of_t [Core_list] |
|
typerep_of_t [Core_lazy] |
|
typerep_of_t [Core_char] |
|
typerep_of_t [Core_array] |
|
typerep_of_t [Bool] |
|
U |
uid [Type_equal.Id] |
|
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 t1 t2 returns the union of the two sets.
|
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 ~comparator list returns the union of all the sets in list .
|
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_int_big_endian [Binary_packing] |
|
unpack_signed_64_int_little_endian [Binary_packing] |
|
unpack_signed_64_little_endian [Binary_packing] |
|
unpack_signed_8 [Binary_packing] |
|
unpack_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_free [Pool_intf.S] |
unsafe_free t pointer frees the tuple pointed to by pointer without checking
pointer_is_valid
|
unsafe_get [Pool_intf.S] |
|
unsafe_get [Obj_array] |
|
unsafe_get [Flat_queue] |
|
unsafe_get [Flat_array_debug.Debug] |
|
unsafe_get [Flat_array] |
|
unsafe_get [Core_string] |
|
unsafe_get [Core_array] |
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 [Percent] |
|
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.O] |
|
zero [Int_intf.S] |
|
zero [Float_intf.S.O] |
|
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] |
|