A | |
| Arg [Batteries.Legacy] | |
| Array [Extlib.ExtArray] | |
| Array [BatteriesExceptionless] | |
| 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.
|
| BatBytes |
Byte sequence operations.
|
| 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.
|
| BatteriesExceptionless | |
| 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] | |
| Bytes [Batteries] | |
| Bytes [Batteries.Legacy] | |
C | |
| C [BatGenlex.Languages.Library] | |
| Cache [Batteries] | |
| Callback [Batteries.Legacy] | |
| Cap [BatteriesExceptionless.String] | |
| Cap [BatteriesExceptionless.Array] | |
| 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 [BatInt32] | |
| 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 [BatteriesExceptionless] | |
| 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 [BatteriesExceptionless] | |
| 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 [BatSet] |
Incubator
|
| 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 [BatSet.PSet] | |
| Infix [BatSet] | |
| Infix [BatSet.S] | |
| 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 [BatInt32] | |
| 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 [BatteriesExceptionless.LazyList] | |
| Labels [BatteriesExceptionless.Enum] | |
| Labels [BatteriesExceptionless.List] | |
| Labels [BatteriesExceptionless.Array] | |
| 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 [BatteriesExceptionless] | |
| LazyList [Batteries] | |
| Legacy [Batteries] | |
| Lexing [Batteries] | |
| Lexing [Batteries.Legacy] | |
| Library [BatGenlex.Languages] | |
| List [Extlib.ExtList] | |
| List [BatteriesExceptionless] | |
| 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
|
| Make2 [BatSet] | |
| MakeLock [BatConcurrent] | |
| MakeNumeric [BatBounded] | |
| MakeTable [BatHashcons] | |
| Make_lev [BatLog] |
Make your own level-based logger, like
Easy
|
| Map [BatteriesExceptionless.Splay] | |
| Map [BatteriesExceptionless] | |
| 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 [BatteriesExceptionless.Map] | |
| 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] | |
| Product [BatSet.Make2] | |
Q | |
| Queue [BatteriesExceptionless] | |
| 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 [BatteriesExceptionless] | |
| Seq [Batteries] | |
| Set [Batteries] | |
| Set [Batteries.Legacy] | |
| Slot [BatPrintexc] | |
| Sort [Batteries.Legacy] | |
| Source [BatParserCo] |
A source for parsing.
|
| Splay [BatteriesExceptionless] | |
| Splay [Batteries] | |
| Stack [BatteriesExceptionless] | |
| 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 [BatteriesExceptionless] | |
| String [Batteries] | |
| String [Batteries.Legacy] | |
| StringLabels [Batteries.Legacy] | |
| StringSet [BatteriesPrint] | |
| Substring [Batteries] | |
| 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
|