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