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