A | |
| Arg [Std] | |
| Arg [Caml] | |
| Array [Hash_queue] | |
| Array [Caml] | |
| ArrayLabels [Caml] | |
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
|
| Binable [Std] | |
| Binary_packing [Std] | |
| Binary_packing |
unpack a signed 1 byte int from the given buf starting at pos
|
| Bool [Std] | |
| Bool | |
| Bucket [Std] | |
| Buffer [Caml] | |
C | |
| Callback [Caml] | |
| Caml [Std] | |
| Caml | |
| Char [Caml] | |
| Check [Container] | |
| Check_S0 [Container] | |
| Check_S0_phantom [Container] | |
| Check_S1 [Container] | |
| Class [Float] | |
| Common [Std] | |
| Comparable [Std] | |
| Comparable |
Inherit comparability from a component.
|
| Complex [Caml] | |
| Condition [Caml] | |
| Container [Std] | |
| Container | |
| Core_arg | |
| Core_array |
A better Array module.
|
| Core_char |
Predicates
|
| Core_filename | make_absolute ~dir file
If file is relative, returns the path of the file file relative to
directory dir.
|
| Core_gc |
Memory management control and statistics; finalised values.
|
| Core_hashtbl | Hashtbl.find_exn
|
| Core_int | |
| Core_int32 | |
| Core_int64 | |
| Core_list |
Tail recursive version of standard List functions, plus
additional operations.
|
| Core_mutex |
A fast_mutex is just like a mutex, except that it uses try_lock to acquire
locks, and is hence faster when it acquires the lock.
|
| Core_nativeint | |
| Core_printf |
failwith and invalid_arg accepting printf's format.
|
| Core_queue |
Core_queue is a re-implementation of OCaml's standard Queue module that
follows Core idioms and adds some functions.
|
| 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 | |
| Core_unix |
Interface to the Unix system.
|
| Crc [Std] | |
| Crc |
Crc functions
|
D | |
| Date [Std] | |
| Dequeue [Std] | |
| Dequeue |
An array that can shrink and expand on both ends - the minimum index needs not be 0.
|
| Digest [Caml] | |
| Doubly_linked [Std] | |
| Doubly_linked |
creating doubly-linked lists
|
E | |
| Elt [Doubly_linked] | |
| Elt [Bag] | |
| Epoll [Linux_ext] | |
| Equatable | |
| Error_check [Std] | |
| Error_check | |
| Event [Caml] | |
| Exn [Std] | |
| Exn |
Raised when finalization after an exception failed, too.
|
F | |
| Fast_hashtbl [Std] | |
| Fast_hashtbl |
Hashtbl which stores a reference to the data for faster replace.
|
| File_descr [Core_unix] | |
| Filename [Std] | |
| Filename [Caml] | |
| Float [Std] | |
| Float [Piecewise_linear] | |
| Float |
Ordinary t-only nan test.
|
| Floatable | |
| 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.
|
| From_compare [Comparable] | |
G | |
| Gc [Std] | |
| Gc [Caml] | |
| Genlex [Caml] | |
H | |
| Hash_queue [Std] | |
| Hash_queue [Hashable.S] | |
| Hash_queue [Hashable.Make] | |
| Hash_queue | |
| Hash_set [Std] | |
| Hash_set [Hashable.S] | |
| Hash_set [Hashable.Make] | |
| Hash_set | |
| Hashable [Std] | |
| Hashable | |
| 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 [Core_string] | |
| Infix [Core_list] | |
| Infix [Core_hashtbl.S] | |
| Infix [Core_hashtbl] | |
| Infix [Core_array] | |
| Inherit [Comparable] |
Inherit comparability from a component.
|
| Int [Piecewise_linear] | |
| Int32 [Caml] | |
| Int64 [Unique_id] | |
| Int64 [Caml] | |
| Int_conversions | |
| Int_intf [Std] | |
| Int_intf | |
| Interfaces [Std] | |
| Interfaces | |
| Interned [Std] | |
| Interned | |
| Interval [Std] | |
| Interval_set [Std] | |
| Interval_set | |
K | |
| Key [Hash_queue.S] | |
| Key [Hash_queue.Make] | |
L | |
| LargeFile [Core_unix] |
This sub-module provides 64-bit variants of the functions
UnixLabels.lseek (for positioning a file descriptor),
UnixLabels.truncate and UnixLabels.ftruncate
(for changing the size of a file),
and UnixLabels.stat, UnixLabels.lstat and UnixLabels.fstat
(for obtaining information on files).
|
| 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 [Hash_set] | |
| List [Hash_queue] | |
| List [Caml] | |
| ListLabels [Caml] | |
M | |
| Make [Setable] | |
| Make [Piecewise_linear] | |
| Make [Monad] | |
| Make [Interned] | |
| Make [Hashable] | |
| Make [Hash_set] | |
| Make [Hash_queue] | |
| Make [Core_hashtbl] | |
| Make_mono_or_poly [Hash_set] | |
| 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.Make] | |
| Monad_infix [Monad.S] | |
| Month [Std] | |
| Month | of_string s accepts three-character abbreviations with any capitalization
|
| MoreLabels [Caml] | |
| Mutex [Std] | |
| Mutex [Caml] | |
N | |
| Nativeint [Caml] | |
O | |
| OUnit_utils [Std] | |
| Of_stringable [Sexpable] | |
| Ofday [Std] | |
| 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 | |
| Out_channel [Std] | |
| Out_channel | |
P | |
| PSet |
Polymorphic set module.
|
| Parsing [Caml] | |
| Pervasives [Caml] | |
| Piecewise_linear [Std] | |
| Piecewise_linear |
piece-wise linear interpolation from float-like types to float
|
| Poly [Hash_set] | |
| Poly [Comparable] | |
| Pretty_printer [Std] | |
| Pretty_printer | |
| Printexc [Caml] | |
| Printf [Caml] | |
| Printf [Bigbuffer] | |
Q | |
| Queue [Caml] | |
| Quickcheck [Std] | |
| Quickcheck |
Module for easily generating unit tests.
|
R | |
| RLimit [Unix_ext] | |
| RUsage [Unix_ext] |
Resource usage
|
| Random [Caml] | |
| Ref | equal t1 t2 returns true if t1 and t2 are the same ref cell.
|
| Result [Std] | |
| Result | |
| Robustly_comparable | |
S | |
| Scanf [Caml] | |
| Set [Setable.Make] | |
| Set [Setable.S] | |
| Set [Caml] | |
| Setable | |
| Sexpable [Std] | |
| Sexpable | |
| Size [Std] | |
| Sort [Caml] | |
| Space_safe_tuple |
The raison d'ĂȘtre 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] | |
| Squeue [Std] | |
| Squeue | create maxsize returns a synchronized queue bounded to have no more than
maxsize elements.
|
| Stack [Caml] | |
| Std | |
| StdLabels [Caml] | |
| Step [Error_check] | |
| Stream [Caml] | |
| String [Caml] | |
| StringLabels [Caml] | |
| String_table [Interned.Make] | |
| Stringable | |
| Sys [Caml] | |
T | |
| T2 [Tuple] | |
| T2 [Space_safe_tuple] | |
| T3 [Tuple] | |
| T3 [Space_safe_tuple] | |
| Table [Hashable.S] | |
| Table [Hashable.Make] | |
| 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 [Std] | |
| Time [Piecewise_linear] | |
| Timer |
Timed events
|
| Timer [Std] | |
| Timer [Error_check] | |
| To_stringable [Sexpable] | |
| Toggle [Error_check] | |
| ToggleN [Error_check] | |
| Tuple | |
| Tuple2 [Std] | |
| Tuple3 [Std] | |
U | |
| Unique_id |
an abstract unique identifier based on 64 bit integers.
|
| Unique_id [Std] | |
| Unit_ref [Unique_id] | |
| Unix [Caml] | |
| UnixLabels [Caml] | |
| Unix_ext |
Interface to additional Unix-system calls
|
| Unix_ext [Std] | |
W | |
| Weak [Caml] | |
| Word_size |