#

- Index of types
- Index of exceptions
- Index of values
- Index of modules
- Index of module types

Applicative | The following functors give a sense of what Applicatives one can define.
Applicative_intf | Applicatives model computations in which values computed by subcomputations cannot affect what subsequent computations will take place.
Array_permute | An internal-only module factored out due to a circular dependency between core_array and core_list.
Avltree | A low-level, mutable AVL tree.
Backtrace | Dealing with stack backtraces.
Bag | Imperative set-like data structure.
Bigbuffer | Extensible string buffers based on Bigstrings.
Bigbuffer_internal |
Bigstring | String type based on `Bigarray`, for use in I/O and C-bindings
Bigstring_marshal | Utility functions for marshalling to and from bigstring.
Bigsubstring | Substring type based on `Bigarray`, for use in I/O and C-bindings
Binable | Module types and utilities for dealing with types that support the bin-io binary encoding.
Binable0 |
Binary_packing | Packs and unpacks various types of integers into and from strings.
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 | A simple boolean domain-specific language
Blit | See `Blit_intf` for documentation.
Blit_intf | Standard type for `blit` functions, and reusable code for validating `blit` arguments.
Bool |
Bounded_int_table | A `Bounded_int_table` is a table whose keys can be mapped to integers in a fixed range, 0 ...
Bucket |
Byte_units | Conversions between units of measure based on bytes.
Caml |
Caml_modify | Increment a counter whenever `caml_modify` is called.
Common | Basic types and definitions required throughout the system.
Commutative_group | A signature for a commutative group (in the group-theory sense).
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 | A type-indexed value that allows one to compare (and for generating error messages, serialize) values of the type in question.
Constrained_float |
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 |
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.
Day_of_week | For representing a day of the week.
Debug | Utilities for printing debug messages.
Decimal | The `decimal` type alias provides more readable serializations to s-expressions, at the cost of lower precision.
Deque | A double ended queue that can shrink and expand on both ends.
Dequeue | `Dequeue` is deprecated, use `Deque` instead.
Doubly_linked | doubly-linked lists
Either |
Either_intf | Many functions in `Either` focus on just one constructor.
Equal | This module defines signatures that are to be included in other signatures to ensure a consistent interface to `equal` functions.
Error | Note that the exception raised by this function maintains a reference to the `t` passed in.
Exn | `sexp_of_t` uses a global table of sexp converters.
Fdeque | A simple polymorphic functional double-ended queue.
Fheap | Functional Heap implementation based on pairing-heap algorithm and immutable data structures.
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 | 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 | 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 |
Float_intf | Floating-point representation and utilities.
Float_robust_compare | intended to be a tolerance on human-entered floats
Floatable |
Fn | various combinators for functions
Force_once | A "force_once" is a thunk that can only be forced once.
Fqueue | A simple polymorphic functional queue.
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 | a hash-queue, where the values are of type 'a
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 |
Hashtbl_unit_tests |
Heap | Heap implementation based on a pairing-heap.
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.
Host_and_port |
Identifiable | a signature for opaque identifier types.
In_channel | `In_channel` collects all of the pervasive functions that work on in_channels.
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.
Int_conversions | Conversions between various integer types
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 | An implementation of compressed integer sets using lists of integer ranges.
Intable |
Interfaces |
Invariant |
Invariant_intf | This module defines signatures that are to be included in other signatures to ensure a consistent interface to invariant-style functions.
Linked_queue | Linked_queue is a wrapper around OCaml's standard Queue module that follows Core idioms and adds some functions.
Linked_stack | A stack implemented with a list.
Make_substring |
Memo | Memoization code -- not re-entrant!
Monad | See `Monad_intf`.
Monad_intf | The following identities ought to hold (for some value of =):
Month | `of_string s` accepts three-character abbreviations with 3 capitalizations (e.g.
Never_returns |
No_polymorphic_compare | Open this in modules where you don't want to accidentally use polymorphic comparison.
Nothing | An uninhabited type.
Nothing0 |
Obj_array | An array of `Obj.t`s.
Only_in_test | This module can be used to safely expose functions and values in signatures that should only be used in unit tests.
Option | Options form a monad, where `return x = Some x`, `(None >>= f) = None`, and `(Some x >>= f) = f x`.
Or_error | Type for tracking errors in an Error.t.
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 | `Ordering` is intended to make code that matches on the result of a comparison more concise and easier to read.
Out_channel | defaults to `true`
Percent | An abstract type of scale factors
Perms | These types are intended to be used as phantom types encoding the permissions on a given type.
Pid | Process ID.
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.
Polymorphic_compare | A module containing the ad-hoc polymorphic comparison functions.
Polymorphic_compare_intf | Interfaces used for hiding and replacing polymorphic compare.
Pool |
Pool_intf | A manual memory manager for a set of mutable tuples.
Pool_unit_tests |
Pooled_hashtbl | A polymorphic hashtbl that uses `Pool` to avoid allocation.
Pooled_hashtbl_unit_test |
Pow_overflow_bounds |
Pretty_printer | A list of pretty printers for various types, for use in toplevels.
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 | 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 |
Raw_quickcheck_generator | See `Quickcheck_generator` for an overview.
Raw_quickcheck_observer | See `Quickcheck_observer` for an overview.
Ref | `swap t1 t2` swaps the values in `t1` and `t2`.
Result | `Result` is often used to handle error messages.
Robustly_comparable |
Rope | A rope is a standard data structure that represents a single string as a tree of strings, and supports constant-time concatenation.
Sequence | A sequence of elements that can be produced one at a time, on demand, normally with no sharing.
Set_once | This module implements an option ref that starts out as None, and may be set only once.
Sexpable |
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 |
Stable |
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_intf | An interface for stacks that follows `Core`'s conventions, as opposed to OCaml's standard `Stack` module.
Stack_unit_tests |
Staged | A type for making staging explicit in the type of a function.
Std |
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 |
String_id | Disallows whitespace around the edges in `of_string` and `t_of_sexp`, but doesn't check when reading from bin_io.
Stringable |
Substring |
Substring_intf | A substring is a contiguous set of characters within a string.
T |
Thread_safe_queue | A thread-safe non-blocking queue of unbounded size.
Time_ns | Time represented as an `Int63.t` number of nanoseconds since the epoch.
Time_ns_alternate_sexp |
Timing_wheel_intf | A specialized priority queue for a set of time-based alarms.
Timing_wheel_ns |
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`.
Total_map | A `('key, 'value, cmp) Map.t` where every value of type `'key` is present.
Tuple | Functors and signatures for dealing with modules for tuples.
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_immediacy | Witnesses that express whether a type's values are always, sometimes, or never immediate.
Type_immediacy_conv_unit_tests | This signature is deliberately empty.
Type_immediacy_witness_unit_tests | This signature is deliberately empty.
Union_find | Imperative data structure for representing disjoint sets.
Unique_id | Functors for creating modules that mint unique identifiers.
Unique_id_intf | Signature for use by `module : Unique_id`.
Unit | Module for the type `unit`.
Univ | An extensible "universal" variant type.
Univ_map | Universal/heterogeneous maps.
Univ_map_intf | The `'s` parameter is shared across all values stored in the map.
Unpack_buffer | A buffer for incremental decoding of an input stream.
Validate | A module for organizing validations of data structures.
Validated | See `Validated_intf` for documentation.
Validated_intf | For making an abstract version of a type that ensures a validation check has passed.
With_return | This is `include`'d and documented in `module: Common`.
Word_size | For determining the word size that the program is using.