Index of modules


A
Arg [Std_kernel]
Arg [Caml]
Array [Std_internal]
Array [Hash_queue]
Array [Caml]
ArrayLabels [Caml]
Array_permute
randomly permute an array.
Assoc [Core_list]
Avltree
This module implements a very low level interface to a mutable AVL tree.

B
Bag [Std_kernel]
Bag
Imperative set-like data structure.
Big_int [Std_internal]
Bigbuffer [Std_common]
Bigbuffer
Extensible string buffers based on Bigstrings.
Bigbuffer_internal
Bigstring [Std_common]
Bigstring
String type based on Bigarray, for use in I/O and C-bindings
Bigstring_marshal [Std_common]
Bigstring_marshal
Utility functions for marshalling to and from bigstring
Bigsubstring [Std_kernel]
Bigsubstring
Bin_prot [Std_kernel]
Binable [Std_kernel]
Binable [Hash_set_intf]
Binable [Hashable]
Binable [Float_intf]
Binable [Core_set_intf]
Binable [Core_map_intf]
Binable [Core_hashtbl_intf]
Binable
Binable0
Binary_packing [Std_kernel]
Binary_packing
Packs and unpacks various types of integers into and from strings.
Blang [Std_kernel]
Blang [Stable]
Blang
A simple boolean domain-specific language
Blit [Std_kernel]
Blit [Make_substring]
Blit
See Blit_intf for documentation.
Blit_intf
Standard type for blit functions, and reusable code for validating blit arguments.
Bool [Std_internal]
Bool
Bounded_int_table [Std_kernel]
Bounded_int_table
A Bounded_int_table is a table whose keys can be mapped to integers in a fixed range, 0 ...
Bucket [Std_kernel]
Bucket
Buffer [Caml]
Byte_units [Std_kernel]
Byte_units
create measure value creates a t from value units of the given measure.

C
Callback [Caml]
Caml [Std_common]
Caml
Char [Std_internal]
Char [Caml]
Check [Container]
Check_S0 [Container]
Check_S0_phantom [Container]
Check_S1 [Container]
Check_S1_phantom [Container]
Check_S1_phantom_invariant [Container]
Check_S2_refines_S [Monad]
Check_accessors [Core_set_intf]
Check_accessors [Core_map_intf]
Check_accessors0 [Core_set_intf]
Check_accessors1 [Core_set_intf]
Check_accessors1 [Core_map_intf]
Check_accessors2 [Core_set_intf]
Check_accessors2 [Core_map_intf]
Check_accessors2_with_comparator [Core_set_intf]
Check_accessors3 [Core_map_intf]
Check_accessors3_with_comparator [Core_map_intf]
Check_creators [Core_set_intf]
Check_creators [Core_map_intf]
Check_creators0 [Core_set_intf]
Check_creators1 [Core_set_intf]
Check_creators1 [Core_map_intf]
Check_creators2 [Core_set_intf]
Check_creators2 [Core_map_intf]
Check_creators2_with_comparator [Core_set_intf]
Check_creators3_with_comparator [Core_map_intf]
Check_sexp_conversion [Comparable]
Class [Float_intf.S]
Common
Basic types and definitions required throughout the system.
Commutative_group [Std_kernel]
Commutative_group
A signature for a commutative group (in the group-theory sense).
Comparable [Tuple]
Comparable [Std_kernel]
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 [Std_kernel]
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.
Complex [Caml]
Composition_preserves_injectivity [Type_equal]
Composition_preserves_injectivity is a functor that proves that composition of injective types is injective.
Constr [Univ]
A Constr.t represents a single constructor in the extensible variant type.
Constrained_float
Container [Std_kernel]
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
Control [Core_gc]
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
For many students of ocaml, using hashtables is complicated by the functors.
Core_hashtbl_intf
Values returned by hash must be non-negative.
Core_int
ceil_pow2 x returns the smallest power of 2 that is greater than or equal to x.
Core_int32
Core_int63
The size of Int63 is always at least 63 bits.
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_map
This module defines the Map module for Core.Std.
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
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
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
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.

D
Day_of_week [Std_kernel]
Day_of_week [Stable]
Day_of_week
For representing a day of the week.
Debug [Std_kernel]
Debug [Stack_unit_tests]
Debug [Pool_intf.Pool]
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.
Debug [Flat_queue_debug]
Debug [Flat_array_debug]
Debug
Utilities for printing debug messages.
Decimal [Std_kernel]
Decimal
The decimal type alias provides more readable serializations to s-expressions, at the cost of lower precision.
Dequeue [Std_kernel]
Dequeue
A double ended queue that can shrink and expand on both ends.
Digest [Caml]
Direct [Core_gc.Control.Fields]
Direct [Core_gc.Stat.Fields]
Doubly_linked [Std_kernel]
Doubly_linked
doubly-linked lists

E
Elt [Heap.Removable]
Elt [Doubly_linked]
Elt [Core_set_intf.S0]
Elt [Bag]
Equal [Std_kernel]
Equal
This module defines signatures that are to be included in other signatures to ensure a consistent interface to equal functions.
Error [Std_kernel]
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.
Error_check [Pool_intf.Pool]
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.
Escaping [Core_string]
Operations for escaping and unescaping strings, with paramaterized escape and escapeworthy characters.
Exn [Std_kernel]
Exn
Raised when finalization after an exception failed, too.
Export [Result]
Export [Ordering]
Export [Month]

F
F [Make_substring]
Field [Std_internal]
Fields [Core_gc.Control]
Fields [Core_gc.Stat]
Filename [Caml]
Flags [Std_kernel]
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 [Std_kernel]
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 [Std_kernel]
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 [Std_kernel]
Float
Float [Core_array]
Float [Bucket]
Float_intf [Std_kernel]
Float_intf
Floating-point representation and utilities.
Float_robust_compare
Floatable [Std_kernel]
Floatable
Fn [Std_kernel]
Fn
various combinators for functions
Force_once [Std_kernel]
Force_once
A "force_once" is a thunk that can only be forced once.
Format [Caml]
Format [Bigbuffer]
Fqueue [Std_kernel]
Fqueue
A simple polymorphic functional queue.
From_string [Bigstring]

G
Gc [Std_common]
Gc [Caml]
Genlex [Caml]

H
Hash_heap [Std_kernel]
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 [Std_kernel]
Hash_queue
a hash-queue, where the values are of type 'a
Hash_queue [Hashable.S_binable]
Hash_queue [Hashable.S]
Hash_queue [Hashable.Make_binable]
Hash_queue [Hashable.Make]
Hash_set [Std_kernel]
Hash_set [Stable_containers]
Hash_set
Hash_set [Hashable.S_binable]
Hash_set [Hashable.S]
Hash_set [Hashable.Make_binable]
Hash_set [Hashable.Make]
Hash_set_intf
Hashable [Tuple]
The difference between Hashable and Hashable_t functors is that the former's result type doesn't contain type t and the latter does.
Hashable [Std_kernel]
Hashable [Hashable.S_binable]
Hashable [Hashable.S]
Hashable [Hashable.Make_binable]
Hashable [Hashable.Make]
Hashable
Hashable [Core_hashtbl_intf.Hashtbl]
Hashable [Core_hashtbl_intf]
Hashable_t [Tuple]
Hashtbl [Std_internal]
Hashtbl [Stable_containers]
Hashtbl [Hash_queue]
Hashtbl [Hash_heap]
Hashtbl [Hashable]
Hashtbl [Caml]
Hashtbl_intf [Std_kernel]
Hashtbl_unit_tests
Heap [Std_kernel]
Heap
Heap implementation based on a pairing-heap.
Heap [Hash_heap]
Heap_block [Std_kernel]
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 [Std_kernel]
Host_and_port [Stable]
Host_and_port

I
Id [Type_equal]
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.
Id [Pool_intf.S.Pointer]
Identifiable [Std_kernel]
Identifiable
a signature for opaque identifier types.
In_channel [Std_kernel]
In_channel
In_channel collects all of the pervasive functions that work on in_channels.
Infix [Core_string]
Infix [Core_list]
Infix [Core_int]
Infix [Core_array]
Infix [Byte_units]
Info [Std_kernel]
Info
Info is a library for lazily constructing human-readable information as a string or sexp, with a primary use being error messages.
Inherit [Comparable]
Inherit comparability from a component.
Int [Unique_id]
An abstract unique identifier based on ordinary OCaml integers.
Int [Std_internal]
Int [Core_array]
Int [Bucket]
Int32 [Std_internal]
Int32 [Caml]
Int63 [Unique_id]
Int63 [Std_kernel]
Int63 [Flags_intf]
Int64 [Std_internal]
Int64 [Caml]
Int64 [Bucket]
Int_conversions
Int_intf [Std_kernel]
Int_intf
Int_math
Int_replace_polymorphic_compare
Int_set [Std_kernel]
Int_set
An implementation of compressed integer sets using lists of integer ranges.
Intable
Interfaces [Std_kernel]
Interfaces
Interned_string [Std_kernel]
Interned_string
Provides a functor for creating an interned string type.
Invariant [Std_kernel]
Invariant
Invariant_intf
This module defines signatures that are to be included in other signatures to ensure a consistent interface to invariant-style functions.

K
Key [Univ_map.Multi]
Key [Univ_map.With_fold]
Key [Univ_map.With_default]
Key [Univ_map]
Key [Hash_heap.S]
Key [Hash_heap.Make]
Key [Hash_queue.S]
Key [Hash_queue.Make]
Key [Core_map_intf.S]

L
Lazy [Std_internal]
Lazy [Caml]
Lexing [Caml]
Lift [Type_equal]
Lift2 [Type_equal]
Linked_stack [Std_kernel]
Linked_stack
A stack implemented with a list.
List [Std_internal]
List [Hash_queue]
List [Core_map_intf]
List [Caml]
List [Binable0]
ListLabels [Caml]

M
Make [Validated_intf.S]
Make [Tuple]
Make [Stable_unit_test]
Make [Monad]
Make [Interned_string]
Make [Int_conversions]
Make [Identifiable]
Make [Hashtbl_unit_tests]
Make [Hash_set]
Make [Hash_queue]
Make [Hash_heap]
Make [Hashable]
Make [Float_robust_compare]
Make [Flags_intf.Flags]
Flags.Make builds a new flags module.
Make [Debug]
Debug.Make produces a debug function used to wrap a function to display arguments before calling and display results after returning.
Make [Core_set]
Make [Core_map]
Make [Core_hashtbl_intf.Hashtbl]
Make [Container]
The idiom for using Container.Make is to bind the resulting module and to explicitly import each of the functions that one wants:
Make [Comparator]
Make [Comparable]
Usage example:
Make [Bucket]
Make [Blit_intf.Blit]
Make is for blitting between two values of the same monomorphic type.
Make1 [Comparator]
Make1 [Blit_intf.Blit]
Make1 is for blitting between two values of the same polymorphic type.
Make2 [Monad]
Make_binable [Validated_intf.S]
Make_binable [Hash_set]
Make_binable [Hashable]
Make_binable [Core_set]
Make_binable [Core_map]
Make_binable [Core_hashtbl_intf.Hashtbl]
Make_binable [Comparator]
Make_binable [Comparable]
Make_binable_using_comparator [Core_set]
Make_binable_using_comparator [Core_map]
Make_distinct [Blit_intf.Blit]
Make_distinct is for blitting between values of disinct monomorphic types.
Make_substring
Make_unordered_container [Stable_unit_test]
Make_using_comparator [Core_set]
Make_using_comparator [Core_map]
Map [Std_internal]
Map [Stable_containers]
Map [Comparable_intf.Map_and_set_binable]
Map [Comparable_intf.S]
Map [Caml]
Map_and_set_binable [Comparable]
Marshal [Caml]
Measure [Byte_units]
Memo [Std_kernel]
Memo
Memoization code -- not re-entrant!
Monad [Std_kernel]
Monad
t >>= f returns a computation that sequences the computations represented by two monad elements.
Monad_infix [Monad.S2]
Monad_infix [Monad.Make2]
Monad_infix [Monad.Check_S2_refines_S]
Monad_infix [Monad.Make]
Monad_infix [Monad.S]
Month [Std_kernel]
Month [Stable]
Month
of_string s accepts three-character abbreviations with 3 capitalizations (e.g.
MoreLabels [Caml]
Multi [Univ_map]
list-accumulating keys with a default value of the empty list

N
Nat [Std_internal]
Nativeint [Std_internal]
Nativeint [Caml]
Never_returns
No_polymorphic_compare [Std_kernel]
No_polymorphic_compare
Nothing [Std_kernel]
Nothing [Stable]
Nothing
An uninhabited type.
Nothing0
Num [Std_internal]

O
O [Core_sexp]
Obj_array
An array of Obj.ts.
Of_sexpable [Sexpable]
Of_stringable [Sexpable]
Of_stringable [Binable]
Of_stringable [Binable0]
Only_in_test [Std_kernel]
Only_in_test
This module can be used to safely expose functions and values in signatures that can only be used in unit tests.
Oo [Caml]
Option [Std_kernel]
Option
Option wraps the output x of successful functions in Some x.
Or_error [Std_kernel]
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 [Std_internal]
Ordering
Ordering is intended to make code that matches on the result of a comparison more concise and easier to read.
Out_channel [Std_kernel]
Out_channel
Outputs a list of lines, each terminated by a newline character

P
Parsing [Caml]
Parts [Float_intf.S]
Returns the fractional part and the whole (i.e.
Permissioned [Ref]
Pervasives [Caml]
Pid [Std_kernel]
Pid
Pointer [Pool_intf.S]
Poly [Std_kernel]
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.
Poly [Hash_set]
Poly [Core_set]
Poly [Core_map]
Poly [Core_hashtbl_intf.Hashtbl]
Poly [Comparator]
Poly [Comparable]
Polymorphic_compare [Std_kernel]
Polymorphic_compare
ascending is identical to compare.
Polymorphic_compare_intf
Interfaces used for hiding and replacing polymorphic compare.
Pool [Std_kernel]
Pool
See pool_intf.ml for documentation.
Pool_intf
A manual memory manager for a set of mutable tuples.
Pool_unit_tests
Pooled_hashtbl [Std_kernel]
Pooled_hashtbl
A polymorphic hashtbl that uses Pool to avoid allocation.
Pooled_hashtbl [Hashable.S_binable]
Pooled_hashtbl [Hashable.S]
Pooled_hashtbl [Hashable.Make_binable]
Pooled_hashtbl [Hashable.Make]
Pooled_hashtbl_unit_test
Pretty_printer [Std_kernel]
Pretty_printer
A list of pretty printers for various types, for use in toplevels.
Printexc [Std_kernel]
Printexc [Caml]
Printf [Std_kernel]
Printf [Caml]
Printf [Bigbuffer]

Q
Queue [Std_internal]
Queue [Caml]
Quickcheck [Std_kernel]
Quickcheck
Module for easily generating unit tests.

R
Random [Std_internal]
Random [Caml]
Random [Array_permute]
Ratio [Std_internal]
Ref [Std_internal]
Ref
swap t1 t2 swaps the values in t1 and t2.
Register [Pretty_printer]
Register builds a pp function from a to_string function, and adds the module_name ^ ".pp" to the list of pretty printers.
Register_pp [Pretty_printer]
Register_pp is like Register, but allows a custom pp function rather than using to_string.
Removable [Heap]
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.
Replace_polymorphic_compare [Comparable_intf.S_common]
Result [Std_kernel]
Result [Stable]
Result
Result is often used to handle error messages.
Robustly_comparable [Std_kernel]
Robustly_comparable

S
S_to_S1 [Comparator]
Scanf [Caml]
Set [Std_internal]
Set [Stable_containers]
Set [Comparable_intf.Map_and_set_binable]
Set [Comparable_intf.S]
Set [Caml]
Set_once [Std_kernel]
Set_once
This module implements an option ref that starts out as None, and may be set only once.
Sexp [Std_internal]
Sexp [Stable_internal]
Sexp_array [Core_sexp]
Sexp_list [Core_sexp]
Sexp_maybe [Std_kernel]
Sexp_maybe [Core_sexp]
Sexp_opaque [Core_sexp]
Sexp_option [Core_sexp]
Sexpable [Tuple]
Sexpable [Std_kernel]
Sexpable
Sign [Float_intf.S]
Slot [Pool_intf.S]
Slot [Flat_queue]
Slot [Flat_array_debug.Debug]
Slot [Flat_array]
Slots [Tuple_type]
Slots [Pool_intf.S]
Slots [Flat_queue]
Slots [Flat_array_debug.Debug]
Slots [Flat_array]
Sort [Caml]
Source_code_position [Std_kernel]
Source_code_position
Source_code_position0
Stable [String_id]
Stable
Stable [Result]
Stable [Nothing]
Stable [Month]
Stable [Host_and_port]
Stable [Day_of_week]
Stable [Blang]
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_unit_test
Stable_unit_test_intf
Stack [Std_kernel]
Stack [Caml]
Stack_intf
An interface for stacks that follows Core's conventions, as opposed to OCaml's standard Stack module.
Stack_unit_tests
Staged [Std_kernel]
Staged
A type for making staging explicit in the type of a function.
Stat [Core_gc]
State [Core_random]
The functions from module State manipulate the current state of the random generator explicitely.
Std
StdLabels [Caml]
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
Stream [Caml]
String [Std_internal]
String [Caml]
StringLabels [Caml]
String_id
String_id [Std_kernel]
String_id [Stable]
Stringable
Stringable [Std_kernel]
Substring
Substring [Std_kernel]
Substring_intf
create ?pos ?len base creates a substring of the base sequence of * length len starting at position pos, i.e.
Substring_intf [Std_kernel]
Sys [Caml]

T
T
T2 [Tuple]
Signature for a 2-tuple module
T3 [Tuple]
Signature for a 3-tuple module
Table [Hashable.S_binable]
Table [Hashable.S]
Table [Hashable.Make_binable]
Table [Hashable.Make]
Terse [Float_intf.S]
Test [Stack_unit_tests]
Test_S1 [Container_unit_tests]
Test_generic [Container_unit_tests]
Thread_safe_queue
Thread_safe_queue [Std_kernel]
To_string [Bigstring]
To_stringable [Sexpable]
Tree [Core_set.Poly]
Tree [Core_set]
Tree [Core_set_intf.S0]
Tree [Core_map.Poly]
Tree [Core_map]
Tree [Core_map_intf.S]
Tuple
Functors and signatures for dealing with modules for tuples.
Tuple [Std_kernel]
Tuple2 [Std_kernel]
Tuple3 [Std_kernel]
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.
Type_equal [Std_kernel]

U
Uid [Type_equal.Id]
Every Id.t contains a unique id that is distinct from the Uid.t in any other Id.t.
Union_find
Imperative data structure for representing disjoint sets.
Union_find [Std_kernel]
Unique_id
Functors for creating modules that mint unique identifiers.
Unique_id [Std_kernel]
Unique_id_intf
Signature for use by module : Unique_id.
Unit
Module for the type unit.
Unit [Std_kernel]
Unit_test [Stable]
Unit_tests [Stable]
Univ
An extensible "universal" variant type, that can be extended by adding new constructors with arguments of arbitrary type.
Univ [Std_kernel]
Univ_map
Universal/heterogeneous maps.
Univ_map [Std_kernel]
Unordered_container_test [Stable_unit_test_intf]
Unpack_buffer
A buffer for incremental decoding of an input stream.
Unpack_buffer [Std_kernel]
Unpack_one [Unpack_buffer]
Unsafe [Pool_intf.Pool]
An Unsafe pool is like an ordinary pool, except that the create function does not require an initial element.

V
V1 [String_id.Stable]
V1 [Stable_containers.Map]
V1 [Stable_containers.Hash_set]
V1 [Stable_containers.Hashtbl]
V1 [Stable_containers.Set]
V1 [Result.Stable]
V1 [Nothing.Stable]
V1 [Month.Stable]
V1 [Host_and_port.Stable]
V1 [Day_of_week.Stable]
V1 [Blang.Stable]
V1_stable_unit_test [Result.Stable]
Validate
A module for organizing validations of data structures.
Validate [Std_kernel]
Validate [Comparable]
Validate_with_zero [Comparable]
Validated
See Validated_intf for documentation.
Validated [Std_kernel]
Validated_intf
For making an abstract version of a type that ensures a validation check has passed.

W
Weak [Std_kernel]
Weak [Caml]
With_comparator [Core_set_intf]
With_comparator [Core_map_intf]
With_default [Univ_map]
keys with associated default values, so that find is no longer partial
With_fold [Univ_map]
keys that map to an accumulator value with an associated fold operation
With_key [Bounded_int_table]
With_return
This is include'd and documented in module: Common.
With_zero [Comparable]
Without_comparator [Core_set_intf]
Without_comparator [Core_map_intf]
Word_size
For determining the word size that the program is using.
Word_size [Std_kernel]
Writer [Core_bin_prot]