|
_bound [Std_kernel] |
|
_either [Either_intf.S.Export] |
|
_ordering [Ordering.Export] |
|
_result [Result.Export] |
|
A |
arg [Applicative_intf.Args2] |
|
arg [Applicative_intf.Args] |
the underlying applicative
|
arg [Applicative_intf.Args_to_Args2] |
|
B |
base [Substring_intf.S] |
the type of strings that type t is a substring of
|
base [Make_substring.F] |
|
bigstring [Make_substring] |
|
bigstring [Binable0] |
|
bigstring [Binable] |
|
binary_search [Binary_searchable_intf] |
|
binary_search_segmented [Binary_searchable_intf] |
|
blit [Blit_intf] |
If blit : (src, dst) blit , then blit ~src ~src_pos ~len ~dst ~dst_pos blits len
values from src starting at position src_pos to dst at position dst_pos .
|
blito [Blit_intf] |
blito is like blit , except that the src_pos , src_len , and dst_pos are
optional (hence the "o" in "blito").
|
bound [Comparable_intf] |
Used for specifying a bound (either upper or lower) as inclusive, exclusive, or
unbounded.
|
bound [Comparable] |
|
bytes [Std_kernel] |
|
C |
check [Validate] |
to make function signatures easier to read
|
cmp [Core_set_intf.Creators_generic] |
|
cmp [Core_set_intf.Accessors_generic] |
|
comparator [Comparator] |
|
comparator_witness [Total_map.S] |
|
comparator_witness [Stable_containers.Comparable.V1.S] |
|
comparator_witness [Core_set_intf.Creators1] |
|
comparator_witness [Core_set_intf.Creators0] |
|
comparator_witness [Core_set_intf.Accessors1] |
|
comparator_witness [Core_set_intf.Accessors0] |
|
comparator_witness [Comparator.S] |
|
comparator_witness [Comparator.S1] |
|
compare [No_polymorphic_compare] |
|
contents [Bucket.S] |
|
contents [Bucket.Make] |
|
control [Core_gc] |
|
create_options [Hash_set_intf.Creators] |
|
create_options [Core_hashtbl_intf.Creators] |
|
create_options_with_hashable [Core_hashtbl_intf] |
|
create_options_with_hashable_required [Hash_set_intf] |
|
create_options_without_hashable [Hash_set_intf] |
|
create_options_without_hashable [Core_hashtbl_intf] |
|
D |
data [Univ_map_intf.S1] |
|
data [Univ_map_intf.S] |
|
decimal [Std_kernel] |
|
dest [Type_immediacy] |
|
dst [Blit_intf.S_distinct] |
|
E |
elt [Hash_set_intf.S] |
|
elt [Hash_set_intf.Creators] |
|
elt [Core_set_intf.Creators0] |
|
elt [Core_set_intf.Creators_generic] |
|
elt [Container_intf.Generic_phantom] |
|
elt [Container_intf.Generic] |
|
elt [Container_intf.S0_phantom] |
|
elt [Container_intf.S0] |
|
elt [Blit_intf.Sequence] |
|
elt [Binary_searchable_intf.S] |
|
elt [Binary_searchable_intf.Indexable] |
|
elt_ [Hash_set_intf.S] |
|
endian [Binary_packing] |
|
equal [Type_equal] |
just an alias, needed when t gets shadowed below
|
equal [Equal] |
|
F |
fn_with_sexp [Quickcheck_generator] |
Generators for functions, annotated with sexps that describe the functions.
|
fold [Container_intf.Container] |
|
fpclass [Common] |
|
G |
gen [Quickcheck_observer] |
|
H |
hash_set [Hash_set_intf.S] |
|
hashtbl [Core_hashtbl_intf.S] |
|
I |
immutable [Perms.Export] |
|
inv [Invariant_intf] |
|
iter [Container_intf.Container] |
|
K |
key [Stable_containers.Hashable.V1.S] |
|
key [Stable_containers.Comparable.V1.S] |
|
key [Core_map_intf.Creators1] |
|
key [Core_map_intf.Creators_generic] |
|
key [Core_map_intf.Accessors1] |
|
key [Core_map_intf.Accessors_generic] |
|
key [Core_hashtbl_intf.S] |
|
key [Core_hashtbl_intf.Creators] |
|
key [Core_hashtbl_intf.Accessors] |
|
key_ [Core_hashtbl_intf.S] |
|
M |
m [Unit] |
|
m [Binable0] |
|
m [Binable] |
|
map [Core_map_intf.S] |
|
map [Core_map.Poly] |
|
map_options [Core_hashtbl_intf.Accessors] |
|
me [Perms] |
|
month [Month.Export] |
|
N |
nan_dist [Quickcheck_generator] |
|
never_returns [Never_returns] |
|
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 _ .
|
no_map_options [Core_hashtbl_intf] |
|
no_raise [Core_sexp] |
no_raise is the identity, but by using 'a no_raise in a sexpable type, the
resulting use sexp_of_no_raise protects the conversion of 'a to a sexp so that if
it fails, one gets a sexp with an error message about the failure, rather than an
exception being raised.
|
nobody [Perms] |
Every type in this module besides the following two represent permission sets; these
two represent who is allowed to write in the Write.t and Immutable.t types.
|
O |
obs [Quickcheck_generator] |
|
options [Core_set_intf.Creators_generic] |
|
options [Core_set_intf.Accessors_generic] |
The options type is used to make Accessors_generic flexible as to whether a
comparator is required to be passed to certain functions.
|
options [Core_map_intf.Creators_generic] |
|
options [Core_map_intf.Accessors_generic] |
|
outer [Float_intf.S] |
|
P |
partial_sexp [Unpack_buffer.Unpack_one] |
Beware that when unpacking sexps, one cannot tell if one is at the end of an atom
until one hits punctuation.
|
perms [Perms.Export] |
|
priority_queue [Timing_wheel_intf.Timing_wheel.Priority_queue] |
|
R |
raw [Validated_intf.Validated] |
|
read [Perms.Export] |
We don't expose bin_io for write due to a naming conflict with the functions
exported by bin_io for read_write .
|
read_write [Perms.Export] |
|
return [With_return] |
|
return [Common] |
with_return f allows for something like the return statement in C within f .
|
S |
seed [Quickcheck_intf] |
seed specifies how to initialize a pseudo-random number generator.
|
sequence [Sequence] |
|
set [Core_set_intf.S0] |
|
set [Core_set_intf.Creators2_with_comparator] |
|
set [Core_set_intf.Creators2] |
|
set [Core_set_intf.Creators1] |
|
set [Core_set_intf.Creators0] |
|
set [Core_set_intf.Creators_generic] |
|
sexp [Core_sexp.O] |
|
sexp_array [Std_internal] |
|
sexp_bool [Std_internal] |
|
sexp_list [Std_internal] |
|
sexp_list [Stable_internal] |
|
sexp_opaque [Std_internal] |
|
sexp_option [Std_internal] |
|
sexp_option [Stable_internal] |
|
src [Blit_intf.S_distinct] |
|
stat [Core_gc] |
|
sub [Blit_intf] |
If sub : (src, dst) sub , then sub ~src ~pos ~len returns a sequence of type dst
containing len characters of src starting at pos .
|
subo [Blit_intf] |
|
T |
t [Validated_intf.S] |
|
t [Validated_intf.Validated] |
|
t [Validated_intf.Raw_binable] |
|
t [Validated_intf.Raw] |
|
t [Univ_map_intf.S1.Packed] |
|
t [Univ_map_intf.S1] |
The 's parameter is shared across all values stored in the map.
|
t [Univ_map_intf.S.Packed] |
|
t [Univ_map_intf.S] |
|
t [Timing_wheel_intf.Timing_wheel.Priority_queue.Elt] |
An Elt.t represents an element that was added to a timing wheel.
|
t [Timing_wheel_intf.Timing_wheel.Priority_queue] |
|
t [Timing_wheel_intf.Timing_wheel.Config] |
|
t [Timing_wheel_intf.Timing_wheel.Level_bits] |
The timing-wheel implementation uses an array of "levels", where level i is an
array of length 2^b_i , where the b_i are the "level bits" specified via
Level_bits.create_exn [b_0, b_1; ...] .
|
t [Timing_wheel_intf.Timing_wheel.Alarm] |
|
t [Timing_wheel_intf.Timing_wheel] |
|
t [Timing_wheel_intf.Interval_num.Span] |
|
t [Timing_wheel_intf.Interval_num] |
|
t [Timing_wheel_intf.Timing_wheel_time.Span] |
|
t [Timing_wheel_intf.Timing_wheel_time] |
|
t [T.T_bin] |
|
t [T.T3] |
|
t [T.T2] |
|
t [T.T1] |
|
t [T.T] |
|
t [Word_size] |
|
t [Validate] |
The result of a validation.
|
t [Unpack_buffer.Unpack_one] |
|
t [Unpack_buffer] |
The type of an unpack buffer.
|
t [Univ_map.Multi.Key] |
|
t [Univ_map.With_fold.Key] |
|
t [Univ_map.With_default.Key] |
|
t [Univ.View] |
|
t [Univ] |
|
t [Unit] |
|
t [Unique_id_intf.Id] |
The sexps and strings look like integers.
|
t [Union_find] |
type 'a t is the type of objects, where each object is part of an
equivalence class that is associated with a single value of type 'a .
|
t [Type_immediacy.Never] |
|
t [Type_immediacy.Sometimes] |
|
t [Type_immediacy.Always] |
|
t [Type_immediacy] |
|
t [Type_equal.Injective2] |
|
t [Type_equal.Id.Uid] |
|
t [Type_equal.Id] |
|
t [Type_equal.Injective] |
|
t [Type_equal] |
|
t [Tuple.Hashable_sexpable] |
|
t [Tuple.Comparable_sexpable] |
|
t [Tuple.Make] |
|
t [Tuple.T3] |
|
t [Tuple.T2] |
|
t [Total_map.Key] |
|
t [Total_map] |
|
t [Thread_safe_queue] |
|
t [Time_ns.Span.Parts] |
|
t [Time_ns.Span] |
Core_int63.t is immediate on 64bit boxes and so plays nicely with the GC write
barrier.
|
t [Time_ns] |
|
t [Staged] |
|
t [Stack_intf.S] |
|
t [Stable_unit_test_intf.Unordered_container_arg] |
|
t [Stable_unit_test_intf.Unordered_container_test] |
|
t [Stable_internal.Sexp] |
|
t [Stable_containers.Hashable.V1.S.Hash_set] |
|
t [Stable_containers.Hashable.V1.S.Table] |
|
t [Stable_containers.Comparable.V1.S.Set] |
|
t [Stable_containers.Comparable.V1.S.Map] |
|
t [Source_code_position0.Stable.V1] |
|
t [Source_code_position] |
|
t [Sexpable.S3] |
|
t [Sexpable.S2] |
|
t [Sexpable.S1] |
|
t [Set_once] |
|
t [Sequence.Step] |
|
t [Sequence] |
|
t [Rope] |
|
t [Stable_unit_test_intf.Arg] |
|
t [Result] |
'a is a function's expected return type, and 'b is often an error message string.
|
t [Ref.Permissioned] |
|
t [Ref] |
|
t [Raw_quickcheck_observer] |
|
t [Raw_quickcheck_generator.Choice] |
|
t [Raw_quickcheck_generator] |
|
t [Quickcheck_observer] |
|
t [Quickcheck_generator] |
|
t [Pretty_printer.S] |
|
t [Pool_intf.S.Pointer.Id] |
|
t [Pool_intf.S.Pointer] |
A pointer to a tuple in a pool.
|
t [Pool_intf.S] |
A pool.
|
t [Pid] |
|
t [Perms.Stable.V1.Upper_bound] |
|
t [Perms.Stable.V1.Read_write] |
|
t [Perms.Stable.V1.Immutable] |
|
t [Perms.Stable.V1.Write] |
|
t [Perms.Stable.V1.Read] |
|
t [Perms.Upper_bound] |
|
t [Perms.Read_write] |
|
t [Perms.Immutable] |
|
t [Perms.Write] |
|
t [Perms.Read] |
|
t [Percent] |
|
t [Out_channel] |
|
t [Ordering] |
|
t [Or_error] |
Serialization and comparison of an Error force the error's lazy message.
|
t [Option] |
|
t [Only_in_test] |
|
t [Obj_array] |
|
t [Nothing0] |
|
t [Nothing] |
|
t [Month] |
|
t [Monad_intf.Infix2] |
|
t [Monad_intf.Basic2] |
|
t [Monad_intf.Infix] |
|
t [Monad_intf.Basic] |
|
t [Monad_intf.S_to_S2] |
|
t [Substring_intf.S] |
|
t [Make_substring.Base] |
|
t [Make_substring.F] |
|
t [Make_substring.Blit] |
|
t [Linked_queue] |
|
t [Invariant_intf.S3] |
|
t [Invariant_intf.S2] |
|
t [Invariant_intf.S1] |
|
t [Invariant_intf.S] |
|
t [Invariant_intf] |
|
t [Stringable.S] |
|
t [Stable_module_types.S2] |
|
t [Sexpable.S] |
|
t [Robustly_comparable.S] |
|
t [Intable.S] |
|
t [Int_set] |
|
t [Int_math.T] |
|
t [Int_intf.S] |
|
t [Int_intf.Round] |
|
t [Int_intf.Hexable] |
|
t [Stable_module_types.S0] |
|
t [Info] |
Serialization and comparison force the lazy message.
|
t [In_channel] |
|
t [Identifiable.S] |
|
t [Host_and_port] |
|
t [Heap_intf.S] |
of_sexp and bin_io functions aren't supplied for heaps due to the difficulties in
reconstructing the correct comparison function when de-serializing.
|
t [Heap_block] |
|
t [Hashable.S_binable] |
|
t [Hashable.S] |
|
t [Hash_set_intf.S] |
|
t [Hash_set_intf.Creators] |
|
t [Hash_set.Poly] |
|
t [Hash_set] |
|
t [Hash_queue.S] |
a hash-queue, where the values are of type 'a
|
t [Hash_queue.Make] |
|
t [Hash_heap.S] |
|
t [Hash_heap.Make] |
|
t [Heap.Removable.Elt] |
|
t [Fqueue] |
|
t [Force_once] |
A "force_once" is a thunk that can only be forced once.
|
t [Floatable.S] |
|
t [Float_intf.S.Terse] |
|
t [Float_intf.S.Sign] |
|
t [Float_intf.S.Class] |
|
t [Float_intf.S.Parts] |
|
t [Float_intf.S] |
|
t [Flat_queue] |
The type of a flat queue.
|
t [Tuple_type_intf.Slot] |
A Slot.t represents a slot in a tuple type.
|
t [Tuple_type_intf.Slots] |
|
t [Flat_array] |
The type of a flat-tuple array.
|
t [Flags_intf.S] |
|
t [Fheap] |
t_of_sexp is not supported, because of the difficulty involved in recreating the
comparison function.
|
t [Fdeque] |
|
t [Exn] |
sexp_of_t uses a global table of sexp converters.
|
t [Equal.S3] |
|
t [Equal.S2] |
|
t [Equal.S1] |
|
t [Equal.S] |
|
t [Equal] |
|
t [Either_intf.S] |
This type represents values with two possibilities.
|
t [Either_intf.Focused] |
|
t [Doubly_linked.Elt] |
|
t [Doubly_linked] |
|
t [Deque] |
|
t [Decimal] |
|
t [Day_of_week] |
|
t [Core_weak] |
|
t [Core_string.Search_pattern] |
|
t [Core_string] |
|
t [Core_sexp.With_text] |
|
t [Core_sexp.Sexp_maybe] |
|
t [Core_sexp.Sexp_opaque] |
|
t [Core_sexp.Sexp_array] |
|
t [Core_sexp.Sexp_list] |
|
t [Core_sexp.Sexp_option] |
|
t [Core_sexp] |
|
t [Core_set_intf.S0.Tree] |
|
t [Core_set_intf.S0.Elt] |
|
t [Core_set_intf.S0] |
|
t [Core_set_intf.Creators2_with_comparator] |
|
t [Core_set_intf.Creators2] |
|
t [Core_set_intf.Creators1] |
|
t [Core_set_intf.Creators0] |
|
t [Core_set_intf.Creators_generic] |
|
t [Core_set_intf.Elt_binable] |
|
t [Core_set_intf.Elt] |
|
t [Core_set.Poly.Tree] |
|
t [Core_set.Poly] |
|
t [Core_set.Tree] |
A Tree.t contains just the tree data structure that a set is based on, without
including the comparator.
|
t [Core_set] |
The type of a set.
|
t [Core_queue] |
|
t [Core_map_intf.S.Tree] |
|
t [Core_map_intf.S] |
|
t [Core_map_intf.Creators3_with_comparator] |
|
t [Core_map_intf.Creators2] |
|
t [Core_map_intf.Creators1] |
|
t [Core_map_intf.Creators_generic] |
|
t [Core_map_intf.Accessors3_with_comparator] |
|
t [Core_map_intf.Accessors3] |
|
t [Core_map_intf.Accessors2] |
|
t [Core_map_intf.Accessors1] |
|
t [Core_map_intf.Accessors_generic] |
|
t [Core_map_intf.With_comparator] |
|
t [Core_map_intf.Without_comparator] |
|
t [Core_map_intf.Key_binable] |
|
t [Core_map_intf.Key] |
|
t [Core_map.Poly.Tree] |
|
t [Core_map.Poly] |
|
t [Core_map.Tree] |
|
t [Core_map] |
|
t [Core_list.Assoc] |
|
t [Core_list] |
compare on lists is lexicographic.
|
t [Stable_module_types.S1] |
|
t [Core_lazy] |
|
t [Core_hashtbl_intf.Hashtbl.Poly] |
|
t [Core_hashtbl_intf.Hashtbl] |
|
t [Core_hashtbl_intf.S] |
|
t [Core_hashtbl_intf.Creators] |
|
t [Core_hashtbl_intf.Accessors] |
|
t [Core_hashtbl_intf.Key_binable] |
|
t [Core_hashtbl_intf.Key] |
|
t [Core_hashtbl_intf.Hashable] |
|
t [Core_gc.Expert.Alarm] |
|
t [Core_gc.Allocation_policy] |
|
t [Core_gc.Control] |
|
t [Core_gc.Stat] |
|
t [Core_char] |
An alias for the type of characters.
|
t [Core_bytes] |
|
t [Core_bin_prot.Writer] |
|
t [Core_array.Permissioned] |
The meaning of the 'perms parameter is as usual (see the Perms module for more
details) with the non-obvious difference that you don't need any permissions to
extract the length of an array.
|
t [Core_array] |
|
t [Core_arg] |
|
t [Container_intf.Make_arg] |
|
t [Container_intf.Generic_phantom] |
|
t [Container_intf.Generic] |
|
t [Container_intf.S1_permissions] |
|
t [Container_intf.S1_phantom] |
|
t [Container_intf.S1_phantom_invariant] |
|
t [Container_intf.S1] |
|
t [Container_intf.S0_phantom] |
|
t [Container_intf.S0] |
|
t [Constrained_float.S] |
|
t [Comparator.S] |
|
t [Comparator.S1] |
|
t [Comparator] |
|
t [Polymorphic_compare_intf.Infix] |
|
t [Comparable_intf.With_zero] |
|
t [Comparable_intf.Validate] |
|
t [Comparable_intf.Map_and_set_binable] |
|
t [Commutative_group.S] |
|
t [Byte_units.Measure] |
|
t [Byte_units] |
|
t [Bucket.S] |
|
t [Bucket.Contents] |
|
t [Bucket.Make] |
|
t [Bounded_int_table.With_key] |
Serialization of a bounded int table using bin_io or sexp preserves num_keys ,
but only takes space proportional to the length of the table.
|
t [Bounded_int_table] |
|
t [Bool] |
|
t [Blit_intf.Sequence] |
|
t [Blit_intf.Elt] |
|
t [Blit_intf.S1_permissions] |
|
t [Blit_intf.S1] |
|
t [Blit_intf.S_permissions] |
|
t [Blit_intf.S] |
|
t [Blang] |
|
t [Binary_searchable_intf.S1_permissions] |
|
t [Binary_searchable_intf.S1] |
|
t [Binary_searchable_intf.S] |
|
t [Binary_searchable_intf.Indexable1] |
|
t [Binary_searchable_intf.Indexable] |
|
t [Bigstring] |
Type of bigstrings
|
t [Bigbuffer_internal] |
|
t [Bigbuffer] |
The abstract type of buffers.
|
t [Bag.Elt] |
|
t [Bag] |
|
t [Backtrace] |
A Backtrace.t is a snapshot of the stack obtained by calling Backtrace.get .
|
t [Avltree] |
|
t [Core_random.State] |
|
t [Applicative_intf.Args2] |
|
t [Applicative_intf.S2] |
|
t [Applicative_intf.Basic2] |
|
t [Applicative_intf.Args] |
'f is the type of a function that consumes the list of arguments and returns an
'r .
|
t [Applicative_intf.S] |
|
t [Applicative_intf.Basic] |
|
t [Applicative_intf.Args_to_Args2] |
|
t [Applicative_intf.S2_to_S] |
|
t [Applicative_intf.S_to_S2] |
|
t1 [Tuple_type_intf.Slots] |
|
t10 [Tuple_type_intf.Slots] |
|
t11 [Tuple_type_intf.Slots] |
|
t12 [Tuple_type_intf.Slots] |
|
t2 [Tuple_type_intf.Slots] |
|
t3 [Tuple_type_intf.Slots] |
|
t4 [Tuple_type_intf.Slots] |
|
t5 [Tuple_type_intf.Slots] |
|
t6 [Tuple_type_intf.Slots] |
|
t7 [Tuple_type_intf.Slots] |
|
t8 [Tuple_type_intf.Slots] |
|
t9 [Tuple_type_intf.Slots] |
|
t_ [Hash_set_intf.S] |
|
t_ [Core_hashtbl_intf.S] |
|
t_hum [Source_code_position0] |
|
t_hum [Source_code_position] |
|
t_now [Timing_wheel_intf.Timing_wheel] |
<:sexp_of< _ t_now >> displays only now t , not all the alarms.
|
table [Bounded_int_table] |
|
timing_wheel [Timing_wheel_intf.Timing_wheel] |
|
tree [Core_set_intf.S0] |
|
tree [Core_set_intf.Creators2_with_comparator] |
|
tree [Core_set_intf.Creators2] |
|
tree [Core_set_intf.Creators1] |
|
tree [Core_set_intf.Creators0] |
|
tree [Core_set_intf.Creators_generic] |
|
tree [Core_set_intf.Accessors2_with_comparator] |
|
tree [Core_set_intf.Accessors2] |
|
tree [Core_set_intf.Accessors1] |
|
tree [Core_set_intf.Accessors0] |
|
tree [Core_set_intf.Accessors_generic] |
|
tree [Core_map_intf.S] |
|
tree [Core_map_intf.Creators3_with_comparator] |
|
tree [Core_map_intf.Creators2] |
|
tree [Core_map_intf.Creators1] |
|
tree [Core_map_intf.Creators_generic] |
|
tree [Core_map_intf.Accessors3_with_comparator] |
|
tree [Core_map_intf.Accessors3] |
|
tree [Core_map_intf.Accessors2] |
|
tree [Core_map_intf.Accessors1] |
|
tree [Core_map_intf.Accessors_generic] |
|
U |
u [Tuple_type_intf.Slots] |
|
V |
validated [Validated_intf.Validated] |
|
W |
with_create_args [Out_channel] |
|
write [Perms.Export] |
|