Agnostic_mutex 
Agnostic mutexes do not remember the thread by which they got locked.

Array_permute 
randomly permute an array.

Avltree 
estokes:

Backtrace  
Bag 
A bag is a data structure like a set, except that:

Bigbuffer 
Extensible string buffers.

Bigstring 
Types and exceptions

Bigstring_marshal 
Utility functions for marshalling to and from bigstring

Bigsubstring  
Binable  
Binary_packing  
Blang 
Simple boolean language: propositional logic

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  
Common 
Basic types and definitions required throughout the system.

Commutative_group  
Comparable 
Inherit comparability from a component.

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  
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 
mod and div operators that have the right behavior on negative numbers,
that is,
x % y always returns a value between 0 and y1.

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

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

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

Core_map_intf 
Test whether a map is empty or not.

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  
Core_set_intf 
if
res = partition_tf set ~f then fst res are the elements on which f
produced true , and snd res are the elements on which f produces false

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.

Crc 
Crc functions

Daemon  daemonize ?(redirect_stdout=`Dev_null) ?(redirect_stderr=`Dev_null)
?(cd = "/") ?umask=[0] () makes the current
executing process a daemon, and dups "/dev/null", redirect_stdout, redirect_stderr
to stdin/stdout/stderr.

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

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

Doubly_linked 
doublylinked lists

Error 
Library for lazily constructing string error messages.

Exn 
Raised when finalization after an exception failed, too.

Float  
Float_intf 
Floatingpoint representation and utilities.

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

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

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.

Int_conversions 
Takes an int represented as a string ((+)?
09 +) and puts delimiter
every 3 digits starting from the right.

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

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

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 any capitalization

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

Nano_mutex  create () returns a new, unlocked mutex.

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 .

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 .

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

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.

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

String_id  
Stringable  
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 
Our time module.

Time_internal  
Timer 
Timed events

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.

Union_find 
Disjointsets.

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

Unpack_buffer 
If
unpack_one : ('value, 'partial_unpack) unpack_one , then unpack_one buf ?pos
?len ?partial_unpack must unpack at most one value of type 'value from buf
starting at pos , and not using more than len characters.

Weekday  of_string s accepts threecharacter abbreviations with any capitalization

With_return  
Word_size  
Zone  find name looks up a t by its name and returns it.
