Index of types


_bound [Std_kernel]
_ordering [Ordering.Export]
_result [Result.Export]

A
alarm [Core_gc]
An alarm is a piece of data that calls a user function at the end of each major GC cycle.
anon_fun [Core_arg]

B
base [Substring_intf.S]
base [Make_substring.F]
bigstring [Make_substring]
bigstring [Binable]
bigstring [Binable0]
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]
bound [Comparable]
bound [Comparable_intf]
Used for specifying a bound (either upper or lower) as inclusive, exclusive, or unbounded.

C
check [Validate]
to make function signatures easier to read
comparator [Comparator.S1]
comparator [Comparator.S_binable]
comparator [Comparator.S]
comparator [Comparable_intf.S_common]
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
decimal [Common]
The decimal type alias provides more readable serializations to s-expressions, at the cost of lower precision.
doc [Core_arg]
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.Generic_phantom]
elt [Container.Generic]
elt [Container.S0_phantom]
elt [Container.S0]
elt [Blit_intf.Sequence]
elt_ [Hash_set_intf.S]
endian [Binary_packing]
equal [Type_equal]
just an alias, needed when t gets shadowed below
equal [Equal]

F
fpclass [Common]

G
gen [Quickcheck]
the type of a random 'a-generator

H
hash_set [Hash_set_intf.S]
hashtbl [Core_hashtbl_intf.S]
heap_el [Heap]
Type of heap elements (they can be efficiently removed)

I
immutable [Common]
inv [Invariant_intf]

K
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_arg]
key_ [Core_hashtbl_intf.S]

M
m [Unit]
m [Binable]
m [Binable0]
map [Core_map.Poly]
map [Core_map_intf.S]
month [Month.Export]

N
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_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.

O
options [Core_set_intf.Creators_generic]
options [Core_set_intf.Accessors_generic]
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.
phantom [Container]

R
raw [Validated_intf.Validated]
read_only [Common]
Types for use as markers in phantom types.
read_write [Common]
return [With_return]
return [Common]
with_return f allows for something like the return statement in C within f.

S
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_opaque [Std_internal]
sexp_option [Std_internal]
sexp_option [Stable_internal]
spec [Core_arg]
The concrete type describing the behavior associated with a keyword.
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.Validated_binable]
t [Validated_intf.Validated]
t [Validated_intf.Raw_binable]
t [Validated_intf.Raw]
t [Word_size]
t [Validate]
The result of a validation.
t [Unpack_buffer.Unpack_one]
t [Unpack_buffer]
t [Univ_map.Multi.Key]
t [Univ_map.With_fold.Key]
t [Univ_map.With_default.Key]
t [Univ_map.Key]
create name to_sexp generates a fresh key.
t [Univ_map]
t [Univ.Constr]
t [Univ]
t [Unit]
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_equal.Injective2]
t [Unique_id_intf.Id]
The sexps and strings look like integers.
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 [Thread_safe_queue]
t [Staged]
t [Stack_intf.S]
t [Stable_unit_test_intf.Unordered_container_arg]
t [Stable_unit_test_intf.Unordered_container_test]
t [String_id.Stable.V1]
t [Stable_internal.Sexp]
t [Stable_containers.Map.V1]
t [Stable_containers.Hash_set.V1]
t [Stable_containers.Hashtbl.V1]
t [Stable_containers.Set.V1]
t [Source_code_position]
t [Source_code_position0]
t [Sexpable.S3]
t [Sexpable.S2]
t [Sexpable.S1]
t [Set_once]
t [Stable_unit_test_intf.Arg]
t [Result.Stable.V1]
t [Result]
'a is a function's expected return type, and 'b is often an error message string.
t [Ref.Permissioned]
t [Ref]
t [Pretty_printer.S]
t [Pool_intf.S.Pointer.Id]
Pointer ids are serializable, but have no other operations.
t [Pool_intf.S.Pointer]
A pointer to a tuple in a pool.
t [Pool_intf.S]
A pool.
t [Pid]
t [Out_channel]
t [Or_error]
t [Ordering]
t [Option]
Options are preferred over exceptions.
t [Only_in_test]
t [Obj_array]
t [Nothing.Stable.V1]
t [Nothing]
t [Nothing0]
t [Month.Stable.V1]
t [Month]
t [Monad.Infix2]
t [Monad.Basic2]
t [Monad.Basic]
t [Monad.Check_S2_refines_S]
t [Substring_intf.S]
t [Make_substring.Base]
t [Make_substring.F]
t [Make_substring.Blit]
t [Invariant_intf.S3]
t [Invariant_intf.S2]
t [Invariant_intf.S1]
t [Invariant_intf.S]
t [Invariant_intf]
t [Int_set]
t [Int_intf.S]
t [Stringable.S]
t [Sexpable.S]
t [Robustly_comparable.S]
t [Monad.Infix]
t [Intable.S]
t [Info]
t [In_channel]
t [Identifiable.S]
t [Host_and_port.Stable.V1]
t [Host_and_port]
t [Heap]
Type of heaps
t [Heap_block]
t [Hash_set.Poly]
t [Hash_set]
t [Hash_set_intf.S]
t [Hash_set_intf.Creators]
t [Hashable.S_binable]
t [Hash_heap.S]
t [Hash_queue.S]
a hash-queue, where the values are of type 'a
t [Hashable.S]
t [Hash_heap.Make]
t [Hash_queue.Make]
t [T.T_bin]
t [T.T3]
t [T.T2]
t [T.T1]
t [T.T]
t [Fqueue]
t [Force_once]
A "force_once" is a thunk that can only be forced once.
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 [Floatable.S]
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 [Exn]
t [Equal.S3]
t [Equal.S2]
t [Equal.S1]
t [Equal.S]
t [Equal]
t [Doubly_linked.Elt]
t [Doubly_linked]
t [Dequeue]
t [Day_of_week.Stable.V1]
t [Day_of_week]
t [Core_weak]
t [Core_string]
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.Poly.Tree]
t [Core_set.Poly]
t [Core_set.Tree]
t [Core_set]
t [Core_set_intf.S0.Tree]
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_queue]
t [Core_map.Poly.Tree]
t [Core_map.Poly]
t [Core_map.Tree]
t [Core_map]
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_list.Assoc]
t [Core_list]
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.Control]
t [Core_gc.Stat]
t [Core_char]
An alias for the type of characters.
t [Core_bin_prot.Writer]
t [Core_array]
t [Core_arg]
t [Container.Generic_phantom]
t [Container.Generic]
t [Container.S1_phantom_invariant]
t [Container.S1_phantom]
t [Container.S1]
t [Container.S0_phantom]
t [Container.S0]
t [Container.T]
t [Constrained_float.S]
t [Comparator.Pre_binable]
t [Comparator.Pre]
t [Comparator.S1]
t [Comparator]
t [Comparable_intf.Map_and_set_binable]
t [Comparable_intf.With_zero]
t [Comparable_intf.Validate]
t [Polymorphic_compare_intf.Infix]
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]
t [Blit_intf.S]
t [Blang.Stable.V1]
t [Blang]
t [Bigstring]
Type of bigstrings
t [Bigbuffer]
The abstract type of buffers.
t [Bigbuffer_internal]
t [Bag.Elt]
t [Bag]
t [Avltree]
t [Core_random.State]
t1 [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_ [Comparator]
table [Bounded_int_table]
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]
usage_msg [Core_arg]

V
variant [Day_of_week]

W
with_create_args [Out_channel]