A | |
| Agnostic_mutex [Std] | |
| Agnostic_mutex | |
| Arg [Std] | |
| Arg [Caml] | |
| Array [Std_internal] | |
| Array [Hash_queue] | |
| Array [Caml] | |
| ArrayLabels [Caml] | |
| Array_permute |
randomly permute an array.
|
B | |
| Backtrace [Std] | |
| Backtrace | |
| Bag [Std] | |
| Bag |
A bag is a data structure like a set, except that:
|
| Bigbuffer [Std] | |
| Bigbuffer |
Bigbuffer
|
| Bigstring [Std] | |
| Bigstring |
Types and exceptions
|
| Bigsubstring [Std] | |
| Bigsubstring | |
| Binable [Std] | |
| Binable | |
| Binary_packing [Std] | |
| Binary_packing |
unpack a signed 1 byte int from the given buf starting at pos
|
| Blit [Make_substring] | |
| Bool [Std] | |
| Bool | |
| Bucket [Std] | |
| Bucket |
Bucket-style datastucture
|
| Buffer [Caml] | |
| Byte_units [Std] | |
| Byte_units | |
C | |
| Callback [Caml] | |
| Caml [Std] | |
| Caml | |
| Char [Std_internal] | |
| Char [Caml] | |
| Check [Container] | |
| Check_S [Hash_set_intf] | |
| Check_S [Set_intf] | |
| Check_S [Map_intf] | |
| Check_S [Hashtbl_intf] | |
| Check_S0 [Container] | |
| Check_S0_phantom [Container] | |
| Check_S1 [Hash_set_intf] | |
| Check_S1 [Set_intf] | |
| Check_S1 [Container] | |
| Check_S2 [Map_intf] | |
| Check_S2 [Hashtbl_intf] | |
| Class [Float] | |
| Clock [Unix_ext] | |
| Common |
Basic types and definitions required throughout the system.
|
| Comparable [Std] | |
| Comparable |
Inherit comparability from a component.
|
| Complex [Caml] | |
| Condition [Std] | |
| Condition [Caml] | |
| Container [Std] | |
| Container | |
| Control [Gc] | |
| Arg | |
| Array |
A better Array module.
|
| Char |
Predicates
|
| Condition | |
| Field | |
| Filename |
Warning! this library assumes we are in a POSIX compliant OS.
|
| Gc |
Memory management control and statistics; finalised values.
|
| Hashtbl | |
| Hashtbl_intf | map t f returns new table with bound values replaced by
f applied to the bound values
|
| 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.
|
| 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 |
Polymorphic map module.
|
| Map_intf |
the empty map
|
| 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
Caml.Printexc
inadvertently
|
| Printf |
failwith, invalid_arg, and exit accepting printf's format.
|
| Queue |
Queue is a wrapper around OCaml's standard Queue module that
follows Core idioms and adds some functions.
|
| Set |
Polymorphic set module.
|
| Set_intf | |
| Sexp | |
| Stack |
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 |
Interface to the Unix system.
|
| Crc [Std] | |
| Crc |
Crc functions
|
D | |
| Daemon [Std] | |
| Daemon | daemonize ?close_stdio ?cd ?umask () makes the executing process a
daemon, i.e.
|
| Date [Time] |
String conversions
|
| Date [Std] | |
| Date_time [TZ] | |
| 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.
|
F | |
| F [Make_substring] | |
| Fast_hashtbl [Std] | |
| Fast_hashtbl |
Hashtbl which stores a reference to the data for faster replace.
|
| Field [Std] | |
| File_descr [Unix] |
File descriptor.
|
| Filename [Std] | |
| Filename [Caml] | |
| Float [Std] | |
| Float [Piecewise_linear] | |
| Float [Interval] |
Specific optimized modules
|
| Float |
Ordinary t-only nan test.
|
| Float [Bucket] | |
| Float_robust_compare | |
| Floatable [Std] | |
| Floatable | |
| Fnmatch_flags [Unix_ext] | |
| 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.
|
| Function [Std] | |
| Function |
A 'pipe' operator.
|
G | |
| Gc [Std] | |
| Gc [Caml] | |
| Gen [Interval_intf] | |
| Gen [Hash_set_intf] | |
| Gen [Set_intf] | |
| Gen [Map_intf] | |
| Gen [Hashtbl_intf] | |
| GenSet [Interval_intf] | |
| Genlex [Caml] | |
H | |
| Hash_heap [Std] | |
| Hash_heap [Hashable.S_binable] | |
| Hash_heap [Hashable.S] | |
| Hash_heap [Hashable.Make_binable] | |
| Hash_heap [Hashable.Make] | |
| 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_queue [Std] | |
| Hash_queue [Hashable.S_binable] | |
| Hash_queue [Hashable.S] | |
| Hash_queue [Hashable.Make_binable] | |
| Hash_queue [Hashable.Make] | |
| Hash_queue | |
| Hash_set [Std] | |
| Hash_set [Hashable.S_binable] | |
| Hash_set [Hashable.S] | |
| Hash_set [Hashable.Make_binable] | |
| Hash_set [Hashable.Make] | |
| Hash_set | |
| Hash_set_intf | strict_add fails if element is already there
|
| Hashable [Std] | |
| Hashable | |
| Hashtbl [Std_internal] | |
| Hashtbl [Caml] | |
| Heap [Std] | |
| Heap |
Min-heap implementation, adapted from CLR.
|
I | |
| IOVec [Unix_ext] |
I/O-vectors for scatter/gather-operations
|
| In_channel [Std] | |
| In_channel |
In_channel collects all of the pervasive functions that work on in_channels.
|
| Infix [String] | |
| Infix [List] | |
| Infix [Int] | |
| Infix [Array] | |
| Inherit [Comparable] |
Inherit comparability from a component.
|
| Int [Std_internal] | |
| Int [Piecewise_linear] | |
| Int [Interval] | |
| Int [Bucket] | |
| Int32 [Std_internal] | |
| Int32 [Caml] | |
| Int63 [Unique_id] |
an abstract unique identifier based on 64 bit integers.
|
| Int63 [Std] | |
| Int64 [Std_internal] | |
| Int64 [Unique_id] | |
| Int64 [Caml] | |
| Int64 [Bucket] | |
| Int_conversions |
Takes an int represented as a string ((-|+)?
0-9+) and puts underscores
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.
|
| 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_queue.S] | |
| Key [Hash_queue.Make] | |
| Key [Hash_heap.S] | |
| Key [Hash_heap.Make] | |
L | |
| Lazy [Caml] | |
| Lexing [Caml] | |
| Linebuf [Std] | |
| Linebuf |
Line-by-line reading of a file.
|
| Linux_ext [Std] | |
| Linux_ext |
Interface to Linux-specific system calls
|
| List [Std_internal] | |
| List [Hash_set_intf] | |
| List [Hash_queue] | |
| List [Caml] | |
| ListLabels [Caml] | |
| Lock_file [Std] | |
| Lock_file |
mutual exclusion between processes using lockf
|
| Low_level_debug | |
M | |
| Make [Piecewise_linear] | |
| Make [Monad] | |
| Make [Interval] | |
| Make [Hashable] | |
| Make [Hash_set] | |
| Make [Hash_queue] | |
| Make [Hash_heap] | |
| Make [Set] | |
| Make [Map] | |
| Make [Hashtbl] | |
| Make [Comparable] | |
| Make [Bucket] | |
| Make2 [Monad] | |
| Make_binable [Hashable] | |
| Make_binable [Hash_set] | |
| Make_binable [Set] | |
| Make_binable [Map] | |
| Make_binable [Hashtbl] | |
| Make_substring | |
| Map [Std_internal] | |
| Map [Comparable.S] | |
| Map [Comparable.Inherit] | |
| Map [Comparable.Make] | |
| Map [Comparable.Poly] | |
| Map [Caml] | |
| Marshal [Caml] | |
| Memo [Std] | |
| Memo |
Memoization code
|
| 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.Make] | |
| Monad_infix [Monad.S] | |
| 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 | |
N | |
| Native_file [Unix] | |
| Nativeint [Std_internal] | |
| Nativeint [Caml] | |
O | |
| OUnit_utils |
positive float generator
|
| Of_stringable [Sexpable] | |
| Of_stringable [Binable] | |
| Ofday [Time] |
A time of day.
|
| Oo [Caml] | |
| Option [Std] | |
| Option |
Options form a monad, where
return x = Some x
None >>= f = None
Some x >>= f = f 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 [Time.Span] | |
| Pervasives [Caml] | |
| Piecewise_linear [Std] | |
| Piecewise_linear |
piece-wise linear interpolation from float-like types to float
|
| Poly [Comparable] | |
| Pretty_printer [Std] | |
| Pretty_printer | |
| Printexc [Std] | |
| Printexc [Caml] | |
| Printf [Caml] | |
| Printf [Bigbuffer] | |
| Process_channels [Unix] |
Similar to
UnixLabels.open_process, but the second argument specifies
the environment passed to the command.
|
| Process_info [Unix] |
High-level process and redirection management
|
| Process_status [Unix] |
The termination status of a process.
|
Q | |
| Queue [Std_internal] | |
| Queue [Caml] | |
| Quickcheck [Std] | |
| Quickcheck |
Module for easily generating unit tests.
|
R | |
| RLimit [Unix_ext] | |
| Random [OUnit_utils] | |
| Random [Caml] | |
| Ref | equal t1 t2 returns true if t1 and t2 are the same ref cell.
|
| ReportAllFails [Error_check] | |
| Resource_usage [Unix_ext] |
Resource usage -- For details, "man getrusage"
|
| Result [Std] | |
| Result |
useful in
List.partition
|
| Robustly_comparable | |
S | |
| Scanf [Caml] | |
| Select_fds [Unix] |
Wait until some input/output operations become possible on
some channels.
|
| Set [Std_internal] | |
| Set [Interval_intf.S1] | |
| Set [Interval_intf.S] | |
| Set [Comparable.S] | |
| Set [Comparable.Inherit] | |
| 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_list [Sexp] | |
| Sexp_option [Sexp] | |
| Sexpable [Std] | |
| Sexpable | |
| Sign [Float] | |
| 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 [Time] |
A timespan.
|
| Squeue [Std] | |
| Squeue |
Synchronized queue module
|
| Stack [Std_internal] | |
| Stack [Caml] | |
| Stat [Gc] | |
| Std | |
| StdLabels [Caml] | |
| Std_internal | |
| Std_unix [Std_internal] | |
| Step [Error_check] |
Module for 'step' error checking with a moving threshold.
|
| Stream [Caml] | |
| String [Std_internal] | |
| String [Caml] | |
| StringLabels [Caml] | |
| Stringable | |
| Stringable [Std] | |
| Substring | |
| Substring [Std] | |
| Substring_intf | create base ~pos ~len creates a a substring of the base sequence of
length len starting at position pos, i.e.
|
| Substring_intf [Std] | |
| Sys [Std_internal] | |
| Sys [Caml] | |
T | |
| T [Interval_intf.S1.Set] | |
| T [Interval_intf.S1] | |
| T [Interval_intf.S.Set] | |
| T [Interval_intf.S] | |
| T [Hash_set_intf.S1] | |
| T [Hash_set_intf.S] | |
| T [Set_intf.Gen] | |
| T [Set_intf.S1] | |
| T [Map_intf.Gen] | |
| T [Map_intf.S2] | |
| T [Hashtbl_intf.Gen] | |
| T [Hashtbl_intf.S2] | |
| T [Hashtbl_intf.S] | |
| T [Set_intf.S] | |
| T [Map_intf.S] | |
| T2 [Tuple] | |
| T2 [Space_safe_tuple] | |
| T3 [Tuple] | |
| T3 [Space_safe_tuple] | |
| TZ | init () pre-load all available time zones from disk, this function has no effect if
it is called multiple times
|
| TZ [Std] | |
| Table [Hashable.S_binable] | |
| Table [Hashable.S] | |
| Table [Hashable.Make_binable] | |
| Table [Hashable.Make] | |
| Terminal_io [Unix] |
The following functions implement the POSIX standard terminal
interface.
|
| Terminal_io_intf |
Ignore the break condition.
|
| Thread [Std] | |
| Thread [Caml] | |
| Thread_safe_queue |
There are four variants of thread-safe queue, depending on whether there are one/many
readers or one/many writers.
|
| Thread_safe_queue [Std] | |
| Time |
Our time module.
|
| Time [Std] | |
| Time [Piecewise_linear] | |
| Time [Interval] | |
| 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 | |
| Tuple2 [Std] | |
| Tuple3 [Std] | |
U | |
| Unique_id |
A unique identifier based on a small allocated block, and an
integer for hashing.
|
| Unique_id [Std] | |
| Unit_ref [Unique_id] |
A unique identifier based on a small allocated block, and an
integer for hashing.
|
| Unix [Std_internal] | |
| Unix [Caml] | |
| UnixLabels [Caml] | |
| Unix_ext |
Interface to additional Unix-system calls
|
| Unix_ext [Std] | |
W | |
| Weak [Caml] | |
| Weekday | of_string s accepts three-character abbreviations with any capitalization
|
| Weekday [Std] | |
| Word_size | |
| Word_size [Std] | |
| Wordexp_flags [Unix_ext] | |
Z | |
| Zone [TZ] |