Array_permute 
randomly permute an array.

Avltree 
This module implements a very low level interface to a mutable AVL tree.

Bag 
Imperative setlike data structure.

Bigbuffer_internal  
Bigbuffer 
Extensible string buffers based on Bigstrings.

Bigstring_marshal 
Utility functions for marshalling to and from bigstring

Bigstring 
String type based on
Bigarray , for use in I/O and Cbindings

Bigsubstring  
Binable0  
Binable  
Binary_packing 
Packs and unpacks various types of integers into and from strings.

Blang 
A simple boolean domainspecific language

Blit 
See
Blit_intf for documentation.

Blit_intf 
Standard type for
blit functions, and reusable code for validating blit
arguments.

Bool  
Bounded_int_table 
A
Bounded_int_table is a table whose keys can be mapped to integers in a fixed
range, 0 ...

Bucket  
Byte_units  create measure value creates a t from value units of the given measure.

Caml  
Common 
Basic types and definitions required throughout the system.

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

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

Comparable  lexicographic cmps x y compares x and y lexicographically using functions in the
list cmps .

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.

Constrained_float  
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  
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_intf 
Values returned by
hash must be nonnegative.

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

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

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

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_intf 
This module defines interfaces used in
Core.Std.Map .

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

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_intf 
This module defines interfaces used in
Core.Std.Set .

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

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.

Day_of_week 
For representing a day of the week.

Dequeue 
A double ended queue that can shrink and expand on both ends.

Doubly_linked 
doublylinked lists

Equal 
This module defines signatures that are to be included in other signatures to ensure a
consistent interface to
equal functions.

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 .

Exn 
Raised when finalization after an exception failed, too.

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

Flags 
See flags_intf.ml for documentation.

Flat_array 
An array of tuples, represented as an
Obj_array .

Flat_array_debug  
Flat_array_unit_tests 
This signature is here to remind us to update the unit tests whenever we change
Flat_array .

Floatable  
Float_intf 
Floatingpoint representation and utilities.

Float  
Float_robust_compare  
Fn 
various combinators for functions

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

Fqueue 
A simple polymorphic functional queue.

Hashable  
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_queue 
a hashqueue, where the values are of type 'a

Hash_set_intf  
Hash_set  
Hashtbl_unit_tests  
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.

Heap 
Minheap implementation, adapted from CLR.

Host_and_port  
Identifiable 
a signature for opaque identifier types.

Import 
This module is a grab bag.

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

Info  Info is a library for lazily constructing humanreadable information as a string or
sexp, with a primary use being error messages.

Intable  
Int_conversions  
Interfaces  
Interned_string 
Provides a functor for creating an interned string type.

Int_intf  
Int_math  
Int_replace_polymorphic_compare  
Int_set 
An implementation of compressed integer sets using lists of integer ranges.

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

Linked_stack 
A stack implemented with a list.

Make_substring  
Memo 
Memoization code  not reentrant!

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

Month  of_string s accepts threecharacter abbreviations with 3 capitalizations (e.g.

Never_returns  
No_polymorphic_compare  
Nothing0  
Nothing 
An uninhabited type.

Obj_array 
An array of
Obj.t s.

Only_in_test 
This module can be used to safely expose functions and values in signatures
that can only be used in unit tests.

Option  Option wraps the output x of successful functions in Some x .

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  Ordering is intended to make code that matches on the result of a comparison
more concise and easier to read.

Or_error 
Type for tracking errors in an Error.t.

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

Pid  
Polymorphic_compare_intf 
Interfaces used for hiding and replacing polymorphic compare.

Polymorphic_compare  ascending is identical to compare .

Pool 
See pool_intf.ml for documentation.

Pool_intf 
A manual memory manager for a set of mutable tuples.

Pool_unit_tests  
Pooled_hashtbl 
A polymorphic hashtbl that uses
Pool to avoid allocation.

Pooled_hashtbl_unit_test  
Pretty_printer 
A list of pretty printers for various types, for use in toplevels.

Quickcheck 
Module for easily generating unit tests.

Ref  swap t1 t2 swaps the values in t1 and t2 .

Result  Result is often used to handle error messages.

Robustly_comparable  
Set_once 
This module implements an option ref that starts out as None, and
may be set only once.

Sexpable  
Source_code_position0  
Source_code_position  
Stable_containers  
Stable_internal  
Stable  
Stable_unit_test_intf  
Stable_unit_test  
Stack_intf 
An interface for stacks that follows
Core 's conventions, as opposed to OCaml's
standard Stack module.

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

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  
Std  
Stringable  
String_id  
Substring_intf  create ?pos ?len base creates a substring of the base sequence of
* length len starting at position pos , i.e.

Substring  
Thread_safe_queue  
T  
Tuple 
Functors and signatures for dealing with modules for tuples.

Tuple_type 
Tuplelike types used in
Flat_array and Pool .

Tuple_type_intf  Slots has types t1 , ..., t9 of arities 1 to 9 that are isomorphic to tuple
types of the corresponding arities.

Type_equal 
For representing type equalities otherwise not known by the typechecker.

Union_find 
Imperative data structure for representing disjoint sets.

Unique_id_intf 
Signature for use by
module : Unique_id .

Unique_id 
Functors for creating modules that mint unique identifiers.

Unit 
Module for the type
unit .

Univ_map 
Universal/heterogeneous maps.

Univ 
An extensible "universal" variant type, that can be extended by adding new
constructors with arguments of arbitrary type.

Unpack_buffer 
A buffer for incremental decoding of an input stream.

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

Validated 
See
Validated_intf for documentation.

Validate 
A module for organizing validations of data structures.

With_return 
This is
include 'd and documented in module: Common .

Word_size 
For determining the word size that the program is using.
