A | |
Alarm [Timing_wheel_intf.Timing_wheel] | |
Alarm [Core_gc.Expert] |
A GC alarm calls a user function at the end of each major GC cycle.
|
Allocation_policy [Core_gc] |
The policy used for allocating in the heap.
|
Alternate_sexp [Time_ns] |
Note that we expose a sexp format that is not the one exposed in
Core .
|
Alternate_sexp [Time_ns.Span] |
Note that we expose a sexp format that is not the one exposed in
Core .
|
Always [Type_immediacy] | |
Applicative [Std_kernel] | |
Applicative |
The following functors give a sense of what Applicatives one can define.
|
Applicative_infix [Applicative_intf.S2] | |
Applicative_infix [Applicative_intf.S] | |
Applicative_intf |
Applicatives model computations in which values computed by subcomputations cannot
affect what subsequent computations will take place.
|
Arbitrary_order [Fdeque] |
Traverse deque elements in arbitrary order.
|
Arg [Std_kernel] | |
Arg [Caml] | |
Args [Either_intf.Focused] | |
Args_to_Args2 [Applicative_intf] | |
Array [Std_internal] | |
Array [Hash_queue] | |
Array [Caml] | |
ArrayLabels [Caml] | |
Array_permute |
An internal-only module factored out due to a circular dependency between core_array
and core_list.
|
Assoc [Core_list] |
Interpret a list of (key, value) pairs as a map in which only the first
occurrence of a key affects the semantics, i.e.:
|
Avltree [Std_kernel] | |
Avltree |
A low-level, mutable AVL tree.
|
B | |
Back_to_front [Fdeque] |
Traverse deque elements back-to-front.
|
Backtrace [Std_kernel] | |
Backtrace |
Dealing with stack backtraces.
|
Bag [Std_kernel] | |
Bag |
Imperative set-like data structure.
|
Bigbuffer [Std_common] | |
Bigbuffer |
Extensible string buffers based on Bigstrings.
|
Bigbuffer_internal | |
Bigstring [Std_common] | |
Bigstring |
String type based on
Bigarray , for use in I/O and C-bindings
|
Bigstring_marshal [Std_common] | |
Bigstring_marshal |
Utility functions for marshalling to and from bigstring.
|
Bigsubstring [Std_kernel] | |
Bigsubstring |
Substring type based on
Bigarray , for use in I/O and C-bindings
|
Bin_prot [Std_kernel] | |
Binable [Tuple] | |
Binable [Std_kernel] | |
Binable [Hashable] | |
Binable [Hash_set_intf] | |
Binable [Float_intf] | |
Binable [Core_set_intf] | |
Binable [Core_map_intf] | |
Binable [Core_hashtbl_intf] | |
Binable |
Module types and utilities for dealing with types that support the bin-io binary
encoding.
|
Binable0 | |
Binary_packing [Std_kernel] | |
Binary_packing |
Packs and unpacks various types of integers into and from strings.
|
Binary_searchable [Std_kernel] | |
Binary_searchable | |
Binary_searchable_intf |
Module types for a
binary_search function for a sequence, and functors for building
binary_search functions.
|
Blang [Std_kernel] | |
Blang [Stable] | |
Blang |
A simple boolean domain-specific language
|
Blit [Std_kernel] | |
Blit [Make_substring] | |
Blit |
See
Blit_intf for documentation.
|
Blit_intf |
Standard type for
blit functions, and reusable code for validating blit
arguments.
|
Bool [Std_internal] | |
Bool | |
Bounded_int_table [Std_kernel] | |
Bounded_int_table |
A
Bounded_int_table is a table whose keys can be mapped to integers in a fixed
range, 0 ...
|
Bucket [Std_kernel] | |
Bucket | |
Buffer [Caml] | |
Byte_units [Std_kernel] | |
Byte_units |
Conversions between units of measure based on bytes.
|
Bytes [Std_kernel] | |
Bytes [Caml] | |
C | |
Callback [Caml] | |
Caml [Std_common] | |
Caml | |
Caseless [Core_string] | Caseless compares and hashes strings ignoring case, so that for example
Caseless.equal "OCaml" "ocaml" and Caseless.("apple" < "Banana") are true , and
Caseless.Map , Caseless.Table lookup and Caseless.Set membership is
case-insensitive.
|
Char [Std_internal] | |
Char [Caml] | |
Check_accessors [Core_set_intf] |
Consistency checks (same as in
Container ).
|
Check_accessors [Core_map_intf] |
Consistency checks (same as in
Container ).
|
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] | Check_sexp_conversion checks that conversion of a map or set to a sexp uses the same
sexp conversion as the underlying element.
|
Choice [Raw_quickcheck_generator] | 'a Choice.t represents the choice of a value from a generator.
|
Class [Float_intf.S] | |
Common |
Basic types and definitions required throughout the system.
|
Commutative_group [Std_kernel] | |
Commutative_group |
A signature for a commutative group (in the group-theory sense).
|
Comparable [Tuple] | |
Comparable [Std_kernel] | |
Comparable [Stable_containers] | |
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_kernel] | |
Comparator |
A type-indexed value that allows one to compare (and for generating error messages,
serialize) values of the type in question.
|
Complex [Caml] | |
Compose [Applicative] | |
Composition_preserves_injectivity [Type_equal] | Composition_preserves_injectivity is a functor that proves that composition of
injective types is injective.
|
Config [Timing_wheel_intf.Timing_wheel] | |
Configure [Quickcheck] | |
Const [Applicative] |
Every monoid gives rise to a constant Applicative.
|
Constrained_float | |
Container [Std_kernel] | |
Container | |
Container_intf |
This file has generic signatures for container data structures, with standard
functions (iter, fold, exists, for_all, ...) that one would expect to find in any
container.
|
Container_unit_tests | |
Control [Core_gc] | |
Core_arg |
INRIA's original command-line parsing library.
|
Core_array |
Note:
Array.length is not constant for a given array, as one can reduce it with
Array.truncate
|
Core_bin_prot | |
Core_bytes |
OCaml's built in
bytes type, currently equal to string .
|
Core_char |
Character operations.
|
Core_field | |
Core_gc |
Memory management control and statistics; finalised values.
|
Core_gc_unit_tests | |
Core_hashtbl |
Core_hashtbl is a reimplementation of the standard MoreLabels.Hashtbl.
|
Core_hashtbl_intf |
Values returned by
hash must be non-negative.
|
Core_int |
OCaml's native integer type.
|
Core_int32 |
An int of exactly 32 bits, regardless of the machine.
|
Core_int63 |
63 or 64 bit integers.
|
Core_int64 | |
Core_lazy |
A value of type
'a Lazy.t is a deferred computation, called
a suspension, that has a result of type 'a .
|
Core_list |
Tail recursive version of standard List functions, plus additional operations.
|
Core_list_unit_tests | |
Core_map |
This module defines the
Map module for Core.Std .
|
Core_map_bench | |
Core_map_intf |
This module defines interfaces used in
Core.Std.Map .
|
Core_map_unit_tests | |
Core_nativeint | |
Core_printexc |
This module is here to ensure that we don't use the functions in
Caml.Printexc
inadvertently
|
Core_printf |
Formatting error and exit functions
|
Core_queue |
A queue implemented with an array.
|
Core_queue_debug |
The following
include exposes the type equivalence Debug(Queue).t = Queue.t .
|
Core_queue_unit_tests |
This signature is deliberately empty.
|
Core_random |
This is a slightly modified version of the OCaml standard library's random.mli.
|
Core_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 | |
Core_sexp |
Code for managing s-expressions
|
Core_stack |
A stack implemented with an array.
|
Core_string |
An extension of the standard StringLabels.
|
Core_weak |
Module for dealing with weak pointers, i.e., pointers that don't prevent garbage
collection of what they point to.
|
D | |
Day_of_week [Std_kernel] | |
Day_of_week [Stable] | |
Day_of_week |
For representing a day of the week.
|
Debug [Stack_unit_tests] | |
Debug [Pool_intf.Pool] | Debug builds a pool in which every function can run invariant on its pool
argument(s) and/or print a debug message to stderr, as determined by
!check_invariant and !show_messages , which are initially both true .
|
Debug [Flat_queue_debug] | |
Debug [Flat_array_debug] | |
Debug |
Utilities for printing debug messages.
|
Debug [Core_queue_debug] | |
Decimal [Std_kernel] | |
Decimal |
The
decimal type alias provides more readable serializations to s-expressions, at
the cost of lower precision.
|
Deque [Std_kernel] | |
Deque |
A double ended queue that can shrink and expand on both ends.
|
Dequeue [Std_kernel] | |
Dequeue | Dequeue is deprecated, use Deque instead.
|
Digest [Caml] | |
Direct [Core_gc.Control.Fields] | |
Direct [Core_gc.Stat.Fields] | |
Doubly_linked [Std_kernel] | |
Doubly_linked |
doubly-linked lists
|
E | |
Either [Std_kernel] | |
Either [Stable] | |
Either | |
Either_intf |
Many functions in
Either focus on just one constructor.
|
Elt [Timing_wheel_intf.Timing_wheel.Priority_queue] | |
Elt [Heap.Removable] | |
Elt [Doubly_linked] | |
Elt [Core_set_intf.S0] | |
Elt [Bag] | |
Equal [Std_kernel] | |
Equal |
This module defines signatures that are to be included in other signatures to ensure a
consistent interface to
equal functions.
|
Error [Std_kernel] | |
Error [Stable] | |
Error |
Note that the exception raised by this function maintains a reference to the
t
passed in.
|
Error_check [Pool_intf.Pool] | Error_check builds a pool that has additional error checking for pointers, in
particular to detect using a free d pointer or multiply free ing a pointer.
|
Escaping [Core_string] |
Operations for escaping and unescaping strings, with paramaterized escape and
escapeworthy characters.
|
Exn [Std_kernel] | |
Exn | sexp_of_t uses a global table of sexp converters.
|
Exn [Backtrace] | Backtrace.Exn has functions for controlling and printing the backtrace of the most
recently raised exception.
|
Expert [Core_gc] |
The
Expert module contains functions that novice users should not use, due to their
complexity.
|
Export [Result] | |
Export [Perms.Stable] | |
Export [Perms] | |
Export [Ordering] | |
Export [Month] | |
Export [Either_intf.S] | |
F | |
F [Make_substring] | |
Fdeque [Std_kernel] | |
Fdeque [Stable] | |
Fdeque |
A simple polymorphic functional double-ended queue.
|
Fheap [Std_kernel] | |
Fheap |
Functional Heap implementation based on pairing-heap algorithm and immutable data
structures.
|
Field [Std_internal] | |
Fields [Core_gc.Control] | |
Fields [Core_gc.Stat] | |
Filename [Caml] | |
First [Either_intf.S] | |
Flags [Std_kernel] | |
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.
|
Flat_array [Std_kernel] | |
Flat_array |
An array of flat tuples.
|
Flat_array_debug | |
Flat_array_unit_tests |
This signature is here to remind us to update the unit tests whenever we change
Flat_array .
|
Flat_queue [Std_kernel] | |
Flat_queue |
A queue of flat tuples, represented in a
Flat_array .
|
Flat_queue_debug | |
Flat_queue_unit_tests |
This signature is here to remind us to update the unit tests whenever we change
Flat_queue .
|
Float [Std_kernel] | |
Float | |
Float [Core_array.Permissioned] | |
Float [Core_array] | |
Float [Bucket] | |
Float_intf [Std_kernel] | |
Float_intf |
Floating-point representation and utilities.
|
Float_robust_compare |
intended to be a tolerance on human-entered floats
|
Floatable [Std_kernel] | |
Floatable | |
Fn [Std_kernel] | |
Fn |
various combinators for functions
|
For_all_parameters_S1 [Type_immediacy.Never] | |
For_all_parameters_S1 [Type_immediacy.Sometimes] | |
For_all_parameters_S1 [Type_immediacy.Always] | |
For_all_parameters_S2 [Type_immediacy.Never] | |
For_all_parameters_S2 [Type_immediacy.Sometimes] | |
For_all_parameters_S2 [Type_immediacy.Always] | |
For_all_parameters_S3 [Type_immediacy.Never] | |
For_all_parameters_S3 [Type_immediacy.Sometimes] | |
For_all_parameters_S3 [Type_immediacy.Always] | |
For_all_parameters_S4 [Type_immediacy.Never] | |
For_all_parameters_S4 [Type_immediacy.Sometimes] | |
For_all_parameters_S4 [Type_immediacy.Always] | |
For_all_parameters_S5 [Type_immediacy.Never] | |
For_all_parameters_S5 [Type_immediacy.Sometimes] | |
For_all_parameters_S5 [Type_immediacy.Always] | |
For_test [Binary_searchable_intf.Indexable1] | |
For_test [Binary_searchable_intf.Indexable] |
To implement the test provided by
Binary_searchable , we need to be able to
construct t with two different values small < big .
|
Force_once [Std_kernel] | |
Force_once |
A "force_once" is a thunk that can only be forced once.
|
Format [Caml] | |
Format [Bigbuffer] | |
Fqueue [Std_kernel] | |
Fqueue [Stable] | |
Fqueue |
A simple polymorphic functional queue.
|
From_string [Bigstring] | |
Front_to_back [Fdeque] |
Traverse deque elements front-to-back.
|
G | |
G [Quickcheck_unit_tests.Test] | |
Gc [Std_kernel] | |
Gc [Caml] | |
Generator [Sequence] | |
Generator [Quickcheck_intf.Quickcheck] | |
Genlex [Caml] | |
H | |
Hash_heap [Std_kernel] | |
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_kernel] | |
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_kernel] | |
Hash_set [Stable_containers.Hashable.V1.S] | |
Hash_set [Hashable.S_binable] | |
Hash_set [Hashable.S] | |
Hash_set [Hashable.Make_binable] | |
Hash_set [Hashable.Make] | |
Hash_set |
We use
with sexp_of but not with sexp because we want people to be explicit about
the hash and comparison functions used when creating hashtables.
|
Hash_set_intf |
override
Container.Generic.mem
|
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_kernel] | |
Hashable [Stable_containers] | |
Hashable | |
Hashable [Core_hashtbl_intf.Hashtbl] | |
Hashable [Core_hashtbl_intf] | |
Hashable_t [Tuple] | |
Hashtbl [Std_internal] | |
Hashtbl [Hashable] | |
Hashtbl [Hash_queue] | |
Hashtbl [Hash_heap] | |
Hashtbl [Caml] | |
Hashtbl_intf [Std_kernel] | |
Hashtbl_unit_tests | |
Heap [Std_kernel] | |
Heap |
Heap implementation based on a pairing-heap.
|
Heap [Hash_heap] | |
Heap_block [Std_kernel] | |
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.
|
Heap_intf |
of_sexp and bin_io functions aren't supplied for heaps due to the difficulties in
reconstructing the correct comparison function when de-serializing.
|
Hex [Int_intf.Hexable] | |
Host_and_port [Std_kernel] | |
Host_and_port [Stable] | |
Host_and_port | |
I | |
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.
|
Id [Pool_intf.S.Pointer] | |
Ident [Monad_intf.Monad] | |
Identifiable [Std_kernel] | |
Identifiable |
a signature for opaque identifier types.
|
Immutable [Perms.Stable.V1] | |
Immutable [Perms] | |
In_channel [Std_kernel] | |
In_channel | In_channel collects all of the pervasive functions that work on in_channels.
|
Infix [Sequence] | |
Infix [Core_string] | |
Infix [Core_list] | |
Infix [Core_array.Permissioned] | |
Infix [Core_array] | |
Infix [Byte_units] | |
Info [Std_kernel] | |
Info [Stable] | |
Info | Info is a library for lazily constructing human-readable information as a string or
sexp, with a primary use being error messages.
|
Info_unit_tests |
Deliberately empty.
|
Inherit [Comparable] |
Inherit comparability from a component.
|
Int [Unique_id] |
An abstract unique identifier based on ordinary OCaml integers.
|
Int [Std_internal] | |
Int [Core_array.Permissioned] | |
Int [Core_array] | |
Int [Bucket] | |
Int32 [Std_internal] | |
Int32 [Caml] | |
Int63 [Timing_wheel_intf] | |
Int63 [Unique_id] |
An abstract unique identifier based on 63 bit integers.
|
Int63 [Std_kernel] | |
Int63 [Pool_intf] | |
Int63 [Flags_intf] | |
Int64 [Std_internal] | |
Int64 [Caml] | |
Int64 [Bucket] | |
Int_conversions [Std_kernel] | |
Int_conversions |
Conversions between various integer types
|
Int_intf [Std_kernel] | |
Int_intf | round rounds an int to a multiple of a given to_multiple_of argument, according
to a direction dir , with default dir being `Nearest .
|
Int_math |
This module is not exposed in Core.Std.
|
Int_pow2 | |
Int_replace_polymorphic_compare | |
Int_set [Std_kernel] | |
Int_set |
An implementation of compressed integer sets using lists of integer ranges.
|
Intable | |
Interfaces [Std_kernel] | |
Interfaces | |
Interval_num [Timing_wheel_intf.Timing_wheel] | |
Invariant [Std_kernel] | |
Invariant | |
Invariant_intf |
This module defines signatures that are to be included in other signatures to ensure a
consistent interface to invariant-style functions.
|
J | |
JC [Quickcheck_unit_tests.Test] | |
K | |
Key [Univ_map_intf] | |
Key [Timing_wheel_intf.Timing_wheel.Priority_queue] | |
Key [Univ_map.Multi] | |
Key [Univ_map.With_fold] | |
Key [Univ_map.With_default] | |
Key [Total_map.S] | |
Key [Hash_queue.S] | |
Key [Hash_queue.Make] | |
Key [Hash_heap.S] | |
Key [Hash_heap.Make] | |
Key [Core_map_intf.S] | |
L | |
Lazy [Std_internal] | |
Lazy [Stable] | |
Lazy [Caml] | |
Level_bits [Timing_wheel_intf.Timing_wheel] | |
Lexing [Caml] | |
Lift [Type_equal] | |
Lift2 [Type_equal] | |
Lift3 [Type_equal] | |
Linked_queue [Std_internal] | |
Linked_queue |
Linked_queue is a wrapper around OCaml's standard Queue module that follows Core
idioms and adds some functions.
|
Linked_stack [Std_kernel] | |
Linked_stack |
A stack implemented with a list.
|
List [Std_internal] | |
List [Hash_queue] | |
List [Core_map_intf] | |
List [Caml] | |
List [Binable0] | |
ListLabels [Caml] | |
M | |
Make [Validated_intf.S] | |
Make [Timing_wheel_unit_tests] | |
Make [Univ_map] | |
Make [Tuple] | |
Make [Total_map] | |
Make [String_id] | Make customizes the error messages generated by of_string /of_sexp to include
module_name .
|
Make [Stable_unit_test] |
Include all of the above tests.
|
Make [Stable_containers.Hashable.V1] | |
Make [Stable_containers.Comparable.V1] | |
Make [Monad_intf.Monad] | |
Make [Int_math] |
derived operations common to various integer modules
|
Make [Int_conversions] |
human-friendly string (and possibly sexp) conversions
|
Make [Identifiable] |
Used for making an Identifiable module.
|
Make [Hashtbl_unit_tests] | |
Make [Hashable] | |
Make [Hash_set] | |
Make [Hash_queue] | |
Make [Hash_heap] | |
Make [Float_robust_compare] | |
Make [Flags_intf.Flags] | Flags.Make builds a new flags module.
|
Make [Debug] | Debug.Make produces a debug function used to wrap a function to display arguments
before calling and display results after returning.
|
Make [Core_set] | Make builds a set from an element type that has a compare function but doesn't
have a comparator.
|
Make [Core_map] | |
Make [Core_hashtbl_intf.Hashtbl] | |
Make [Container_intf.Container] |
The idiom for using
Container.Make is to bind the resulting module and to
explicitly import each of the functions that one wants:
|
Make [Comparator] | |
Make [Comparable] |
Usage example:
|
Make [Bucket] | |
Make [Blit_intf.Blit] | Make is for blitting between two values of the same monomorphic type.
|
Make [Binary_searchable_intf.Binary_searchable] | |
Make [Applicative] | |
Make1 [Univ_map] | |
Make1 [Comparator] | |
Make1 [Blit_intf.Blit] | Make1 is for blitting between two values of the same polymorphic type.
|
Make1 [Binary_searchable_intf.Binary_searchable] | |
Make2 [Monad_intf.Monad] | |
Make2 [Applicative] | |
Make_args [Applicative] | |
Make_args2 [Applicative] | |
Make_bin_io_test [Stable_unit_test] | |
Make_binable [Validated_intf.S] | |
Make_binable [Hashable] | |
Make_binable [Hash_set] | |
Make_binable [Core_set] | |
Make_binable [Core_map] | |
Make_binable [Core_hashtbl_intf.Hashtbl] | |
Make_binable [Comparable] | |
Make_binable_using_comparator [Core_set] | |
Make_binable_using_comparator [Core_map] | |
Make_distinct [Blit_intf.Blit] | Make_distinct is for blitting between values of distinct monomorphic types.
|
Make_hex [Int_conversions] | |
Make_sexp_deserialization_test [Stable_unit_test] |
We provide separate access to sexp serialization and deserialization tests because
some stable types will have varying sexp serializations.
|
Make_sexp_serialization_test [Stable_unit_test] | |
Make_substring | |
Make_unordered_container [Stable_unit_test] |
See
stable_unit_test_intf.ml for documentation.
|
Make_using_comparator [Core_set] | Make_using_comparator builds a set from an element type that has a comparator.
|
Make_using_comparator [Core_map] | |
Make_without_pretty_printer [String_id] |
This does what
Make does without registering a pretty printer.
|
Map [Std_internal] | |
Map [Stable_containers.Comparable.V1.S] | |
Map [Core_set_intf] | |
Map [Comparable_intf.Map_and_set_binable] | |
Map [Comparable_intf.S] | |
Map [Caml] | |
Map_and_set_binable [Comparable] | |
Marshal [Caml] | |
Measure [Byte_units] | |
Memo [Std_kernel] | |
Memo |
Memoization code -- not re-entrant!
|
Monad [Std_kernel] | |
Monad |
See
Monad_intf .
|
Monad_infix [Monad_intf.S2] | |
Monad_infix [Monad_intf.S] | |
Monad_intf |
The following identities ought to hold (for some value of =):
|
Month [Std_kernel] | |
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
|
N | |
Nativeint [Std_internal] | |
Nativeint [Caml] | |
Never [Type_immediacy] | |
Never_returns | |
No_polymorphic_compare [Std_kernel] | |
No_polymorphic_compare |
Open this in modules where you don't want to accidentally use polymorphic comparison.
|
Nothing [Std_kernel] | |
Nothing [Stable] | |
Nothing |
An uninhabited type.
|
Nothing0 | |
O | |
O [Quickcheck_unit_tests.Test] | |
O [Int_intf.S] |
A sub-module designed to be opened to make working with ints more convenient.
|
O [Float_intf.S] |
A sub-module designed to be opened to make working with floats more convenient.
|
O [Core_sexp] | |
Obj_array |
An array of
Obj.t s.
|
Observer [Quickcheck_intf.Quickcheck] | |
Of_binable [Binable0] | |
Of_binable [Binable] | |
Of_binable1 [Binable0] | |
Of_binable1 [Binable] | |
Of_binable2 [Binable0] | |
Of_binable2 [Binable] | |
Of_monad [Applicative] |
Every monad is Applicative via:
|
Of_sexpable [Sexpable] | |
Of_sexpable1 [Sexpable] | |
Of_stringable [Sexpable] | |
Of_stringable [Binable0] | |
Of_stringable [Binable] | |
Only_in_test [Std_kernel] | |
Only_in_test |
This module can be used to safely expose functions and values in signatures
that should only be used in unit tests.
|
Oo [Caml] | |
Option [Std_kernel] | |
Option |
Options form a monad, where
return x = Some x ,
(None >>= f) = None , and (Some x >>= f) = f x .
|
Or_error [Std_kernel] | |
Or_error [Stable] | |
Or_error |
Type for tracking errors in an Error.t.
|
Ordered_collection_common [Std_kernel] | |
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_kernel] | |
Out_channel |
defaults to
true
|
P | |
Packed [Univ_map_intf.S1] | |
Packed [Univ_map_intf.S] | |
Pair [Applicative] | |
Parsing [Caml] | |
Parts [Time_ns.Span] |
Similar to
Time.Span.Parts , but adding ns .
|
Parts [Float_intf.S] |
Returns the fractional part and the whole (i.e.
|
Percent [Std_kernel] | |
Percent [Stable] | |
Percent |
An abstract type of scale factors
|
Permissioned [Ref] | |
Permissioned [Core_array] |
The
Permissioned module gives the ability to restrict permissions on an array, so
you can give a function read-only access to an array, create an immutable array, etc.
|
Perms [Stable] | |
Perms |
These types are intended to be used as phantom types encoding the permissions on a
given type.
|
Pervasives [Caml] | |
Pid [Std_kernel] | |
Pid |
Process ID.
|
Pointer [Pool_intf.S] | |
Poly [Std_kernel] | |
Poly | Poly is a convenient shorthand for Polymorphic_compare in the common case that one
wants to use a polymorphic comparator directly in an expression, e.g.
|
Poly [Hash_set] |
A hash set that uses polymorphic comparison
|
Poly [Core_set] | |
Poly [Core_map] | |
Poly [Core_hashtbl_intf.Hashtbl] | |
Poly [Comparator] | |
Poly [Comparable] | |
Polymorphic_compare [Std_kernel] | |
Polymorphic_compare |
A module containing the ad-hoc polymorphic comparison functions.
|
Polymorphic_compare_intf |
Interfaces used for hiding and replacing polymorphic compare.
|
Pool [Std_kernel] | |
Pool | |
Pool_intf |
A manual memory manager for a set of mutable tuples.
|
Pool_unit_tests | |
Pooled_hashtbl [Std_kernel] | |
Pooled_hashtbl |
A polymorphic hashtbl that uses
Pool to avoid allocation.
|
Pooled_hashtbl_unit_test | |
Pow_overflow_bounds | |
Pretty_printer [Std_kernel] | |
Pretty_printer |
A list of pretty printers for various types, for use in toplevels.
|
Printexc [Std_kernel] | |
Printexc [Caml] | |
Printf [Std_kernel] | |
Printf [Caml] | |
Printf [Bigbuffer] | |
Priority_queue [Timing_wheel_intf.Timing_wheel] |
Timing wheel is implemented as a priority queue in which the keys are
non-negative integers corresponding to the intervals of time.
|
Q | |
Queue [Std_internal] | |
Queue [Caml] | |
Quickcheck [Std_kernel] | |
Quickcheck |
You should start reading in quickcheck_generator.mli
|
Quickcheck_generator |
An
'a Quickcheck_generator.t a generates values of type 'a with a specific
probability distribution.
|
Quickcheck_intf [Std_kernel] | |
Quickcheck_intf |
You should start reading in quickcheck_generator.mli
|
Quickcheck_observer |
An
'a Quickcheck.Observer.t represents observations that can be made to distinguish
values of type 'a .
|
Quickcheck_unit_tests | |
R | |
Random [Std_internal] | |
Random [Caml] | |
Random [Array_permute] | |
Raw_quickcheck_generator |
See
Quickcheck_generator for an overview.
|
Raw_quickcheck_observer |
See
Quickcheck_observer for an overview.
|
Read [Perms.Stable.V1] | |
Read [Perms] | |
Read_write [Perms.Stable.V1] | |
Read_write [Perms] | |
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 .
|
Removable [Heap] |
Removable augments a heap with the ability to remove elements from the heap in lg(n)
(amortized) time at any point after they have been added.
|
Replace_polymorphic_compare [Comparable_intf.S_common] | |
Result [Std_kernel] | |
Result [Stable] | |
Result | Result is often used to handle error messages.
|
Robustly_comparable [Std_kernel] | |
Robustly_comparable | |
Rope [Std_kernel] | |
Rope |
A rope is a standard data structure that represents a single string as a tree of
strings, and supports constant-time concatenation.
|
S | |
S2_to_S [Applicative_intf] | |
S_to_S1 [Comparator] | |
S_to_S2 [Monad_intf] | |
S_to_S2 [Applicative_intf] |
This module serves mostly as a partial check that
S2 and S are in sync, but
actually calling it is occasionally useful.
|
Scanf [Caml] | |
Search_pattern [Core_string] |
Substring search and replace functions.
|
Second [Either_intf.S] | |
Sequence [Std_kernel] | |
Sequence |
A sequence of elements that can be produced one at a time, on demand, normally with no
sharing.
|
Set [Std_internal] | |
Set [Stable_containers.Comparable.V1.S] | |
Set [Comparable_intf.Map_and_set_binable] | |
Set [Comparable_intf.S] | |
Set [Caml] | |
Set_once [Std_kernel] | |
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 [Source_code_position0] | |
Sexp_array [Core_sexp] | |
Sexp_list [Core_sexp] | |
Sexp_maybe [Std_kernel] | |
Sexp_maybe [Core_sexp] |
If
sexp_of_t fails , it returns Error rather than raising.
|
Sexp_opaque [Core_sexp] | |
Sexp_option [Core_sexp] |
The purpose of these modules is to allow bin_io to work with these special sexp types.
|
Sexpable [Tuple] | |
Sexpable [Std_kernel] | |
Sexpable | |
Sign [Float_intf.S] | |
Slot [Pool_intf.S] | |
Slot [Flat_queue] | |
Slot [Flat_array_debug.Debug] | |
Slot [Flat_array] | |
Slots [Tuple_type] | |
Slots [Pool_intf.S] | |
Slots [Flat_queue] | |
Slots [Flat_array_debug.Debug] | |
Slots [Flat_array] | |
Sometimes [Type_immediacy] | |
Sort [Caml] | |
Source_code_position [Std_kernel] | |
Source_code_position |
One typically obtains a
Source_code_position.t using a _here_ expression, which is
implemented by the pa_here preprocessor.
|
Source_code_position0 | |
Span [Timing_wheel_intf.Interval_num] | |
Span [Timing_wheel_intf.Timing_wheel_time] | |
Span [Time_ns_alternate_sexp] | |
Span [Time_ns] | |
Stable [String_id.S] | |
Stable | |
Stable [Source_code_position0] | |
Stable [Source_code_position] | |
Stable [Result] | |
Stable [Perms] | |
Stable [Percent] | |
Stable [Or_error] | |
Stable [Nothing] | |
Stable [Month] | |
Stable [Info] | |
Stable [Host_and_port] | |
Stable [Fqueue] | |
Stable [Fdeque] | |
Stable [Either_intf.S] | |
Stable [Day_of_week] | |
Stable [Core_lazy] | |
Stable [Blang] | |
Stable_containers |
The Stable versions of Hashtbl, Hash_set, Map, and Set are defined here rather than in
their respective modules because:
|
Stable_internal | |
Stable_module_types |
The polymorphic signatures require a mapping function so people can write conversion
functions without either (1) re-implementing the mapping function inline or (2)
reaching into the unstable part of the module.
|
Stable_unit_test |
The tests generated by these functors are run like any other unit tests: by the inline
test runner when the functor is applied.
|
Stable_unit_test_intf |
An interface for creating unit tests to check stability of sexp and bin-io
serializations
|
Stack [Std_kernel] | |
Stack [Caml] | |
Stack_intf |
An interface for stacks that follows
Core 's conventions, as opposed to OCaml's
standard Stack module.
|
Stack_unit_tests | |
Staged [Std_kernel] | |
Staged |
A type for making staging explicit in the type of a function.
|
Stat [Core_gc] | |
State [Core_random] |
The functions from module
State manipulate the current state
of the random generator explicitely.
|
Std | |
StdLabels [Caml] | |
Std_common | |
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).
|
Std_kernel | |
Step [Sequence] |
A
Step describes the next step of the sequence construction.
|
Stream [Caml] | |
String [Std_internal] | |
String [Caml] | |
StringLabels [Caml] | |
String_id |
Disallows whitespace around the edges in
of_string and t_of_sexp , but doesn't
check when reading from bin_io.
|
String_id [Std_kernel] | |
String_id [Stable] | |
Stringable | |
Stringable [Std_kernel] | |
Substring | |
Substring [Std_kernel] | |
Substring_intf |
A substring is a contiguous set of characters within a string.
|
Substring_intf [Std_kernel] | |
Sys [Caml] | |
T | |
T | |
T2 [Tuple] |
Signature for a 2-tuple module
|
T3 [Tuple] |
Signature for a 3-tuple module
|
T_unforcing [Core_lazy] |
This type offers a serialization function
sexp_of_t that won't force its argument.
|
Table [Stable_containers.Hashable.V1.S] | |
Table [Hashable.S_binable] | |
Table [Hashable.S] | |
Table [Hashable.Make_binable] | |
Table [Hashable.Make] | |
Terse [Float_intf.S] |
S-expressions contain at most 8 significant digits.
|
Test [Stack_unit_tests] | |
Test [Quickcheck_unit_tests] | |
Test_S1 [Container_unit_tests] | |
Test_generic [Container_unit_tests] | |
Thread_safe_queue |
A thread-safe non-blocking queue of unbounded size.
|
Thread_safe_queue [Std_kernel] | |
Time [Timing_wheel_intf.Timing_wheel] | |
Time_ns |
Time represented as an
Int63.t number of nanoseconds since the epoch.
|
Time_ns [Std_common] | |
Time_ns_alternate_sexp | |
Timing_wheel_intf |
A specialized priority queue for a set of time-based alarms.
|
Timing_wheel_ns | |
Timing_wheel_ns [Std_kernel] | |
Timing_wheel_ns_unit_tests |
Deliberately empty.
|
Timing_wheel_unit_tests | Timing_wheel_unit_tests.Make implements timing-wheel unit tests, and is used by both
Timing_wheel_float and Timing_wheel_ns .
|
To_string [Bigstring] | |
To_stringable [Sexpable] | |
Total_map |
A
('key, 'value, cmp) Map.t where every value of type 'key is present.
|
Total_map [Std_kernel] | |
Tree [Core_set_intf.S0] | |
Tree [Core_set.Poly] | |
Tree [Core_set] | |
Tree [Core_map_intf.S] | |
Tree [Core_map.Poly] | |
Tree [Core_map] | |
Tuple |
Functors and signatures for dealing with modules for tuples.
|
Tuple [Std_kernel] | |
Tuple2 [Std_kernel] | |
Tuple3 [Std_kernel] | |
Tuple_type |
Tuple-like types used in
Flat_array and Pool .
|
Tuple_type_intf | Slots has types t1 , ..., t12 of arities 1 to 12 that are isomorphic to tuple
types of the corresponding arities.
|
Type_equal |
For representing type equalities otherwise not known by the type-checker.
|
Type_equal [Std_kernel] | |
Type_immediacy |
Witnesses that express whether a type's values are always, sometimes, or never
immediate.
|
Type_immediacy [Std_kernel] | |
Type_immediacy_conv_unit_tests |
This signature is deliberately empty.
|
Type_immediacy_witness_unit_tests |
This signature is deliberately empty.
|
Typename_of_sexp_array [Std_internal] | |
Typename_of_sexp_bool [Std_internal] | |
Typename_of_sexp_list [Std_internal] | |
Typename_of_sexp_opaque [Std_internal] | |
Typename_of_sexp_option [Std_internal] | |
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_kernel] | |
Unique_id |
Functors for creating modules that mint unique identifiers.
|
Unique_id [Std_kernel] | |
Unique_id_intf |
Signature for use by
module : Unique_id .
|
Unit |
Module for the type
unit .
|
Unit [Std_kernel] | |
Unit_test [Stable] | |
Unit_tests [Stable] | |
Univ |
An extensible "universal" variant type.
|
Univ [Std_kernel] | |
Univ_map |
Universal/heterogeneous maps.
|
Univ_map [Std_kernel] | |
Univ_map_intf |
The
's parameter is shared across all values stored in the map.
|
Unordered_container_test [Stable_unit_test_intf] |
Unordered container tests are for types with serializations that will contain a
certain set of elements (each represented by a single sexp or bin-io string) which may
appear in any order, such as hash tables and hash sets.
|
Unpack_buffer |
A buffer for incremental decoding of an input stream.
|
Unpack_buffer [Std_kernel] | |
Unpack_one [Unpack_buffer] | |
Unsafe [Pool_intf.Pool] |
An
Unsafe pool is like an ordinary pool, except that the create function does
not require an initial element.
|
Upper_bound [Perms.Stable.V1] | |
Upper_bound [Perms] | |
V | |
V1 [String_id.S.Stable] | |
V1 [Stable_containers.Hashable] | |
V1 [Stable_containers.Comparable] | |
V1 [Source_code_position0.Stable] | |
V1 [Source_code_position.Stable] | |
V1 [Result.Stable] | |
V1 [Perms.Stable] | |
V1 [Percent.Stable] | |
V1 [Or_error.Stable] | Or_error.t is wire compatible with V2.t , but not V1.t , like Info.Stable
and Error.Stable .
|
V1 [Nothing.Stable] | |
V1 [Month.Stable] | |
V1 [Info.Stable] | Info.t is wire-compatible with V2.t , but not V1.t .
|
V1 [Host_and_port.Stable] | |
V1 [Fqueue.Stable] | |
V1 [Fdeque.Stable] | |
V1 [Either_intf.S.Stable] | |
V1 [Day_of_week.Stable] | |
V1 [Core_lazy.Stable] | |
V1 [Blang.Stable] | |
V1_stable_unit_test [Result.Stable] |
We export the unit test arg rather than instantiate the functor inside result.ml in
order to avoid circular dependencies.
|
V2 [Or_error.Stable] | |
V2 [Info.Stable] | |
Validate |
A module for organizing validations of data structures.
|
Validate [Std_kernel] | |
Validate [Comparable] | |
Validate_with_zero [Comparable] | |
Validated |
See
Validated_intf for documentation.
|
Validated [Std_kernel] | |
Validated_intf |
For making an abstract version of a type that ensures a validation check has passed.
|
View [Univ] | |
W | |
Weak [Std_kernel] | |
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_return [Std_kernel] | |
With_text [Core_sexp] |
A
With_text.t is a value paired with the full textual representation of its sexp.
|
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_kernel] | |
Write [Perms.Stable.V1] | |
Write [Perms] | |
Writer [Core_bin_prot] |