Index of modules


A
Access_sig [Core_hashtbl_intf]
Agnostic_mutex [Std]
Agnostic_mutex
Agnostic mutexes do not remember the thread by which they got locked.
Algebraic_group [Std]
Algebraic_group
Arg [Std]
Arg [Caml]
Array [Std_internal]
Array [Hash_queue]
Array [Caml]
ArrayLabels [Caml]
Array_permute
randomly permute an array.
Assoc [Core_list]
Avltree
estokes:

B
Bag [Std]
Bag
A bag is a data structure like a set, except that: * * - It doesn't require anything (hashable, comparable) of elements in the bag.
Big_int [Std_internal]
Bigbuffer [Std]
Bigbuffer
Extensible string buffers.
Bigstring [Std]
Bigstring
Types and exceptions
Bigstring_marshal
Utility functions for marshalling to and from bigstring
Bigstring_marshal [Std]
Bigsubstring [Std]
Bigsubstring
Bin_prot [Std]
Binable [Std]
Binable
Binary_packing [Std]
Binary_packing
Blang [Std]
Blang
Simple boolean language
Blit [Make_substring]
Bool [Std_internal]
Bool
Bucket [Std]
Bucket
Buffer [Caml]
Byte_units [Std]
Byte_units

C
Callback [Caml]
Caml [Std]
Caml
Char [Std_internal]
Char [Caml]
Check [Container]
Check_S [Core_set_intf]
Check_S [Core_map_intf]
Check_S0 [Container]
Check_S0_phantom [Container]
Check_S1 [Core_set_intf]
Check_S1 [Container]
Check_S1_phantom [Container]
Check_S2 [Core_map_intf]
Check_S2_refines_S [Monad]
Class [Float_intf.S]
Clock [Linux_ext]
Common
Basic types and definitions required throughout the system.
Comparable [Tuple]
Comparable [Std]
Comparable
Inherit comparability from a component.
Complex [Caml]
Condition [Std]
Condition [Caml]
Constrained_float
Container [Std]
Container
fold f a [b1; ...; bn] is f (... (f (f a b1) b2) ...) bn.
Control [Core_gc]
Core_arg
Core_array
Array.get a n returns the element number n of array a.
Core_bin_prot
Core_char
Character operations.
Core_condition
timedwait cond mtx timeout waits on condition variable cond with mutex mtx until either the condition is signalled, or until timeout expires.
Core_field
Core_filename
Warning! this library assumes we are in a POSIX compliant OS.
Core_gc
Memory management control and statistics; finalised values.
Core_hashtbl
For many students of ocaml, using hashtables is complicated by the functors.
Core_hashtbl_intf
change t key f updates the given table by changing the value stored under key according to f, just like Map.change (see that for example).
Core_int
mod and div operators that have the right behavior on negative numbers, that is, x % y always returns a positive int between 0 and y-1.
Core_int32
Core_int63
The size of Int63 is always at least 63 bits.
Core_int64
Core_list
Tail recursive version of standard List functions, plus additional operations.
Core_map
Polymorphic map module.
Core_map_intf
the empty map
Core_mutex
lock mtx locks mtx, possibly waiting for it to be released first by another thread.
Core_nativeint
Core_printexc
This module is here to ensure that we don't use the functions 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_set
Polymorphic set module.
Core_set_intf
Core_sexp
Core_stack
Core_stack is a replacement for OCaml's standard Stack module that follows Core idioms and adds some functions.
Core_string
An extension of the standard StringLabels.
Core_sys
System interface.
Core_thread
Lightweight threads.
Core_unix
Interface to the Unix system.
Crc [Std]
Crc
Crc functions
Create_sig [Core_hashtbl_intf]

D
Daemon [Std]
Daemon
daemonize ?(close_stdio = true) ?(cd = "/") ?umask=[0] () makes the current executing process a daemon, and dups /dev/null to stdin/stdout/stderr if close_stdio=true.
Date [Std]
Date [Std.Time]
Date
converts a string to a date, in formats: * m/d/y * y-m-d (* valid iso8601_extended *) * DD MMM YYYY * DDMMMYYYY * YYYYMMDD
Debug_compare [Utest]
This functor will give you comparison functions which automatically call debug_printf when they are called with what they were called with and their result
Dequeue [Std]
Dequeue
An array that can shrink and expand on both ends - the minimum index need not be 0.
Digest [Caml]
Doubly_linked [Std]
Doubly_linked
doubly-linked lists

E
Elt [Doubly_linked]
Elt [Bag]
Error_check [Std]
Error_check
Module for 'toggle' error checking.
Event [Caml]
Exn [Std]
Exn
Raised when finalization after an exception failed, too.
Export [Result]
Export [Date]

F
F [Make_substring]
Field [Std]
File_descr [Core_unix]
File descriptor.
Filename [Std]
Filename [Caml]
Float [Std]
Float [Piecewise_linear]
Float [Interval]
Float
Float [Bucket]
Float_intf [Std]
Float_intf
Floating-point representation and utilities.
Float_robust_compare
Floatable [Std]
Floatable
Flock_command [Core_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
Simple implementation of a polymorphic functional queue.

G
Gc [Std]
Gc [Caml]
Gen [Interval_intf]
Gen [Core_set_intf]
Gen [Core_map_intf]
GenSet [Interval_intf]
Genlex [Caml]
Group [Core_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
Hash_set [Hashable.S_binable]
Hash_set [Hashable.S]
Hash_set [Hashable.Make_binable]
Hash_set [Hashable.Make]
Hash_set_intf
Hashable [Tuple]
Hashable [Std]
Hashable [Hashable.S_binable]
Hashable [Hashable.S]
Hashable [Hashable.Make_binable]
Hashable [Hashable.Make]
Hashable
Hashable_sexpable [Tuple]
Hashtbl [Std_internal]
Hashtbl [Hash_queue]
Hashtbl [Hash_heap]
Hashtbl [Hashable]
Hashtbl [Caml]
Heap [Std]
Heap
Min-heap implementation, adapted from CLR.
Helpers [Time_internal]
Host [Core_unix]
Host_and_port [Std]
Host_and_port

I
IOVec [Core_unix]
I/O-vectors for scatter/gather-operations
Identifiable [Std]
Identifiable
This module type is used to create various opaque identifier types.
In_channel [Std]
In_channel
In_channel collects all of the pervasive functions that work on in_channels.
Infix [Core_string]
Infix [Core_list]
Infix [Core_int]
Infix [Core_array]
Infix [Comparable.Make_common]
Inherit [Comparable]
Inherit comparability from a component.
Int [Std_internal]
Int [Unique_id]
Int [Piecewise_linear]
Int [Interval]
Int [Bucket]
Int32 [Std_internal]
Int32 [Caml]
Int63 [Unique_id]
Int63 [Std]
Int64 [Std_internal]
Int64 [Caml]
Int64 [Bucket]
Int_conversions
Takes an int represented as a string ((-|+)?0-9+) and puts delimiter every 3 digits starting from the right.
Int_intf [Std]
Int_intf
Int_set [Std]
Int_set
An implementation of compressed integer sets using lists of integer ranges.
Intable
Interfaces [Std]
Interfaces
Interval [Std]
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.

K
Key [Hash_heap.S]
Key [Hash_queue.S]
Key [Hash_heap.Make]
Key [Hash_queue.Make]
Key [Core_hashtbl_intf.Monomorphic.S]
Key1 [Core_hashtbl_intf.Monomorphic]
Key_poly [Core_hashtbl_intf]

L
Lazy [Caml]
Lexing [Caml]
Linebuf [Std]
Linebuf
Line-by-line reading of a file.
Linux_ext
Interface to Linux-specific system calls
Linux_ext [Std]
List [Std_internal]
List [Hash_queue]
List [Caml]
ListLabels [Caml]
Local_utest
Lock_file [Std]
Lock_file
Mutual exclusion between processes using flock and lockf.

M
Make [Utest]
Make [Piecewise_linear]
Make [Monad]
Make [Interval]
Make [Int_conversions]
Make [Hash_set]
Make [Hash_queue]
Make [Hash_heap]
Make [Hashable]
Make [Float_robust_compare]
Make [Core_set]
Make [Core_map]
Make [Core_hashtbl]
Make [Comparable]
Make [Bucket]
Make2 [Monad]
Make_binable [Hash_set]
Make_binable [Hashable]
Make_binable [Core_set]
Make_binable [Core_map]
Make_binable [Core_hashtbl]
Make_binable [Comparable]
Make_common [Comparable]
Make_substring
Map [Std_internal]
Map [Comparable.S_binable]
Map [Comparable.S]
Map [Comparable.Inherit]
Map [Comparable.Make_binable]
Map [Comparable.Make]
Map [Comparable.Poly]
Map [Caml]
Marshal [Caml]
Mcl_flags [Core_unix.Mman]
Measure [Byte_units]
Memo [Std]
Memo
Memoization code -- not re-entrant!
Mman [Core_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]
Monomorphic [Core_hashtbl_intf]
Month [Std]
Month
sexp_of_t_mode controls how months are converted to strings by sexp_of_t.
MoreLabels [Caml]
Mutex [Std]
Mutex [Caml]
Mutex0
create like Mutex.create, but creates an error-checking mutex.

N
Nat [Std_internal]
Native_file [Core_unix]
Nativeint [Std_internal]
Nativeint [Caml]
Nfs [Lock_file]
an implementation neutral NFS lock file scheme that relies on the atomicity of link and rename over NFS (see NFS Illustrated, atomicity for more information).
Num [Std_internal]

O
Of_sexpable [Identifiable]
Of_stringable [Sexpable]
Of_stringable [Identifiable]
Of_stringable [Binable]
Of_stringable_sexpable [Identifiable]
Of_stringable_sexpable, Of_stringable and Of_sexpable creates an identiable that uses string conversions for binable, sexpable, equality, hash, compare, and pp.
Ofday [Std]
Ofday [Std.Time]
Ofday
add t s shifts the time of day t by the span s.
Only_in_test [Utest]
Only_in_test [Std]
Oo [Caml]
Option [Std]
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.
Out_channel [Std]
Out_channel

P
Parsing [Caml]
Parts [Span]
Parts [Float_intf.S]
Returns the fractional part and the whole (i.e.
Passwd [Core_unix]
Structure of entries in the passwd database
Pervasives [Caml]
Piecewise_linear [Std]
Piecewise_linear
piece-wise linear interpolation from float-like types to float
Policy [Core_unix.Scheduler]
Poly [Hash_set]
Poly [Core_hashtbl]
Poly [Comparable]
Pretty_printer [Std]
Pretty_printer
Printexc [Std]
Printexc [Caml]
Printf [Caml]
Printf [Bigbuffer]
Priority [Core_unix]
Process_channels [Core_unix]
Similar to UnixLabels.open_process, but the second argument specifies the environment passed to the command.
Process_info [Core_unix]
Process_status [Core_unix]
The termination status of a process.
Protocol [Core_unix]

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

R
RLimit [Core_unix]
Resource limits
Random [Caml]
Ratio [Std_internal]
Ref
equal t1 t2 returns true if t1 and t2 are the same ref cell.
ReportAllFails [Error_check]
Resource_usage [Core_unix]
Resource usage -- For details, "man getrusage"
Result [Std]
Result
Result is often used to handle error messages.
Robust_compare [Time_internal]
Robustly_comparable [Std]
Robustly_comparable

S
Scanf [Caml]
Scheduler [Core_unix]
Select_fds [Core_unix]
Wait until some input/output operations become possible on some channels.
Service [Core_unix]
Set [Std_internal]
Set [Interval_intf.S1]
Set [Interval_intf.S]
Set [Comparable.S_binable]
Set [Comparable.S]
Set [Comparable.Inherit]
Set [Comparable.Make_binable]
Set [Comparable.Make]
Set [Comparable.Poly]
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_array [Core_sexp]
Sexp_list [Core_sexp]
Sexp_maybe [Std]
Sexp_maybe [Core_sexp]
Sexp_opaque [Core_sexp]
Sexp_option [Core_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]
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 [Std]
Span [Std.Time]
Span
Basic operations on spans
Squeue [Std]
Squeue
Thread-safe queue module, using locks.
Stack [Std_internal]
Stack [Caml]
Stat [Core_gc]
Std
StdLabels [Caml]
Std_internal
Step [Error_check]
Module for 'step' error checking with a moving threshold.
Stream [Caml]
String [Std_internal]
String [Caml]
StringLabels [Caml]
String_id
String_id [Std]
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.

T
T [Time_internal]
T [Interval_intf.S1.Set]
T [Interval_intf.S1]
T [Interval_intf.S.Set]
T [Interval_intf.S]
T [Core_set_intf.Gen]
T [Core_set_intf.S1]
T [Core_map_intf.Gen]
T [Core_map_intf.S2]
T [Core_hashtbl_intf.Monomorphic]
T [Core_hashtbl]
T [Core_set_intf.S]
T [Core_map_intf.S]
T2 [Tuple]
T2 [Space_safe_tuple]
T3 [Tuple]
T3 [Space_safe_tuple]
Table [Hashable.S_binable]
Table [Hashable.S]
Table [Hashable.Make_binable]
Table [Hashable.Make]
Table_sig [Hashable]
Terminal_io [Core_unix]
Terminal_io_intf
Ignore the break condition.
Terse [Float_intf.S]
Thread [Std]
Thread [Caml]
Thread_safe_queue
Thread_safe_queue [Std]
Time
Our time module.
Time [Std]
Time [Piecewise_linear]
Time [Interval]
Time_internal
Timer
Timed events
Timer [Std]
Timer [Error_check]
To_stringable [Sexpable]
Toggle [Error_check]
Module for 'toggle' error checking.
ToggleN [Error_check]
ToggleN error checking is the same as Toggle, except here you may specify a maximum number of failures that will be reported.
Tuple
Tuple [Std]
Tuple2 [Std]
Tuple3 [Std]

U
Unique_id
Unique_id [Std]
Unique_id_intf
Unique_id_intf [Std]
Unit
Unit [Std]
Unix [Std]
Unix [Caml]
UnixLabels [Caml]
Utest
Lightweight module for registering and running unit tests
Utest [Std]
Utsname [Core_unix]

W
Weak [Caml]
Weekday
of_string s accepts three-character abbreviations with any capitalization
Weekday [Std]
With_return
Word_size
Word_size [Std]
Writer [Core_bin_prot]

Z
Zone
find name looks up a t by its name and returns it.
Zone [Std]
Zone [Std.Time]