Index of modules

Array of threads

The module type of Array for this ring buffer

The abstract type for arrays

An efficient byte based ring buffer

Efficient array version for the char type

Simple Cache for Allocations

Applicative Parser Combinators

Array utils

Bigarrays of dimension 1

Imperative Bitvectors

Batch Operations on Collections Define and combine operations on a collection of elements, then run the composition of those operations on some collection.

Interface to 1-dimension Bigarrays of bytes (char)

Bit Field

Blocking Queue

Bloom Filter

Basic Bool functions

Caches

Categorical Constructs

Utils around char

Imperative deque

Error Monad

Functional queues

Open-Addressing Hash-table

Basic Float functions

Helpers for Format

Basic Functions

Simple Graph Interface

Hash combinators

Mutable Set

Hash Tries

Hashconsed Sets

Extension to the standard Hashtbl

Leftist Heaps following Okasaki

Associative containers with Heterogenerous Values

IO Utils

Immutable Arrays

Basic Int functions

Int64

Map specialized for Int keys

Continuation List

Knuth-Morris-Pratt

Lazy Tree Structure This structure can be used to represent trees and directed graphs (as infinite trees) in a lazy fashion.

Lazy List

Levenshtein distance

LINQ-like operations on collections

complements to list

Utils around Mutex

Extensions of Standard Map

Maps with Heterogeneous Values

Set of Heterogeneous Values

Hash Table with Heterogeneous Keys

IO Monad

Multimap

Multiset

Options

Comparisons

Tuple Functions

Very Simple Parser Combinators

Persistent Arrays

Persistent hash-table on top of OCaml's hashtables

Thread Pool, and Futures

Printer Combinators

Random-Access Lists

Random Generators

References

Error Monad

Circular Buffer (Deque)

Semaphores

Wrapper around Set

Handling S-expressions

Simple and efficient S-expression parsing/printing

Basic String Utils

Threads

Event timer

Prefix Tree

High-level Functions on top of Unix

Growable, mutable vector

Weight-Balanced Tree

Drop-In replacement to Stdlib

CCIO has moved into Containers, the main library.

Decoder that just blocks when input is not available

More detailed interface

Futures

The monad that just uses blocking calls as bind

Infix Operators

Infix Operators

Type allowing to manipulate the lock as a reference

Functor

Create a new Pool

Functors

Create a new bitfield type

Buffer using regular arrays

Makes an array given an arbitrary element type

Create a new counter type The type t is exposed

Makes a ring buffer module with the given array type.

Use the custom X.weight function

Example:

 module PrintLwt = CCPrint.MakeIO(struct

    include Lwt

    type output = Lwt_io.output_channel

    let write = Lwt_io.write

  end);;



  PrintLwt.printl Lwt_io.stdout (CCList.pp CCInt.pp) [1;2;3;4];;

  - : unit Lwt.t

Immutable map

Polymorphic Maps

Low level access

Imperative table indexed by CCHet.Key

Transient Identifiers

Implement the applicative and functor modules from only return and bind