Array_permute 
randomly permute an array.

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

Backtrace  Backtrace.Exn has functions for controlling and printing the backtrace of the most
recently raised exception.

Bag 
Imperative setlike data structure.

Bigbuffer 
Extensible string buffers based on Bigstrings.

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

Bigstring_marshal 
Utility functions for marshalling to and from bigstring

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

Blang 
A simple boolean domainspecific language

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  
Caml  
Command 
purely functional command line parsing

Common 
Basic types and definitions required throughout the system.

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

Comparable  ascending is identical to compare .

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  
Arg 
Parsing of command line arguments.

Array 
Maximum length of a normal array.

Bin_prot  
Char 
Character operations.

Condition  timedwait cond mtx timeout waits on condition variable cond
with mutex mtx until either the condition is signalled, or until
timeout expires.

Field  
Filename 
Warning! this library assumes we are in a POSIX compliant OS.

Gc 
Memory management control and statistics; finalised values.

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

Core_hashtbl_intf 
Values returned by
hash must be nonnegative.

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

Int32  
Int63 
The size of Int63 is always at least 63 bits.

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

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

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  
Mutex  lock mtx locks mtx , possibly waiting for it to be released
first by another thread.

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

Printf 
Formatting error and exit functions

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

Random 
Pseudorandom number generators (PRNG).

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

Stack 
Core_stack is a replacement for OCaml's standard Stack module that follows
Core idioms and adds some functions.

String 
An extension of the standard StringLabels.

Sys 
System interface.

Thread 
Lightweight threads.

Unix 
File descriptor.

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.

Crc 
Crc functions

Daemon  daemonize makes the executing process a daemon.

Date 
converts a string to a date, in formats:
* m/d/y
* ymd (* valid iso8601_extended *)
* DD MMM YYYY
* DDMMMYYYY
* YYYYMMDD

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 
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  
Floatable  
Float_intf 
Floatingpoint representation and utilities.

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  
Hash_set_intf  
Heap 
Minheap implementation, adapted from CLR.

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  
Identifiable 
a signature for opaque identifier types.

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  
Interval 
Module for simple closed intervals over arbitrary types that are ordered
correctly using polymorphic compare.

Interval_intf 
Module for simple closed intervals over arbitrary types that are ordered correctly
using polymorphic compare.

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

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

Linux_ext 
Interface to Linuxspecific system calls

Lock_file 
Mutual exclusion between processes using flock and lockf.

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.

Mutex0  create like Mutex.create , but creates an errorchecking mutex.

Nano_mutex  create () returns a new, unlocked mutex.

Never_returns  
No_polymorphic_compare  
Ofday  add t s shifts the time of day t by the span 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  
Piecewise_linear 
piecewise linear interpolation from floatlike types to float

Polymorphic_compare  ascending is identical to compare .

Polymorphic_compare_intf 
Interfaces used for hiding and replacing polymorphic compare.

Pretty_printer  
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  
Signal  of_system_int and to_system_int return and take respectively a signal number
corresponding to those in the system's /usr/include/bits/signum.h (or equivalent).

Source_code_position  
Source_code_position0  
Space_safe_tuple 
The raison d'etre for Space_safe_tuple<N> is that OCaml doesn't properly
free variables matched in tuple patterns.

Span 
Basic operations on spans

Squeue 
Threadsafe queue module, using locks.

Stable  
Stable_containers  
Stable_internal  
Stable_unit_test  
Stable_unit_test_intf  
Staged 
A type for making staging explicit in the type of a function.

Std  
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).

Stringable  
String_id  
Substring  
Substring_intf  create ?pos ?len base creates a substring of the base sequence of
* length len starting at position pos , i.e.

Sys_open_patch 
This module is here to avoid holding the runtime lock when doing an
open_in_gen lock.

T  
Thread_safe_queue  
Time 
A module for representing absolute points in time, independent of time zone.

Time_internal  
Timer 
Timed events

Tuple 
Functors and signatures for dealing with modules for tuples.

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

Union_find 
Imperative data structure for representing disjoint sets.

Unique_id 
Functors for creating modules that mint unique identifiers.

Unique_id_intf 
Signature for use by
module : Unique_id .

Unit 
Module for the type
unit .

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

Univ_map 
Universal/heterogeneous maps.

Unpack_buffer 
A buffer for incremental decoding of an input stream.

Uuid 
Implements universally unique identifiers based on version 3 of the UUID
specification.

Weekday 
For representing a day of the week.

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

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

Zone 
Timezone handling.
