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.Dump] |
|
| 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.
|