Index of types


_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]