A  
Arg [Std_kernel]  
Arg [Caml]  
Array [Std_internal]  
Array [Hash_queue]  
Array [Caml]  
ArrayLabels [Caml]  
Array_permute 
randomly permute an array.

Assoc [Core_list]  
Avltree 
This module implements a very low level interface to a mutable AVL tree.

B  
Bag [Std_kernel]  
Bag 
Imperative setlike data structure.

Big_int [Std_internal]  
Bigbuffer [Std_common]  
Bigbuffer 
Extensible string buffers based on Bigstrings.

Bigbuffer_internal  
Bigstring [Std_common]  
Bigstring 
String type based on
Bigarray , for use in I/O and Cbindings

Bigstring_marshal [Std_common]  
Bigstring_marshal 
Utility functions for marshalling to and from bigstring

Bigsubstring [Std_kernel]  
Bigsubstring  
Bin_prot [Std_kernel]  
Binable [Std_kernel]  
Binable [Hash_set_intf]  
Binable [Hashable]  
Binable [Float_intf]  
Binable [Core_set_intf]  
Binable [Core_map_intf]  
Binable [Core_hashtbl_intf]  
Binable  
Binable0  
Binary_packing [Std_kernel]  
Binary_packing 
Packs and unpacks various types of integers into and from strings.

Blang [Std_kernel]  
Blang [Stable]  
Blang 
A simple boolean domainspecific language

Blit [Make_substring]  
Bool [Std_internal]  
Bool  
Bounded_int_table [Std_kernel]  
Bounded_int_table 
A
Bounded_int_table is a table whose keys can be mapped to integers in a fixed
range, 0 ...

Bucket [Std_kernel]  
Bucket  
Buffer [Caml]  
Byte_units [Std_kernel]  
Byte_units  create measure value creates a t from value units of the given measure.

C  
Callback [Caml]  
Caml [Std_common]  
Caml  
Char [Std_internal]  
Char [Caml]  
Check [Container]  
Check_S0 [Container]  
Check_S0_phantom [Container]  
Check_S1 [Container]  
Check_S1_phantom [Container]  
Check_S1_phantom_invariant [Container]  
Check_S2_refines_S [Monad]  
Check_accessors [Core_set_intf]  
Check_accessors [Core_map_intf]  
Check_accessors0 [Core_set_intf]  
Check_accessors1 [Core_set_intf]  
Check_accessors1 [Core_map_intf]  
Check_accessors2 [Core_set_intf]  
Check_accessors2 [Core_map_intf]  
Check_accessors2_with_comparator [Core_set_intf]  
Check_accessors3 [Core_map_intf]  
Check_accessors3_with_comparator [Core_map_intf]  
Check_creators [Core_set_intf]  
Check_creators [Core_map_intf]  
Check_creators0 [Core_set_intf]  
Check_creators1 [Core_set_intf]  
Check_creators1 [Core_map_intf]  
Check_creators2 [Core_set_intf]  
Check_creators2 [Core_map_intf]  
Check_creators2_with_comparator [Core_set_intf]  
Check_creators3_with_comparator [Core_map_intf]  
Check_sexp_conversion [Comparable]  
Class [Float_intf.S]  
Common 
Basic types and definitions required throughout the system.

Commutative_group [Std_kernel]  
Commutative_group 
A signature for a commutative group (in the grouptheory sense).

Comparable [Tuple]  
Comparable [Std_kernel]  
Comparable  lexicographic cmps x y compares x and y lexicographically using functions in the
list cmps .

Comparable_intf 
Used for specifying a bound (either upper or lower) as inclusive, exclusive, or
unbounded.

Comparator [Std_kernel]  
Comparator 
A Comparator.t is a typeindexed value that allows you to compare (and for generating
error messages, serialize) values of the type in question.

Complex [Caml]  
Composition_preserves_injectivity [Type_equal]  Composition_preserves_injectivity is a functor that proves that composition of
injective types is injective.

Constr [Univ] 
A
Constr.t represents a single constructor in the extensible variant type.

Constrained_float  
Container [Std_kernel]  
Container 
The idiom for using
Container.Make is to bind the resulting module and to explicitly
import each of the functions that one wants:

Container_unit_tests  
Control [Core_gc]  
Core_arg 
Parsing of command line arguments.

Core_array 
Maximum length of a normal array.

Core_bin_prot  
Core_char 
Character operations.

Core_field  
Core_gc 
Memory management control and statistics; finalised values.

Core_hashtbl 
For many students of ocaml, using hashtables is complicated by the
functors.

Core_hashtbl_intf 
Values returned by
hash must be nonnegative.

Core_int  ceil_pow2 x returns the smallest power of 2 that is greater than or equal to
x .

Core_int32  
Core_int63 
The size of Int63 is always at least 63 bits.

Core_int64  
Core_lazy 
A value of type
'a Lazy.t is a deferred computation, called
a suspension, that has a result of type 'a .

Core_list 
Tail recursive version of standard List functions, plus additional operations.

Core_map 
This module defines the
Map module for Core.Std .

Core_map_intf 
This module defines interfaces used in
Core.Std.Map .

Core_map_unit_tests  
Core_nativeint  
Core_printexc 
This module is here to ensure that we don't use the functions in
Caml.Printexc
inadvertently

Core_printf 
Formatting error and exit functions

Core_queue 
Core_queue is a wrapper around OCaml's standard Queue module that
follows Core idioms and adds some functions.

Core_random 
Pseudorandom number generators (PRNG).

Core_set 
This module defines the
Set module for Core.Std .

Core_set_intf 
This module defines interfaces used in
Core.Std.Set .

Core_set_unit_tests  
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.

Core_stack 
A stack implemented with an array.

Core_string 
An extension of the standard StringLabels.

Core_weak  Weak is like the OCaml standard library module of the same name, except that it
requires that the values in the weak set are heap blocks.

D  
Day_of_week [Std_kernel]  
Day_of_week [Stable]  
Day_of_week 
For representing a day of the week.

Debug [Stack_unit_tests]  
Dequeue [Std_kernel]  
Dequeue 
A double ended queue that can shrink and expand on both ends.

Digest [Caml]  
Direct [Core_gc.Control.Fields]  
Direct [Core_gc.Stat.Fields]  
Doubly_linked [Std_kernel]  
Doubly_linked 
doublylinked lists

E  
Elt [Doubly_linked]  
Elt [Core_set_intf.S0]  
Elt [Bag]  
Equal [Std_kernel]  
Equal 
This module defines signatures that are to be included in other signatures to ensure a
consistent interface to
equal functions.

Error [Std_kernel]  
Error  failwiths message value sexp_of_value raises an exception with the supplied
message and value , by constructing an Error.t and using Error.raise .

Escaping [Core_string] 
Operations for escaping and unescaping strings, with paramaterized escape and
escapeworthy characters.

Exn [Std_kernel]  
Exn 
Raised when finalization after an exception failed, too.

Export [Result]  
Export [Ordering]  
Export [Month]  
F  
F [Make_substring]  
Field [Std_internal]  
Fields [Core_gc.Control]  
Fields [Core_gc.Stat]  
Filename [Caml]  
Flags [Std_kernel]  
Flags 
See flags_intf.ml for documentation.

Flags_intf  module Flags implements Unixstyle sets of flags that are represented as
an int with various bits set, one bit for each flag.

Float [Std_kernel]  
Float  
Float [Bucket]  
Float_intf [Std_kernel]  
Float_intf 
Floatingpoint representation and utilities.

Float_robust_compare  
Floatable [Std_kernel]  
Floatable  
Fn [Std_kernel]  
Fn 
various combinators for functions

Force_once [Std_kernel]  
Force_once 
A "force_once" is a thunk that can only be forced once.

Format [Caml]  
Format [Bigbuffer]  
Fqueue [Std_kernel]  
Fqueue 
A simple polymorphic functional queue.

G  
Gc [Std_common]  
Gc [Caml]  
Genlex [Caml]  
H  
Hash_heap [Std_kernel]  
Hash_heap 
A hashheap is a combination of a heap and a hashtbl that supports
constant time lookup, and log(n) time removal and replacement of
elements in addition to the normal heap operations.

Hash_heap [Hashable.S_binable]  
Hash_heap [Hashable.S]  
Hash_heap [Hashable.Make_binable]  
Hash_heap [Hashable.Make]  
Hash_queue [Std_kernel]  
Hash_queue 
a hashqueue, where the values are of type 'a

Hash_queue [Hashable.S_binable]  
Hash_queue [Hashable.S]  
Hash_queue [Hashable.Make_binable]  
Hash_queue [Hashable.Make]  
Hash_set [Std_kernel]  
Hash_set [Stable_containers]  
Hash_set  
Hash_set [Hashable.S_binable]  
Hash_set [Hashable.S]  
Hash_set [Hashable.Make_binable]  
Hash_set [Hashable.Make]  
Hash_set_intf  
Hashable [Tuple] 
The difference between
Hashable and Hashable_t functors is that the former's
result type doesn't contain type t and the latter does.

Hashable [Std_kernel]  
Hashable [Hashable.S_binable]  
Hashable [Hashable.S]  
Hashable [Hashable.Make_binable]  
Hashable [Hashable.Make]  
Hashable  
Hashable [Core_hashtbl_intf.Hashtbl]  
Hashable [Core_hashtbl_intf]  
Hashable_t [Tuple]  
Hashtbl [Std_internal]  
Hashtbl [Stable_containers]  
Hashtbl [Hash_queue]  
Hashtbl [Hash_heap]  
Hashtbl [Hashable]  
Hashtbl [Caml]  
Hashtbl_intf [Std_kernel]  
Hashtbl_unit_tests  
Heap [Std_kernel]  
Heap 
Minheap implementation, adapted from CLR.

Heap_block [Std_kernel]  
Heap_block 
A heap block is a value that is guaranteed to live on the OCaml heap, and is hence
guaranteed to be usable with finalization or in a weak pointer.

Host_and_port [Std_kernel]  
Host_and_port [Stable]  
Host_and_port  
I  
Id [Type_equal]  Id provides identifiers for types, and the ability to test (via Id.same ) at
runtime if two identifiers are equal, and if so to get a proof of equality of their
types.

Identifiable [Std_kernel]  
Identifiable 
a signature for opaque identifier types.

In_channel [Std_kernel]  
In_channel 
In_channel collects all of the pervasive functions that work on in_channels.

Infix [Core_string]  
Infix [Core_list]  
Infix [Core_int]  
Infix [Core_array]  
Infix [Byte_units]  
Info [Std_kernel]  
Info  Info is a library for lazily constructing humanreadable information as a string or
sexp, with a primary use being error messages.

Inherit [Comparable] 
Inherit comparability from a component.

Int [Unique_id] 
An abstract unique identifier based on ordinary OCaml integers.

Int [Std_internal]  
Int [Bucket]  
Int32 [Std_internal]  
Int32 [Caml]  
Int63 [Unique_id]  
Int63 [Std_kernel]  
Int63 [Flags_intf]  
Int64 [Std_internal]  
Int64 [Caml]  
Int64 [Bucket]  
Int_conversions  
Int_intf [Std_kernel]  
Int_intf  
Int_math  
Int_replace_polymorphic_compare  
Int_set [Std_kernel]  
Int_set 
An implementation of compressed integer sets using lists of integer ranges.

Intable  
Interfaces [Std_kernel]  
Interfaces  
Interned_string [Std_kernel]  
Interned_string 
Provides a functor for creating an interned string type.

Invariant [Std_kernel]  
Invariant 
This module defines signatures that are to be included in other signatures to ensure a
consistent interface to invariantstyle functions.

K  
Key [Univ_map.Multi]  
Key [Univ_map.With_fold]  
Key [Univ_map.With_default]  
Key [Univ_map]  
Key [Hash_heap.S]  
Key [Hash_queue.S]  
Key [Hash_heap.Make]  
Key [Hash_queue.Make]  
Key [Core_map_intf.S]  
L  
Lazy [Std_internal]  
Lazy [Caml]  
Lexing [Caml]  
Lift [Type_equal]  
Lift2 [Type_equal]  
Linked_stack [Std_kernel]  
Linked_stack 
A stack implemented with a list.

List [Std_internal]  
List [Hash_queue]  
List [Core_map_intf]  
List [Caml]  
List [Binable0]  
ListLabels [Caml]  
M  
Make [Validated_intf.S]  
Make [Tuple]  
Make [Stable_unit_test]  
Make [Monad]  
Make [Interned_string]  
Make [Int_conversions]  
Make [Identifiable]  
Make [Hashtbl_unit_tests]  
Make [Hash_set]  
Make [Hash_queue]  
Make [Hash_heap]  
Make [Hashable]  
Make [Float_robust_compare]  
Make [Flags_intf.Flags]  Flags.Make builds a new flags module.

Make [Core_set]  
Make [Core_map]  
Make [Core_hashtbl_intf.Hashtbl]  
Make [Container] 
The idiom for using
Container.Make is to bind the resulting module and to explicitly
import each of the functions that one wants:

Make [Comparator]  
Make [Comparable]  
Make [Bucket]  
Make1 [Comparator]  
Make2 [Monad]  
Make_binable [Validated_intf.S]  
Make_binable [Hash_set]  
Make_binable [Hashable]  
Make_binable [Core_set]  
Make_binable [Core_map]  
Make_binable [Core_hashtbl_intf.Hashtbl]  
Make_binable [Comparator]  
Make_binable [Comparable]  
Make_binable_using_comparator [Core_set]  
Make_binable_using_comparator [Core_map]  
Make_substring  
Make_unordered_container [Stable_unit_test]  
Make_using_comparator [Core_set]  
Make_using_comparator [Core_map]  
Map [Std_internal]  
Map [Stable_containers]  
Map [Comparable_intf.Map_and_set_binable]  
Map [Comparable_intf.S]  
Map [Caml]  
Map_and_set_binable [Comparable]  
Marshal [Caml]  
Measure [Byte_units]  
Memo [Std_kernel]  
Memo 
Memoization code  not reentrant!

Monad [Std_kernel]  
Monad  t >>= f returns a computation that sequences the computations represented by two
monad elements.

Monad_infix [Monad.S2]  
Monad_infix [Monad.Make2]  
Monad_infix [Monad.Check_S2_refines_S]  
Monad_infix [Monad.Make]  
Monad_infix [Monad.S]  
Month [Std_kernel]  
Month [Stable]  
Month  of_string s accepts threecharacter abbreviations with 3 capitalizations (e.g.

MoreLabels [Caml]  
Multi [Univ_map] 
listaccumulating keys with a default value of the empty list

N  
Nat [Std_internal]  
Nativeint [Std_internal]  
Nativeint [Caml]  
Never_returns  
No_polymorphic_compare [Std_kernel]  
No_polymorphic_compare  
Nothing [Std_kernel]  
Nothing [Stable]  
Nothing 
An uninhabited type.

Nothing0  
Num [Std_internal]  
O  
O [Core_sexp]  
Of_sexpable [Sexpable]  
Of_stringable [Sexpable]  
Of_stringable [Binable]  
Of_stringable [Binable0]  
Only_in_test [Std_kernel]  
Only_in_test 
This module can be used to safely expose functions and values in signatures
that can only be used in unit tests.

Oo [Caml]  
Option [Std_kernel]  
Option  Option wraps the output x of successful functions in Some x .

Or_error [Std_kernel]  
Or_error 
Type for tracking errors in an Error.t.

Ordered_collection_common  normalize length_fun thing_with_length i is just i , unless
i is negative, in which case it's length_fun thing_with_length + i .

Ordering [Std_internal]  
Ordering  Ordering is intended to make code that matches on the result of a comparison
more concise and easier to read.

Out_channel [Std_kernel]  
Out_channel 
Outputs a list of lines, each terminated by a newline character

P  
Parsing [Caml]  
Parts [Float_intf.S] 
Returns the fractional part and the whole (i.e.

Permissioned [Ref]  
Pervasives [Caml]  
Pid [Std_kernel]  
Pid  
Poly [Hash_set]  
Poly [Core_set]  
Poly [Core_map]  
Poly [Core_hashtbl_intf.Hashtbl]  
Poly [Comparator]  
Poly [Comparable]  
Polymorphic_compare [Std_kernel]  
Polymorphic_compare  ascending is identical to compare .

Polymorphic_compare_intf 
Interfaces used for hiding and replacing polymorphic compare.

Pretty_printer [Std_kernel]  
Pretty_printer 
A list of pretty printers for various types, for use in toplevels.

Printexc [Std_kernel]  
Printexc [Caml]  
Printf [Std_kernel]  
Printf [Caml]  
Printf [Bigbuffer]  
Q  
Queue [Std_internal]  
Queue [Caml]  
Quickcheck [Std_kernel]  
Quickcheck 
Module for easily generating unit tests.

R  
Random [Std_internal]  
Random [Caml]  
Random [Array_permute]  
Ratio [Std_internal]  
Ref [Std_internal]  
Ref  swap t1 t2 swaps the values in t1 and t2 .

Register [Pretty_printer]  Register builds a pp function from a to_string function, and adds the
module_name ^ ".pp" to the list of pretty printers.

Register_pp [Pretty_printer]  Register_pp is like Register , but allows a custom pp function rather than using
to_string .

Replace_polymorphic_compare [Comparable_intf.S_common]  
Result [Std_kernel]  
Result [Stable]  
Result  Result is often used to handle error messages.

Robustly_comparable [Std_kernel]  
Robustly_comparable  
S  
S_to_S1 [Comparator]  
Scanf [Caml]  
Set [Std_internal]  
Set [Stable_containers]  
Set [Comparable_intf.Map_and_set_binable]  
Set [Comparable_intf.S]  
Set [Caml]  
Set_once [Std_kernel]  
Set_once 
This module implements an option ref that starts out as None, and
may be set only once.

Sexp [Std_internal]  
Sexp [Stable_internal]  
Sexp_array [Core_sexp]  
Sexp_list [Core_sexp]  
Sexp_maybe [Std_kernel]  
Sexp_maybe [Core_sexp]  
Sexp_opaque [Core_sexp]  
Sexp_option [Core_sexp]  
Sexpable [Tuple]  
Sexpable [Std_kernel]  
Sexpable  
Sign [Float_intf.S]  
Sort [Caml]  
Source_code_position [Std_kernel]  
Source_code_position  
Source_code_position0  
Stable [String_id]  
Stable  
Stable [Result]  
Stable [Nothing]  
Stable [Month]  
Stable [Host_and_port]  
Stable [Day_of_week]  
Stable [Blang]  
Stable_containers  
Stable_internal  
Stable_unit_test  
Stable_unit_test_intf  
Stack [Std_kernel]  
Stack [Caml]  
Stack_intf 
An interface for stacks that follows
Core 's conventions, as opposed to OCaml's
standard Stack module.

Stack_unit_tests  
Staged [Std_kernel]  
Staged 
A type for making staging explicit in the type of a function.

Stat [Core_gc]  
State [Core_random] 
The functions from module
State manipulate the current state
of the random generator explicitely.

Std  
StdLabels [Caml]  
Std_common  
Std_internal  stable_dedup Same as dedup but maintains the order of the list and doesn't allow
compare function to be specified (otherwise, the implementation in terms of Set.t
would hide a heavyweight functor instantiation at each call).

Std_kernel  
Stream [Caml]  
String [Std_internal]  
String [Caml]  
StringLabels [Caml]  
String_id  
String_id [Std_kernel]  
String_id [Stable]  
Stringable  
Stringable [Std_kernel]  
Substring  
Substring [Std_kernel]  
Substring_intf  create ?pos ?len base creates a substring of the base sequence of
* length len starting at position pos , i.e.

Substring_intf [Std_kernel]  
Sys [Caml]  
T  
T  
T2 [Tuple] 
Signature for a 2tuple module

T3 [Tuple] 
Signature for a 3tuple module

Table [Hashable.S_binable]  
Table [Hashable.S]  
Table [Hashable.Make_binable]  
Table [Hashable.Make]  
Terse [Float_intf.S]  
Test [Stack_unit_tests]  
Test_S1 [Container_unit_tests]  
Test_generic [Container_unit_tests]  
Thread_safe_queue  
Thread_safe_queue [Std_kernel]  
To_stringable [Sexpable]  
Tree [Core_set.Poly]  
Tree [Core_set]  
Tree [Core_set_intf.S0]  
Tree [Core_map.Poly]  
Tree [Core_map]  
Tree [Core_map_intf.S]  
Tuple 
Functors and signatures for dealing with modules for tuples.

Tuple [Std_kernel]  
Tuple2 [Std_kernel]  
Tuple3 [Std_kernel]  
Type_equal 
For representing type equalities otherwise not known by the typechecker.

Type_equal [Std_kernel]  
U  
Uid [Type_equal.Id] 
Every
Id.t contains a unique id that is distinct from the Uid.t in any other
Id.t .

Union_find 
Imperative data structure for representing disjoint sets.

Union_find [Std_kernel]  
Unique_id 
Functors for creating modules that mint unique identifiers.

Unique_id [Std_kernel]  
Unique_id_intf 
Signature for use by
module : Unique_id .

Unit 
Module for the type
unit .

Unit [Std_kernel]  
Unit_test [Stable]  
Unit_tests [Stable]  
Univ 
An extensible "universal" variant type, that can be extended by adding new
constructors with arguments of arbitrary type.

Univ [Std_kernel]  
Univ_map 
Universal/heterogeneous maps.

Univ_map [Std_kernel]  
Unordered_container_test [Stable_unit_test_intf]  
Unpack_buffer 
A buffer for incremental decoding of an input stream.

Unpack_buffer [Std_kernel]  
Unpack_one [Unpack_buffer]  
V  
V1 [String_id.Stable]  
V1 [Stable_containers.Map]  
V1 [Stable_containers.Hash_set]  
V1 [Stable_containers.Hashtbl]  
V1 [Stable_containers.Set]  
V1 [Result.Stable]  
V1 [Nothing.Stable]  
V1 [Month.Stable]  
V1 [Host_and_port.Stable]  
V1 [Day_of_week.Stable]  
V1 [Blang.Stable]  
V1_stable_unit_test [Result.Stable]  
Validate 
A module for organizing validations of data structures.

Validate [Std_kernel]  
Validate [Comparable]  
Validate_with_zero [Comparable]  
Validated 
See
Validated_intf for documentation.

Validated [Std_kernel]  
Validated_intf 
For making an abstract version of a type that ensures a validation check has passed.

W  
Weak [Std_kernel]  
Weak [Caml]  
With_comparator [Core_set_intf]  
With_comparator [Core_map_intf]  
With_default [Univ_map] 
keys with associated default values, so that
find is no longer partial

With_fold [Univ_map] 
keys that map to an accumulator value with an associated fold operation

With_key [Bounded_int_table]  
With_return 
This is
include 'd and documented in module: Common .

With_zero [Comparable]  
Without_comparator [Core_set_intf]  
Without_comparator [Core_map_intf]  
Word_size 
For determining the word size that the program is using.

Word_size [Std_kernel]  
Writer [Core_bin_prot] 