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