Index of modules

Zero-dimensional arrays.

One-dimensional arrays.

Two-dimensional arrays.

Three-dimensional arrays.

Array operations

Internals of ISet and IMap, usable as generic tree library

Base64 codec.

Operations on arbitrary-precision integers.

Additional and modified functions for big arrays.

Efficient bit sets.

Operations on booleans

Bounded values

Extensible string buffers.

Byte sequence operations.

The data structure for a manual cache with keys 'a and values 'b.

Operations on characters.

Parsing character strings.

Additional and modified functions for complex numbers.

Definition of concurrency primitives.

Functional double-ended queues

MD5 message digest.

A mutable, imperative, circular, doubly linked list library

Dynamic arrays.

Either type.

Enumeration over abstract collection of elements.

File manipulation.

Operations on file names.

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

Operations on floating-point numbers.

Memory management control and statistics; finalised values.

A generic lexical analyzer.

Mutable global variable.

Hash consing of data structures

Extra functions over hashtables.

Functional heaps over ordered types

DIET Maps from integers, packed using ranges

High-order abstract I/O.

DIET : Discrete Interval Encoding Trees

Core of the BatIO module.

Weak hash table library for OCaml, with an interface compatible with the standard Hashtbl module.

Operations on integers.

32-bit integers.

64-bit integers.

Common signatures for data structures.

Lazy lists of elements.

Simple lexing using ocaml conventions

Additional and modified functions for lists.

Simple logging

Logging Library

Association tables over ordered types.

Marshaling of data structures.

Polymorphic Multi-Map.

Polymorphic Multi-Map.

Locks for mutual exclusion.

Processor-native integers.

Operation on arbitrary-precision numbers.

A common interface for numbers.

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

Functions for the option type.

A simple parser combinator library.

Filepath handling.

Additional functions.

Facilities for printing exceptions.

First-in first-out queues.

Reentrant Mutexes

Pseudo-random number generators (PRNG).

Operations on references.

Reference on lists.

Monadic results of computations that can raise exceptions

Local exceptions/labels/goto/return.

Formatted input functions.

Sequence of elements

Sets over ordered types.

Maps over ordered types based on splay trees.

Last-in first-out stacks.

Streams and stream parsers

String operations.

System interface.

Heavyweight strings ("ropes")

Tuples.

Unicode characters.

UTF-8 encoded Unicode strings.

Operations on unit.

Low-level interface to the operating system (both Unix and Windows).

Unifiable references using destructive union-find

Extensible vectors with constant-time append/prepend.

Same operations as module BatIO, but with big-endian encoding

Buffer module for UTF-8 strings

Capabilities for strings.

Capabilities for hashtables.

Capabilities for arrays.

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.

Exceptionless counterparts for error-raising operations

Exceptionless counterparts for error-raising operations

Operations on Set without exceptions.

Exceptionless versions of functions

Exceptionless versions of functions

Operations on Map without exceptions.

Exceptionless counterparts for error-raising operations

Exceptionless counterparts for error-raising operations

Operations on BatHashtbl.Cap without exceptions.

Operations on Hashtbl without exceptions.

Operations on Hashtbl without exceptions.

Operations on BatEnum without exceptions.

Operations on DynArray without exceptions.

Operations on BatArray.Cap without exceptions.

Operations on Array without exceptions.

This module contains the types and functions for implementing custom usage message formatters.

Generic arrays (of arbitrarily many dimensions)

Hashing utilities

uses icompare as ordering function

Incubator

Functions that operate on the element at index i in a list (with indices starting from 0).

This infix module provides the operator (>>=)

As other Operators modules in batteries are named "Infix" we provide Infix as well.

Infix submodule regrouping all infix operators

Infix operators over a BatMultiPMap

Infix operators over a BatMultiPMap

Infix operators over a BatMap.PMap

Infix operators over a BatPMap

Infix operators over a BatMap

Infix submodule regrouping all infix operators

Infix submodule regrouping all infix operators

Infix operators over a BatIMap

Infix operators over a BatHashtbl

Infix operators over a BatHashtbl

Infix submodule regrouping all infix operators

Operations on BatVect with labels.

Operations on BatVect with labels.

Operations on Set with labels.

Operations on options, with labels.

Operations on Map with labels.

Operations on List with labels.

Operations on LazyList with labels.

Operations on BatHashtbl.Cap with labels.

Operations on Hashtbl with labels.

Operations on Hashtbl with labels.

Operations on BatEnum with labels.

Operations on BatArray.Cap with labels.

Operations on Array with labels.

File operations on large files.

Functor building an implementation of the set structure given a totally ordered type.

Constructs path handling module for string-like type and its operations given in S.

Functor building an implementation of the map structure given a totally ordered type.

Build a logger module with custom, fixed output, prefix and flags

Functor building an implementation of the hashtable structure.

Functorized heaps over arbitrary orderings.

Functor building an implementation of the hashtable structure.

Functor to build an implementation of a bounded type given the bounded values definition M

Make your own level-based logger, like Easy

Memprof is a sampling engine for allocated memory words.

This module provides everything needed to write and execute computations in the Option monad.

The BatEnum Monad

uses numeric_compare as its ordering function

This implementation can be used with UTF-8, but encoding of used strings is not verified.

Convenience operator for lifting primitive strings to ustring type.

Infix operators for path construction.

This module contains the basic functions and types for defining new option types and accessing the values of options.

This module contains the option parser itself.

Operations on floating-point numbers, with exceptions raised in case of error.

Safe operations on integers.

Scanning buffers

A source for parsing.

Manipulate the current state of the random generator.

This module contains various standard options.

Pairs.

Triples.

4-Tuples.

5-Tuples.

Monadic operations on Enumerations containing monadic elements