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