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] |