A | 
| any_field [CCBitField.S] | 
 | 
| array_ [CCArray1] | 
 | 
| async_call_result [CCUnix] | 
A subprocess for interactive usage (read/write channels line by line)
 
 | 
| attribute [CCGraph.Dot] | 
Dot attribute
 
 | 
| attribute [CCKTree.Dot] | 
Dot attributes for nodes
 
 | 
| automaton [CCLevenshtein.S] | 
Levenshtein automaton
 
 | 
 B | 
| bag [CCGraph] | 
Bag of elements of type 'a
 
 | 
 C | 
| call_result [CCUnix] | 
 | 
| char [CCKMP.STRING] | 
 | 
| char_ [CCLevenshtein.STRING] | 
 | 
| char_ [CCLevenshtein.S] | 
 | 
| char_ [CCTrie.WORD] | 
 | 
| char_ [CCTrie.S] | 
 | 
| col_num [CCParse] | 
 
 | 
| conv [CCSexp.Traverse] | 
A converter from S-expressions to 'a is a function sexp -> 'a option.
 
 | 
 E | 
| edge_kind [CCGraph.Traverse.Event] | 
 | 
| elt [CCArray1.View.S] | 
 | 
| elt [CCArray1.S] | 
 | 
| elt [CCHashSet.S] | 
 | 
| elt [CCHashconsedSet.S] | 
 | 
| elt [CCRingBuffer.Array.S] | 
The element type
 
 | 
| elt [CCMultiSet.S] | 
 | 
| elt [CCHashtbl.COUNTER] | 
Elements that are to be counted
 
 | 
| elt [CCArray.MONO_ARRAY] | 
 | 
| elt [CCHeap.S] | 
 | 
| eq [CCHashtbl] | 
 | 
| eq [CCRef] | 
 | 
| equal [CCLinq] | 
 | 
| equal [CCFQueue] | 
 | 
| equal [CCPersistentHashtbl] | 
 | 
| equal [CCCache] | 
 | 
| equal [CCKList] | 
 | 
| equal [CCResult] | 
 | 
| equal [CCArray] | 
 | 
| equal [CCError] | 
 | 
| equal [CCVector] | 
 | 
| error [CCApp_parse] | 
 | 
| error [CCResult] | 
 | 
 F | 
| field [CCBitField.S] | 
 | 
| field_kind [CCBitField.S] | 
 | 
| fmt [CCOpt] | 
 | 
| formatter [CCPersistentHashtbl] | 
 | 
| formatter [CCKList] | 
 | 
| formatter [CCKTree] | 
 | 
| formatter [CCResult] | 
 | 
| formatter [CCMap] | 
 | 
| formatter [CCSet] | 
 | 
| formatter [CCFloat] | 
 | 
| formatter [CCBool] | 
 | 
| formatter [CCInt] | 
 | 
| formatter [CCPair] | 
 | 
| formatter [CCList] | 
 | 
| formatter [CCError] | 
 | 
| formatter [CCVector] | 
 | 
| fpclass [CCFloat] | 
 | 
| future [CCPool.Make.Fut] | 
 | 
 G | 
| gen [CCSexpM] | 
 | 
| gen [CCUnix] | 
 | 
| gen [CCMonadIO.Seq] | 
 | 
| gen [CCBigstring] | 
 | 
| gen [CCLevenshtein] | 
 | 
| gen [CCKMP] | 
 | 
| gen [CCHet] | 
 | 
| gen [CCImmutArray] | 
 | 
| gen [CCRAL] | 
 | 
| gen [CCWBTree] | 
 | 
| gen [CCBloom] | 
 | 
| gen [CCHashTrie] | 
 | 
| gen [CCHashconsedSet.S] | 
 | 
| gen [CCPersistentArray] | 
 | 
| gen [CCIntMap] | 
 | 
| gen [CCDeque] | 
 | 
| gen [CCLazy_list] | 
 | 
| gen [CCKList] | 
 | 
| gen [CCKTree] | 
 | 
| gen [CCIO] | 
See Gen in the gen library
 
 | 
| gen [CCString] | 
 | 
| gen [CCArray] | 
 | 
| gen [CCHash] | 
 | 
| gen [CCOpt] | 
 | 
| gen [CCList] | 
 | 
| gen [CCHeap] | 
 | 
| gen [CCVector] | 
 | 
| graph [CCGraph] | 
 | 
| graph [CCKTree.Dot] | 
A dot graph is a name, plus a list of trees labelled with attributes
 
 | 
 H | 
| hash [CCLinq] | 
 | 
| hash [CCCache] | 
 | 
| hash [CCHashtbl] | 
 | 
| hash_fun [CCHash.S] | 
 | 
| hash_fun [CCHash] | 
Hash function for values of type 'a, merging a fingerprint of the
    value into the state of type t
 
 | 
| hash_funs [CCBloom] | 
An array of k hash functions on values of type 'a.
 
 | 
 I | 
| injection [CCMixmap] | 
An accessor for values of type 'a in any map.
 
 | 
| injection [CCMixtbl] | 
An accessor for values of type 'b in any table.
 
 | 
| input [CCParse] | 
The type of input, which must allow for backtracking somehow.
 
 | 
| io [CCMonadIO] | 
 | 
 J | 
| json [CCArray1] | 
 | 
 K | 
| key [CCWBTree.S] | 
 | 
| key [CCHashTrie.S] | 
 | 
| key [CCMixset] | 
A unique "key" to access a value of type 'a in a set
 
 | 
| key [CCMixmap.S] | 
 | 
| key [CCPersistentHashtbl.S] | 
 | 
| key [CCFlatHashtbl.S] | 
 | 
| key [CCTrie.S] | 
 | 
| key [CCMultiMap.S] | 
 | 
| key [CCHashtbl.DEFAULT] | 
 | 
| klist [CCLevenshtein] | 
 | 
| klist [CCIntMap] | 
 | 
| klist [CCFQueue] | 
 | 
| klist [CCKTree] | 
 | 
| klist [CCString] | 
 | 
| klist [CCArray] | 
 | 
| klist [CCHash] | 
 | 
| klist [CCList] | 
 | 
| klist [CCHeap] | 
 | 
| klist [CCVector] | 
 | 
| ktree [CCHashTrie] | 
 | 
| ktree [CCTrie] | 
 | 
| ktree [CCHeap] | 
 | 
 L | 
| left [CCMultiMap.BIDIR] | 
 | 
| line [CCUnix] | 
 | 
| line_num [CCParse] | 
 
 | 
 M | 
| mut_graph [CCGraph] | 
 | 
 N | 
| node [CCLazy_list] | 
 | 
 O | 
| of_json [CCArray1] | 
 | 
| op [CCBatch.S] | 
Operation that converts a 'a t into a 'b t
 
 | 
| or_error [CCSexpM] | 
 | 
| or_error [CCUnix] | 
 | 
| or_error [CCMonadIO] | 
 | 
| or_error [CCArray1] | 
 | 
| or_error [CCParse] | 
 | 
| or_error [CCIO.File] | 
 | 
| ord [CCLinq] | 
 | 
| ord [CCKList] | 
 | 
| ord [CCResult] | 
 | 
| ord [CCRef] | 
 | 
| ord [CCArray] | 
 | 
| ord [CCError] | 
 | 
| ord [CCVector] | 
 | 
| output [CCPrint.MONAD_IO] | 
Output channels
 
 | 
 P | 
| pair [CCHet] | 
 | 
| parse_result [CCSexpM] | 
A parser of 'a can return `Ok x when it parsed a value,
    or `Error e when a parse error was encountered, or
    `End if the input was empty
 
 | 
| path [CCGraph.Traverse] | 
 | 
| pattern [CCKMP.S] | 
Compiled pattern (needle: string to search in another string)
 
 | 
| pp [CCRef] | 
 | 
| print [CCRef] | 
 | 
| printer [CCArray1] | 
 | 
| printer [CCBigstring] | 
 | 
| printer [CCImmutArray] | 
 | 
| printer [CCRAL] | 
 | 
| printer [CCWBTree] | 
 | 
| printer [CCHashTrie] | 
 | 
| printer [CCHashSet] | 
 | 
| printer [CCPersistentArray] | 
 | 
| printer [CCIntMap] | 
 | 
| printer [CCFQueue] | 
 | 
| printer [CCDeque] | 
 | 
| printer [CCPersistentHashtbl] | 
 | 
| printer [CCKList] | 
 | 
| printer [CCKTree] | 
 | 
| printer [CCResult] | 
 | 
| printer [CCFormat] | 
 | 
| printer [CCMap] | 
 | 
| printer [CCHashtbl] | 
 | 
| printer [CCSet] | 
 | 
| printer [CCFloat] | 
 | 
| printer [CCBool] | 
 | 
| printer [CCInt] | 
 | 
| printer [CCPair] | 
 | 
| printer [CCOpt] | 
 | 
| printer [CCList] | 
 | 
| printer [CCHeap] | 
 | 
| printer [CCError] | 
 | 
| printer [CCVector] | 
 | 
| process_full [CCUnix] | 
Handle to a subprocess.
 
 | 
 R | 
| random [CCArray1] | 
 | 
| random_gen [CCRandom] | 
 | 
| random_gen [CCArray] | 
 | 
| random_gen [CCFloat] | 
 | 
| random_gen [CCInt] | 
 | 
| random_gen [CCOpt] | 
 | 
| random_gen [CCList] | 
 | 
| result [CCApp_parse] | 
 | 
| right [CCMultiMap.BIDIR] | 
 | 
| ro [CCVector] | 
 | 
| ro_vector [CCVector] | 
Alias for immutable vectors.
 
 | 
| rw [CCVector] | 
 | 
 S | 
| scc_state [CCGraph] | 
 | 
| sequence [CCSexpM] | 
 | 
| sequence [CCLinq] | 
 | 
| sequence [CCCat] | 
Cheating: use an equivalent of "to List" with a sequence
 
 | 
| sequence [CCArray1] | 
 | 
| sequence [CCBigstring] | 
 | 
| sequence [CCLevenshtein] | 
 | 
| sequence [CCKMP] | 
 | 
| sequence [CCHet] | 
 | 
| sequence [CCImmutArray] | 
 | 
| sequence [CCRAL] | 
 | 
| sequence [CCWBTree] | 
 | 
| sequence [CCBloom] | 
 | 
| sequence [CCHashTrie] | 
 | 
| sequence [CCHashSet] | 
 | 
| sequence [CCGraph] | 
A sequence of items of type 'a, possibly infinite
 
 | 
| sequence [CCHashconsedSet.S] | 
 | 
| sequence [CCPersistentArray] | 
 | 
| sequence [CCIntMap] | 
 | 
| sequence [CCMixmap.S] | 
 | 
| sequence [CCMixtbl] | 
 | 
| sequence [CCBV] | 
 | 
| sequence [CCFQueue] | 
 | 
| sequence [CCDeque] | 
 | 
| sequence [CCPersistentHashtbl] | 
 | 
| sequence [CCFlatHashtbl] | 
 | 
| sequence [CCTrie] | 
 | 
| sequence [CCMultiSet] | 
 | 
| sequence [CCMultiMap] | 
 | 
| sequence [CCKList] | 
 | 
| sequence [CCKTree] | 
 | 
| sequence [CCResult] | 
 | 
| sequence [CCFormat] | 
 | 
| sequence [CCMap] | 
 | 
| sequence [CCHashtbl] | 
 | 
| sequence [CCString] | 
 | 
| sequence [CCSet] | 
 | 
| sequence [CCRef] | 
 | 
| sequence [CCArray] | 
 | 
| sequence [CCHash] | 
 | 
| sequence [CCOpt] | 
 | 
| sequence [CCList] | 
 | 
| sequence [CCHeap] | 
 | 
| sequence [CCError] | 
 | 
| sequence [CCPrint] | 
 | 
| sequence [CCVector] | 
 | 
| sequence_once [CCGraph] | 
Sequence that should be used only once
 
 | 
| set [CCGraph] | 
Mutable set
 
 | 
| sexp [CCSexpM] | 
 | 
| source [CCApp_parse.READER] | 
 | 
| source [CCApp_parse.S] | 
Source of characters
 
 | 
| state [CCPool] | 
 | 
| state [CCRandom] | 
 | 
| state [CCHash.HASH] | 
 | 
| state [CCHash] | 
State required by the hash function.
 
 | 
| step_result [CCMonadIO.Seq] | 
 | 
| string [CCKMP.S] | 
 | 
| string_ [CCLevenshtein.S] | 
 | 
 T | 
| t [CCSexpM.MONAD] | 
 | 
| t [CCSexpM.MakeDecode] | 
Decoder
 
 | 
| t [CCSexpM] | 
 | 
| t [CCSexp] | 
 | 
| t [CCMonadIO.File] | 
A file is always represented by its absolute path
 
 | 
| t [CCMonadIO.Seq] | 
An IO stream of values of type 'a, consumable (iterable only once)
 
 | 
| t [CCMonadIO] | 
 | 
| t [CCLinq.PMap] | 
 | 
| t [CCLinq] | 
Type of a query that returns zero, one or more values of type 'a
 
 | 
| t [CCCat.TRAVERSE] | 
 | 
| t [CCCat.MONAD_BARE] | 
 | 
| t [CCCat.APPLICATIVE] | 
 | 
| t [CCCat.MONOID] | 
 | 
| t [CCCat.FOLDABLE] | 
 | 
| t [CCCat.FUNCTOR] | 
 | 
| t [CCCat.FREE_MONAD] | 
 | 
| t [CCBatch.COLLECTION] | 
 | 
| t [CCBatch.S] | 
 | 
| t [CCTimer] | 
A scheduler for events.
 
 | 
| t [CCBlockingQueue] | 
Safe-thread queue for values of type 'a
 
 | 
| t [CCThread.Barrier] | 
Barrier, used to synchronize threads
 
 | 
| t [CCThread] | 
 | 
| t [CCSemaphore] | 
A semaphore
 
 | 
| t [CCLock.LockRef] | 
 | 
| t [CCLock] | 
A value surrounded with a lock
 
 | 
| t [CCPool.Make.Fut] | 
A future value of type 'a
 
 | 
| t [CCArray1.View] | 
A view on an array or part of an array
 
 | 
| t [CCArray1.S] | 
 | 
| t [CCArray1.Bool] | 
A simple bitvector based on some integral type 'b
 
 | 
| t [CCArray1] | 
Array of OCaml values of type 'a with C representation of type b'
    with permissions 'perm
 
 | 
| t [CCBigstring] | 
 | 
| t [CCLevenshtein.STRING] | 
 | 
| t [CCLevenshtein.S.Index] | 
Index that maps strings to values of type 'b.
 
 | 
| t [CCKMP.STRING] | 
 | 
| t [CCParse.MemoTbl] | 
 | 
| t [CCParse] | 
Takes the input and two continuations:
     ok to call with the result when it's done, err to call when the parser met an error
    The type definition changed since 0.14 to avoid stack overflows
 
 | 
| t [CCApp_parse.READER] | 
 | 
| t [CCApp_parse.INPUT] | 
 | 
| t [CCApp_parse] | 
Parser that yields an error or a value of type 'a
 
 | 
| t [CCHet.Map] | 
 | 
| t [CCHet.Tbl] | 
 | 
| t [CCHet.Key] | 
 | 
| t [CCImmutArray] | 
Array of values of type 'a.
 
 | 
| t [CCAllocCache.Arr] | 
Cache for 'a arrays
 
 | 
| t [CCRAL] | 
List containing elements of type 'a
 
 | 
| t [CCWBTree.ORD] | 
 | 
| t [CCWBTree.S] | 
 | 
| t [CCBloom] | 
Bloom filter containing values of type 'a
 
 | 
| t [CCHashTrie.KEY] | 
 | 
| t [CCHashTrie.S] | 
 | 
| t [CCHashTrie.Transient] | 
Identifiers for transient modifications.
 
 | 
| t [CCBitField.S] | 
Generative type of bitfields.
 
 | 
| t [CCHashSet.ELEMENT] | 
 | 
| t [CCHashSet.S] | 
 | 
| t [CCGraph.MAP] | 
 | 
| t [CCGraph.LazyTree] | 
 | 
| t [CCGraph.Traverse.Event] | 
A traversal is a sequence of such events
 
 | 
| t [CCGraph.Seq] | 
 | 
| t [CCGraph] | 
Directed graph with vertices of type 'v and edges of type e'
 
 | 
| t [CCHashconsedSet.ELT] | 
 | 
| t [CCHashconsedSet.S] | 
Set of elements
 
 | 
| t [CCMixset] | 
A set of values of heterogeneous types
 
 | 
| t [CCPersistentArray] | 
The type of persistent arrays
 
 | 
| t [CCIntMap] | 
 | 
| t [CCRingBuffer.S] | 
Defines the ring buffer type, with both bounded and
      unbounded flavors
 
 | 
| t [CCRingBuffer.Array.S] | 
The type of an array instance
 
 | 
| t [CCMixmap.ORD] | 
 | 
| t [CCMixmap.S] | 
A map containing values of different types, indexed by  CCMixmap.S.key.
  
 | 
| t [CCMixtbl] | 
A hash table containing values of different types.
 
 | 
| t [CCBV] | 
A resizable bitvector
 
 | 
| t [CCFQueue] | 
Queue containing elements of type 'a
 
 | 
| t [CCDeque] | 
Contains 'a elements, queue in both ways
 
 | 
| t [CCPersistentHashtbl.HashedType] | 
 | 
| t [CCPersistentHashtbl.S] | 
 | 
| t [CCCache] | 
 | 
| t [CCFlatHashtbl.HASHABLE] | 
 | 
| t [CCFlatHashtbl.S] | 
 | 
| t [CCTrie.ORDERED] | 
 | 
| t [CCTrie.WORD] | 
 | 
| t [CCTrie.S] | 
 | 
| t [CCMultiSet.S] | 
 | 
| t [CCMultiMap.OrderedType] | 
 | 
| t [CCMultiMap.BIDIR] | 
 | 
| t [CCMultiMap.S] | 
 | 
| t [CCLazy_list] | 
 | 
| t [CCKList.MONAD] | 
 | 
| t [CCKList] | 
 | 
| t [CCKTree] | 
 | 
| t [CCResult.MONAD] | 
 | 
| t [CCResult] | 
 | 
| t [CCChar] | 
 | 
| t [CCInt64] | 
 | 
| t [CCIO.File] | 
A file should be represented by its absolute path, but currently
      this is not enforced.
 
 | 
| t [CCFormat] | 
 | 
| t [CCHashtbl.COUNTER] | 
 | 
| t [CCHashtbl.DEFAULT] | 
A hashtable for keys of type key and values of type 'a
 
 | 
| t [CCString.S] | 
 | 
| t [CCString.Sub] | 
A string, an offset, and the length of the slice
 
 | 
| t [CCRandom] | 
Random generator for values of type 'a
 
 | 
| t [CCOrd] | 
Comparison (total ordering) between two elements, that returns an int
 
 | 
| t [CCRef] | 
 | 
| t [CCArray.MONO_ARRAY] | 
 | 
| t [CCArray.S] | 
Array, or sub-array, containing elements of type 'a
 
 | 
| t [CCArray.Sub] | 
A slice is an array, an offset, and a length
 
 | 
| t [CCArray] | 
 | 
| t [CCFloat] | 
 | 
| t [CCBool] | 
 | 
| t [CCInt] | 
 | 
| t [CCHash] | 
A hash value is a positive integer
 
 | 
| t [CCFun.Monad] | 
 | 
| t [CCPair] | 
 | 
| t [CCOpt] | 
 | 
| t [CCList.MONAD] | 
 | 
| t [CCList.Ref] | 
 | 
| t [CCList.Zipper] | 
The pair l, r represents the list List.rev_append l r, but
      with the focus on r.
 
 | 
| t [CCList.Assoc] | 
 | 
| t [CCList] | 
 | 
| t [CCHeap.PARTIAL_ORD] | 
 | 
| t [CCHeap.S] | 
 | 
| t [CCError.MONAD] | 
 | 
| t [CCError] | 
 | 
| t [CCPrint.MONAD_IO] | 
the IO monad
 
 | 
| t [CCPrint] | 
A printer for the type 'a
 
 | 
| t [CCVector] | 
The type of a vector of elements of type 'a, with
    a mutability flat 'mut
 
 | 
| table [CCGraph] | 
Mutable table with keys 'k and values 'a
 
 | 
| tag_set [CCGraph] | 
Mutable tags from values of type 'v to tags of type bool
 
 | 
| to_json [CCArray1] | 
 | 
| token [CCApp_parse] | 
 | 
| tree [CCIntMap] | 
 | 
 V | 
| value [CCBitField.S.FIELD] | 
Values contained in the field
 
 | 
| value [CCMixmap.S] | 
 | 
| value [CCMixtbl] | 
 | 
| value [CCMultiMap.S] | 
 | 
| vector [CCVector] | 
Type synonym: a 'a vector is mutable.
 
 | 
| vertex [CCGraph.MAP] | 
 | 
| vertex_state [CCGraph.Dot] | 
Hidden state associated to a vertex
 
 | 
 W | 
| walk_item [CCIO.File] | 
 | 
| with_err [CCLinq] | 
 | 
| with_finalizer [CCMonadIO] | 
A value of type 'a with_finalizer is similar to a value 'a t but
    also contains a finalizer that must be run to cleanup.
 
 |