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
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 freed pointer or multiply freeing 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.ts.
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]