A | |
| Arg [Batteries_uni] | |
| Arg [Batteries_uni.Legacy] | |
| Array [Batteries_uni] | |
| Array [Batteries_uni.Legacy] | |
| Array1 [BatBigarray] |
One-dimensional arrays.
|
| Array2 [BatBigarray] |
Two-dimensional arrays.
|
| Array3 [BatBigarray] |
Three-dimensional arrays.
|
| ArrayLabels [Batteries_uni.Legacy] | |
B | |
| Base64 [Batteries_uni] | |
| BatArg |
Parsing of command line arguments.
|
| BatArray |
Additional and modified functions for arrays.
|
| 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
|
| BatBuffer |
Extensible string buffers.
|
| BatCamomile | |
| BatChar |
Operations on characters.
|
| BatCharEncodings |
Character encodings.
|
| BatCharParser |
Parsing character strings.
|
| BatComplex |
Additional and modified functions for complex numbers.
|
| BatConcurrent |
Definition of concurrency primitives.
|
| 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.
|
| 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.
|
| BatHashtbl |
Extra functions over hashtables.
|
| BatIMap |
DIET Maps from integers, packed using ranges
|
| BatIO |
High-order abstract I/O.
|
| BatISet |
DIET Sets of integers represented as ranges
|
| BatInnerIO |
Core of the BatIO module.
|
| 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.
|
| BatLogger |
Logging Library
|
| BatMap |
Association tables over ordered types.
|
| BatMarshal |
Marshaling of data structures.
|
| BatMonad |
Definition of monads.
|
| 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.
|
| BatPMap |
Polymorphic Map.
|
| BatPSet |
Polymorphic sets of elements.
|
| BatPair |
Functions for pairs of values
|
| BatParserCo |
A simple parser combinator library.
|
| BatPathGen |
Filepath handling.
|
| BatPervasives |
Additional functions.
|
| BatPrint |
Formatted output functions (also known as unparsing).
|
| BatPrintexc |
Facilities for printing exceptions.
|
| BatPrintf |
Formatted output functions (also known as unparsing).
|
| BatQueue |
First-in first-out queues.
|
| BatRMutex |
Locks for mutual exclusion.
|
| 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.
|
| BatRope |
Heavyweight strings ("ropes")
|
| BatScanf |
Formatted input functions.
|
| BatSeq |
Sequence of elements
|
| BatSet |
Sets over ordered types.
|
| BatStack |
Last-in first-out stacks.
|
| BatStd |
Additional functions.
|
| BatStr |
Regular expressions and high-level string processing
|
| 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.
|
| BatUChar |
Unicode (ISO-UCS) characters.
|
| BatUCharParser |
Parsing unicode text
|
| BatUTF8 |
UTF-8 encoded Unicode strings.
|
| BatUnit |
Operations on
unit.
|
| BatUnix |
Low-level interface to the operating system (both Unix and Windows).
|
| BatValue_printer |
Value printers
|
| BatVect |
Extensible vectors with constant-time append/prepend.
|
| Batteries | |
| Batteries_config |
This system's configuration.
|
| Batteries_print | |
| Batteries_uni | |
| BigEndian [BatIO] |
Same operations as module
BatIO, but with big-endian encoding
|
| Big_int [Batteries_uni] | |
| Bigarray [Batteries_uni] | |
| BitSet [Batteries_uni] | |
| Bit_set [Batteries_uni] | |
| Bool [Batteries_uni] | |
| Buf [BatUTF8] |
Buffer module for UTF-8 strings
|
| Buffer [Batteries_uni] | |
| Buffer [Batteries_uni.Legacy] | |
| Byte [BatUTF8] |
Positions in the string represented by the number of bytes from
the head.
|
C | |
| C [BatGenlex.Languages.Library] | |
| CDC [BatCamomile] | |
| Callback [Batteries_uni.Legacy] | |
| CamConfig [BatCamomile] | |
| Cap [BatHashtbl] |
Capabilities for hashtables.
|
| Char [Batteries_uni] | |
| Char [Batteries_uni.Legacy] | |
| CharParser [Batteries_uni] | |
| CharSet [BatSet] |
A set of characters.
|
| Complex [Batteries_uni] | |
| Complex [Batteries_uni.Legacy] | |
| Concurrent [Batteries_uni] | |
D | |
| Digest [Batteries_uni] | |
| Digest [Batteries_uni.Legacy] | |
| Dllist [Batteries_uni] | |
| DynArray [Batteries_uni] | |
E | |
| Enum [Batteries_uni] | |
| Exceptionless [BatSet.S] |
Operations on
Set without exceptions.
|
| Exceptionless [BatSeq] | |
| 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
Hashtbl without exceptions.
|
| Exceptionless [BatHashtbl.S] |
Operations on
Hashtbl without exceptions.
|
| Exceptionless [BatHashtbl] |
Operations on
Hashtbl without exceptions.
|
| Exceptionless [BatEnum] |
Operations on
BatEnum without exceptions.
|
F | |
| File [Batteries_uni] | |
| Filename [Batteries_uni.Legacy] | |
| Float [Batteries_uni] | |
| Format [Batteries_uni] | |
| Format [Batteries_uni.Legacy] | |
| Formatter [BatOptParse] |
This module contains the types and functions for implementing
custom usage message formatters.
|
G | |
| Gc [Batteries_uni] | |
| Gc [Batteries_uni.Legacy] | |
| Genarray [BatBigarray] |
Generic arrays (of arbitrarily many dimensions)
|
| Genlex [Batteries_uni] | |
| Genlex [Batteries_uni.Legacy] | |
| Global [Batteries_uni] | |
H | |
| Hashtbl [Batteries_uni] | |
| Hashtbl [Batteries_uni.Legacy] | |
I | |
| IMap [Batteries_uni] | |
| IO [Batteries_uni] | |
| IRope [BatRope] | |
| IRopeMap [BatMap] |
A map on ropes.
|
| IRopeSet [BatSet] |
A set of ropes.
|
| ISet [Batteries_uni] | |
| IString [BatString] |
uses icompare as ordering function
|
| IStringMap [BatMap] |
A map on strings.
|
| IStringSet [BatSet] |
A set of strings.
|
| IUChar [BatUChar] | |
| Index [BatRefList] |
Functions that operate on the
ith element of a list.
|
| Infix [BatPMap] |
Infix operators over a
BatPMap
|
| Infix [BatMultiPMap] |
Infix operators over a
BatMultiPMap
|
| Infix [BatMap] |
Infix operators over a
BatMap
|
| Infix [BatMap.S] |
Infix operators over a
BatMap
|
| Infix [BatIMap] |
Infix operators over a
BatIMap
|
| Infix [BatHashtbl.S] |
Infix operators over a
BatHashtbl
|
| Infix [BatHashtbl] |
Infix operators over a
BatHashtbl
|
| Input [BatInnerIO] | |
| Int [Batteries_uni] | |
| Int32 [Batteries_uni] | |
| Int32 [Batteries_uni.Legacy] | |
| Int64 [Batteries_uni] | |
| Int64 [Batteries_uni.Legacy] | |
| IntMap [BatMap] |
A map on integers.
|
| IntSet [BatSet] |
A set of integers.
|
| Interfaces [Batteries_uni] | |
| Internal [BatOo.Oo] | |
L | |
| LExceptionless [BatList.Labels] | |
| LExceptionless [BatEnum.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
Hashtbl with labels.
|
| Labels [BatHashtbl.S] |
Operations on
Hashtbl with labels.
|
| Labels [BatHashtbl] |
Operations on
Hashtbl with labels.
|
| Labels [BatEnum] |
Operations on
BatEnum with labels.
|
| Languages [BatGenlex] | |
| Lazy [Batteries_uni.Legacy] | |
| LazyList [Batteries_uni] | |
| Legacy [Batteries_uni] | |
| Lexing [Batteries_uni] | |
| Lexing [Batteries_uni.Legacy] | |
| Library [BatGenlex.Languages] | |
| List [Batteries_uni] | |
| List [Batteries_uni.Legacy] | |
| ListLabels [Batteries_uni.Legacy] | |
| Logger [Batteries_uni] | |
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 [BatInnerWeaktbl] |
Functor building an implementation of the hashtable structure.
|
| Make [BatHashtbl] |
Functor building an implementation of the hashtable structure.
|
| Make [BatGenlex.Languages] | |
| MakeLock [BatConcurrent] | |
| Map [Batteries_uni] | |
| Map [Batteries_uni.Legacy] | |
| Marshal [Batteries_uni] | |
| Marshal [Batteries_uni.Legacy] | |
| Monad [Batteries_uni] | |
| Monad [BatOption] |
This module provides everything needed to write and execute computations
in the Option monad.
|
| Monad [BatEnum] |
The BatEnum Monad
|
| MoreLabels [Batteries_uni.Legacy] | |
| MultiPMap [Batteries_uni] | |
| Mutex [Batteries] | |
| Mutex [BatMutex] | |
N | |
| Nativeint [Batteries_uni] | |
| Nativeint [Batteries_uni.Legacy] | |
| NoLock [BatConcurrent] | |
| NumString [BatString] |
uses numeric_compare as its ordering function
|
| NumStringMap [BatMap] |
A map on strings.
|
| NumStringSet [BatSet] |
A set of strings.
|
| Number [Batteries_uni] | |
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_uni] | |
| Oo [Batteries_uni.Legacy] | |
| Oo [BatOo] | |
| 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 [Batteries_uni] | |
| OptParser [BatOptParse] |
This module contains the option parser itself.
|
| Option [Batteries_uni] | |
| Output [BatInnerIO] | |
P | |
| PMap [Batteries_uni] | |
| PSet [Batteries_uni] | |
| Pair [Batteries_uni] | |
| Parse [BatPathGen.StringType] | |
| ParserCo [Batteries_uni] | |
| Parsing [Batteries_uni.Legacy] | |
| PathGen [Batteries_uni] | |
| Print [Batteries_uni] | |
| Printexc [Batteries_uni] | |
| Printexc [Batteries_uni.Legacy] | |
| Printf [Batteries_uni] | |
| Printf [Batteries_uni.Legacy] | |
| Printf [BatInnerIO] |
Formatted output functions (also known as unparsing).
|
Q | |
| Queue [Batteries_uni] | |
| Queue [Batteries_uni.Legacy] | |
R | |
| RMutex [Batteries] | |
| Random [Batteries_uni] | |
| Random [Batteries_uni.Legacy] | |
| Ref [Batteries_uni] | |
| RefList [Batteries_uni] | |
| Result [Batteries_uni] | |
| Return [Batteries_uni] | |
| Rope [Batteries_uni] | |
| RopeMap [BatMap] |
A map on ropes.
|
| RopeSet [BatSet] |
A set of ropes.
|
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_uni] | |
| Scanf [Batteries_uni.Legacy] | |
| Scanning [BatScanf] |
Scanning buffers
|
| Seq [Batteries_uni] | |
| Set [Batteries_uni] | |
| Set [Batteries_uni.Legacy] | |
| Sort [Batteries_uni.Legacy] | |
| Source [BatParserCo] |
A source for parsing.
|
| Stack [Batteries_uni] | |
| Stack [Batteries_uni.Legacy] | |
| State [BatRandom] |
Manipulate the current state of the random generator.
|
| Std [Batteries_uni] | |
| StdLabels [Batteries_uni.Legacy] | |
| StdOpt [BatOptParse] |
This module contains various standard options.
|
| Str [Batteries_uni] | |
| Stream [Batteries_uni] | |
| Stream [Batteries_uni.Legacy] | |
| StreamLabels [BatStream] | |
| String [Batteries_uni] | |
| String [Batteries_uni.Legacy] | |
| StringLabels [Batteries_uni.Legacy] | |
| StringMap [BatMap] |
A map on strings.
|
| StringSet [BatSet] |
A set of strings.
|
| Substring [Batteries_uni] | |
| Sys [Batteries_uni] | |
| Sys [Batteries_uni.Legacy] | |
U | |
| UChar [Batteries_uni] | |
| UCharParser [Batteries_uni] | |
| UTF8 [Batteries_uni] | |
| Unit [Batteries_uni] | |
| Unix [Batteries_uni] | |
V | |
| Value_printer [Batteries_uni] | |
| Vect [Batteries_uni] | |
W | |
| Weak [Batteries_uni.Legacy] | |
| WithMonad [BatEnum] |
Monadic operations on Enumerations containing monadic elements
|