Array_permute
randomly permute an array.
Avltree
This module implements a very low level interface to a mutable AVL tree.
Bag
Imperative set-like data structure.
Bigbuffer_internal
Bigbuffer
Extensible string buffers based on Bigstrings.
Bigstring_marshal
Utility functions for marshalling to and from bigstring
Bigstring
String type based on Bigarray, for use in I/O and C-bindings
Bigsubstring
Binable0
Binable
Binary_packing
Packs and unpacks various types of integers into and from strings.
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
create measure value creates a t from value units of the given measure.
Caml
Common
Basic types and definitions required throughout the system.
Commutative_group
A signature for a commutative group (in the group-theory sense).
Comparable_intf
Used for specifying a bound (either upper or lower) as inclusive, exclusive, or unbounded.
Comparable
lexicographic cmps x y compares x and y lexicographically using functions in the list cmps.
Comparator
A Comparator.t is a type-indexed value that allows you to compare (and for generating error messages, serialize) values of the type in question.
Constrained_float
Container
The idiom for using Container.Make is to bind the resulting module and to explicitly import each of the functions that one wants:
Container_unit_tests
Core_arg
Parsing of command line arguments.
Core_array
Maximum length of a normal array.
Core_bin_prot
Core_char
Character operations.
Core_field
Core_gc
Memory management control and statistics; finalised values.
Core_hashtbl_intf
Values returned by hash must be non-negative.
Core_hashtbl
For many students of ocaml, using hashtables is complicated by the functors.
Core_int32
Core_int63
The size of Int63 is always at least 63 bits.
Core_int64
Core_int
ceil_pow2 x returns the smallest power of 2 that is greater than or equal to x.
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_map_intf
This module defines interfaces used in Core.Std.Map.
Core_map
This module defines the Map module for Core.Std.
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
Core_queue is a wrapper around OCaml's standard Queue module that follows Core idioms and adds some functions.
Core_random
Pseudo-random number generators (PRNG).
Core_set_intf
This module defines interfaces used in Core.Std.Set.
Core_set
This module defines the Set module for Core.Std.
Core_set_unit_tests
Core_sexp
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.
Core_stack
A stack implemented with an array.
Core_string
An extension of the standard StringLabels.
Core_weak
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.
Day_of_week
For representing a day of the week.
Dequeue
A double ended queue that can shrink and expand on both ends.
Doubly_linked
doubly-linked lists
Equal
This module defines signatures that are to be included in other signatures to ensure a consistent interface to equal functions.
Error
failwiths message value sexp_of_value raises an exception with the supplied message and value, by constructing an Error.t and using Error.raise.
Exn
Raised when finalization after an exception failed, too.
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.
Flags
See flags_intf.ml for documentation.
Flat_array
An array of tuples, represented as an Obj_array.
Flat_array_debug
Flat_array_unit_tests
This signature is here to remind us to update the unit tests whenever we change Flat_array.
Floatable
Float_intf
Floating-point representation and utilities.
Float
Float_robust_compare
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.
Hashable
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_intf
Hash_set
Hashtbl_unit_tests
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
Min-heap implementation, adapted from CLR.
Host_and_port
Identifiable
a signature for opaque identifier types.
Import
This module is a grab bag.
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.
Intable
Int_conversions
Interfaces
Interned_string
Provides a functor for creating an interned string type.
Int_intf
Int_math
Int_replace_polymorphic_compare
Int_set
An implementation of compressed integer sets using lists of integer ranges.
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_stack
A stack implemented with a list.
Make_substring
Memo
Memoization code -- not re-entrant!
Monad
t >>= f returns a computation that sequences the computations represented by two monad elements.
Month
of_string s accepts three-character abbreviations with 3 capitalizations (e.g.
Never_returns
No_polymorphic_compare
Nothing0
Nothing
An uninhabited type.
Obj_array
An array of Obj.ts.
Only_in_test
This module can be used to safely expose functions and values in signatures that can only be used in unit tests.
Option
Option wraps the output x of successful functions in Some x.
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.
Or_error
Type for tracking errors in an Error.t.
Out_channel
Outputs a list of lines, each terminated by a newline character
Pid
Polymorphic_compare_intf
Interfaces used for hiding and replacing polymorphic compare.
Polymorphic_compare
ascending is identical to compare.
Pool
See pool_intf.ml for documentation.
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
Pretty_printer
A list of pretty printers for various types, for use in toplevels.
Quickcheck
Module for easily generating unit tests.
Ref
swap t1 t2 swaps the values in t1 and t2.
Result
Result is often used to handle error messages.
Robustly_comparable
Set_once
This module implements an option ref that starts out as None, and may be set only once.
Sexpable
Source_code_position0
Source_code_position
Stable_containers
Stable_internal
Stable
Stable_unit_test_intf
Stable_unit_test
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_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
Std
Stringable
String_id
Substring_intf
create ?pos ?len base creates a substring of the base sequence of * length len starting at position pos, i.e.
Substring
Thread_safe_queue
T
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, ..., t9 of arities 1 to 9 that are isomorphic to tuple types of the corresponding arities.
Type_equal
For representing type equalities otherwise not known by the type-checker.
Union_find
Imperative data structure for representing disjoint sets.
Unique_id_intf
Signature for use by module : Unique_id.
Unique_id
Functors for creating modules that mint unique identifiers.
Unit
Module for the type unit.
Univ_map
Universal/heterogeneous maps.
Univ
An extensible "universal" variant type, that can be extended by adding new constructors with arguments of arbitrary type.
Unpack_buffer
A buffer for incremental decoding of an input stream.
Validated_intf
For making an abstract version of a type that ensures a validation check has passed.
Validated
See Validated_intf for documentation.
Validate
A module for organizing validations of data structures.
With_return
This is include'd and documented in module: Common.
Word_size
For determining the word size that the program is using.