A | |
Agnostic_mutex [Std] | |
Agnostic_mutex |
Agnostic mutexes do not remember the thread by which they got locked.
|
Arg [Std] | |
Arg [Caml] | |
Array [Std_internal] | |
Array [Hash_queue] | |
Array [Caml] | |
ArrayLabels [Caml] | |
Array_permute |
randomly permute an array.
|
Assoc [List] | |
Avltree |
estokes:
|
B | |
Backtrace [Std] | |
Backtrace | |
Bag [Std] | |
Bag |
A bag is a data structure like a set, except that:
|
Big_int [Std_internal] | |
Bigbuffer [Std] | |
Bigbuffer |
Extensible string buffers.
|
Bigstring [Std] | |
Bigstring |
Types and exceptions
|
Bigstring_marshal [Std] | |
Bigstring_marshal |
Utility functions for marshalling to and from bigstring
|
Bigsubstring [Std] | |
Bigsubstring | |
Bin_prot [Std] | |
Binable [Std] | |
Binable | |
Binary_packing [Std] | |
Binary_packing | |
Blang [Std] | |
Blang |
Simple boolean language: propositional logic
|
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 | |
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] | |
Common |
Basic types and definitions required throughout the system.
|
Commutative_group [Std] | |
Commutative_group | |
Comparable [Tuple] | |
Comparable [Std] | |
Comparable |
Inherit comparability from a component.
|
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] | |
Condition [Std] | |
Condition [Caml] | |
Constr [Univ] |
The Constr.t represents a single constructor in the extensible variant type.
|
Constrained_float | |
Container [Std] | |
Container | |
Control [Gc] | |
Arg | |
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 |
mod and div operators that have the right behavior on negative numbers,
that is,
x % y always returns a value 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 |
This module defines the
Map module for Core.Std .
|
Core_map_intf |
Test whether a map is empty or not.
|
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 | |
Core_set_intf |
if
res = partition_tf set ~f then fst res are the elements on which f
produced true , and snd res are the elements on which f produces false
|
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.
|
Crc [Std] | |
Crc |
Crc functions
|
D | |
Daemon [Std] | |
Daemon | daemonize ?(redirect_stdout=`Dev_null) ?(redirect_stderr=`Dev_null)
?(cd = "/") ?umask=[0] () makes the current
executing process a daemon, and dups "/dev/null", redirect_stdout, redirect_stderr
to stdin/stdout/stderr.
|
Date [Std] | |
Date [Time] | |
Date |
converts a string to a date, in formats:
m/d/y
y-m-d (* valid iso8601_extended *)
DD MMM YYYY
DDMMMYYYY
YYYYMMDD
|
Default [Std] | |
Default | |
Dequeue [Std] | |
Dequeue |
A double ended queue that can shrink and expand on both ends.
|
Digest [Caml] | |
Direct [Unix.Resource_usage.Fields] | |
Doubly_linked [Std] | |
Doubly_linked |
doubly-linked lists
|
E | |
Elt [Doubly_linked] | |
Elt [Core_set_intf.S] | |
Elt [Bag] | |
Error [Std] | |
Error |
Library for lazily constructing string error messages.
|
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.
|
Export [Result] | |
Export [Date] | |
F | |
F [Make_substring] | |
False_ [Bool] | |
Field [Std] | |
Fields [Unix.Resource_usage] | |
File_descr [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 [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] | |
Gen [Interval_intf] | |
GenSet [Interval_intf] | |
Genlex [Caml] | |
Group [Unix] |
Structure of entries in the
groups database.
|
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 |
a hash-queue, where the values are of type 'a
|
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 | |
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 [Hashable] | |
Hashtbl [Hash_queue] | |
Hashtbl [Hash_heap] | |
Hashtbl [Caml] | |
Heap [Std] | |
Heap |
Min-heap implementation, adapted from CLR.
|
Helpers [Time_internal] | |
Host [Unix] | |
Host_and_port [Std] | |
Host_and_port | |
I | |
IOVec [Unix] |
I/O-vectors for scatter/gather-operations
|
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] | |
Inherit [Comparable] |
Inherit comparability from a component.
|
Int [Std_internal] | |
Int [Unique_id_intf.S] | |
Int [Piecewise_linear] | |
Int [Interval] | |
Int [Bucket] | |
Int32 [Std_internal] | |
Int32 [Caml] | |
Int63 [Unique_id_intf.S] | |
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_replace_polymorphic_compare | |
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_queue.S] | |
Key [Hash_queue.Make] | |
Key [Hash_heap.S] | |
Key [Hash_heap.Make] | |
Key [Core_map_intf.S] | |
L | |
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] | |
ListLabels [Caml] | |
Lock_file [Std] | |
Lock_file |
Mutual exclusion between processes using flock and lockf.
|
Low_level [Unix.Passwd] | |
M | |
Make [Tuple] | |
Make [Piecewise_linear] | |
Make [Monad] | |
Make [Interval] | |
Make [Int_conversions] | |
Make [Hashable] | |
Make [Hash_set] | |
Make [Hash_queue] | |
Make [Hash_heap] | |
Make [Float_robust_compare] | |
Make [Set] | |
Make [Map] | |
Make [Hashtbl] | |
Make [Container] | |
Make [Comparator] | |
Make [Comparable] | |
Make [Bucket] | |
Make1 [Comparator] | |
Make2 [Monad] | |
Make_binable [Hashable] | |
Make_binable [Hash_set] | |
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 [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 | of_string s accepts three-character abbreviations with any capitalization
|
MoreLabels [Caml] | |
Mutex [Std] | |
Mutex [Caml] | |
Mutex0 | create like Mutex.create , but creates an error-checking mutex.
|
N | |
Nano_mutex [Std] | |
Nano_mutex | create () returns a new, unlocked mutex.
|
Nat [Std_internal] | |
Native_file [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).
|
No_polymorphic_compare [Std] | |
No_polymorphic_compare | |
Num [Std_internal] | |
O | |
Of_sexpable [Identifiable] | |
Of_stringable [Sexpable] | |
Of_stringable [Identifiable] | Of_stringable and Of_sexpable each create an identifiable that uses string
conversions for binable, sexpable, equality, hash, compare, and pp.
|
Of_stringable [Binable] | |
Ofday [Std] | |
Ofday [Time] | |
Ofday | add t s shifts the time of day t by the span s .
|
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 .
|
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 | |
Polymorphic_compare_intf |
Interfaces used for hiding and replacing polymorphic compare.
|
Pretty_printer [Std] | |
Pretty_printer | |
Printexc [Std] | |
Printexc [Caml] | |
Printf [Std] | |
Printf [Caml] | |
Printf [Bigbuffer] | |
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 .
|
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 | 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 [Interval_intf.S1] | |
Set [Interval_intf.S] | |
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_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] | |
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 |
Basic operations on spans
|
Squeue [Std] | |
Squeue |
Thread-safe queue module, using locks.
|
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] | |
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 | |
T [Interval_intf.S1.Set] | |
T [Interval_intf.S1] | |
T [Interval_intf.S.Set] | |
T [Interval_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] | |
Terminal_io [Unix] | |
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] | |
To_stringable [Sexpable] | |
True_ [Bool] | |
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.
|
Tuple [Std] | |
Tuple2 [Std] | |
Tuple3 [Std] | |
U | |
Union_find |
Disjoint-sets.
|
Union_find [Std] | |
Unique_id | |
Unique_id [Std] | |
Unique_id_intf | |
Unique_id_intf [Std] | |
Unit | |
Unit [Std] | |
Univ |
An extensible "universal" variant type, that can be extended by adding new
constructors with arguments of arbitrary type.
|
Univ [Std] | |
Unix [Std] | |
Unix [Caml] | |
UnixLabels [Caml] | |
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.
|
Unpack_buffer [Std] | |
Unpack_one [Unpack_buffer] | |
Utsname [Unix] | |
W | |
Weak [Caml] | |
Weekday | of_string s accepts three-character abbreviations with any capitalization
|
Weekday [Std] | |
With_return | |
Word_size | |
Word_size [Std] | |
Bin_prot.Writer.html">Writer [Bin_prot] | |
Z | |
Zone | find name looks up a t by its name and returns it.
|
Zone [Std] | |
Zone [Time] |