# Index of modules

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 | See `Binary_searchable_intf`.
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 |
Caml_modify | Increment a counter whenever `caml_modify` is called.
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] |