Index of modules

A GC alarm calls a user function at the end of each major GC cycle.

The policy used for allocating in the heap.

Note that we expose a sexp format that is not the one exposed in Core.

Note that we expose a sexp format that is not the one exposed in Core.

The following functors give a sense of what Applicatives one can define.

Applicatives model computations in which values computed by subcomputations cannot affect what subsequent computations will take place.

Traverse deque elements in arbitrary order.

An internal-only module factored out due to a circular dependency between core_array and 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.:

A low-level, mutable AVL tree.

Traverse deque elements back-to-front.

Dealing with stack backtraces.

Imperative set-like data structure.

Extensible string buffers based on Bigstrings.

String type based on Bigarray, for use in I/O and C-bindings

Utility functions for marshalling to and from bigstring.

Substring type based on Bigarray, for use in I/O and C-bindings

Module types and utilities for dealing with types that support the bin-io binary encoding.

Packs and unpacks various types of integers into and from strings.

See Binary_searchable_intf.

Module types for a binary_search function for a sequence, and functors for building binary_search functions.

A simple boolean domain-specific language

See Blit_intf for documentation.

Standard type for blit functions, and reusable code for validating blit arguments.

A Bounded_int_table is a table whose keys can be mapped to integers in a fixed range, 0 ...

Conversions between units of measure based on bytes.

Increment a counter whenever caml_modify is called.

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.

Consistency checks (same as in Container).

Consistency checks (same as in Container).

Check_sexp_conversion checks that conversion of a map or set to a sexp uses the same sexp conversion as the underlying element.

'a Choice.t represents the choice of a value from a generator.

Basic types and definitions required throughout the system.

A signature for a commutative group (in the group-theory sense).

lexicographic cmps x y compares x and y lexicographically using functions in the list cmps.

Used for specifying a bound (either upper or lower) as inclusive, exclusive, or unbounded.

A type-indexed value that allows one to compare (and for generating error messages, serialize) values of the type in question.

Composition_preserves_injectivity is a functor that proves that composition of injective types is injective.

Every monoid gives rise to a constant Applicative.

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.

INRIA's original command-line parsing library.

Note: Array.length is not constant for a given array, as one can reduce it with Array.truncate

OCaml's built in bytes type, currently equal to string.

Character operations.

Memory management control and statistics; finalised values.

Core_hashtbl is a reimplementation of the standard MoreLabels.Hashtbl.

Values returned by hash must be non-negative.

OCaml's native integer type.

An int of exactly 32 bits, regardless of the machine.

63 or 64 bit integers.

A value of type 'a Lazy.t is a deferred computation, called a suspension, that has a result of type 'a.

Tail recursive version of standard List functions, plus additional operations.

This module defines the Map module for Core.Std.

This module defines interfaces used in Core.Std.Map.

This module is here to ensure that we don't use the functions in Caml.Printexc inadvertently

Formatting error and exit functions

A queue implemented with an array.

The following include exposes the type equivalence Debug(Queue).t = Queue.t.

This signature is deliberately empty.

This is a slightly modified version of the OCaml standard library's random.mli.

This module defines the Set module for Core.Std.

This module defines interfaces used in Core.Std.Set.

Code for managing s-expressions

A stack implemented with an array.

An extension of the standard StringLabels.

Module for dealing with weak pointers, i.e., pointers that don't prevent garbage collection of what they point to.

For representing a day of the week.

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.

Utilities for printing debug messages.

The decimal type alias provides more readable serializations to s-expressions, at the cost of lower precision.

A double ended queue that can shrink and expand on both ends.

Dequeue is deprecated, use Deque instead.

doubly-linked lists

Many functions in Either focus on just one constructor.

This module defines signatures that are to be included in other signatures to ensure a consistent interface to equal functions.

Note that the exception raised by this function maintains a reference to the t passed in.

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.

Operations for escaping and unescaping strings, with paramaterized escape and escapeworthy characters.

sexp_of_t uses a global table of sexp converters.

Backtrace.Exn has functions for controlling and printing the backtrace of the most recently raised exception.

The Expert module contains functions that novice users should not use, due to their complexity.

A simple polymorphic functional double-ended queue.

Functional Heap implementation based on pairing-heap algorithm and immutable data structures.

See flags_intf.ml for documentation.

module Flags implements Unix-style sets of flags that are represented as an int with various bits set, one bit for each flag.

An array of flat tuples.

This signature is here to remind us to update the unit tests whenever we change Flat_array.

A queue of flat tuples, represented in a Flat_array.

This signature is here to remind us to update the unit tests whenever we change Flat_queue.

Floating-point representation and utilities.

intended to be a tolerance on human-entered floats

various combinators for functions

To implement the test provided by Binary_searchable, we need to be able to construct t with two different values small < big.

A "force_once" is a thunk that can only be forced once.

A simple polymorphic functional queue.

Traverse deque elements front-to-back.

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.

a hash-queue, where the values are of type 'a

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.

override Container.Generic.mem

The difference between Hashable and Hashable_t functors is that the former's result type doesn't contain type t and the latter does.

Heap implementation based on a pairing-heap.

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.

of_sexp and bin_io functions aren't supplied for heaps due to the difficulties in reconstructing the correct comparison function when de-serializing.

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.

a signature for opaque identifier types.

In_channel collects all of the pervasive functions that work on in_channels.

Info is a library for lazily constructing human-readable information as a string or sexp, with a primary use being error messages.

Deliberately empty.

Inherit comparability from a component.

An abstract unique identifier based on ordinary OCaml integers.

An abstract unique identifier based on 63 bit integers.

Conversions between various integer types

round rounds an int to a multiple of a given to_multiple_of argument, according to a direction dir, with default dir being `Nearest.

This module is not exposed in Core.Std.

An implementation of compressed integer sets using lists of integer ranges.

This module defines signatures that are to be included in other signatures to ensure a consistent interface to invariant-style functions.

Linked_queue is a wrapper around OCaml's standard Queue module that follows Core idioms and adds some functions.

A stack implemented with a list.

Make customizes the error messages generated by of_string/of_sexp to include module_name.

Include all of the above tests.

derived operations common to various integer modules

human-friendly string (and possibly sexp) conversions

Used for making an Identifiable module.

Flags.Make builds a new flags module.

Debug.Make produces a debug function used to wrap a function to display arguments before calling and display results after returning.

Make builds a set from an element type that has a compare function but doesn't have a comparator.

The idiom for using Container.Make is to bind the resulting module and to explicitly import each of the functions that one wants:

Usage example:

Make is for blitting between two values of the same monomorphic type.

Make1 is for blitting between two values of the same polymorphic type.

Make_distinct is for blitting between values of distinct monomorphic types.

We provide separate access to sexp serialization and deserialization tests because some stable types will have varying sexp serializations.

See stable_unit_test_intf.ml for documentation.

Make_using_comparator builds a set from an element type that has a comparator.

This does what Make does without registering a pretty printer.

Memoization code -- not re-entrant!

See Monad_intf.

The following identities ought to hold (for some value of =):

of_string s accepts three-character abbreviations with 3 capitalizations (e.g.

list-accumulating keys with a default value of the empty list

Open this in modules where you don't want to accidentally use polymorphic comparison.

An uninhabited type.

A sub-module designed to be opened to make working with ints more convenient.

A sub-module designed to be opened to make working with floats more convenient.

An array of Obj.ts.

Every monad is Applicative via:

This module can be used to safely expose functions and values in signatures that should only be used in unit tests.

Options form a monad, where return x = Some x, (None >>= f) = None, and (Some x >>= f) = f x.

Type for tracking errors in an Error.t.

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 is intended to make code that matches on the result of a comparison more concise and easier to read.

defaults to true

Similar to Time.Span.Parts, but adding ns.

Returns the fractional part and the whole (i.e.

An abstract type of scale factors

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.

These types are intended to be used as phantom types encoding the permissions on a given type.

Process ID.

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.

A hash set that uses polymorphic comparison

A module containing the ad-hoc polymorphic comparison functions.

Interfaces used for hiding and replacing polymorphic compare.

A manual memory manager for a set of mutable tuples.

A polymorphic hashtbl that uses Pool to avoid allocation.

A list of pretty printers for various types, for use in toplevels.

Timing wheel is implemented as a priority queue in which the keys are non-negative integers corresponding to the intervals of time.

You should start reading in quickcheck_generator.mli

An 'a Quickcheck_generator.t a generates values of type 'a with a specific probability distribution.

You should start reading in quickcheck_generator.mli

An 'a Quickcheck.Observer.t represents observations that can be made to distinguish values of type 'a.

See Quickcheck_generator for an overview.

See Quickcheck_observer for an overview.

swap t1 t2 swaps the values in t1 and t2.

Register builds a pp function from a to_string function, and adds the module_name ^ ".pp" to the list of pretty printers.

Register_pp is like Register, but allows a custom pp function rather than using to_string.

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.

Result is often used to handle error messages.

A rope is a standard data structure that represents a single string as a tree of strings, and supports constant-time concatenation.

This module serves mostly as a partial check that S2 and S are in sync, but actually calling it is occasionally useful.

Substring search and replace functions.

A sequence of elements that can be produced one at a time, on demand, normally with no sharing.

This module implements an option ref that starts out as None, and may be set only once.

If sexp_of_t fails, it returns Error rather than raising.

The purpose of these modules is to allow bin_io to work with these special sexp types.

One typically obtains a Source_code_position.t using a _here_ expression, which is implemented by the pa_here preprocessor.

The Stable versions of Hashtbl, Hash_set, Map, and Set are defined here rather than in their respective modules because:

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.

The tests generated by these functors are run like any other unit tests: by the inline test runner when the functor is applied.

An interface for creating unit tests to check stability of sexp and bin-io serializations

An interface for stacks that follows Core's conventions, as opposed to OCaml's standard Stack module.

A type for making staging explicit in the type of a function.

The functions from module State manipulate the current state of the random generator explicitely.

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).

A Step describes the next step of the sequence construction.

Disallows whitespace around the edges in of_string and t_of_sexp, but doesn't check when reading from bin_io.

A substring is a contiguous set of characters within a string.

Signature for a 2-tuple module

Signature for a 3-tuple module

This type offers a serialization function sexp_of_t that won't force its argument.

S-expressions contain at most 8 significant digits.

A thread-safe non-blocking queue of unbounded size.

Time represented as an Int63.t number of nanoseconds since the epoch.

A specialized priority queue for a set of time-based alarms.

Deliberately empty.

Timing_wheel_unit_tests.Make implements timing-wheel unit tests, and is used by both Timing_wheel_float and Timing_wheel_ns.

A ('key, 'value, cmp) Map.t where every value of type 'key is present.

Functors and signatures for dealing with modules for tuples.

Tuple-like types used in Flat_array and Pool.

Slots has types t1, ..., t12 of arities 1 to 12 that are isomorphic to tuple types of the corresponding arities.

For representing type equalities otherwise not known by the type-checker.

Witnesses that express whether a type's values are always, sometimes, or never immediate.

This signature is deliberately empty.

This signature is deliberately empty.

Every Id.t contains a unique id that is distinct from the Uid.t in any other Id.t.

Imperative data structure for representing disjoint sets.

Functors for creating modules that mint unique identifiers.

Signature for use by module : Unique_id.

Module for the type unit.

An extensible "universal" variant type.

Universal/heterogeneous maps.

The 's parameter is shared across all values stored in the map.

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.

A buffer for incremental decoding of an input stream.

An Unsafe pool is like an ordinary pool, except that the create function does not require an initial element.

Or_error.t is wire compatible with V2.t, but not V1.t, like Info.Stable and Error.Stable.

Info.t is wire-compatible with V2.t, but not V1.t.

We export the unit test arg rather than instantiate the functor inside result.ml in order to avoid circular dependencies.

A module for organizing validations of data structures.

See Validated_intf for documentation.

For making an abstract version of a type that ensures a validation check has passed.

keys with associated default values, so that find is no longer partial

keys that map to an accumulator value with an associated fold operation

This is include'd and documented in module: Common.

A With_text.t is a value paired with the full textual representation of its sexp.

For determining the word size that the program is using.