Index of modules

A
Arg [Batteries.Legacy]
Array [Extlib.ExtArray]
Array [BatteriesExceptionless]
Array [Batteries]
Array [Batteries.Legacy]
Array0 [BatBigarray]

Zero-dimensional arrays.

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.

BatBytesCompat
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.

BatConcreteQueue
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.

BatEither

Either type.

BatEnum

Enumeration over abstract collection of elements.

BatFile

File manipulation.

BatFilename

Operations on file names.

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
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
BatInnerShuffle
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.

BatOpaqueInnerSys
BatOptParse

Modules for GNU getopt(3)-style command line parsing.

BatOption

Functions for the option type.

BatOrd
BatParserCo

A simple parser combinator library.

BatPathGen

Filepath handling.

BatPervasives

Additional functions.

BatPrintexc

Facilities for printing exceptions.

BatPrintf
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 over ordered types based on splay trees.

BatStack

Last-in first-out stacks.

BatStream

Streams and stream parsers

BatString

String operations.

BatSubstring
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
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.Array]
Cap [BatString]

Capabilities for strings.

Cap [BatHashtbl]

Capabilities for hashtables.

Cap [BatArray]

Capabilities for arrays.

Char [Batteries]
Char [Batteries.Legacy]
Char [BatSet]
Char [BatMap]
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.

Either [Batteries]
Either [Batteries.Legacy]
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 [BatDynArray]

Operations on DynArray 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]
Filename [Batteries.Legacy]
FingerTree [Batteries]
Float [Batteries]
Float [BatSet]
Float [BatMap]
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

Immediate64 [BatSys]
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 [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]
Int [BatSet]
Int [BatMap]
Int32 [Batteries]
Int32 [Batteries.Legacy]
Int32 [BatSet]
Int32 [BatMap]
Int64 [Batteries]
Int64 [Batteries.Legacy]
Int64 [BatSet]
Int64 [BatMap]
Interfaces [Batteries]
L
LExceptionless [BatList.Labels]
LExceptionless [BatEnum.Labels]
LExceptionless [BatArray.Labels]
Labels [BatteriesExceptionless.LazyList]
Labels [BatteriesExceptionless.Enum]
Labels [BatteriesExceptionless.List]
Labels [BatteriesExceptionless.Array]
Labels [BatVect.Make]

Operations on BatVect with labels.

Labels [BatVect]

Operations on BatVect with 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 [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]
Memprof [BatGc]

Memprof is a sampling engine for allocated memory words.

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]
Nativeint [BatSet]
Nativeint [BatMap]
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.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]
Result [Batteries.Legacy]
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]
Seq [Batteries.Legacy]
Set [Batteries]
Set [Batteries.Legacy]
Slot [BatPrintexc]
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]
String [BatSet]
String [BatMap]
StringLabels [Batteries.Legacy]
Substring [Batteries]
Sys [Batteries]
Sys [Batteries.Legacy]
T
TaggedInfix [BatNum]
Text [Batteries]
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