A | |
Arg [Std] | |
Arg [Caml] | |
Arg_type [Command.Spec] | |
Array [Std_internal] | |
Array [Hash_queue] | |
Array [Caml] | |
ArrayLabels [Caml] | |
Array_permute |
randomly permute an array.
|
Assoc [List] | |
Avltree |
This module implements a very low level interface to a mutable AVL tree.
|
B | |
Backtrace [Std] | |
Backtrace |
Dealing with stack backtraces.
|
Bag [Std] | |
Bag |
Imperative set-like data structure.
|
Big_int [Std_internal] | |
Bigbuffer [Std] | |
Bigbuffer |
Extensible string buffers based on Bigstrings.
|
Bigstring [Std] | |
Bigstring |
String type based on
Bigarray , for use in I/O and C-bindings
|
Bigstring_marshal [Std] | |
Bigstring_marshal |
Utility functions for marshalling to and from bigstring
|
Bigsubstring [Std] | |
Bigsubstring | |
Bin_prot [Std] | |
Binable [Std] | |
Binable [Hash_set_intf] | |
Binable [Hashable] | |
Binable [Float_intf] | |
Binable [Core_set_intf] | |
Binable [Core_map_intf] | |
Binable [Core_hashtbl_intf] | |
Binable | |
Binable0 | |
Binary_packing [Std] | |
Binary_packing |
Packs and unpacks various types of integers into and from strings.
|
Blang [Std] | |
Blang [Stable] | |
Blang |
A simple boolean domain-specific language
|
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 | create measure value creates a t from value units of the given measure.
|
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_S1_phantom_invariant [Container] | |
Check_S2_refines_S [Monad] | |
Check_accessors [Core_set_intf] | |
Check_accessors [Core_map_intf] | |
Check_accessors0 [Core_set_intf] | |
Check_accessors1 [Core_set_intf] | |
Check_accessors1 [Core_map_intf] | |
Check_accessors2 [Core_set_intf] | |
Check_accessors2 [Core_map_intf] | |
Check_accessors2_with_comparator [Core_set_intf] | |
Check_accessors3 [Core_map_intf] | |
Check_accessors3_with_comparator [Core_map_intf] | |
Check_creators [Core_set_intf] | |
Check_creators [Core_map_intf] | |
Check_creators0 [Core_set_intf] | |
Check_creators1 [Core_set_intf] | |
Check_creators1 [Core_map_intf] | |
Check_creators2 [Core_set_intf] | |
Check_creators2 [Core_map_intf] | |
Check_creators2_with_comparator [Core_set_intf] | |
Check_creators3_with_comparator [Core_map_intf] | |
Check_sexp_conversion [Comparable] | |
Cidr [Unix] |
A representation of CIDR netmasks (e.g.
|
Class [Float_intf.S] | |
Clock [Linux_ext.Timerfd] |
Clock used to mark the progress of a timer.
|
Clock [Linux_ext] | |
Command [Std] | |
Command |
purely functional command line parsing
|
Common |
Basic types and definitions required throughout the system.
|
Commutative_group [Std] | |
Commutative_group |
A signature for a commutative group (in the group-theory sense).
|
Comparable [Tuple] | |
Comparable [Std] | |
Comparable | lexicographic cmps x y compares x and y lexicographically using functions in the
list cmps .
|
Comparable_intf |
Used for specifying a bound (either upper or lower) as inclusive, exclusive, or
unbounded.
|
Comparator [Std] | |
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] | |
Composition_preserves_injectivity [Type_equal] | Composition_preserves_injectivity is a functor that proves that composition of
injective types is injective.
|
Condition [Std] | |
Condition [Caml] | |
Constr [Univ] |
A
Constr.t represents a single constructor in the extensible variant type.
|
Constrained_float | |
Container [Std] | |
Container | |
Control [Gc] | |
Arg |
Parsing of command line arguments.
|
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 | ceil_pow2 x returns the smallest power of 2 that is greater than or equal to
x .
|
Int32 | |
Int63 |
The size of Int63 is always at least 63 bits.
|
Int64 | |
Lazy |
A value of type
'a Lazy.t is a deferred computation, called
a suspension, that has a result of type 'a .
|
List |
Tail recursive version of standard List functions, plus additional operations.
|
Map |
This module defines the
Map module for Core.Std .
|
Core_map_intf |
This module defines interfaces used in
Core.Std.Map .
|
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 |
This module defines the
Set module for Core.Std .
|
Core_set_intf |
This module defines interfaces used in
Core.Std.Set .
|
Core_set_unit_tests | |
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.
|
Weak | Weak is like the OCaml standard library module of the same name, except that it
requires that the values in the weak set are heap blocks.
|
Crc [Std] | |
Crc |
Crc functions
|
D | |
Daemon [Std] | |
Daemon | daemonize makes the executing process a daemon.
|
Date [Std] | |
Date [Time] | |
Date [Stable] | |
Date |
converts a string to a date, in formats:
* m/d/y
* y-m-d (* valid iso8601_extended *)
* DD MMM YYYY
* DDMMMYYYY
* YYYYMMDD
|
Day_of_week [Std] | |
Day_of_week [Stable] | |
Day_of_week |
For representing a day of the week.
|
Deprecated [Command] | Deprecated should be used only by Core_extended.Deprecated_command .
|
Dequeue [Std] | |
Dequeue |
A double ended queue that can shrink and expand on both ends.
|
Digest [Caml] | |
Direct [Unix.Resource_usage.Fields] | |
Direct [Gc.Control.Fields] | |
Direct [Gc.Stat.Fields] | |
Doubly_linked [Std] | |
Doubly_linked |
doubly-linked lists
|
E | |
Elt [Doubly_linked] | |
Elt [Core_set_intf.S0] | |
Elt [Bag] | |
Epoll [Linux_ext] |
epoll() - a linux I/O multiplexer of the same family as select() or poll().
|
Equal [Std] | |
Equal |
This module defines signatures that are to be included in other signatures to ensure a
consistent interface to
equal functions.
|
Error [Std] | |
Error | failwiths message value sexp_of_value raises an exception with the supplied
message and value , by constructing an Error.t and using Error.raise .
|
Error [Unix] | |
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.
|
Exn [Backtrace] | Backtrace.Exn has functions for controlling and printing the backtrace of the most
recently raised exception.
|
Export [Result] | |
Export [Ordering] | |
Export [Month] | |
Export [Date] | |
F | |
F [Make_substring] | |
Fd_redirection [Daemon] | |
Field [Std_internal] | |
Fields [Unix.Resource_usage] | |
Fields [Gc.Control] | |
Fields [Gc.Stat] | |
File_descr [Unix] |
File descriptor.
|
Filename [Std] | |
Filename [Caml] | |
Flags [Std] | |
Flags [Linux_ext.Epoll] | |
Flags [Linux_ext.Timerfd] | |
Flags |
See flags_intf.ml for documentation.
|
Flags_intf | module Flags implements Unix-style sets of flags that are represented as
an int with various bits set, one bit for each flag.
|
Float [Std] | |
Float [Piecewise_linear] | |
Float [Interval.Stable.V1] | |
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] | |
Genlex [Caml] | |
Group [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 [Stable_containers] | |
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] |
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 [Stable_containers] | |
Hashtbl [Hash_queue] | |
Hashtbl [Hash_heap] | |
Hashtbl [Hashable] | |
Hashtbl [Caml] | |
Heap [Std] | |
Heap |
Min-heap implementation, adapted from CLR.
|
Heap_block [Std] | |
Heap_block |
A heap block is a value that is guaranteed to live on the OCaml heap, and is hence
guaranteed to be usable with finalization or in a weak pointer.
|
Helpers [Time_internal] | |
Host [Unix] | |
Host_and_port [Std] | |
Host_and_port [Stable] | |
Host_and_port | |
I | |
IOVec [Unix] |
I/O-vectors for scatter/gather-operations
|
Id [Type_equal] | Id provides identifiers for types, and the ability to test (via Id.same ) at
run-time if two identifiers are equal, and if so to get a proof of equality of their
types.
|
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] | |
Info [Std] | |
Info | Info is a library for lazily constructing human-readable information as a string or
sexp, with a primary use being error messages.
|
Inherit [Comparable] |
Inherit comparability from a component.
|
Int [Std_internal] | |
Int [Unique_id] |
An abstract unique identifier based on ordinary OCaml integers.
|
Int [Piecewise_linear] | |
Int [Interval.Stable.V1] | |
Int [Interval] | |
Int [Bucket] | |
Int32 [Std_internal] | |
Int32 [Caml] | |
Int63 [Unique_id] | |
Int63 [Std] | |
Int63 [Flags_intf] | |
Int64 [Std_internal] | |
Int64 [Caml] | |
Int64 [Bucket] | |
Int_conversions | |
Int_intf [Std] | |
Int_intf | |
Int_math | |
Int_replace_polymorphic_compare | |
Int_set [Std] | |
Int_set |
An implementation of compressed integer sets using lists of integer ranges.
|
Intable | |
Interfaces [Std] | |
Interfaces | |
Interned_string [Std] | |
Interned_string |
Provides a functor for creating an interned string type.
|
Interval [Std] | |
Interval [Stable] | |
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.
|
Invariant [Std] | |
Invariant |
This module defines signatures that are to be included in other signatures to ensure a
consistent interface to invariant-style functions.
|
K | |
Key [Univ_map.Multi] | |
Key [Univ_map.With_fold] | |
Key [Univ_map.With_default] | |
Key [Univ_map] | |
Key [Hash_heap.S] | |
Key [Hash_queue.S] | |
Key [Hash_heap.Make] | |
Key [Hash_queue.Make] | |
Key [Core_map_intf.S] | |
L | |
Lazy [Std_internal] | |
Lazy [Caml] | |
Lexing [Caml] | |
Lift [Type_equal] | |
Lift2 [Type_equal] | |
Linux_ext [Std] | |
Linux_ext |
Interface to Linux-specific system calls
|
List [Std_internal] | |
List [Hash_queue] | |
List [Core_map_intf] | |
List [Caml] | |
List [Binable0] | |
ListLabels [Caml] | |
Lock_file [Std] | |
Lock_file |
Mutual exclusion between processes using flock and lockf.
|
Low_level [Unix.Passwd] | |
M | |
Make [Tuple] | |
Make [Stable_unit_test] | |
Make [Piecewise_linear] | |
Make [Monad] | |
Make [Interval] | |
Make [Interned_string] | |
Make [Int_conversions] | |
Make [Identifiable] | |
Make [Hash_set] | |
Make [Hash_queue] | |
Make [Hash_heap] | |
Make [Hashable] | |
Make [Float_robust_compare] | |
Make [Flags_intf.Flags] | Flags.Make builds a new flags module.
|
Make [Set] | |
Make [Map] | |
Make [Hashtbl] | |
Make [Container] | |
Make [Comparator] | |
Make [Comparable] | |
Make [Bucket] | |
Make1 [Comparator] | |
Make2 [Monad] | |
Make_binable [Hash_set] | |
Make_binable [Hashable] | |
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_invertible [Piecewise_linear] | |
Make_substring | |
Make_unordered_container [Stable_unit_test] | |
Make_using_comparator [Set] | |
Make_using_comparator [Map] | |
Map [Std_internal] | |
Map [Stable_containers] | |
Map [Comparable_intf.Map_and_set_binable] | |
Map [Comparable_intf.S] | |
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 [Stable] | |
Month | of_string s accepts three-character abbreviations with 3 capitalizations (e.g.
|
MoreLabels [Caml] | |
Multi [Univ_map] |
list-accumulating keys with a default value of the empty list
|
Mutex [Std] | |
Mutex [Caml] | |
Mutex0 | create like Mutex.create , but creates an error-checking mutex.
|
N | |
Nano_mutex [Std] | |
Nano_mutex |
A nano-mutex is a lightweight mutex that can be used only within a single OCaml
runtime.
|
Nat [Std_internal] | |
Native_file [Unix] | |
Nativeint [Std_internal] | |
Nativeint [Caml] | |
Never_returns | |
Nfs [Lock_file] |
An implementation neutral NFS lock file scheme that relies on the atomicity of link
over NFS (see NFS Illustrated, atomicity for more information).
|
No_polymorphic_compare [Std] | |
No_polymorphic_compare | |
Nothing [Std] | |
Nothing [Stable] | |
Nothing |
An uninhabited type.
|
Nothing0 | |
Num [Std_internal] | |
O | |
O [Sexp] | |
Of_sexpable [Sexpable] | |
Of_stringable [Sexpable] | |
Of_stringable [Binable0] | |
Of_stringable [Binable] | |
Ofday [Time] | |
Ofday [Stable] | |
Ofday [Piecewise_linear] | |
Ofday | add t s shifts the time of day t by the span s .
|
Ofday [Interval.Stable.V1] | |
Ofday [Interval] | |
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] | |
Open_flags [Unix] | |
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 .
|
Ordering [Std_internal] | |
Ordering | Ordering is intended to make code that matches on the result of a comparison
more concise and easier to read.
|
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
|
Permissioned [Ref] | |
Pervasives [Caml] | |
Pid [Std] | |
Pid | |
Piecewise_linear [Std] | |
Piecewise_linear |
piece-wise linear interpolation from float-like types to float
|
Piecewise_linear_intf | create enforces that key values are non-decreasing.
|
Policy [Unix.Scheduler] | |
Poly [Hash_set] | |
Poly [Set] | |
Poly [Map] | |
Poly [Hashtbl] | |
Poly [Comparator] | |
Poly [Comparable] | |
Polymorphic_compare [Std] | |
Polymorphic_compare | ascending is identical to compare .
|
Polymorphic_compare_intf |
Interfaces used for hiding and replacing polymorphic compare.
|
Pretty_printer [Std] | |
Pretty_printer |
A list of pretty printers for various types, for use in toplevels.
|
Printexc [Std] | |
Printexc [Caml] | |
Printf [Std] | |
Printf [Caml] | |
Printf [Bigbuffer] | |
Priority [Linux_ext] | |
Priority [Unix] | |
Process_channels [Unix] |
Similar to
UnixLabels.open_process , but the second argument specifies
the environment passed to the command.
|
Process_env [Std] | |
Process_env |
Utility functions for dealing with the environment.
|
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 [Std_internal] | |
Ref | swap t1 t2 swaps the values in t1 and t2 .
|
Register [Pretty_printer] | Register builds a pp function from a to_string function, and adds the
module_name ^ ".pp" to the list of pretty printers.
|
Register_pp [Pretty_printer] | Register_pp is like Register , but allows a custom pp function rather than using
to_string .
|
Replace_polymorphic_compare [Comparable_intf.S_common] | |
Resource_usage [Unix] |
Resource usage -- For details, "man getrusage"
|
Result [Std] | |
Result [Stable] | |
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 [Stable_containers] | |
Set [Interval_intf.S] | |
Set [Interval_intf.S1] | |
Set [Comparable_intf.Map_and_set_binable] | |
Set [Comparable_intf.S] | |
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 [Stable_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] | |
Source_code_position [Std] | |
Source_code_position | |
Source_code_position0 | |
Span [Time] | |
Span [Stable] | |
Span |
Basic operations on spans
|
Span [Piecewise_linear] | |
Spec [Command.Deprecated] | |
Spec [Command] |
composable command-line specifications
|
Squeue [Std] | |
Squeue |
Thread-safe queue module, using locks.
|
Stable [Time] | |
Stable [User_and_group] | |
Stable [String_id] | |
Stable [Zone] | |
Stable | |
Stable [Span] | |
Stable [Result] | |
Stable [Ofday] | |
Stable [Nothing] | |
Stable [Month] | |
Stable [Interval] | |
Stable [Host_and_port] | |
Stable [Day_of_week] | |
Stable [Date] | |
Stable [Blang] | |
Stable_containers | |
Stable_internal | |
Stable_unit_test | |
Stable_unit_test_intf | |
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] | |
String_id [Stable] | |
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] | |
Sysinfo [Linux_ext] | |
T | |
T [Time_internal] | |
T | |
T2 [Tuple] |
Signature for a 2-tuple module
|
T3 [Tuple] |
Signature for a 3-tuple module
|
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 |
A module for representing absolute points in time, independent of time zone.
|
Time [Std] | |
Time [Stable] | |
Time [Piecewise_linear] | |
Time [Interval] | |
Time_internal | |
Timer |
Timed events
|
Timer [Std] | |
Timerfd [Linux_ext] | |
To_stringable [Sexpable] | |
Tree [Core_set_intf.S0] | |
Tree [Set.Poly] | |
Tree [Set] | |
Tree [Core_map_intf.S] | |
Tree [Map.Poly] | |
Tree [Map] | |
Tuple |
Functors and signatures for dealing with modules for tuples.
|
Tuple [Std] | |
Tuple2 [Std] | |
Tuple3 [Std] | |
Type_equal |
For representing type equalities otherwise not known by the type-checker.
|
Type_equal [Std] | |
U | |
Uid [Type_equal.Id] |
Every
Id.t contains a unique id that is distinct from the Uid.t in any other
Id.t .
|
Union_find |
Imperative data structure for representing disjoint sets.
|
Union_find [Std] | |
Unique_id |
Functors for creating modules that mint unique identifiers.
|
Unique_id [Std] | |
Unique_id_intf |
Signature for use by
module : Unique_id .
|
Unit |
Module for the type
unit .
|
Unit [Std] | |
Unit_test [Stable] | |
Unit_tests [Stable] | |
Univ |
An extensible "universal" variant type, that can be extended by adding new
constructors with arguments of arbitrary type.
|
Univ [Std] | |
Univ_map |
Universal/heterogeneous maps.
|
Univ_map [Std] | |
Unix [Std] | |
Unix [Caml] | |
UnixLabels [Caml] | |
Unordered_container_test [Stable_unit_test_intf] | |
Unpack_buffer |
A buffer for incremental decoding of an input stream.
|
Unpack_buffer [Std] | |
Unpack_one [Unpack_buffer] | |
User_and_group |
A pair of unix username and primary unix group.
|
User_and_group [Std] | |
User_and_group [Stable] | |
Utsname [Unix] | |
Uuid |
Implements universally unique identifiers based on version 3 of the UUID
specification.
|
Uuid [Std] | |
V | |
V1 [Stable_containers.Map] | |
V1 [Stable_containers.Hash_set] | |
V1 [Stable_containers.Hashtbl] | |
V1 [Stable_containers.Set] | |
V1 [Zone.Stable] | |
V1 [User_and_group.Stable] | |
V1 [Time.Stable] | |
V1 [String_id.Stable] | |
V1 [Span.Stable] | |
V1 [Result.Stable] | |
V1 [Ofday.Stable] | |
V1 [Nothing.Stable] | |
V1 [Month.Stable] | |
V1 [Interval.Stable] | |
V1 [Host_and_port.Stable] | |
V1 [Day_of_week.Stable] | |
V1 [Date.Stable] | |
V1 [Blang.Stable] | |
V1_stable_unit_test [Result.Stable] | |
Validate |
A module for organizing validations of data structures.
|
Validate [Std] | |
Validate [Comparable] | |
Validate_with_zero [Comparable] | |
W | |
Weak [Std] | |
Weak [Caml] | |
With_comparator [Core_set_intf] | |
With_comparator [Core_map_intf] | |
With_default [Univ_map] |
keys with associated default values, so that
find is no longer partial
|
With_fold [Univ_map] |
keys that map to an accumulator value with an associated fold operation
|
With_key [Bounded_int_table] | |
With_return |
This is
include 'd and documented in module: Common .
|
With_zero [Comparable] | |
Without_comparator [Core_set_intf] | |
Without_comparator [Core_map_intf] | |
Word_size |
For determining the word size that the program is using.
|
Word_size [Std] | |
Writer [Bin_prot] | |
Z | |
Zone |
Time-zone handling.
|
Zone [Std] | |
Zone [Time] | |
Zone [Stable] |