A |
| 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
|
B |
| bag [CCGraph] |
Bag of elements of type 'a
|
C |
| call_result [CCUnix] |
|
| char_ [CCTrie.WORD] |
|
| char_ [CCTrie.S] |
|
| col_num [CCParse] |
|
E |
| edge_kind [CCGraph.Traverse.Event] |
|
| elt [CCHashSet.S] |
|
| elt [CCRingBuffer.Array.S] |
The element type
|
| elt [CCMultiSet.S] |
|
| elt [CCArrayLabels.MONO_ARRAY] |
|
| elt [CCArray.MONO_ARRAY] |
|
| elt [CCHeap.S] |
|
| eq [CCHashtbl] |
|
| eq [CCRef] |
|
| equal [CCFQueue] |
|
| equal [CCPersistentHashtbl] |
|
| equal [CCCache] |
|
| equal [CCKList] |
|
| equal [CCArrayLabels] |
|
| equal [CCArray_slice] |
|
| equal [CCResult] |
|
| equal [CCArray] |
|
| equal [CCVector] |
|
| error [CCResult] |
|
F |
| field [CCBitField.S] |
|
| fpclass [CCFloat] |
|
| future [CCPool.Make.Fut] |
|
G |
| gen [CCSexp] |
|
| gen [CCUnix] |
|
| gen [CCHet] |
|
| gen [CCImmutArray] |
|
| gen [CCRAL] |
|
| gen [CCWBTree] |
|
| gen [CCHashTrie] |
|
| gen [CCPersistentArray] |
|
| gen [CCIntMap] |
|
| gen [CCDeque] |
|
| gen [CCLazy_list] |
|
| gen [CCKList] |
|
| gen [CCKTree] |
|
| gen [CCArrayLabels] |
|
| gen [CCListLabels] |
|
| gen [CCArray_slice] |
|
| 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 [CCCache] |
|
| hash [CCHashtbl] |
|
| hash [CCHash] |
A hash value is a positive integer
|
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.
|
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] |
|
| klist [CCIntMap] |
|
| klist [CCFQueue] |
|
| klist [CCKTree] |
|
| klist [CCArrayLabels] |
|
| klist [CCListLabels] |
|
| klist [CCArray_slice] |
|
| 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 |
| or_error [CCSexp] |
|
| or_error [CCUnix] |
|
| or_error [CCParse] |
|
| or_error [CCIO] |
|
| ord [CCKList] |
|
| ord [CCArrayLabels] |
|
| ord [CCArray_slice] |
|
| ord [CCResult] |
|
| ord [CCRef] |
|
| ord [CCArray] |
|
| ord [CCVector] |
|
P |
| pair [CCHet] |
|
| parse_branch [CCParse] |
|
| parse_result [CCSexp] |
A parser of 'a can return Yield x when it parsed a value,
or Fail e when a parse error was encountered, or
End if the input was empty
|
| path [CCGraph.Traverse] |
|
| pattern [CCString.Find] |
|
| position [CCParse] |
|
| 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 [CCArrayLabels] |
|
| printer [CCListLabels] |
|
| printer [CCArray_slice] |
|
| printer [CCResult] |
|
| printer [CCFormat] |
|
| printer [CCMap] |
|
| printer [CCHashtbl] |
|
| printer [CCSet] |
|
| printer [CCRef] |
|
| printer [CCArray] |
|
| printer [CCFloat] |
|
| printer [CCBool] |
|
| printer [CCInt] |
|
| printer [CCPair] |
|
| printer [CCOpt] |
|
| printer [CCList] |
|
| printer [CCHeap] |
|
| printer [CCVector] |
|
| process_full [CCUnix] |
Handle to a subprocess.
|
R |
| random_gen [CCArrayLabels] |
|
| random_gen [CCListLabels] |
|
| random_gen [CCArray_slice] |
|
| random_gen [CCRandom] |
|
| random_gen [CCArray] |
|
| random_gen [CCFloat] |
|
| random_gen [CCInt] |
|
| random_gen [CCOpt] |
|
| random_gen [CCList] |
|
| right [CCMultiMap.BIDIR] |
|
| ro [CCVector] |
|
| ro_vector [CCVector] |
Alias for immutable vectors.
|
| rw [CCVector] |
|
S |
| scc_state [CCGraph] |
|
| sequence [CCSexp] |
|
| sequence [CCHet] |
|
| sequence [CCImmutArray] |
|
| sequence [CCRAL] |
|
| sequence [CCWBTree] |
|
| sequence [CCHashTrie] |
|
| sequence [CCHashSet] |
|
| sequence [CCGraph] |
A sequence of items of type 'a, possibly infinite
|
| 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 [CCArrayLabels] |
|
| sequence [CCListLabels] |
|
| sequence [CCArray_slice] |
|
| sequence [CCResult] |
|
| sequence [CCFormat] |
|
| sequence [CCMap] |
|
| sequence [CCHashtbl] |
|
| sequence [CCString] |
|
| sequence [CCSet] |
|
| sequence [CCRef] |
|
| sequence [CCArray] |
|
| sequence [CCInt] |
|
| sequence [CCHash] |
|
| sequence [CCOpt] |
|
| sequence [CCList] |
|
| sequence [CCHeap] |
|
| sequence [CCVector] |
|
| sequence_once [CCGraph] |
Sequence that should be used only once
|
| set [CCGraph] |
Mutable set
|
| sexp [CCSexp] |
|
| state [CCPool] |
|
| state [CCParse] |
|
| state [CCRandom] |
|
T |
| t [CCSexp.Decoder] |
Decoder
|
| t [CCSexp] |
|
| 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 [CCZipper] |
The pair l, r represents the list List.rev_append l r, but
with the focus on r.
|
| t [CCHet.Map] |
|
| t [CCHet.Tbl] |
|
| t [CCHet.Key] |
|
| t [CCImmutArray] |
Array of values of type 'a.
|
| t [CCRAL] |
List containing elements of type 'a
|
| t [CCWBTree.ORD] |
|
| t [CCWBTree.S] |
|
| 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.Lazy_tree] |
|
| 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 labeled with e'
|
| 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 [CCEqual] |
Equality function.
|
| t [CCArrayLabels.MONO_ARRAY] |
|
| t [CCArrayLabels] |
|
| t [CCListLabels.MONAD] |
|
| t [CCListLabels.Ref] |
|
| t [CCListLabels.Assoc] |
|
| t [CCListLabels] |
|
| t [CCArray_slice] |
Array slice, containing elements of type 'a
|
| 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
|
| t [CCResult.MONAD] |
|
| t [CCResult] |
|
| 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 [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] |
|
| t [CCFloat] |
|
| t [CCBool] |
|
| t [CCInt] |
|
| t [CCHash] |
A hash function for values of type 'a
|
| t [CCFun.Monad] |
|
| t [CCPair] |
|
| t [CCOpt] |
|
| t [CCList.MONAD] |
|
| t [CCList.Ref] |
|
| t [CCList.Assoc] |
|
| t [CCList] |
|
| t [CCHeap.PARTIAL_ORD] |
|
| t [CCHeap.S] |
|
| t [CCVector] |
The type of a vector of elements of type 'a, with
a mutability flat 'mut
|
| table [CCGraph] |
Table
|
| tag_set [CCGraph] |
Tags
|
| token [CCSexp_lex] |
|
| tree [CCIntMap] |
|
U |
| unescape_state [CCSexp_lex] |
|
V |
| 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] |
|