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