Index of modules


A
Arg [Std]
Arg [Caml]
Arg_type [Command.Spec]
Array [Std_internal]
Array [Hash_queue]
Array [Caml]
ArrayLabels [Caml]
Array_permute
randomly permute an array.
Assoc [List]
Avltree
This module implements a very low level interface to a mutable AVL tree.

B
Backtrace [Std]
Backtrace
Backtrace.Exn has functions for controlling and printing the backtrace of the most recently raised exception.
Bag [Std]
Bag
Imperative set-like data structure.
Big_int [Std_internal]
Bigbuffer [Std]
Bigbuffer
Extensible string buffers based on Bigstrings.
Bigstring [Std]
Bigstring
String type based on Bigarray, for use in I/O and C-bindings
Bigstring_marshal [Std]
Bigstring_marshal
Utility functions for marshalling to and from bigstring
Bigsubstring [Std]
Bigsubstring
Bin_prot [Std]
Binable [Std]
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]
Binary_packing
Packs and unpacks various types of integers into and from strings.
Blang [Std]
Blang [Stable]
Blang
A simple boolean domain-specific language
Blit [Make_substring]
Bool [Std_internal]
Bool
Bounded_int_table [Std]
Bounded_int_table
A Bounded_int_table is a table whose keys can be mapped to integers in a fixed range, 0 ...
Bucket [Std]
Bucket
Buffer [Caml]
Byte_units [Std]
Byte_units
create measure value creates a t from value units of the given measure.

C
Callback [Caml]
Caml [Std]
Caml
Char [Std_internal]
Char [Caml]
Check [Container]
Check_S0 [Container]
Check_S0_phantom [Container]
Check_S1 [Container]
Check_S1_phantom [Container]
Check_S2_refines_S [Monad]
Class [Float_intf.S]
Clock [Linux_ext]
Command [Std]
Command
purely functional command line parsing
Common
Basic types and definitions required throughout the system.
Commutative_group [Std]
Commutative_group
A signature for a commutative group (in the group-theory sense).
Comparable [Tuple]
Comparable [Std]
Comparable
ascending is identical to compare.
Comparator [Std]
Comparator
A Comparator.t is a type-indexed 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.
Condition [Std]
Condition [Caml]
Constr [Univ]
A Constr.t represents a single constructor in the extensible variant type.
Constrained_float
Container [Std]
Container
Control [Gc]
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 non-negative.
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
Pseudo-random 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 [Std]
Crc
Crc functions

D
Daemon [Std]
Daemon
daemonize makes the executing process a daemon.
Date [Std]
Date [Time]
Date [Stable]
Date
converts a string to a date, in formats: * m/d/y * y-m-d (* valid iso8601_extended *) * DD MMM YYYY * DDMMMYYYY * YYYYMMDD
Deprecated [Command]
Deprecated should be used only by Core_extended.Deprecated_command.
Dequeue [Std]
Dequeue
A double ended queue that can shrink and expand on both ends.
Digest [Caml]
Direct [Unix.Resource_usage.Fields]
Direct [Gc.Control.Fields]
Direct [Gc.Stat.Fields]
Doubly_linked [Std]
Doubly_linked
doubly-linked lists

E
Elt [Doubly_linked]
Elt [Core_set_intf.S]
Elt [Bag]
Epoll [Linux_ext]
epoll() - a linux I/O multiplexer of the same family as select() or poll().
Equal [Std]
Equal
This module defines signatures that are to be included in other signatures to ensure a consistent interface to equal functions.
Error [Std]
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.
Error [Unix]
Escaping [String]
Operations for escaping and unescaping strings, with paramaterized escape and escapeworthy characters.
Event [Caml]
Exit [Unix]
The termination status of a process.
Exit_or_signal [Unix]
Exit_or_signal_or_stop [Unix]
Exn [Std]
Exn
Raised when finalization after an exception failed, too.
Exn [Backtrace]
Backtrace.Exn has functions for controlling and printing the backtrace of the most recently raised exception.
Export [Result]
Export [Ordering]
Export [Month]
Export [Date]

F
F [Make_substring]
Fd_redirection [Daemon]
Field [Std]
Fields [Unix.Resource_usage]
Fields [Gc.Control]
Fields [Gc.Stat]
File_descr [Unix]
File descriptor.
Filename [Std]
Filename [Caml]
Flags [Linux_ext.Epoll]
Flags
See flags_intf.ml for documentation.
Flags_intf
module Flags implements Unix-style sets of flags that are represented as an int with various bits set, one bit for each flag.
Float [Std]
Float [Piecewise_linear]
Float [Interval.Stable.V1]
Float [Interval]
Float
Float [Bucket]
Float_intf [Std]
Float_intf
Floating-point representation and utilities.
Float_robust_compare
Floatable [Std]
Floatable
Flock_command [Unix]
Fn [Std]
Fn
various combinators for functions
Force_once [Std]
Force_once
A "force_once" is a thunk that can only be forced once.
Format [Caml]
Format [Bigbuffer]
Fqueue [Std]
Fqueue
A simple polymorphic functional queue.

G
Gc [Std]
Gc [Caml]
Genlex [Caml]
Group [Unix]
Structure of entries in the groups database.

H
Hash_heap [Std]
Hash_heap
A hash-heap 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]
Hash_queue
a hash-queue, 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]
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]
Hashable [Hashable.S_binable]
Hashable [Hashable.S]
Hashable [Hashable.Make_binable]
Hashable [Hashable.Make]
Hashable
Hashable [Core_hashtbl_intf]
Hashable [Hashtbl]
Hashable_t [Tuple]
Hashtbl [Std_internal]
Hashtbl [Stable_containers]
Hashtbl [Hash_queue]
Hashtbl [Hash_heap]
Hashtbl [Hashable]
Hashtbl [Caml]
Heap [Std]
Heap
Min-heap implementation, adapted from CLR.
Heap_block [Std]
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.
Helpers [Time_internal]
Host [Unix]
Host_and_port [Std]
Host_and_port [Stable]
Host_and_port

I
IOVec [Unix]
I/O-vectors for scatter/gather-operations
Id [Type_equal]
Id provides identifiers for types, and the ability to test (via Id.same) at run-time if two identifiers are equal, and if so to get a proof of equality of their types.
Identifiable [Std]
Identifiable
a signature for opaque identifier types.
In_channel [Std]
In_channel
In_channel collects all of the pervasive functions that work on in_channels.
Inet_addr [Unix]
Infix [String]
Infix [List]
Infix [Int]
Infix [Array]
Infix [Byte_units]
Info [Std]
Info
Info is a library for lazily constructing human-readable information as a string or sexp, with a primary use being error messages.
Inherit [Comparable]
Inherit comparability from a component.
Int [Std_internal]
Int [Unique_id]
An abstract unique identifier based on ordinary OCaml integers.
Int [Piecewise_linear]
Int [Interval.Stable.V1]
Int [Interval]
Int [Bucket]
Int32 [Std_internal]
Int32 [Caml]
Int63 [Unique_id]
Int63 [Std]
Int63 [Flags_intf]
Int64 [Std_internal]
Int64 [Caml]
Int64 [Bucket]
Int_conversions
Int_intf [Std]
Int_intf
Int_math
Int_replace_polymorphic_compare
Int_set [Std]
Int_set
An implementation of compressed integer sets using lists of integer ranges.
Intable
Interfaces [Std]
Interfaces
Interned_string [Std]
Interned_string
Provides a functor for creating an interned string type.
Interval [Std]
Interval [Stable]
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.
Invariant [Std]
Invariant
This module defines signatures that are to be included in other signatures to ensure a consistent interface to invariant-style 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]
Linux_ext [Std]
Linux_ext
Interface to Linux-specific system calls
List [Std_internal]
List [Hash_queue]
List [Core_map_intf]
List [Caml]
List [Binable0]
ListLabels [Caml]
Lock_file [Std]
Lock_file
Mutual exclusion between processes using flock and lockf.
Low_level [Unix.Passwd]

M
Make [Tuple]
Make [Stable_unit_test]
Make [Piecewise_linear]
Make [Monad]
Make [Interval]
Make [Interned_string]
Make [Int_conversions]
Make [Identifiable]
Make [Hash_set]
Make [Hash_queue]
Make [Hash_heap]
Make [Hashable]
Make [Float_robust_compare]
Make [Flags_intf.Flags]
We expose type t = int in the result of Flags.Make so that one can easily use flag constants as values of the flag type without having to coerce them.
Make [Set]
Make [Map]
Make [Hashtbl]
Make [Container]
Make [Comparator]
Make [Comparable]
Make [Bucket]
Make1 [Comparator]
Make2 [Monad]
Make_binable [Hash_set]
Make_binable [Hashable]
Make_binable [Set]
Make_binable [Map]
Make_binable [Hashtbl]
Make_binable [Comparator]
Make_binable [Comparable]
Make_binable_using_comparator [Set]
Make_binable_using_comparator [Map]
Make_common [Comparable]
Make_substring
Make_using_comparator [Set]
Make_using_comparator [Map]
Map [Std_internal]
Map [Stable_containers]
Map [Comparable.S]
Map [Comparable.Make_binable]
Map [Comparable.Make]
Map [Comparable.Poly]
Map [Comparable.Map_and_set_binable]
Map [Caml]
Map_and_set_binable [Comparable]
Marshal [Caml]
Mcl_flags [Unix.Mman]
Measure [Byte_units]
Memo [Std]
Memo
Memoization code -- not re-entrant!
Mman [Unix]
Monad [Std]
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]
Month [Stable]
Month
of_string s accepts three-character abbreviations with 3 capitalizations (e.g.
MoreLabels [Caml]
Multi [Univ_map]
list-accumulating keys with a default value of the empty list
Mutex [Std]
Mutex [Caml]
Mutex0
create like Mutex.create, but creates an error-checking mutex.

N
Nano_mutex [Std]
Nano_mutex
A nano-mutex is a lightweight mutex that can be used only within a single OCaml runtime.
Nat [Std_internal]
Native_file [Unix]
Nativeint [Std_internal]
Nativeint [Caml]
Never_returns
Nfs [Lock_file]
An implementation neutral NFS lock file scheme that relies on the atomicity of link over NFS (see NFS Illustrated, atomicity for more information).
No_polymorphic_compare [Std]
No_polymorphic_compare
Num [Std_internal]

O
O [Sexp]
Of_sexpable [Sexpable]
Of_stringable [Sexpable]
Of_stringable [Binable0]
Of_stringable [Binable]
Ofday [Time]
Ofday [Stable]
Ofday [Piecewise_linear]
Ofday
add t s shifts the time of day t by the span s.
Ofday [Interval.Stable.V1]
Ofday [Interval]
Only_in_test [Std]
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]
Option
Option wraps the output x of successful functions in Some x.
Or_error [Std]
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]
Out_channel
Outputs a list of lines, each terminated by a newline character

P
Parsing [Caml]
Parts [Span]
Parts [Float_intf.S]
Returns the fractional part and the whole (i.e.
Passwd [Unix]
Structure of entries in the passwd database
Pervasives [Caml]
Pid [Std]
Pid
Piecewise_linear [Std]
Piecewise_linear
piece-wise linear interpolation from float-like types to float
Policy [Unix.Scheduler]
Poly [Hash_set]
Poly [Set]
Poly [Map]
Poly [Hashtbl]
Poly [Comparator]
Poly [Comparable]
Polymorphic_compare [Std]
Polymorphic_compare
ascending is identical to compare.
Polymorphic_compare_intf
Interfaces used for hiding and replacing polymorphic compare.
Pretty_printer [Std]
Pretty_printer
A list of pretty printers for various types, for use in toplevels.
Printexc [Std]
Printexc [Caml]
Printf [Std]
Printf [Caml]
Printf [Bigbuffer]
Priority [Linux_ext]
Priority [Unix]
Process_channels [Unix]
Similar to UnixLabels.open_process, but the second argument specifies the environment passed to the command.
Process_info [Unix]
Protocol [Unix]
Protocol_family [Unix]

Q
Queue [Std_internal]
Queue [Caml]
Quickcheck [Std]
Quickcheck
Module for easily generating unit tests.

R
RLimit [Unix]
Resource limits
Random [Std_internal]
Random [Caml]
Random [Array_permute]
Ratio [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.S_common]
Replace_polymorphic_compare [Comparable.Make_common]
Replace_polymorphic_compare [Comparable.Poly]
Resource_usage [Unix]
Resource usage -- For details, "man getrusage"
Result [Std]
Result [Stable]
Result
Result is often used to handle error messages.
Robustly_comparable [Std]
Robustly_comparable

S
S_to_S1 [Comparator]
Scanf [Caml]
Scheduler [Unix]
Select_fds [Unix]
Wait until some input/output operations become possible on some channels.
Service [Unix]
Set [Std_internal]
Set [Stable_containers]
Set [Interval_intf.S]
Set [Interval_intf.S1]
Set [Comparable.S]
Set [Comparable.Make_binable]
Set [Comparable.Make]
Set [Comparable.Poly]
Set [Comparable.Map_and_set_binable]
Set [Caml]
Set_once [Std]
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 [Sexp]
Sexp_list [Sexp]
Sexp_maybe [Std]
Sexp_maybe [Sexp]
Sexp_opaque [Sexp]
Sexp_option [Sexp]
Sexpable [Tuple]
Sexpable [Std]
Sexpable
Sign [Float_intf.S]
Signal [Std]
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).
Sort [Caml]
Source_code_position [Std]
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.
Space_safe_tuple2 [Std]
Space_safe_tuple3 [Std]
Span [Time]
Span [Stable]
Span
Basic operations on spans
Span [Piecewise_linear]
Spec [Command.Deprecated]
Spec [Command]
composable command-line specifications
Squeue [Std]
Squeue
Thread-safe queue module, using locks.
Stable [Time]
Stable [Weekday]
Stable [String_id]
Stable [Zone]
Stable
Stable [Span]
Stable [Result]
Stable [Ofday]
Stable [Month]
Stable [Interval]
Stable [Host_and_port]
Stable [Date]
Stable [Blang]
Stable_containers
Stable_internal
Stable_unit_test
Stable_unit_test_intf
Stack [Std_internal]
Stack [Caml]
Staged [Std]
Staged
A type for making staging explicit in the type of a function.
Stat [Gc]
State [Random]
The functions from module State manipulate the current state of the random generator explicitely.
Std
StdLabels [Caml]
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).
Stream [Caml]
String [Std_internal]
String [Caml]
StringLabels [Caml]
String_id
String_id [Std]
String_id [Stable]
Stringable
Stringable [Std]
Substring
Substring [Std]
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]
Sys [Std_internal]
Sys [Caml]
Sys_open_patch
This module is here to avoid holding the runtime lock when doing an open_in_gen lock.
Sysinfo [Linux_ext]

T
T [Time_internal]
T
T2 [Tuple]
Signature for a 2-tuple module
T2 [Space_safe_tuple]
T3 [Tuple]
Signature for a 3-tuple module
T3 [Space_safe_tuple]
Table [Hashable.S_binable]
Table [Hashable.S]
Table [Hashable.Make_binable]
Table [Hashable.Make]
Terminal_io [Unix]
Terse [Float_intf.S]
Thread [Std]
Thread [Caml]
Thread_safe_queue
Thread_safe_queue [Std]
Time
A module for representing absolute points in time, independent of time zone.
Time [Std]
Time [Stable]
Time [Piecewise_linear]
Time [Interval]
Time_internal
Timer
Timed events
Timer [Std]
To_stringable [Sexpable]
Tree [Core_set_intf.S]
Tree [Set]
Tree [Set.Poly]
Tree [Core_map_intf.S]
Tree [Map]
Tree [Map.Poly]
Tuple
Functors and signatures for dealing with modules for tuples.
Tuple [Std]
Tuple2 [Std]
Tuple3 [Std]
Type_equal
For representing type equalities otherwise not known by the type-checker.
Type_equal [Std]

U
Union_find
Imperative data structure for representing disjoint sets.
Union_find [Std]
Unique_id
Functors for creating modules that mint unique identifiers.
Unique_id [Std]
Unique_id_intf
Signature for use by module : Unique_id.
Unit
Module for the type unit.
Unit [Std]
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]
Univ_map
Universal/heterogeneous maps.
Univ_map [Std]
Unix [Std]
Unix [Caml]
UnixLabels [Caml]
Unpack_buffer
A buffer for incremental decoding of an input stream.
Unpack_buffer [Std]
Unpack_one [Unpack_buffer]
Utsname [Unix]
Uuid
Implements universally unique identifiers based on version 3 of the UUID specification.
Uuid [Std]

V
V1 [Stable_containers.Map]
V1 [Stable_containers.Hash_set]
V1 [Stable_containers.Hashtbl]
V1 [Stable_containers.Set]
V1 [Zone.Stable]
V1 [Weekday.Stable]
V1 [Time.Stable]
V1 [String_id.Stable]
V1 [Span.Stable]
V1 [Result.Stable]
V1 [Ofday.Stable]
V1 [Month.Stable]
V1 [Interval.Stable]
V1 [Host_and_port.Stable]
V1 [Date.Stable]
V1 [Blang.Stable]
V1_stable_unit_test [Result.Stable]

W
Weak [Std]
Weak [Caml]
Weekday
For representing a day of the week.
Weekday [Std]
Weekday [Stable]
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.
Without_squelch [Comparable.Make_common.Replace_polymorphic_compare]
Word_size
For determining the word size that the program is using.
Word_size [Std]
Writer [Bin_prot]

Z
Zone
Time-zone handling.
Zone [Std]
Zone [Time]
Zone [Stable]