Index of modules

An internal-only module factored out due to a circular dependency between core_array and core_list.

A low-level, mutable AVL tree.

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

create measure value creates a t from value units of the given measure.

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.

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

Parsing of command line arguments.

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

Character operations.

Memory management control and statistics; finalised values.

For many students of ocaml, using hashtables is complicated by the functors.

Values returned by hash must be non-negative.

OCaml's native integer type.

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

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

Pseudo-random number generators (PRNG).

This module defines the Set module for Core.Std.

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

no_raise is the identity, but by using 'a no_raise in a sexpable type, the resulting use sexp_of_no_raise protects the conversion of 'a to a sexp so that if it fails, one gets a sexp with an error message about the failure, rather than an exception being raised.

A stack implemented with an array.

An extension of the standard StringLabels.

Weak is like the OCaml standard library module of the same name, except that it requires that the values in the weak set are heap blocks.

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.

doubly-linked lists

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

failwiths message value sexp_of_value raises an exception with the supplied message and value, by constructing an Error.t and using Error.raise.

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

Raised when finalization after an exception failed, too.

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.

various combinators for functions

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

A simple polymorphic functional queue.

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

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.

Inherit comparability from a component.

An abstract unique identifier based on ordinary OCaml integers.

delimiter is underscore by default

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

Provides a functor for creating an interned string type.

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

A stack implemented with a list.

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 disinct monomorphic types.

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

Memoization code -- not re-entrant!

Although map can be defined in terms of bind and return, it is almost always better to define it directly.

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

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

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.

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

Option wraps the output x of successful functions in Some 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.

Outputs a list of lines, each terminated by a newline character

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

An abstract type of scale factors

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.

ascending is identical to compare.

Interfaces used for hiding and replacing polymorphic compare.

See pool_intf.ml for documentation.

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.

Module for easily generating unit tests.

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.

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

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:

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

create ?pos ?len base creates a substring of the base sequence of * length len starting at position pos, i.e.

Signature for a 2-tuple module

Signature for a 3-tuple module

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.

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.

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.

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.

For determining the word size that the program is using.