Array_permute 
randomly permute an array.

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

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  
Binable0  
Binary_packing 
As with integers, floats can be be packed big endian or little endian, depending on
the order in which the bytes of the float are layed out.

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

Common 
Basic types and definitions required throughout the system.

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

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.

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

Univ_map 
universal/heterogeneous maps

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.
