A | |
Arg [Batteries.Legacy] | |
Array [Extlib.ExtArray] | |
Array [Batteries] | |
Array [Batteries.Legacy] | |
Array1 [BatBigarray] |
One-dimensional arrays.
|
Array2 [BatBigarray] |
Two-dimensional arrays.
|
Array3 [BatBigarray] |
Three-dimensional arrays.
|
ArrayLabels [Batteries.Legacy] | |
B | |
Base64 [Extlib] | |
Base64 [Batteries] | |
BatArray |
Array operations
|
BatAvlTree |
Internals of ISet and IMap, usable as generic tree library
|
BatBase64 |
Base64 codec.
|
BatBig_int |
Operations on arbitrary-precision integers.
|
BatBigarray |
Additional and modified functions for big arrays.
|
BatBitSet |
Efficient bit sets.
|
BatBool |
Operations on booleans
|
BatBounded |
Bounded values
|
BatBuffer |
Extensible string buffers.
|
BatCache |
The data structure for a manual cache with keys
'a and values 'b .
|
BatChar |
Operations on characters.
|
BatCharParser |
Parsing character strings.
|
BatComplex |
Additional and modified functions for complex numbers.
|
BatConcurrent |
Definition of concurrency primitives.
|
BatDeque |
Functional double-ended queues
|
BatDigest |
MD5 message digest.
|
BatDllist |
A mutable, imperative, circular, doubly linked list library
|
BatDynArray |
Dynamic arrays.
|
BatEnum |
Enumeration over abstract collection of elements.
|
BatFile |
File manipulation.
|
BatFingerTree |
This module implements a generic finger tree datastructure
as described here:
Finger Trees: A Simple General-purpose Data Structure
http://www.soi.city.ac.uk/~ross/papers/FingerTree.pdf
|
BatFloat |
Operations on floating-point numbers.
|
BatFormat |
Pretty printing.
|
BatGc |
Memory management control and statistics; finalised values.
|
BatGenlex |
A generic lexical analyzer.
|
BatGlobal |
Mutable global variable.
|
BatHashcons |
Hash consing of data structures
|
BatHashtbl |
Extra functions over hashtables.
|
BatHeap |
Functional heaps over ordered types
|
BatIMap |
DIET Maps from integers, packed using ranges
|
BatIO |
High-order abstract I/O.
|
BatISet |
DIET : Discrete Interval Encoding Trees
|
BatInnerIO |
Core of the BatIO module.
|
BatInnerPervasives |
Operators
|
BatInnerWeaktbl |
Weak hash table library for OCaml, with an interface compatible with
the standard Hashtbl module.
|
BatInt |
Operations on integers.
|
BatInt32 |
32-bit integers.
|
BatInt64 |
64-bit integers.
|
BatInterfaces |
Common signatures for data structures.
|
BatLazyList |
Lazy lists of elements.
|
BatLexing |
Simple lexing using ocaml conventions
|
BatList |
Additional and modified functions for lists.
|
BatLog |
Simple logging
|
BatLogger |
Logging Library
|
BatMap |
Association tables over ordered types.
|
BatMarshal |
Marshaling of data structures.
|
BatMultiMap |
Polymorphic Multi-Map.
|
BatMultiPMap |
Polymorphic Multi-Map.
|
BatMutex |
Locks for mutual exclusion.
|
BatNativeint |
Processor-native integers.
|
BatNum |
Operation on arbitrary-precision numbers.
|
BatNumber |
A common interface for numbers.
|
BatOo |
Operations on objects
|
BatOptParse |
Modules for GNU
getopt(3) -style command line parsing.
|
BatOption |
Functions for the option type.
|
BatOrd |
An algebraic datatype for ordering.
|
BatParserCo |
A simple parser combinator library.
|
BatPathGen |
Filepath handling.
|
BatPervasives |
Additional functions.
|
BatPrintexc |
Facilities for printing exceptions.
|
BatPrintf |
Formatted output functions (also known as unparsing).
|
BatQueue |
First-in first-out queues.
|
BatRMutex |
Reentrant Mutexes
|
BatRandom |
Pseudo-random number generators (PRNG).
|
BatRef |
Operations on references.
|
BatRefList |
Reference on lists.
|
BatResult |
Monadic results of computations that can raise exceptions
|
BatReturn |
Local exceptions/labels/goto/return.
|
BatScanf |
Formatted input functions.
|
BatSeq |
Sequence of elements
|
BatSet |
Sets over ordered types.
|
BatSplay |
Maps and sets based on splay trees
|
BatStack |
Last-in first-out stacks.
|
BatStream |
Streams and stream parsers
|
BatString |
String operations.
|
BatSubstring | Substring.t is the type of substrings of a basestring, an efficient
representation of a piece of a string.
|
BatSys |
System interface.
|
BatText |
Heavyweight strings ("ropes")
|
BatTuple |
Tuples.
|
BatUChar |
Unicode characters.
|
BatUTF8 |
UTF-8 encoded Unicode strings.
|
BatUnit |
Operations on
unit .
|
BatUnix |
Low-level interface to the operating system (both Unix and Windows).
|
BatUref |
Unifiable references using destructive union-find
|
BatVect |
Extensible vectors with constant-time append/prepend.
|
Batteries | |
BatteriesConfig |
The default function to open a www browser.
|
BatteriesPrint | |
BatteriesThread | |
BigEndian [BatIO] |
Same operations as module
BatIO , but with big-endian encoding
|
Big_int [Batteries] | |
Big_int [Batteries.Legacy] | |
Bigarray [Batteries] | |
Bigarray [Batteries.Legacy] | |
BitSet [Extlib] | |
BitSet [Batteries] | |
Bit_set [Batteries] | |
Bool [Batteries] | |
Bounded [Batteries.Incubator] | |
Buf [BatUTF8] |
Buffer module for UTF-8 strings
|
Buffer [Batteries] | |
Buffer [Batteries.Legacy] | |
C | |
C [BatGenlex.Languages.Library] | |
Cache [Batteries] | |
Callback [Batteries.Legacy] | |
Cap [BatString] |
Capabilities for strings.
|
Cap [BatHashtbl] |
Capabilities for hashtables.
|
Cap [BatArray] |
Capabilities for arrays.
|
Char [Batteries] | |
Char [Batteries.Legacy] | |
CharParser [Batteries] | |
Comp [BatTuple.Tuple5] | |
Comp [BatTuple.Tuple4] | |
Comp [BatTuple.Tuple3] | |
Comp [BatTuple.Tuple2] | |
Comp [BatOrd] | |
Comp [BatList] | |
Comp [BatChar.Incubator] | |
Compare [BatNumber.Numeric] | |
Compare [BatNum] | |
Compare [BatNativeint] | |
Compare [BatInt64] | |
Compare [BatInt.Safe_int] | |
Compare [BatInt] | |
Compare [BatFloat] | |
Compare [BatComplex] | |
Compare [BatBool] | |
Compare [BatBig_int] | |
Complex [Batteries] | |
Complex [Batteries.Legacy] | |
Concurrent [Batteries] | |
D | |
Deque [Batteries] | |
Digest [Batteries] | |
Digest [Batteries.Legacy] | |
Dllist [Extlib] | |
Dllist [Batteries] | |
DynArray [Extlib] | |
DynArray [Batteries] | |
E | |
Easy [BatLog] |
A simple-to-use logger with verbosity levels that outputs by
default to stderr (changeable at runtime) with the date and time
at the beginning of each log message.
|
Enum [Extlib] | |
Enum [Batteries] | |
Eq [BatTuple.Tuple5] | |
Eq [BatTuple.Tuple4] | |
Eq [BatTuple.Tuple3] | |
Eq [BatTuple.Tuple2] | |
Eq [BatOrd] | |
Eq [BatList] | |
Eq [BatChar.Incubator] | |
Eq [BatArray.Incubator] | |
EqComp [BatOrd] | |
EqOrd [BatOrd] | |
Exceptionless [BatString.Cap] |
Exceptionless counterparts for error-raising operations
|
Exceptionless [BatString] |
Exceptionless counterparts for error-raising operations
|
Exceptionless [BatStack] | |
Exceptionless [BatSet.S] |
Operations on
Set without exceptions.
|
Exceptionless [BatSeq] | |
Exceptionless [BatQueue] | |
Exceptionless [BatMap.PMap] |
Exceptionless versions of functions
|
Exceptionless [BatMap] |
Exceptionless versions of functions
|
Exceptionless [BatMap.S] |
Operations on
Map without exceptions.
|
Exceptionless [BatList] |
Exceptionless counterparts for error-raising operations
|
Exceptionless [BatLazyList.Labels] | |
Exceptionless [BatLazyList] |
Exceptionless counterparts for error-raising operations
|
Exceptionless [BatHashtbl.Cap] |
Operations on
BatHashtbl.Cap without exceptions.
|
Exceptionless [BatHashtbl.S] |
Operations on
Hashtbl without exceptions.
|
Exceptionless [BatHashtbl] |
Operations on
Hashtbl without exceptions.
|
Exceptionless [BatEnum] |
Operations on
BatEnum without exceptions.
|
Exceptionless [BatArray.Cap] |
Operations on
BatArray.Cap without exceptions.
|
Exceptionless [BatArray] |
Operations on
Array without exceptions.
|
ExtArray [Extlib] | |
ExtHashtbl [Extlib] | |
ExtList [Extlib] | |
ExtString [Extlib] | |
Extlib | |
F | |
File [Batteries] | |
Filename [Batteries.Legacy] | |
FingerTree [Batteries] | |
Float [Batteries] | |
Format [Batteries] | |
Format [Batteries.Legacy] | |
Formatter [BatOptParse] |
This module contains the types and functions for implementing
custom usage message formatters.
|
G | |
Gc [Batteries] | |
Gc [Batteries.Legacy] | |
Genarray [BatBigarray] |
Generic arrays (of arbitrarily many dimensions)
|
Generic [BatFingerTree] | |
Genlex [Batteries] | |
Genlex [Batteries.Legacy] | |
Global [Extlib] | |
Global [Batteries] | |
H | |
H [BatHashcons] |
Hashing utilities
|
Hashcons [Batteries] | |
Hashtbl [Extlib.ExtHashtbl] | |
Hashtbl [Batteries] | |
Hashtbl [Batteries.Legacy] | |
Heap [Batteries] | |
I | |
IMap [Batteries] | |
IO [Extlib] | |
IO [Batteries] | |
ISet [Batteries] | |
IString [BatString] |
uses icompare as ordering function
|
Incubator [Batteries] | |
Incubator [BatRandom] | |
Incubator [BatOrd] | |
Incubator [BatChar] | |
Incubator [BatArray] | |
Index [BatRefList] |
Functions that operate on the element at index
i in a list (with
indices starting from 0).
|
Infix [BatSeq] | |
Infix [BatResult] |
This infix module provides the operator
(>>=)
|
Infix [BatPathGen.PathType] |
As other Operators modules in batteries are named "Infix" we provide Infix as well.
|
Infix [BatParserCo] |
Infix submodule regrouping all infix operators
|
Infix [BatOption] | |
Infix [BatNumber.Numeric] | |
Infix [BatNum] | |
Infix [BatNativeint] | |
Infix [BatMultiPMap] |
Infix operators over a
BatMultiPMap
|
Infix [BatMultiMap] |
Infix operators over a
BatMultiPMap
|
Infix [BatMap.PMap] |
Infix operators over a
BatMap.PMap
|
Infix [BatMap] |
Infix operators over a
BatPMap
|
Infix [BatMap.S] |
Infix operators over a
BatMap
|
Infix [BatList] |
Infix submodule regrouping all infix operators
|
Infix [BatLazyList] |
Infix submodule regrouping all infix operators
|
Infix [BatInt64] | |
Infix [BatInt.Safe_int] | |
Infix [BatInt] | |
Infix [BatIMap] |
Infix operators over a
BatIMap
|
Infix [BatHashtbl.S] |
Infix operators over a
BatHashtbl
|
Infix [BatHashtbl] |
Infix operators over a
BatHashtbl
|
Infix [BatFloat] | |
Infix [BatEnum] | |
Infix [BatComplex] | |
Infix [BatChar] |
Infix submodule regrouping all infix operators
|
Infix [BatBounded.BoundedNumericType] | |
Infix [BatBool] | |
Infix [BatBig_int] | |
Input [BatInnerIO] | |
Int [Batteries] | |
Int32 [Batteries] | |
Int32 [Batteries.Legacy] | |
Int64 [Batteries] | |
Int64 [Batteries.Legacy] | |
IntSet [BatteriesPrint] | |
Interfaces [Batteries] | |
Internal [BatOo] | |
L | |
LExceptionless [BatList.Labels] | |
LExceptionless [BatEnum.Labels] | |
LExceptionless [BatArray.Labels] | |
Labels [BatSet.S] |
Operations on
Set with labels.
|
Labels [BatOption] |
Operations on options, with labels.
|
Labels [BatMap.S] |
Operations on
Map with labels.
|
Labels [BatList] |
Operations on
List with labels.
|
Labels [BatLazyList] |
Operations on
LazyList with labels.
|
Labels [BatHashtbl.Cap] |
Operations on
BatHashtbl.Cap with labels.
|
Labels [BatHashtbl.S] |
Operations on
Hashtbl with labels.
|
Labels [BatHashtbl] |
Operations on
Hashtbl with labels.
|
Labels [BatEnum] |
Operations on
BatEnum with labels.
|
Labels [BatArray.Cap] |
Operations on
BatArray.Cap with labels.
|
Labels [BatArray] |
Operations on
Array with labels.
|
Languages [BatGenlex] | |
LargeFile [BatUnix] |
File operations on large files.
|
Lazy [Batteries.Legacy] | |
LazyList [Batteries] | |
Legacy [Batteries] | |
Lexing [Batteries] | |
Lexing [Batteries.Legacy] | |
Library [BatGenlex.Languages] | |
List [Extlib.ExtList] | |
List [Batteries] | |
List [Batteries.Legacy] | |
ListLabels [Batteries.Legacy] | |
Log [Batteries.Incubator] | |
Logger [Batteries] | |
M | |
Make [BatVect] | |
Make [BatSet] |
Functor building an implementation of the set structure
given a totally ordered type.
|
Make [BatPathGen] |
Constructs path handling module for string-like type and its operations given in
S .
|
Make [BatMap] |
Functor building an implementation of the map structure
given a totally ordered type.
|
Make [BatLog] |
Build a logger module with custom, fixed output, prefix and flags
|
Make [BatInnerWeaktbl] |
Functor building an implementation of the hashtable structure.
|
Make [BatHeap] |
Functorized heaps over arbitrary orderings.
|
Make [BatHashtbl] |
Functor building an implementation of the hashtable structure.
|
Make [BatGenlex.Languages] | |
Make [BatBounded] |
Functor to build an implementation of a bounded type given the bounded
values definition
M
|
MakeLock [BatConcurrent] | |
MakeNumeric [BatBounded] | |
MakeTable [BatHashcons] | |
Make_lev [BatLog] |
Make your own level-based logger, like
Easy
|
Map [Batteries] | |
Map [Batteries.Legacy] | |
Map [BatSplay] | |
Marshal [Batteries] | |
Marshal [Batteries.Legacy] | |
Monad [BatResult] | |
Monad [BatOption] |
This module provides everything needed to write and execute computations
in the Option monad.
|
Monad [BatEnum] |
The BatEnum Monad
|
MoreLabels [Batteries.Legacy] | |
MultiMap [Batteries] | |
MultiPMap [Batteries] | |
Mutex [BatteriesThread] | |
N | |
Nativeint [Batteries] | |
Nativeint [Batteries.Legacy] | |
NoLock [BatConcurrent] | |
Num [Batteries] | |
Num [Batteries.Legacy] | |
NumString [BatString] |
uses numeric_compare as its ordering function
|
Number [Batteries] | |
O | |
OCaml [BatGenlex.Languages.Library] | |
OfString [BatPathGen] |
This implementation can be used with UTF-8, but encoding of used strings is not verified.
|
Oo [Batteries] | |
Oo [Batteries.Legacy] | |
OperatorLift [BatPathGen.PathType] |
Convenience operator for lifting primitive strings to
ustring type.
|
Operators [BatPathGen.PathType] |
Infix operators for path construction.
|
Opt [BatOptParse] |
This module contains the basic functions and types for defining
new option types and accessing the values of options.
|
OptParse [Extlib] | |
OptParser [BatOptParse] |
This module contains the option parser itself.
|
Option [Extlib] | |
Option [Batteries] | |
Ord [BatTuple.Tuple5] | |
Ord [BatTuple.Tuple4] | |
Ord [BatTuple.Tuple3] | |
Ord [BatTuple.Tuple2] | |
Ord [BatOrd] | |
Ord [BatList] | |
Ord [BatChar.Incubator] | |
Ord [BatArray.Incubator] | |
Output [BatInnerIO] | |
P | |
PMap [Extlib] | |
PMap [BatMap] | |
PSet [BatSet] | |
Parse [BatPathGen.StringType] | |
ParserCo [Batteries] | |
Parsing [Batteries.Legacy] | |
PathGen [Batteries.Incubator] | |
Printexc [Batteries] | |
Printexc [Batteries.Legacy] | |
Printf [Batteries] | |
Printf [Batteries.Legacy] | |
Private_state_enums [BatRandom.Incubator] | |
Q | |
Queue [Batteries] | |
Queue [Batteries.Legacy] | |
R | |
RMutex [BatteriesThread] | |
Random [Batteries] | |
Random [Batteries.Legacy] | |
Ref [Batteries] | |
RefList [Extlib] | |
RefList [Batteries] | |
Result [Batteries] | |
Return [Batteries] | |
Rev [BatOrd] | |
RevComp [BatOrd] | |
RevOrd [BatOrd] | |
S | |
Safe_float [BatFloat] |
Operations on floating-point numbers, with exceptions raised in
case of error.
|
Safe_int [BatInt] |
Safe operations on integers.
|
Scanf [Batteries] | |
Scanf [Batteries.Legacy] | |
Scanning [BatScanf] |
Scanning buffers
|
Seq [Batteries] | |
Set [Batteries] | |
Set [Batteries.Legacy] | |
Sort [Batteries.Legacy] | |
Source [BatParserCo] |
A source for parsing.
|
Splay [Batteries] | |
Stack [Batteries] | |
Stack [Batteries.Legacy] | |
State [BatRandom.Incubator.Private_state_enums] | |
State [BatRandom] |
Manipulate the current state of the random generator.
|
Std [Extlib] | |
StdLabels [Batteries.Legacy] | |
StdOpt [BatOptParse] |
This module contains various standard options.
|
Str [Batteries.Legacy] | |
Stream [Batteries] | |
Stream [Batteries.Legacy] | |
StreamLabels [BatStream] | |
String [Extlib.ExtString] | |
String [Batteries] | |
String [Batteries.Legacy] | |
StringLabels [Batteries.Legacy] | |
StringSet [BatteriesPrint] | |
Substring [Batteries.Incubator] | |
Sys [Batteries] | |
Sys [Batteries.Legacy] | |
T | |
TaggedInfix [BatNum] | |
Text [Batteries] | |
TextSet [BatteriesPrint] | |
Tuple [Batteries] | |
Tuple2 [Batteries] | |
Tuple2 [BatTuple] |
Pairs.
|
Tuple3 [Batteries] | |
Tuple3 [BatTuple] |
Triples.
|
Tuple4 [Batteries] | |
Tuple4 [BatTuple] |
4-Tuples.
|
Tuple5 [Batteries] | |
Tuple5 [BatTuple] |
5-Tuples.
|
U | |
UChar [Extlib] | |
UChar [Batteries] | |
UTF8 [Extlib] | |
UTF8 [Batteries] | |
Unit [Batteries] | |
Unix [Batteries] | |
Unix [Batteries.Legacy] | |
Uref [Batteries] | |
V | |
Vect [Batteries] | |
W | |
Weak [Batteries.Legacy] | |
WithMonad [BatEnum] |
Monadic operations on Enumerations containing monadic elements
|