Index of values


( * ) [CCArray1.S.Infix]
Alias to CCArray1.S.mult
( * ) [CCInt64]
( *! ) [CCArray1.S.Infix]
( *** ) [CCPair]
Map on both sides of a tuple
( *> ) [CCParse]
a *> b parses a, then parses b into x, and returns x.
( <* ) [CCParse]
a <* b parses a into x, parses b and ignores its result, and returns x
(%) [CCFun]
Mathematical composition
(%>) [CCFun]
Alias to compose
(&&&) [CCParse]
Conjunction on predicates
(&&&) [CCPair]
f &&& g is fun x -> f x, g x.
(+!) [CCArray1.S.Infix]
(+) [CCArray1.S.Infix]
Alias to CCArray1.S.add
(+) [CCInt64]
(-) [CCInt64]
(--) [CCLinq.Infix]
(--) [CCLinq]
Synonym to CCLinq.range
(--) [CCRAL.Infix]
Alias to CCRAL.range
(--) [CCFQueue]
a -- b is the integer range from a to b, both included.
(--) [CCKList.Infix]
(--) [CCKList]
a -- b is the range of integers containing a and b (therefore, never empty)
(--) [CCArray]
Range array
(--) [CCList.Infix]
(--) [CCList]
Infix alias for range
(--) [CCVector]
Range of integers, either ascending or descending (both included, therefore the result is never empty).
(--^) [CCRAL.Infix]
a -- b is the integer range from a to b, where b is excluded.
(--^) [CCFQueue]
a -- b is the integer range from a to b, where b is excluded.
(--^) [CCKList.Infix]
(--^) [CCKList]
a -- b is the integer range from a to b, where b is excluded.
(--^) [CCArray]
Range array, excluding right bound
(--^) [CCList.Infix]
(--^) [CCList]
Infix alias for range'
(--^) [CCVector]
Range of integers, either ascending or descending, but excluding right., Example: 1 --^ 10 returns the vector [1;2;3;4;5;6;7;8;9]
(/) [CCInt64]
(<$>) [CCOpt.Infix]
(<$>) [CCOpt]
(<$>) [CCList.Infix]
(<$>) [CCList]
(<) [CCFloat.Infix]
(<) [CCInt.Infix]
(<*>) [CCMonadIO]
(<*>) [CCLinq.Infix]
(<*>) [CCLinq]
Infix synonym to CCLinq.app
(<*>) [CCCat.APPLICATIVE]
(<*>) [CCPool.Make.Fut.Infix]
(<*>) [CCPool.Make.Fut]
(<*>) [CCParse]
Applicative
(<*>) [CCApp_parse.Infix]
Synonym to CCApp_parse.app
(<*>) [CCRAL.Infix]
Alias to CCRAL.app
(<*>) [CCKList.Infix]
(<*>) [CCKList]
(<*>) [CCResult.Infix]
(<*>) [CCResult]
a <*> b evaluates a and b, and, in case of success, returns Ok (a b).
(<*>) [CCRandom]
(<*>) [CCOpt.Infix]
(<*>) [CCOpt]
(<*>) [CCList.Infix]
(<*>) [CCList]
(<*>) [CCError.Infix]
(<*>) [CCError]
a <*> b evaluates a and b, and, in case of success, returns `Ok (a b).
(<+>) [CCApp_parse.Infix]
a <+> b is choice [a;b], a binary choice
(<+>) [CCOpt.Infix]
(<+>) [CCOpt]
a <+> b is a if a is Some _, b otherwise
(<.>) [CCKList.Infix]
(<.>) [CCKList]
Infix version of CCKList.fair_app
(<::>) [CCApp_parse.Infix]
a <::> b is app (fun x l -> x::l) a b
(<<) [CCApp_parse.Infix]
a << b parses a, then b, and discards b to return a
(<<<) [CCPair]
Map on the left side of the tuple
(<=) [CCFloat.Infix]
(<=) [CCInt.Infix]
(<>) [CCFloat.Infix]
(<>) [CCInt.Infix]
(<?>) [CCRandom]
a <?> b is a choice operator.
(<?>) [CCOrd]
c1 @@? (ord, x, y) returns the same as c1 if c1 is not 0; otherwise it uses ord to compare the two values x and y, of type 'a.
(<|>) [CCParse]
a <|> b tries to parse a, and if a fails, backtracks and tries to parse b.
(=) [CCFloat.Infix]
(=) [CCInt.Infix]
(>) [CCFloat.Infix]
(>) [CCInt.Infix]
(>=) [CCFloat.Infix]
(>=) [CCInt.Infix]
(>>) [CCPool.Make.Fut.Infix]
(>>) [CCPool.Make.Fut]
(>>) [CCApp_parse.Infix]
a >> b parses a, ignores its result, then parses b
(>>-) [CCKList.Infix]
(>>-) [CCKList]
Infix version of CCKList.fair_flat_map
(>>=) [CCSexpM.MONAD]
(>>=) [CCSexp.Traverse]
(>>=) [CCMonadIO]
Wait for the result of an action, then use a function to build a new action and execute it
(>>=) [CCLinq.Infix]
(>>=) [CCLinq]
Infix version of CCLinq.bind
(>>=) [CCCat.MONAD_BARE]
(>>=) [CCPool.Make.Fut.Infix]
(>>=) [CCPool.Make.Fut]
(>>=) [CCParse]
Monadic bind
(>>=) [CCRAL.Infix]
Alias to CCRAL.flat_map
(>>=) [CCGraph.Seq]
(>>=) [CCLazy_list.Infix]
(>>=) [CCKList.MONAD]
(>>=) [CCKList.Infix]
(>>=) [CCKList]
(>>=) [CCResult.MONAD]
(>>=) [CCResult.Infix]
(>>=) [CCResult]
(>>=) [CCRandom]
(>>=) [CCArray]
Infix version of CCArray.flat_map
(>>=) [CCFun.Monad]
(>>=) [CCOpt.Infix]
(>>=) [CCOpt]
Monadic bind
(>>=) [CCList.MONAD]
(>>=) [CCList.Infix]
(>>=) [CCList]
(>>=) [CCError.MONAD]
(>>=) [CCError.Infix]
(>>=) [CCError]
(>>=) [CCPrint.MONAD_IO]
(>>=) [CCVector]
Infix version of CCVector.flat_map
(>>>) [CCBatch.S]
(>>>) [CCPair]
Map on the right side of the tuple
(>>>=) [CCMonadIO]
Same as CCMonadIO.(>>=), but taking the finalizer into account.
(>>|) [CCArray]
Infix version of CCArray.map
(>|=) [CCSexp.Traverse]
(>|=) [CCMonadIO]
(>|=) [CCLinq.Infix]
(>|=) [CCLinq]
Infix synonym of CCLinq.map
(>|=) [CCPool.Make.Fut.Infix]
(>|=) [CCPool.Make.Fut]
(>|=) [CCParse]
Map
(>|=) [CCApp_parse.Infix]
Infix version of CCApp_parse.map
(>|=) [CCRAL.Infix]
Alias to CCRAL.map
(>|=) [CCFQueue]
Synonym to CCFQueue.map
(>|=) [CCLazy_list.Infix]
(>|=) [CCKList.Infix]
(>|=) [CCKList]
(>|=) [CCKTree]
(>|=) [CCResult.Infix]
(>|=) [CCResult]
(>|=) [CCRandom]
(>|=) [CCArray]
Infix version of CCArray.map
(>|=) [CCFun.Monad]
(>|=) [CCOpt.Infix]
(>|=) [CCOpt]
Infix version of CCOpt.map
(>|=) [CCList.Infix]
(>|=) [CCList]
Infix version of map with reversed arguments
(>|=) [CCError.Infix]
(>|=) [CCError]
(>|=) [CCVector]
Infix version of CCVector.map
(@) [CCList.Infix]
(@) [CCList]
(@+) [CCRAL.Infix]
Cons (alias to CCRAL.cons)
(@@) [CCFun]
f @@ x is the same as f x, but right-associative.
(asr) [CCInt64]
(land) [CCInt64]
(lor) [CCInt64]
(lsl) [CCInt64]
(lsr) [CCInt64]
(lxor) [CCInt64]
(mod) [CCInt64]
(|>) [CCFun]
Pipeline.
(|||) [CCParse]
Disjunction on predicates
(~-) [CCInt64]
(~~~) [CCParse]
Negation on predicates
?| [CCUnix.Infix]
Infix version of CCUnix.call
?|& [CCUnix.Infix]
Infix version of CCUnix.async_call

A
above [CCTrie.S]
All bindings whose key is bigger or equal to the given key, in ascending order
abs [CCInt64]
abs [CCFloat]
acquire [CCSemaphore]
acquire n s blocks until get s >= n, then atomically sets s := !s - n
activate [CCThread.Barrier]
activate b unblocks all threads that were waiting on b
activated [CCThread.Barrier]
activated b returns true iff activate b was called, and reset b was not called since.
active [CCTimer]
Returns true until stop t has been called.
active [CCPool.Make]
active () is true as long as stop() has not been called yet
active [CCHashTrie.Transient]
active i is not (frozen i)
add [CCArray1.View.S]
add [CCArray1.S]
Elementwise sum
add [CCLevenshtein.S.Index]
Add a pair string/value to the index.
add [CCHet.Map]
add [CCHet.Tbl]
add [CCWBTree.S]
add [CCBloom]
add f x adds x into f
add [CCHashTrie.S]
add [CCGraph.MAP]
Add a vertex, possibly with no outgoing edge
add [CCHashconsedSet.S]
add [CCIntMap]
add [CCMixmap.S]
Bind the key to the value, using inj
add [CCPersistentHashtbl.S]
Add the binding to the table, returning a new table.
add [CCFlatHashtbl.S]
add tbl k v adds k -> v to tbl, possibly replacing the old value associated with k.
add [CCTrie.S]
Add a binding to the trie (possibly erasing the previous one)
add [CCMultiSet.S]
add [CCMultiMap.BIDIR]
Add a binding (left,right)
add [CCMultiMap.S]
Add a key/value binding
add [CCFloat]
add [CCList.Set]
add x set adds x to set if it was not already present.
add [CCHeap.S]
Synonym to CCHeap.S.insert
add_array [CCRAL]
add_edge [CCGraph.MAP]
add_gen [CCLevenshtein.S.Index]
add_gen [CCRAL]
add_gen [CCWBTree.S]
add_gen [CCBloom]
add_gen [CCHashTrie.S]
add_gen [CCIntMap]
add_gen [CCHeap.S]
add_gen_mut [CCHashTrie.S]
add_klist [CCIntMap]
add_klist [CCHeap.S]
add_list [CCHet.Map]
add_list [CCHet.Tbl]
add_list [CCRAL]
add_list [CCWBTree.S]
add_list [CCBloom]
add_list [CCHashTrie.S]
add_list [CCGraph.MAP]
add_list [CCHashconsedSet.S]
add_list [CCIntMap]
add_list [CCPersistentHashtbl.S]
add_list [CCMap.S]
add_list [CCHashtbl.COUNTER]
add_list [CCHashtbl.S]
add_list tbl x y adds y to the list x is bound to.
add_list [CCHashtbl]
add_list tbl x y adds y to the list x is bound to.
add_list [CCSet.S]
add_list [CCHeap.S]
add_list_mut [CCHashTrie.S]
add_mult [CCMultiSet.S]
add_mult set x n adds n occurrences of x to set
add_mut [CCHashTrie.S]
add_mut ~id k v m behaves like add k v m, except it will mutate in place whenever possible.
add_pairs [CCMultiMap.BIDIR]
Add pairs
add_scalar [CCArray1.View.S]
add_seq [CCLevenshtein.S.Index]
add_seq [CCHet.Map]
add_seq [CCHet.Tbl]
add_seq [CCRAL]
add_seq [CCWBTree.S]
add_seq [CCBloom]
add_seq [CCHashTrie.S]
add_seq [CCHashSet.S]
add_seq [CCGraph.MAP]
add_seq [CCHashconsedSet.S]
add_seq [CCIntMap]
add_seq [CCPersistentHashtbl.S]
add_seq [CCMap.S]
add_seq [CCHashtbl.COUNTER]
Increment each element of the sequence
add_seq [CCHashtbl.S]
Add the corresponding pairs to the table, using Hashtbl.add.
add_seq [CCHashtbl]
Add the corresponding pairs to the table, using Hashtbl.add.
add_seq [CCSet.S]
add_seq [CCHeap.S]
add_seq_back [CCFQueue]
add_seq_back [CCDeque]
add_seq_back q seq adds elements of seq into the back of q, in order.
add_seq_count [CCHashtbl.S]
add_seq_count tbl seq increments the count of each element of seq by calling CCHashtbl.S.incr.
add_seq_count [CCHashtbl]
add_seq_count tbl seq increments the count of each element of seq by calling CCHashtbl.incr.
add_seq_front [CCFQueue]
add_seq_front [CCDeque]
add_seq_front q seq adds elements of seq into the front of q, in reverse order.
add_seq_mut [CCHashTrie.S]
after [CCTimer]
Call the callback f after the given number of seconds.
alpha [CCApp_parse]
alpha_lower [CCApp_parse]
alpha_num [CCApp_parse]
alpha_upper [CCApp_parse]
and_ [CCArray1.Bool]
Boolean conjunction.
and_then [CCPool.Make.Fut]
Wait for the first future to succeed, then launch the second
any_of [CCApp_parse]
Parse any of the chars present in the given string
app [CCLinq]
Apply each function to each value
app [CCPool.Make.Fut]
app f x applies the result of f to the result of x
app [CCApp_parse]
Applicative
app [CCRAL]
app_async [CCPool.Make.Fut]
app f x applies the result of f to the result of x, in a separated job scheduled in the pool
append [CCLinq]
Append two collections together
append [CCCat.MONOID]
append [CCArray1]
append a b ~into assumes length a + length b = length into and copies a and b side by side in into
append [CCImmutArray]
append [CCRAL]
append [CCPersistentArray]
Append the two arrays
append [CCRingBuffer.S]
append b ~into copies all data from b and adds it at the end of into
append [CCFQueue]
Append two queues.
append [CCLazy_list]
Lazy concatenation
append [CCKList]
append [CCIO.File]
Append the given string into the given file
append [CCList]
Safe version of append
append [CCVector]
append a b adds all elements of b to a
append_array [CCVector]
Same as append, with an array
append_back [CCDeque]
append_back ~into q adds all elements of q at the back of into.
append_exn [CCIO.File]
Append the given string into the given file, possibly raising
append_front [CCDeque]
append_front ~into q adds all elements of q at the front of into O(length q) in time
append_gen [CCVector]
Append content of generator
append_list [CCVector]
Append content of list
append_seq [CCVector]
Append content of sequence
apply [CCBatch.S]
Apply the operation to the collection.
apply [CCHash]
Apply a hash function to a value.
apply' [CCBatch.S]
Flip of CCBatch.S.apply
apply_fold [CCBatch.S]
Apply the operation plus a fold to the collection.
array [CCFormat.Dump]
array [CCFormat]
array [CCHash.S]
array [CCPrint]
array_ [CCOrd]
array_ [CCHash]
arrayi [CCFormat]
arrayi [CCPrint]
as_graph [CCGraph.MAP]
Graph view of the map
as_tree [CCHashTrie.S]
For debugging purpose: explore the structure of the tree, with `L (h,l) being a leaf (with shared hash h) and `N an inner node
as_tree [CCIntMap]
async_call [CCUnix]
Spawns a subprocess, like CCUnix.call, but the subprocess's channels are line generators and line sinks (for stdin).
at [CCTimer]
Create a future that evaluates to () at the given Unix timestamp
atom [CCSexp]
Build an atom directly from a string
average [CCLinq]

B
below [CCTrie.S]
All bindings whose key is smaller or equal to the given key, in decreasing order
bfs [CCGraph.Traverse]
bfs [CCKTree]
Breadth-first traversal of the tree
bfs_tag [CCGraph.Traverse]
bind [CCMonadIO]
bind f a runs the action a and applies f to its result to obtain a new action.
bind [CCLinq]
Use the result of a query to build another query and immediately run it.
bindings [CCMixmap.S]
Iterate on all bindings
bindings [CCMixtbl]
Iterate on all bindings
bindings_of [CCMixmap.S]
All the bindings that come from the corresponding injection
bindings_of [CCMixtbl]
All the bindings that come from the corresponding injection
blit [CCArray1]
blit the first array to the second
blit [CCBigstring]
Blit a slice of the bigstring into another
blit [CCRingBuffer.Array.S]
blit t s arr i len copies len elements from arr starting at i to position s from t
blit [CCString.S]
Similar to String.blit.
blit [CCArray.S]
blit from i into j len copies len elements from the first array to the second.
blit_from [CCRingBuffer.S]
blit_from buf from_buf o len copies the slice o, ... o + len - 1 from a input buffer from_buf to the end of the buffer.
blit_into [CCRingBuffer.S]
blit_into buf to_buf o len copies at most len elements from buf into to_buf starting at offset o in s.
blit_of_bytes [CCBigstring]
blit_of_string [CCBigstring]
blit_to_bytes [CCBigstring]
bool [CCApp_parse]
Parse "true" or "false"
bool [CCBitField.S]
New field of type bool
bool [CCFormat.Dump]
bool [CCFormat]
bool [CCHash.HASH]
bool [CCPrint]
bool_ [CCOrd]
bool_ [CCHash]
both [CCResult]
both a b, in case of success, returns Ok (o, o') with the ok values of a and b.
both [CCError]
both a b, in case of success, returns `Ok (o, o') with the ok values of a and b.
bsearch [CCArray.S]
bsearch ?cmp x arr finds the index of the object x in the array arr, provided arr is sorted using cmp.

C
call [CCUnix]
call cmd wraps the result of Unix.open_process_full cmd into an object.
capacity [CCBlockingQueue]
Number of values the queue can hold
capacity [CCRingBuffer.S]
Length of the inner buffer.
capacity [CCVector]
Number of elements the vector can contain without being resized
capitalize_ascii [CCString]
See String.
cardinal [CCArray1.Bool]
Number of ones
cardinal [CCLevenshtein.S.Index]
Number of bindings
cardinal [CCHet.Map]
cardinal [CCWBTree.S]
cardinal [CCHashTrie.S]
cardinal [CCHashSet.S]
cardinal s returns the number of elements in s
cardinal [CCHashconsedSet.S]
cardinal [CCMixset]
Number of mappings
cardinal [CCIntMap]
Number of bindings in the map.
cardinal [CCMixmap.S]
Number of bindings
cardinal [CCBV]
Number of bits set
cardinal [CCMultiSet.S]
Number of distinct elements
cardinal_left [CCMultiMap.BIDIR]
Number of distinct left keys
cardinal_right [CCMultiMap.BIDIR]
Number of distinct right keys
catch [CCResult]
catch e ~ok ~err calls either ok or err depending on the value of e.
catch [CCError]
catch e ~ok ~err calls either ok or err depending on the value of e.
char [CCParse]
char c parses the char c and nothing else
char [CCApp_parse]
char c parses c and c only
char [CCFormat.Dump]
char [CCFormat]
char [CCHash.HASH]
char [CCPrint]
char_ [CCHash]
char_equal [CCKMP.STRING]
char_if [CCParse]
char_if f parses a character c if f c = true
chars1_if [CCParse]
Same as CCParse.chars_if, but only non-empty strings
chars_if [CCParse]
chars_if f parses a string of chars that satisfy f
choice [CCApp_parse]
choice l chooses between the parsers, unambiguously
choice [CCOpt]
choice returns the first non-None element of the list, or None
choice_seq [CCOpt]
choice_seq s is similar to CCOpt.choice, but works on sequences.
choose [CCLinq]
Choose one element (if any, otherwise empty) in the collection.
choose [CCWBTree.S]
choose [CCHashTrie.S]
choose [CCHashconsedSet.S]
choose [CCIntMap]
choose [CCResult]
choose l selects a member of l that is a Ok _ value, or returns Error l otherwise, where l is the list of errors.
choose [CCRandom]
Choose a generator within the list.
choose [CCError]
choose l selects a member of l that is a `Ok _ value, or returns `Error l otherwise, where l is the list of errors.
choose_a [CCPool.Make.Fut]
Choose among those futures (the first to terminate).
choose_array [CCRandom]
choose_exn [CCWBTree.S]
choose_exn [CCHashTrie.S]
choose_exn [CCHashconsedSet.S]
choose_exn [CCIntMap]
choose_exn [CCRandom]
Same as CCRandom.choose but without option.
choose_l [CCPool.Make.Fut]
Choose among those futures (the first to terminate).
choose_return [CCRandom]
Choose among the list
chop_prefix [CCString]
chop_pref ~pre s removes pre from s if pre really is a prefix of s, returns None otherwise
chop_suffix [CCString]
chop_suffix ~suf s removes suf from s if suf really is a suffix of s, returns None otherwise
chunks [CCMonadIO.Seq]
Read the channel's content into chunks of size size
classify [CCFloat]
clear [CCHashSet.S]
clear s removes all elements from s
clear [CCRingBuffer.S]
Clear the content of the buffer.
clear [CCMixtbl]
Clear content of the hashtable
clear [CCBV]
Set every bit to 0
clear [CCDeque]
Remove all elements
clear [CCCache]
Clear the content of the cache
clear [CCList.Ref]
Remove all elements
clear [CCVector]
Clear the content of the vector
col [CCApp_parse.READER]
compare [CCSexp]
compare [CCBigstring]
Lexicographic order
compare [CCRAL]
Lexicographic comparison
compare [CCWBTree.ORD]
compare [CCHashconsedSet.ELT]
Total order
compare [CCHashconsedSet.S]
Fast (arbitrary) comparison test O(1)
compare [CCIntMap]
Total order between maps; the precise order is unspecified .
compare [CCMixmap.ORD]
compare [CCDeque]
compare a b compares lexicographically a and b
compare [CCTrie.ORDERED]
compare [CCTrie.WORD]
compare [CCMultiSet.S]
compare [CCMultiMap.OrderedType]
compare [CCMultiMap.S]
Total order on multimaps
compare [CCKList]
Lexicographic comparison.
compare [CCResult]
compare [CCChar]
compare [CCInt64]
compare [CCString]
compare [CCOrd]
Polymorphic "magic" comparison
compare [CCRef]
compare [CCArray.S]
compare [CCFloat]
compare [CCBool]
Total ordering on booleans, similar to Pervasives.compare
compare [CCInt]
compare [CCPair]
compare [CCOpt]
compare [CCList]
compare [CCError]
compare [CCVector]
Total ordering on vectors.
compare_char [CCLevenshtein.STRING]
compare_versions [CCString]
compare_versions a b compares version strings a and b, considering that numbers are above text.
compile [CCKMP.S]
Compile a string into a pattern
compose [CCBatch.S]
compose [CCFun]
Composition
compose_binop [CCFun]
compose_binop f g is fun x y -> g (f x) (f y) Example (partial order): List.sort (compose_binop fst CCInt.compare) [1, true; 2, false; 1, false]
concat_gen [CCString]
concat_gen ~sep g concatenates all strings of g, separated with sep.
cons [CCMonadIO.Seq]
cons [CCRAL]
Add an element at the front of the list
cons [CCFQueue]
Push element at the front of the queue
cons [CCLazy_list]
cons [CCKList]
cons [CCList]
cons x l is x::l
cons_maybe [CCList]
cons_maybe (Some x) l is x :: l cons_maybe None l is l
const [CCFun]
const x y = x for any y
contains [CCLinq]
contains [CCMultiSet.S]
contains a x = (count m x > 0)
convolution [CCArray1.Bool]
convolution a ~by:b ~into assumes length into = length a >= length b and computes the boolean convolution of a by b
copy [CCArray1]
Fresh copy
copy [CCBigstring]
Copy of the string
copy [CCBloom]
Copy of the filter
copy [CCHashSet.S]
Fresh copy
copy [CCPersistentArray]
copy a returns a fresh copy of a.
copy [CCRingBuffer.S]
Make a fresh copy of the buffer.
copy [CCRingBuffer.Array.S]
copy t makes a fresh copy of the array t
copy [CCMixtbl]
Copy of the table
copy [CCBV]
Copy of bitvector
copy [CCDeque]
Fresh copy, O(n) in time
copy [CCPersistentHashtbl.S]
Fresh copy of the table; the underlying structure is not shared anymore, so using both tables alternatively will be efficient
copy [CCString.Sub]
Make a copy of the substring
copy [CCArray.Sub]
Copy into a new array
copy [CCVector]
Shallow copy (may give an immutable or mutable vector)
copy_into [CCHashSet.S]
copy_into ~into s copies all elements of s into into
count [CCLinq]
count c returns a map from elements of c to the number of time those elements occur.
count [CCMultiSet.S]
count [CCMultiMap.S]
Number of bindings for this key
count' [CCLinq]
create [CCTimer]
A new timer.
create [CCBlockingQueue]
Create a new queue of size n.
create [CCThread.Barrier]
Create a barrier
create [CCSemaphore]
create n creates a semaphore with initial value n
create [CCLock]
Create a new protected value
create [CCBigstring]
Create a new bigstring of the given size.
create [CCParse.MemoTbl]
New memoization table
create [CCApp_parse.READER]
create [CCHet.Tbl]
create [CCHet.Key]
create [CCAllocCache.Arr]
create n makes a new cache of arrays up to length n
create [CCBloom]
create ?hash size creates a filter with given size, and functions.
create [CCHashTrie.Transient]
Create a new, active ID
create [CCHashSet.S]
create n makes a new set with the given capacity n
create [CCRingBuffer.S]
create ?bounded size creates a new buffer with given size.
create [CCMixtbl]
create n creates a hash table of initial size n.
create [CCBV]
Create a bitvector of given size, with given default value
create [CCDeque]
New deque
create [CCPersistentHashtbl.S]
Create a new hashtable, with the given initial capacity
create [CCFlatHashtbl.S]
Create a new table of the given initial capacity
create [CCHashtbl.COUNTER]
A counter maps elements to natural numbers (the number of times this element occurred)
create [CCHashtbl.DEFAULT]
create d makes a new table that maps every key to d by default.
create [CCRef]
Alias to ref
create [CCList.Ref]
Create a new list reference
create [CCVector]
Create a new, empty vector
create_default [CCBloom]
create_default ?hash_len size is the same as create ~hash:(default_hash_funs hash_len) size.
create_inj [CCMixmap]
Return a value that works for a given type of values.
create_inj [CCMixtbl]
Return a value that works for a given type of values.
create_with [CCHashtbl.DEFAULT]
Similar to create d but here d is a function called to obtain a new default value for each distinct key.
create_with [CCVector]
Create a new vector, using the given value as a filler.
curry [CCFun]
cut_depth [CCKTree]
Cut the tree at the given depth, so it becomes finite.
cycle [CCKList]
Cycle through the iterator infinitely.

D
debug_print [CCLevenshtein.S]
Output the automaton's structure on the given channel.
debug_print [CCLevenshtein]
decr [CCLock]
Atomically decrement the value
decr [CCHashtbl.COUNTER]
Remove one occurrence of the element
decr [CCHashtbl.S]
Same as CCHashtbl.S.incr but substract 1 (or the value of by).
decr [CCHashtbl]
Same as CCHashtbl.incr but substract 1 (or the value of by).
decr_then_get [CCLock]
decr_then_get x decrements x, and return its new value
default_hash_funs [CCBloom]
Use Hashtbl.seeded_hash on k seeds
delay [CCRandom]
Delay evaluation.
detach [CCThread]
detach f is the same as ignore (spawn f)
dfs [CCGraph.Traverse.Event]
Full version of DFS.
dfs [CCGraph.Traverse]
dfs [CCKTree]
Depth-first traversal of the tree
dfs_tag [CCGraph.Traverse.Event]
Full version of DFS using integer tags
dfs_tag [CCGraph.Traverse]
diagonal [CCList]
All pairs of distinct positions of the list.
diff [CCLinq]
Set difference
diff [CCHashSet.S]
diff a b returns a - b
diff [CCHashconsedSet.S]
diff [CCMultiSet.S]
MultiSet difference.
diff [CCMultiMap.S]
Difference of maps, ie bindings of the first that are not in the second
dijkstra [CCGraph.Traverse]
Dijkstra algorithm, traverses a graph in increasing distance order.
dijkstra_tag [CCGraph.Traverse]
distinct [CCLinq]
Remove duplicate elements from the input collection.
divisors_graph [CCGraph]
n points to all its strict divisors
dot_product [CCArray1.S]
dot_product a b returns sum_i a(i)*b(i) with the given sum and product, on elt.
doubleton [CCImmutArray]
doubleton [CCHashconsedSet.S]
doubleton [CCIntMap]
doubleton [CCFQueue]
drop [CCMonadIO.Seq]
drop [CCRAL]
drop [CCKList]
drop [CCString]
drop n s removes the n first chars of s
drop [CCList]
Drop the n first elements, keep the rest
drop_after [CCList.Zipper]
Drop every element on the "right" (calling CCList.Zipper.right then will do nothing), keeping the focused element, if any.
drop_after_and_focused [CCList.Zipper]
Drop every element on the "right" (calling CCList.Zipper.right then will do nothing), including the focused element if it is present.
drop_before [CCList.Zipper]
Drop every element on the "left" (calling CCList.Zipper.left then will do nothing).
drop_while [CCMonadIO.Seq]
drop_while [CCRAL]
drop_while [CCKList]
drop_while [CCList]
dummy [CCCache]
Dummy cache, never stores any value
dup [CCPair]
dup x = (x,x) (duplicate the value)
dup_map [CCPair]
dup_map f x = (x, f x).

E
edit_distance [CCLevenshtein.S]
Edition distance between two strings.
elements [CCHashSet.S]
List of elements
empty [CCMonadIO.Seq]
empty [CCLinq]
Empty collection
empty [CCCat.MONOID]
empty [CCBatch.COLLECTION]
empty [CCBigstring]
Empty string
empty [CCLevenshtein.S.Index]
Empty index
empty [CCHet.Map]
empty [CCImmutArray]
empty [CCRAL]
Empty list
empty [CCWBTree.S]
empty [CCHashTrie.S]
empty [CCBitField.S]
Empty bitfields (all bits 0)
empty [CCGraph.MAP]
empty [CCHashconsedSet.S]
empty [CCMixset]
Empty set
empty [CCIntMap]
empty [CCRingBuffer.Array.S]
The empty array
empty [CCMixmap.S]
Empty map
empty [CCBV]
Empty bitvector
empty [CCFQueue]
empty [CCPersistentHashtbl.S]
Empty table.
empty [CCTrie.S]
empty [CCMultiSet.S]
empty [CCMultiMap.BIDIR]
empty [CCMultiMap.S]
Empty multimap
empty [CCLazy_list]
Empty list
empty [CCKList]
empty [CCKTree]
empty [CCArray.S]
empty [CCList.Zipper]
Empty zipper
empty [CCList]
empty [CCHeap.S]
Empty heap
endline [CCParse]
Parses '\n'
ensure [CCVector]
Hint to the vector that it should have at least the given capacity.
ensure_with [CCVector]
Hint to the vector that it should have at least the given capacity.
eof [CCApp_parse]
Matches the end of input, fails otherwise
eoi [CCParse]
Expect the end of input, fails otherwise
eprintf [CCPrint]
epsilon [CCFloat]
equal [CCSexp]
equal [CCBigstring]
equal [CCHet.Key]
Compare two keys that have compatible types
equal [CCRAL]
equal [CCHashTrie.KEY]
equal [CCHashTrie.Transient]
Equality between IDs
equal [CCHashSet.ELEMENT]
equal [CCHashSet.S]
equal a b is extensional equality (a and b have the same elements)
equal [CCHashconsedSet.S]
Fast equality test O(1)
equal [CCIntMap]
equal ~eq a b checks whether a and b have the same set of pairs (key, value), comparing values with eq
equal [CCFQueue]
equal [CCDeque]
equal a b checks whether a and b contain the same sequence of elements.
equal [CCPersistentHashtbl.HashedType]
equal [CCPersistentHashtbl.S]
equal [CCFlatHashtbl.HASHABLE]
equal [CCMultiSet.S]
equal [CCMultiMap.S]
Same multimap
equal [CCKList]
Equality step by step.
equal [CCResult]
equal [CCChar]
equal [CCInt64]
equal [CCString]
equal [CCRef]
equal [CCArray.S]
equal [CCFloat]
equal [CCBool]
equal [CCInt]
equal [CCPair]
equal [CCOpt]
equal [CCList]
equal [CCError]
equal [CCVector]
equal_precision [CCFloat]
Equality with allowed error up to a non negative epsilon value
equiv [CCOrd]
Returns true iff the two comparison results are the same
errcode [CCUnix]
escape_str [CCUnix]
Escape a string so it can be a shell argument.
establish_server [CCUnix]
Listen on the address and calls the handler in a blocking fashion.
every [CCTimer]
every timer n ~f calls f () every n seconds.
except_idx [CCArray]
Remove given index, obtaining the list of the other elements
exists [CCMonadIO.File]
exists [CCLinq]
exists [CCArray1]
exists [CCImmutArray]
exists [CCHashSet.S]
exists [CCPersistentHashtbl.S]
exists [CCIO.File]
exists [CCString]
True for some char?
exists [CCArray.S]
exists [CCOpt]
exists [CCVector]
Existential test (is there an element that satisfies the predicate?)
exists2 [CCKList]
exists2 [CCString]
Exists a pair of chars?
exists2 [CCArray.S]
Exists on pairs of arrays.
extern [CCBatch.S]
Use a specific function that won't be optimized
extract_max [CCWBTree.S]
extract_max m returns k, v, m' where k,v is the pair with the highest key in m, and m' does not contain k.
extract_min [CCWBTree.S]
extract_min m returns k, v, m' where k,v is the pair with the smallest key in m, and m' does not contain k.

F
fail [CCMonadIO]
fail msg fails with the given message.
fail [CCPool.Make.Fut]
Future that fails immediately
fail [CCParse]
fail msg fails with the given message.
fail [CCApp_parse]
fail msg fails with the given error message
fail [CCResult]
Fail with an error
fail [CCError]
Fail with an error
fail_fprintf [CCResult]
fail_printf format uses format to obtain an error message and then returns Error msg
fail_printf [CCResult]
fail_printf format uses format to obtain an error message and then returns Error msg
fail_printf [CCError]
fail_printf format uses format to obtain an error message and then returns `Error msg
failf [CCApp_parse]
fair_app [CCKList]
Fair version of CCKList.(<*>)
fair_flat_map [CCKList]
Fair version of CCKList.flat_map.
field [CCSexp.Traverse]
Enriched version of CCSexp.Traverse.get_field, with a converter as argument
field_list [CCSexp.Traverse]
field_list name f "(... (name a b c d) ...record)" will look for a field based on the given name, and expect it to have a list of arguments dealt with by f (here, "a b c d").
fill [CCArray1]
fill a x fills a with x
fill [CCBigstring]
Fill with a single byte
filter [CCMonadIO.Seq]
filter [CCLinq]
Filter out values that do not satisfy predicate
filter [CCBatch.COLLECTION]
filter [CCBatch.S]
filter [CCArray1]
filter [CCApp_parse]
filter f p parses the same as p, but fails if the returned value does not satisfy f
filter [CCRAL]
filter [CCBV]
filter bv p only keeps the true bits of bv whose index satisfies p index
filter [CCPersistentHashtbl.S]
filter [CCLazy_list]
Filter values.
filter [CCKList]
filter [CCString]
filter [CCArray]
Filter elements out of the array.
filter [CCOpt]
Filter on 0 or 1 element
filter [CCList]
Safe version of List.filter
filter [CCHeap.S]
Filter values, only retaining the ones that satisfy the predicate.
filter [CCVector]
Filter elements from the vector.
filter' [CCVector]
Filter elements in place.
filter_map [CCMonadIO.Seq]
filter_map [CCLinq]
Filter and map elements at once
filter_map [CCBatch.COLLECTION]
filter_map [CCBatch.S]
filter_map [CCRAL]
filter_map [CCGraph.Seq]
filter_map [CCPersistentHashtbl.S]
filter_map [CCKList]
filter_map [CCString]
filter_map [CCArray]
Map each element into another value, or discard it
filter_map [CCList]
Map and remove elements at the same time
filter_map [CCVector]
Map elements with a function, possibly filtering some of them out
finally [CCFun]
finally h f calls f () and returns its result.
finally1 [CCFun]
finally1 ~h f x is the same as f x, but after the computation, h () is called whether f x rose an exception or not.
finally2 [CCFun]
finally2 ~h f x y is the same as f x y, but after the computation, h () is called whether f x y rose an exception or not.
find [CCLinq]
find [CCKMP.S]
find ~pattern s i finds the next occurrence of pattern in s starting at offset i, and returns it, or returns None if the pattern doesn't occur.
find [CCHet.Map]
find [CCHet.Tbl]
find [CCHashSet.S]
Safe version of CCHashSet.S.find_exn
find [CCIntMap]
find [CCMixmap.S]
Find the value for the given key, which must be of the right type.
find [CCMixtbl]
Find the value for the given key, which must be of the right type.
find [CCPersistentHashtbl.S]
Find the value for this key, or fails
find [CCFlatHashtbl.S]
find [CCTrie.S]
Find the value associated with the key, if any
find [CCMultiMap.S]
List of values for this key
find [CCKTree]
Look for an element that maps to Some _
find [CCString]
Find sub in string, returns its first index or -1.
find [CCArray.S]
find f a returns Some y if there is an element x such that f x = Some y, else it returns None
find [CCList]
find [CCVector]
Find an element that satisfies the predicate
find1_left [CCMultiMap.BIDIR]
like CCMultiMap.BIDIR.find_left but returns at most one value
find1_right [CCMultiMap.BIDIR]
like CCMultiMap.BIDIR.find_right but returns at most one value
find_all [CCKMP.S]
Generator on all occurrences of the pattern
find_all [CCString]
find_all ~sub s finds all occurrences of sub in s, even overlapping instances.
find_all' [CCKMP.S]
find_all_l [CCString]
find_all ~sub s finds all occurrences of sub in s and returns them in a list
find_exn [CCHet.Map]
find_exn [CCHet.Tbl]
find_exn [CCHashSet.S]
find_exn s x returns y if x and y are equal, and mem s y.
find_exn [CCIntMap]
Same as CCIntMap.find but unsafe
find_exn [CCFlatHashtbl.S]
find_exn [CCTrie.S]
Same as CCTrie.S.find but can fail.
find_exn [CCVector]
Find an element that satisfies the predicate, or
find_idx [CCArray.S]
find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds.
find_idx [CCList]
find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds.
find_iter [CCMultiMap.S]
Iterate on bindings for this key
find_left [CCMultiMap.BIDIR]
Find all bindings for this given left-key
find_map [CCLinq]
find_map [CCList]
find_map f l traverses l, applying f to each element.
find_map [CCVector]
find_map f v returns the first Some y = f x for x in v, or None if f x = None for each x in v
find_mapi [CCList]
Like CCList.find_map, but also pass the index to the predicate function.
find_min [CCHeap.S]
Find minimal element
find_min_exn [CCHeap.S]
Same as CCHeap.S.find_min but can fail
find_pred [CCList]
find_pred p l finds the first element of l that satisfies p, or returns None if no element satisfies p
find_pred_exn [CCList]
Unsafe version of CCList.find_pred
find_right [CCMultiMap.BIDIR]
Find all bindings for this given right-key
findi [CCArray.S]
Like CCArray.S.find, but also pass the index to the predicate function.
findi [CCList]
finish [CCHash]
Extract a usable hash value
first [CCBV]
First set bit, or
first [CCFQueue]
First element of the queue
first_exn [CCFQueue]
Same as CCFQueue.first but
fix [CCParse]
Fixpoint combinator
fix [CCApp_parse]
fix f makes a fixpoint
fix [CCRandom]
Recursion combinators, for building recursive values.
fix_memo [CCParse]
Same as CCParse.fix, but the fixpoint is memoized.
flat_map [CCMonadIO.Seq]
Map each value to a sub sequence of values
flat_map [CCLinq]
Same as CCLinq.flat_map but using sequences
flat_map [CCBatch.COLLECTION]
flat_map [CCBatch.S]
flat_map [CCPool.Make.Fut]
Monadic combination of futures
flat_map [CCRAL]
flat_map [CCPersistentArray]
Flat map (map + concatenation)
flat_map [CCLazy_list]
Monadic flatten + map
flat_map [CCKList]
flat_map [CCResult]
flat_map [CCString]
Map each chars to a string, then concatenates them all
flat_map [CCRandom]
flat_map [CCArray]
Transform each element into an array, then flatten
flat_map [CCOpt]
Flip version of >>=
flat_map [CCList]
Map and flatten at the same time (safe).
flat_map [CCError]
flat_map [CCVector]
Map each element to a sub-vector
flat_map' [CCVector]
flat_map_l [CCLinq]
map each element to a collection and flatten the result
flat_map_list [CCVector]
Like CCVector.flat_map, but using list for intermediate collections.
flat_map_seq [CCVector]
Like CCVector.flat_map, but using CCVector.sequence for intermediate collections.
flatten [CCLinq.PMap]
View a multimap as a collection of individual key/value pairs
flatten [CCLinq]
flatten [CCRAL]
flatten [CCPersistentArray]
Concatenates all the sub-arrays
flatten [CCKList]
flatten [CCList]
Safe flatten
flatten_l [CCLinq.PMap]
View a multimap as a list of individual key/value pairs
flatten_opt [CCLinq]
Flatten the collection by removing options
flatten_seq [CCLinq]
flip [CCBV]
Flip i-th bit
flip [CCFun]
Flip arguments
float [CCApp_parse]
Parse a floating point number
float [CCFormat.Dump]
float [CCFormat]
float [CCRandom]
Random float within the given range
float [CCPrint]
float3 [CCFormat]
float3 [CCPrint]
float_ [CCOrd]
float_of_yojson [CCArray1]
float_range [CCRandom]
Inclusive range.
float_to_yojson [CCArray1]
flush [CCMonadIO]
fmap [CCKList]
focused [CCList.Zipper]
Returns the focused element, if any.
focused_exn [CCList.Zipper]
Returns the focused element, or
fold [CCMonadIO.Seq]
fold f acc seq folds over seq, consuming it.
fold [CCLinq.PMap]
Fold on the items of the map
fold [CCLinq]
Fold over the collection
fold [CCBatch.COLLECTION]
fold [CCBigstring]
fold [CCLevenshtein.S.Index]
Fold over the stored pairs string/value
fold [CCImmutArray]
fold [CCRAL]
Fold on the list's elements
fold [CCWBTree.S]
fold [CCHashTrie.S]
fold [CCHashSet.S]
Fold on values
fold [CCGraph.Seq]
fold [CCHashconsedSet.S]
Fold on elements, in arbitrary order
fold [CCIntMap]
fold [CCFQueue]
fold [CCDeque]
Fold on elements
fold [CCPersistentHashtbl.S]
Fold over bindings
fold [CCTrie.S]
Fold on key/value bindings.
fold [CCMultiSet.S]
fold [CCMultiMap.BIDIR]
Fold on pairs
fold [CCMultiMap.S]
Fold on all key/value
fold [CCKList]
Fold on values
fold [CCKTree]
Fold on values in no specified order.
fold [CCResult]
fold ~ok ~error e opens e and, if e = Ok x, returns ok x, otherwise e = Error s and it returns error s.
fold [CCString.S]
Fold on chars by increasing index.
fold [CCArray.S]
fold [CCPair]
Synonym to CCPair.merge
fold [CCOpt]
Fold on 0 or 1 element
fold [CCHeap.S]
Fold on all values
fold [CCError]
fold ~success ~failure e opens e and, if e = `Ok x, returns success x, otherwise e = `Error s and it returns failure s.
fold [CCVector]
Fold on elements of the vector
fold2 [CCKList]
Fold on two collections at once.
fold2 [CCString]
Fold on pairs of chars
fold2 [CCArray.S]
Fold on two arrays stepwise.
fold_filter_map [CCList]
fold_filter_map f acc l is a fold_left-like function, but also generates a list of output in a way similar to CCList.filter_map
fold_flat_map [CCList]
fold_flat_map f acc l is a fold_left-like function, but it also maps the list to a list of lists that is then flatten'd..
fold_keys [CCMixmap.S]
Fold over the keys
fold_keys [CCMixtbl]
Fold over the keys
fold_l [CCResult]
fold_l [CCError]
fold_left [CCPersistentArray]
fold_m [CCCat.TRAVERSE]
fold_m [CCKList.Traverse]
fold_m [CCResult.Traverse]
fold_m [CCList.Traverse]
fold_m [CCError.Traverse]
fold_map [CCList]
fold_map f acc l is a fold_left-like function, but it also maps the list to another list.
fold_map2 [CCList]
fold_map2 is to fold_map what List.map2 is to List.map.
fold_multimap [CCLinq.PMap]
Fold on the items of the multimap
fold_product [CCList]
Fold on the cartesian product
fold_pure [CCMonadIO.Seq]
fold f acc seq folds over seq, consuming it.
fold_rev [CCRAL]
Fold on the list's elements, in reverse order (starting from the tail)
fold_right [CCPersistentArray]
Fold on the elements of the array.
fold_right [CCList]
Safe version of fold_right
fold_seq [CCResult]
fold_seq [CCError]
fold_v [CCGraph.LazyTree]
fold_values [CCTrie.S]
More efficient version of CCTrie.S.fold, that doesn't keep keys
fold_while [CCArray.S]
Fold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator
fold_while [CCList]
Fold until a stop condition via ('a, `Stop) is indicated by the accumulator
foldi [CCArray1.View]
Fold on values with their index
foldi [CCArray1]
foldi [CCImmutArray]
foldi [CCArray.S]
Fold left on array, with index
foldi [CCList.Idx]
Fold on list, with index
for_all [CCLinq]
for_all [CCArray1]
for_all [CCImmutArray]
for_all [CCHashSet.S]
for_all [CCPersistentHashtbl.S]
for_all [CCString]
True for all chars?
for_all [CCArray.S]
for_all [CCOpt]
for_all [CCVector]
Universal test (do all the elements satisfy the predicate?)
for_all2 [CCKList]
for_all2 [CCString]
All pairs of chars respect the predicate?
for_all2 [CCArray.S]
Forall on pairs of arrays.
force [CCKTree]
force t evaluates t completely and returns a regular tree structure
fprintf [CCFormat]
Alias to Format.fprintf
fprintf [CCPrint.MakeIO]
Fprintf on a monadic output
fprintf [CCPrint]
Print on a channel
fprintf_dyn_color [CCFormat]
Similar to CCFormat.fprintf but enable/disable colors depending on colors
free [CCAllocCache.Arr]
Return array to the cache.
freeze [CCHashTrie.Transient]
freeze i makes i unusable for new modifications.
freeze [CCBitField.S]
Prevent new fields from being added.
freeze [CCVector]
Make an immutable vector (no copy! Don't use the old version)
freeze_copy [CCVector]
Copy the vector into an immutable version
front [CCRAL]
Remove and return the first element of the list
front_exn [CCRAL]
Unsafe version of CCRAL.front.
frozen [CCHashTrie.Transient]
frozen i returns true if freeze i was called before.
fsign [CCFloat]
fsign x is one of -1., -0., +0., +1., or nan if x is NaN.
fst [CCLinq]
full [CCString.Sub]
Full string
full [CCArray.Sub]
Slice that covers the full array

G
gen [CCString.Split]
gen [CCHash.S]
gen [CCHash]
gen_cpy [CCString.Split]
general_iter [CCMonadIO.Seq]
general_iter f acc seq performs a filter_map over seq, using f.
generic [CCGraph.Traverse]
Traversal of the given graph, starting from a sequence of vertices, using the given bag to choose the next vertex to explore.
generic_tag [CCGraph.Traverse]
One-shot traversal of the graph using a tag set and the given bag
get [CCLinq.PMap]
get [CCSemaphore]
Current value
get [CCLock.LockRef]
get [CCLock]
Get the value in the lock.
get [CCPool.Make.Fut]
Blocking get: wait for the future to be evaluated, and get the value, or the exception that failed the future is returned.
get [CCArray1.View]
get v i returns the i-th element of v.
get [CCArray1.Bool]
get [CCArray1]
Get n-th element
get [CCBigstring]
get [CCLevenshtein.STRING]
get [CCKMP.STRING]
get [CCImmutArray]
Access the element
get [CCRAL]
get l i accesses the i-th element of the list.
get [CCWBTree.S]
get [CCHashTrie.S]
get [CCBitField.S.FIELD]
get [CCMixset]
get ~key set obtains the value for key in set, if any.
get [CCPersistentArray]
get a i returns the element with index i from the array a.
get [CCRingBuffer.Array.S]
get t i gets the element at position i
get [CCMixmap.S]
Get the value corresponding to this key, if it exists and belongs to the same key
get [CCMixtbl]
Get the value corresponding to this key, if it exists and belongs to the same key
get [CCBV]
Is the i-th bit true? Returns false if the index is too high
get [CCPersistentHashtbl.S]
Safe version of !
get [CCFlatHashtbl.S]
get k tbl recovers the value for k in tbl, or returns None if k doesn't belong
get [CCMap.S]
Safe version of find
get [CCHashtbl.COUNTER]
Number of occurrences for this element
get [CCHashtbl.DEFAULT]
Unfailing retrieval (possibly returns the default value).
get [CCHashtbl.S]
Safe version of Hashtbl.find
get [CCHashtbl]
Safe version of Hashtbl.find
get [CCArray.MONO_ARRAY]
get [CCArray.S]
get [CCOpt]
get default x unwraps x, but if x = None it returns default instead.
get [CCList.Assoc]
Find the element
get [CCList.Idx]
get [CCVector]
Access element by its index, or
get_back [CCRingBuffer.S]
get_back buf i returns the i-th element of buf from the back, ie the one returned by take_back buf after i-1 calls to junk_back buf.
get_edge [CCGraph.Traverse.Event]
get_edge_kind [CCGraph.Traverse.Event]
get_enter [CCGraph.Traverse.Event]
get_exit [CCGraph.Traverse.Event]
get_exn [CCSexp.Traverse]
Unwrap an option, possibly failing.
get_exn [CCRAL]
Unsafe version of CCRAL.get
get_exn [CCWBTree.S]
get_exn [CCHashTrie.S]
get_exn [CCMixset]
Same as CCMixset.get, but can fail
get_exn [CCPersistentHashtbl.S]
Synonym to CCPersistentHashtbl.S.find with flipped arguments
get_exn [CCFlatHashtbl.S]
get_exn [CCResult]
Extract the value x from Ok x, fails otherwise.
get_exn [CCOpt]
Open the option, possibly failing if it is None
get_exn [CCList.Assoc]
Same as get
get_exn [CCList.Idx]
Get the i-th element, or
get_exn [CCError]
Extract the value x from `Ok x, fails otherwise.
get_field [CCSexp.Traverse]
get_field name e, when e = List [(n1,x1); (n2,x2) ... ], extracts the xi such that name = ni, if it can find it.
get_front [CCRingBuffer.S]
get_front buf i returns the i-th element of buf from the front, ie the one returned by take_front buf after i-1 calls to junk_front buf.
get_lazy [CCOpt]
get_lazy default_fn x unwraps x, but if x = None it returns default_fn () instead.
get_or [CCResult]
get_or e ~default returns x if e = Ok x, default otherwise
get_or [CCMap.S]
get_or k m ~or_ returns the value associated to k if present, and returns or_ otherwise (if k doesn't belong in m)
get_or [CCHashtbl.S]
get_or tbl k ~or_ returns the value associated to k if present, and returns or_ otherwise (if k doesn't belong in tbl)
get_or [CCHashtbl]
get_or tbl k ~or_ returns the value associated to k if present, and returns or_ otherwise (if k doesn't belong in tbl)
get_or [CCOpt]
get_or ~default o extracts the value from o, or returns default if o = None.
get_safe [CCArray.S]
get_safe a i returns Some a.(i) if i is a valid index
get_seq [CCLinq.PMap]
Select a key from a map and wrap into sequence
get_then_clear [CCLock]
get_then_clear b sets b to false, and return the old value
get_then_decr [CCLock]
get_then_decr x decrements x, and return its previous value
get_then_incr [CCLock]
get_then_incr x increments x, and return its previous value
get_then_incr [CCRef]
get_then_incr r increments r and returns its old value, think r++
get_then_set [CCLock]
get_then_set b sets b to true, and return the old value
get_variant [CCSexp.Traverse]
get_variant l e checks whether e = List (Atom s :: args), and if some pair of l is s, f.
get_vertex [CCGraph.Traverse.Event]
group [CCKList]
group eq l groups together consecutive elements that satisfy eq.
group_by [CCLinq]
group_by f takes a collection c as input, and returns a multimap m such that for each x in c, x occurs in m under the key f x.
group_by' [CCLinq]
group_join [CCLinq]
group_join key2 associates to every element x of the first collection, all the elements y of the second collection such that eq x (key y)
group_succ [CCList]
group_succ ~eq l groups together consecutive elements that are equal according to eq
guard [CCResult]
guard f runs f () and returns its result wrapped in Ok.
guard [CCError]
guard f runs f () and returns its result wrapped in `Ok.
guard_str [CCResult]
Same as CCResult.guard but uses CCResult.of_exn to print the exception.
guard_str [CCError]
Same as CCError.guard but uses CCError.of_exn to print the exception.
guard_str_trace [CCResult]
Same as CCResult.guard_str but uses CCResult.of_exn_trace instead of CCResult.of_exn so that the stack trace is printed.
guard_str_trace [CCError]
Same as CCError.guard_str but uses CCError.of_exn_trace instead of CCError.of_exn so that the stack trace is printed.

H
hash [CCSexp]
hash [CCHashTrie.KEY]
hash [CCHashSet.ELEMENT]
Positive value
hash [CCHashconsedSet.ELT]
Deterministic
hash [CCHashconsedSet.S]
Fast (arbitrary, deterministic) hash O(1)
hash [CCPersistentHashtbl.HashedType]
hash [CCFlatHashtbl.HASHABLE]
hash [CCInt64]
hash [CCString]
hash [CCFloat]
hash [CCInt]
hbox [CCFormat]
Wrap the printer in an horizontal box
hd [CCRAL]
First element of the list, or
hd_tl [CCList]
hd_tl (x :: l) returns hd, l.
head [CCLazy_list]
Evaluate head, return it, or None if the list is empty
head [CCKList]
Head of the list
head_exn [CCKList]
Unsafe version of CCKList.head
head_opt [CCList]
First element.
height [CCKTree]
Length of the longest path to empty leaves
hovbox [CCFormat]
Wrap the printer in a horizontal or vertical box
hvbox [CCFormat]
Wrap the printer in a horizontal/vertical box

I
id [CCBatch.S]
id [CCFun]
Identity function
if_ [CCHash.S]
Decide which hash function to use depending on the boolean
if_ [CCHash]
Decide which hash function to use depending on the boolean
if_ [CCOpt]
if_ f x is Some x if f x, None otherwise
incr [CCLock]
Atomically increment the value
incr [CCHashtbl.COUNTER]
Increment the counter for the given element
incr [CCHashtbl.S]
incr ?by tbl x increments or initializes the counter associated with x.
incr [CCHashtbl]
incr ?by tbl x increments or initializes the counter associated with x.
incr_by [CCHashtbl.COUNTER]
Add or remove several occurrences at once.
incr_then_get [CCLock]
incr_then_get x increments x, and return its new value
incr_then_get [CCRef]
incr_then_get r increments r and returns its new value, think ++ r
init [CCArray1]
Initialize with given size and initialization function
init [CCBigstring]
Initialize with the given function (called at every index)
init [CCImmutArray]
init n f makes the array [| f 0; f 1; ... ; f (n-1) |].
init [CCPersistentArray]
make n f returns a persistent array of length n, with element i initialized to the result of f i.
init [CCFQueue]
Queue deprived of its last element.
init [CCString]
Analog to Array.init.
init [CCHash]
Initial value
init [CCList]
Similar to Array.init
init [CCVector]
Init the vector with the given function and size
inj [CCCat.FREE_MONAD]
input_of_chan [CCParse]
input_of_chan ic reads lazily the content of ic as parsing goes.
input_of_string [CCParse]
Parse the string
insert [CCHashSet.S]
insert s x adds x into s
insert [CCList.Zipper]
Insert an element at the current position.
insert [CCList.Idx]
Insert at i-th position, between the two existing elements.
insert [CCHeap.S]
Insert a value in the heap
int [CCParse.U]
int [CCApp_parse]
Parse an integer
int [CCBitField.S]
New field for width bits.
int [CCFormat.Dump]
int [CCFormat]
int [CCRandom]
int [CCHash.HASH]
int [CCPrint]
int2 [CCBitField.S]
New field of type 2-bits int (same as int ~width:2)
int3 [CCBitField.S]
New field of type 3-bits int (same as int ~width:3)
int32 [CCFormat.Dump]
int32 [CCFormat]
int32 [CCHash.HASH]
int32_ [CCHash]
int64 [CCFormat.Dump]
int64 [CCFormat]
int64 [CCHash.HASH]
int64_ [CCHash]
int_ [CCOrd]
int_ [CCHash]
int_of_yojson [CCArray1]
int_range [CCRandom]
Inclusive range
int_to_yojson [CCArray1]
inter [CCLinq]
Intersection of two collections.
inter [CCBloom]
The sets MUST have the same set of hash functions
inter [CCHashSet.S]
inter a b returns a ∩ b
inter [CCHashconsedSet.S]
inter [CCIntMap]
inter [CCBV]
inter bv1 bv2 returns the intersection of the two sets
inter [CCMultiMap.S]
Intersection of multimaps
inter [CCList.Set]
List intersection.
inter_into [CCBV]
inter ~into bv sets into to the intersection of itself and bv
inter_mut [CCBloom]
inter_mut ~into f changes into into the intersection of into and f into and f MUST have the same set of hash functions
inter_mut [CCHashSet.S]
inter_mut ~into a changes into into a ∩ into
interleave [CCKList]
Fair interleaving of both streams.
intersection [CCMultiSet.S]
intersection a b is a multiset such that count (intersection a b) x = min (count a x) (count b x)
is_alpha [CCParse]
Is the char a letter?
is_alpha_num [CCParse]
is_dag [CCGraph]
is_dag ~graph vs returns true if the subset of graph reachable from vs is acyclic.
is_directory [CCMonadIO.File]
is_directory [CCIO.File]
is_done [CCPool.Make.Fut]
Is the future evaluated (success/failure)?
is_empty [CCLinq]
is_empty [CCLevenshtein.S.Index]
is_empty [CCRAL]
Check whether the list is empty
is_empty [CCWBTree.S]
is_empty [CCHashTrie.S]
is_empty [CCRingBuffer.S]
Is the buffer empty (i.e.
is_empty [CCBV]
Any bit set?
is_empty [CCFQueue]
is_empty [CCDeque]
Is the deque empty?
is_empty [CCPersistentHashtbl.S]
Is the table empty?
is_empty [CCTrie.S]
is_empty [CCMultiSet.S]
is_empty [CCMultiMap.BIDIR]
is_empty [CCMultiMap.S]
Empty multimap?
is_empty [CCLazy_list]
Evaluates the head
is_empty [CCKList]
is_empty [CCKTree]
is_empty [CCList.Zipper]
Empty zipper? Returns true iff the two lists are empty.
is_empty [CCList]
is_empty l returns true iff l = []
is_empty [CCHeap.S]
Is the heap empty?
is_empty [CCVector]
Is the vector empty?
is_focused [CCList.Zipper]
Is the zipper focused on some element? That is, will CCList.Zipper.focused return a Some v?
is_nan [CCFloat]
is_none [CCOpt]
is_num [CCParse]
Is the char a digit?
is_some [CCOpt]
is_sorted [CCList]
is_sorted l returns true iff l is sorted (according to given order)
is_space [CCParse]
True on ' ' and '\t'
is_sub [CCString]
is_sub ~sub i s j ~len returns true iff the substring of sub starting at position i and of length len is a substring of s starting at position j
is_white [CCParse]
True on ' ' and '\t' and '\n'
iter [CCMonadIO.Seq]
Iterate on the stream, with an action for each element
iter [CCLinq.PMap]
View a multimap as a proper collection
iter [CCArray1]
iter a ~f calls f v where get a i = v for each i < length a.
iter [CCBigstring]
iter [CCLevenshtein.S.Index]
Iterate on the pairs
iter [CCHet.Map]
iter [CCHet.Tbl]
iter [CCImmutArray]
iter [CCRAL]
Iterate on the list's elements
iter [CCWBTree.S]
iter [CCHashTrie.S]
iter [CCHashSet.S]
Iterate on values
iter [CCGraph.Seq]
iter [CCHashconsedSet.S]
Iterate on elements, in no particular order
iter [CCPersistentArray]
iter [CCIntMap]
iter [CCRingBuffer.S]
iter b ~f calls f i t for each element t in buf
iter [CCRingBuffer.Array.S]
iter f t iterates over the array t invoking f with the current element, in array order
iter [CCBV]
Iterate on all bits
iter [CCFQueue]
iter [CCDeque]
Iterate on elements
iter [CCPersistentHashtbl.S]
Iterate over bindings
iter [CCCache]
Iterate on cached values.
iter [CCTrie.S]
Same as CCTrie.S.fold, but for effectful functions
iter [CCMultiSet.S]
iter [CCMultiMap.S]
Iterate on all key/value
iter [CCKList]
iter [CCKTree]
iter [CCResult]
Apply the function only in case of Ok
iter [CCString]
Alias to String.iter
iter [CCRef]
Call the function on the content of the reference
iter [CCArray.S]
iter [CCPair]
iter [CCOpt]
Iterate on 0 or 1 element
iter [CCHeap.S]
Iterate on elements
iter [CCError]
Apply the function only in case of `Ok
iter [CCVector]
Iterate on the vector's content
iter2 [CCKList]
Iterate on two collections at once.
iter2 [CCString]
Iterate on pairs of chars
iter2 [CCArray.S]
Iterate on two arrays stepwise.
iter_fields [CCBitField.S]
Iterate on all currently present fields
iter_keys [CCMixmap.S]
Iterate on the keys of this map
iter_keys [CCMixtbl]
Iterate on the keys of this table
iter_ones [CCArray1.Bool]
iter_ones ~f a calls f i for every index i such that get a i = true
iter_true [CCBV]
Iterate on bits set to 1
iter_values [CCTrie.S]
iter_zeroes [CCArray1.Bool]
iter_ones ~f a calls f i for every index i such that get a i = false
iteri [CCArray1.View]
iteri ~f v iterates on elements of v with their index
iteri [CCArray1]
iteri a ~f calls f i v where get a i = v for each i < length a.
iteri [CCImmutArray]
iteri [CCRAL]
iteri [CCPersistentArray]
iter f t applies function f to all elements of the persistent array, in order from element 0 to element length t - 1.
iteri [CCRingBuffer.S]
iteri b ~f calls f i t for each element t in buf, with i being its relative index within buf.
iteri [CCKList]
Iterate with index (starts at 0)
iteri [CCString]
Iter on chars with their index
iteri [CCArray.S]
iteri [CCList.Idx]
iteri [CCVector]
Iterate on the vector, with indexes
iteri2 [CCString]
Iterate on pairs of chars with their index

J
join [CCLinq.IO]
join [CCLinq]
join key1 key2 ~merge is a binary operation that takes two collections a and b, projects their elements resp.
join [CCThread.Arr]
A.join a joins every thread in a
join [CCResult]
join t, in case of success, returns Ok o from Ok (Ok o).
join [CCError]
join t, in case of success, returns `Ok o from `Ok (`Ok o).
junk [CCApp_parse.READER]
junk [CCApp_parse]
Skip next char
junk_back [CCRingBuffer.S]
Drop the back element from t.
junk_front [CCRingBuffer.S]
Drop the front element from t.

K
keys [CCIntMap]
keys [CCFlatHashtbl.S]
keys [CCMultiMap.S]
keys [CCMap.S]
Iterate on keys only
keys [CCHashtbl.S]
Iterate on keys (similar order as Hashtbl.iter)
keys [CCHashtbl]
Iterate on keys (similar order as Hashtbl.iter)
keys_list [CCHashtbl.S]
keys t is the list of keys in t.
keys_list [CCHashtbl]
keys_list t is the list of keys in t.
keys_seq [CCMixmap.S]
All the keys
keys_seq [CCMixtbl]
All the keys
kind [CCBitField.S.FIELD]
klist [CCString.Split]
klist [CCHash.S]
klist [CCHash]
klist_cpy [CCString.Split]
klist_to_list [CCLevenshtein]
Helper for short lists.
ksprintf [CCFormat]
ksprintf fmt ~f formats using fmt, in a way similar to CCFormat.sprintf, and then calls f on the resulting string.

L
last [CCFQueue]
Last element of the queue
last [CCList]
last n l takes the last n elements of l (or less if l doesn't have that many elements
last_exn [CCFQueue]
last_opt [CCList]
Last element.
lazy_ [CCLinq]
left [CCString.Split]
Split on the first occurrence of by from the leftmost part of the string
left [CCList.Zipper]
Go to the left, or do nothing if the zipper is already at leftmost pos
left_exn [CCString.Split]
Split on the first occurrence of by from the leftmost part of the string
left_exn [CCList.Zipper]
Go to the left, or
length [CCMonadIO.Seq]
Length of the stream
length [CCArray1.View]
length v is the number of elements of v
length [CCArray1]
Number of elements
length [CCBigstring]
Alias for size.
length [CCLevenshtein.STRING]
length [CCKMP.STRING]
length [CCHet.Map]
length [CCHet.Tbl]
length [CCImmutArray]
length [CCRAL]
Number of elements.
length [CCPersistentArray]
Returns the length of the persistent array.
length [CCRingBuffer.S]
Number of elements currently stored in the buffer.
length [CCRingBuffer.Array.S]
length t gets the total number of elements currently in t
length [CCMixtbl]
Number of bindings
length [CCBV]
Length of underlying array
length [CCDeque]
Number of elements used to be linear time, now constant time
length [CCPersistentHashtbl.S]
Number of bindings
length [CCLazy_list]
length l returns the number of elements in l, eagerly (linear time).
length [CCKList]
Number of elements in the list.
length [CCHashtbl.COUNTER]
Number of distinct elements
length [CCString.S]
length [CCArray.MONO_ARRAY]
length [CCArray.S]
length [CCVector]
Synonym for CCVector.size
leq [CCHeap.PARTIAL_ORD]
leq x y shall return true iff x is lower or equal to y
lexicographic [CCFun]
Lexicographic combination of comparison functions
lift [CCMonadIO]
Synonym to CCMonadIO.map
lift [CCCat.MONAD_TRANSFORMER]
lift [CCList.Ref]
Apply a list function to the content
lift2 [CCMonadIO]
lift3 [CCMonadIO]
line [CCApp_parse.READER]
linear [CCCache]
Linear cache with the given size.
lines [CCMonadIO.Seq]
Lines of an input channel
lines [CCLinq.IO]
Convert a string into a collection of lines
lines [CCString]
lines s returns a list of the lines of s (splits along '\n')
lines' [CCLinq.IO]
Convert a string into a list of lines
lines_gen [CCString]
lines_gen s returns a generator of the lines of s (splits along '\n')
list [CCParse.U]
list p parses a list of p, with the OCaml conventions for start token "", stop token "" and separator ";".
list [CCFormat.Dump]
list [CCFormat]
list [CCHash.S]
list [CCPrint]
list_ [CCString.Split]
Eplit the given string along the given separator by.
list_ [CCOrd]
Lexicographic combination on lists
list_ [CCHash]
Hash a list.
list_all [CCSexp.Traverse]
list_all f (List l) returns the list of all y such that x in l and f x = Some y
list_any [CCSexp.Traverse]
list_any f (List l) tries f x for every element x in List l, and returns the first non-None result (if any).
list_cpy [CCString.Split]
list_seq [CCRandom]
Build random lists from lists of random generators
lnot [CCInt64]
load [CCBloom]
Ratio of 1 bits in the underlying array.
longest_prefix [CCTrie.S]
longest_prefix k m finds the longest prefix of k that leads to at least one path in m (it does not mean that the prefix is bound to a value.
lookup [CCArray.S]
Lookup the index of some value in a sorted array.
lookup_exn [CCArray.S]
Same as CCArray.S.lookup_exn, but
lowercase_ascii [CCChar]
See Char
lowercase_ascii [CCString]
See String.
lru [CCCache]
LRU cache of the given size ("Least Recently Used": keys that have not been used recently are deleted first).

M
make [CCSexpM.MakeDecode]
Make a decoder with the given function used to refill an internal buffer.
make [CCMonadIO.File]
Build a file representation from a path (absolute or relative)
make [CCPool.Make.Fut]
Create a future, representing a value that will be computed by the function.
make [CCArray1]
New array with undefined elements
make [CCImmutArray]
make n x makes an array of n times x
make [CCAllocCache.Arr]
make cache i x is like Array.make i x, but might return a cached array instead of allocating one.
make [CCRAL]
make [CCGraph]
Make a graph by providing its fields
make [CCPersistentArray]
make n x returns a persistent array of length n, with x.
make [CCRingBuffer.Array.S]
make s e makes an array of size s with e elements
make [CCKTree.Dot]
make [CCIO.File]
Build a file representation from a path (absolute or relative)
make [CCString.Sub]
make [CCArray.Sub]
Create a slice.
make [CCPair]
Make a tuple from its components
make [CCList.Zipper]
Create a zipper pointing at the first element of the list
make [CCVector]
make n x makes a vector of size n, filled with x
make1 [CCPool.Make.Fut]
make2 [CCPool.Make.Fut]
make_char [CCArray1]
make_complex32 [CCArray1]
make_complex64 [CCArray1]
make_float32 [CCArray1]
make_float64 [CCArray1]
make_int [CCArray1]
make_int16s [CCArray1]
make_int16u [CCArray1]
make_int32 [CCArray1]
make_int64 [CCArray1]
make_int8s [CCArray1]
make_int8u [CCArray1]
make_labelled_tuple [CCGraph]
Make a graph with edges being triples (origin,label,dest)
make_native [CCArray1]
make_tuple [CCGraph]
Make a graph with edges being pairs (origin,dest)
many [CCParse]
many p parses a list of p, eagerly (as long as possible)
many [CCApp_parse]
0 or more parsed elements of the given type.
many1 [CCParse]
parses a non empty list
many1 [CCApp_parse]
Same as CCApp_parse.many, but needs at least one element
map [CCMonadIO.Seq]
Map values with actions
map [CCMonadIO]
Map values
map [CCLinq.PMap]
Transform values
map [CCLinq]
Map each value
map [CCCat.FUNCTOR]
map [CCBatch.COLLECTION]
map [CCBatch.S]
map [CCPool.Make.Fut]
Maps the value inside the future.
map [CCArray1.View]
Map values
map [CCArray1]
map [CCParse.U]
map [CCApp_parse]
Map the parsed value
map [CCImmutArray]
map [CCRAL]
Map on elements
map [CCWBTree.S]
Map values, giving only the value.
map [CCGraph.Seq]
map [CCPersistentArray]
map [CCIntMap]
map [CCFQueue]
Map values
map [CCPersistentHashtbl.S]
Map all values
map [CCTrie.S]
Map values, giving only the value.
map [CCLazy_list]
Lazy map
map [CCKList]
map [CCKTree]
map [CCResult]
Map on success
map [CCFormat]
map [CCString]
Map chars
map [CCRandom]
map [CCOrd]
map f ord is the comparison function that, given objects x and y, projects x and y using f (e.g.
map [CCRef]
Transform the value
map [CCArray]
map [CCPair]
map [CCOpt]
Transform the element inside, if any
map [CCList]
Safe version of map
map [CCError]
Map on success
map [CCPrint]
map [CCVector]
Map elements of the vector, yielding a new vector
map1 [CCLinq]
map1 [CCPair]
map2 [CCLinq]
map2 [CCArray1.View]
Map values
map2 [CCArray1]
map2 [CCParse.U]
map2 [CCKList]
Map on two collections at once.
map2 [CCResult]
Same as CCResult.map, but also with a function that can transform the error message in case of failure
map2 [CCString]
Map pairs of chars
map2 [CCArray]
Map on two arrays stepwise.
map2 [CCPair]
map2 [CCOpt]
map2 [CCError]
Same as CCError.map, but also with a function that can transform the error message in case of failure
map3 [CCParse.U]
map_a [CCPool.Make.Fut]
map_l f a maps f on every element of a, and will return the array of every result if all calls succeed, or an error otherwise.
map_async [CCPool.Make.Fut]
Maps the value inside the future, to be computed in a separated job.
map_err [CCResult]
Map on the error variant
map_err [CCError]
Map on error.
map_file_descr [CCBigstring]
map_file_descr descr len is a lower-level access to an underlying file descriptor.
map_fst [CCPair]
Compose the given function with fst.
map_l [CCPool.Make.Fut]
map_l f l maps f on every element of l, and will return the list of every result if all calls succeed, or an error otherwise.
map_l [CCResult]
map_l [CCError]
map_list [CCHashtbl.S]
Map on a hashtable's items, collect into a list
map_list [CCHashtbl]
Map on a hashtable's items, collect into a list
map_m [CCCat.TRAVERSE]
map_m [CCKList.Traverse]
map_m [CCResult.Traverse]
map_m [CCList.Traverse]
map_m [CCError.Traverse]
map_m_par [CCList.Traverse]
Same as map_m but map_m_par f (x::l) evaluates f x and f l "in parallel" before combining their result (for instance in Lwt).
map_opt [CCSexp.Traverse]
Map over a list, failing as soon as the function fails on any element
map_or [CCResult]
map_or f e ~default returns f x if e = Ok x, default otherwise
map_or [CCOpt]
map_or ~default f o is f x if o = Some x, default otherwise
map_pure [CCMonadIO.Seq]
Map values with a pure function
map_same [CCPair]
map_snd [CCPair]
Compose the given function with snd.
map_v [CCGraph.LazyTree]
mapi [CCImmutArray]
mapi [CCRAL]
Map with index
mapi [CCWBTree.S]
Map values, giving both key and value.
mapi [CCPersistentArray]
Applies the given function to all elements of the array, and returns a persistent array initialized by the results of f.
mapi [CCIntMap]
mapi [CCTrie.S]
Map values, giving both key and value.
mapi [CCKList]
Map with index (starts at 0)
mapi [CCString]
Map chars with their index
mapi [CCList.Idx]
match_with [CCLevenshtein.S]
match_with a s matches the string s against a, and returns true if the distance from s to the word represented by a is smaller than the limit used to build a
max [CCLinq]
max [CCMultiSet.S]
Maximal element w.r.t the total ordering on elements
max [CCFloat]
max [CCInt]
max_capacity [CCRingBuffer.S]
Maximum length of the inner buffer, or None if unbounded.
max_finite_value [CCFloat]
max_int [CCInt64]
max_size [CCPool.PARAM]
Maximum number of threads in the pool
max_value [CCFloat]
max_width [CCBitField]
System-dependent maximum width for a bitfield, typically 30 or 62
maybe [CCOpt]
maybe f x o is x if o is None, otherwise it's f y if o = Some y
meet [CCMultiSet.S]
meet a b is a multiset such that count (meet a b) x = max (count a x) (count b x)
mem [CCHet.Map]
mem [CCHet.Tbl]
mem [CCWBTree.S]
mem [CCBloom]
mem f x tests whether x (probably) belongs to f
mem [CCHashTrie.S]
mem [CCHashSet.S]
mem s x returns true iff x is in s
mem [CCHashconsedSet.S]
mem [CCIntMap]
mem [CCMixmap.S]
Is the given key in the map, with the right type?
mem [CCMixtbl]
Is the given key in the table, with the right type?
mem [CCPersistentHashtbl.S]
Is the key bound?
mem [CCFlatHashtbl.S]
mem tbl k returns true iff k is mapped to some value in tbl
mem [CCMultiSet.S]
mem [CCMultiMap.S]
Is there a binding for this key?
mem [CCString]
mem ~sub s is true iff sub is a substring of s
mem [CCList.Assoc]
mem l x returns true iff x is a key in l
mem [CCList.Set]
Membership to the list.
mem_left [CCMultiMap.BIDIR]
Is the left key present in at least one pair?
mem_right [CCMultiMap.BIDIR]
Is the right key present in at least one pair?
member [CCVector]
Is the element a member of the vector?
memo [CCParse]
Memoize the parser.
memoize [CCKList]
Avoid recomputations by caching intermediate results
merge [CCWBTree.S]
Similar to Map.S.merge
merge [CCPersistentHashtbl.S]
Merge two tables together into a new table.
merge [CCTrie.S]
Merge two tries together.
merge [CCKList]
Merge two sorted iterators into a sorted iterator
merge [CCPair]
Uncurrying (merges the two components of a tuple)
merge [CCHeap.S]
Merge two heaps
merge_safe [CCMap.S]
merge_safe ~f a b merges the maps a and b together.
min [CCLinq]
min [CCMultiSet.S]
Minimal element w.r.t the total ordering on elements
min [CCFloat]
min [CCInt]
min_int [CCInt64]
min_size [CCPool.PARAM]
Minimum number of threads in the pool
min_value [CCFloat]
mix [CCArray1.Bool]
mix a b ~into assumes length a + length b = length into and mixes (interleaves) bits of a and b in into.
mk_heap [CCGraph]
mk_heap ~leq makes a priority queue where leq x y = true means that x is smaller than y and should be prioritary
mk_id [CCKTree.Dot]
Using a formatter string, build an ID
mk_label [CCKTree.Dot]
Using a formatter string, build a label
mk_map [CCGraph]
Use a Map.S underneath
mk_mut_tbl [CCGraph]
Make a new mutable graph from a Hashtbl.
mk_queue [CCGraph]
mk_stack [CCGraph]
mk_table [CCGraph]
Default implementation for CCGraph.table: a Hashtbl.t
modify [CCList.Zipper]
Modify the current element, if any, by returning a new element, or returning None if the element is to be deleted
mult [CCArray1.View.S]
mult [CCArray1.S]
Elementwise product
mult_scalar [CCArray1.View.S]
mutex [CCLock]
Underlying mutex

N
name [CCBitField.S.FIELD]
nan [CCFloat]
nativeint [CCFormat.Dump]
nativeint [CCFormat]
nativeint [CCHash.HASH]
nativeint_ [CCHash]
neg [CCFloat]
neg [CCInt]
neg i = - i
negate [CCBool]
Negation on booleans (functional version of not)
newkey [CCMixset]
newkey () creates a new unique key that can be used to access a 'a value in a set.
next [CCSexpM.MakeDecode]
Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression
next [CCApp_parse.READER]
nil [CCKList]
node [CCKTree]
Build a node from a label and a list of children
node1 [CCKTree]
Node with one child
node2 [CCKTree]
Node with two children
nop [CCParse]
Succeed with ()
not_ [CCArray1.Bool]
Boolean negation (negation of a 0 becomes a 1)
nth [CCWBTree.S]
nth i m returns the i-th key, value in the ascending order.
nth [CCFQueue]
Return the i-th element of the queue in logarithmic time
nth_exn [CCWBTree.S]
nth_exn [CCFQueue]
Unsafe version of CCFQueue.nth
num [CCApp_parse]

O
of_array [CCMonadIO.Seq]
of_array [CCLinq.Array]
of_array [CCLinq]
of_array [CCArray1.View]
of_array [CCArray1]
of_array [CCRAL]
of_array [CCPersistentArray]
from_array a returns an immutable copy of a.
of_array [CCRingBuffer.S]
Create a buffer from an initial array, but doesn't take ownership of it (stills allocates a new internal array)
of_array [CCKList]
Iterate on the array
of_array [CCString]
of_array [CCVector]
of_array_i [CCLinq]
of_array_unsafe [CCImmutArray]
Take ownership of the given array.
of_bigarray [CCArray1]
Convert from a big array
of_bool [CCSexp]
of_bytes [CCBigstring]
of_bytes_slice [CCBigstring]
of_char [CCString]
of_char 'a' = "a"
of_err [CCResult]
of_exn [CCResult]
of_exn e uses Printexc to print the exception as a string
of_exn [CCError]
of_exn e uses Printexc to print the exception as a string
of_exn_trace [CCResult]
of_exn_trace e is similar to of_exn e, but it adds the stacktrace to the error message.
of_exn_trace [CCError]
of_exn_trace e is similar to of_exn e, but it adds the stacktrace to the error message.
of_field [CCSexp]
Used to represent one record field
of_float [CCSexp]
of_float [CCInt64]
of_float_exn [CCInt64]
of_fun [CCMonadIO.Seq]
Create a stream from a function that yields an element or stops
of_fun [CCGraph]
of_fun f makes a graph out of a function that maps a vertex to the list of its children.
of_gen [CCLevenshtein.S.Index]
of_gen [CCImmutArray]
of_gen [CCRAL]
of_gen [CCWBTree.S]
of_gen [CCHashTrie.S]
of_gen [CCPersistentArray]
of_gen [CCIntMap]
of_gen [CCDeque]
of_gen g makes a deque containing the elements of g
of_gen [CCLazy_list]
of_gen [CCKList]
of_gen g consumes the generator and caches intermediate results
of_gen [CCString]
of_gen [CCList]
of_gen [CCHeap.S]
of_gen [CCVector]
of_hashtbl [CCLinq]
of_hashtbl [CCGraph]
of_hashtbl tbl makes a graph from a hashtable that maps vertices to lists of children
of_int [CCSexp]
of_int [CCInt64]
of_int [CCFloat]
of_int32 [CCInt64]
of_int32_exn [CCInt64]
of_int_exn [CCInt64]
of_klist [CCIntMap]
of_klist [CCFQueue]
of_klist [CCString]
of_klist [CCList]
of_klist [CCHeap.S]
of_klist [CCVector]
of_list [CCSexp]
of_list [CCMonadIO.Seq]
of_list [CCLinq.List]
of_list [CCLinq]
Query that just returns the elements of the list
of_list [CCLevenshtein.STRING]
of_list [CCLevenshtein.S.Index]
Build an index from a list of pairs of strings and values
of_list [CCLevenshtein.S]
Build an automaton from a list, with a maximal distance limit
of_list [CCHet.Map]
of_list [CCHet.Tbl]
of_list [CCImmutArray]
of_list [CCRAL]
Convert a list to a RAL.
of_list [CCWBTree.S]
of_list [CCHashTrie.S]
of_list [CCHashSet.S]
of_list [CCGraph.MAP]
of_list [CCGraph]
of_list l makes a graph from a list of pairs of vertices.
of_list [CCHashconsedSet.S]
of_list [CCPersistentArray]
of_list l returns a fresh persistent array containing the elements of l.
of_list [CCIntMap]
of_list [CCBV]
From a list of true bits
of_list [CCFQueue]
of_list [CCDeque]
Conversion from list, in order
of_list [CCPersistentHashtbl.S]
of_list [CCFlatHashtbl.S]
of_list [CCTrie.WORD]
of_list [CCTrie.S]
of_list [CCMultiSet.S]
of_list [CCLazy_list]
of_list [CCKList]
of_list [CCMap.S]
of_list [CCHashtbl.COUNTER]
of_list [CCHashtbl.S]
From the given list of bindings, added in order
of_list [CCHashtbl]
From the given list of bindings, added in order
of_list [CCString]
of_list [CCSet.S]
of_list [CCOpt]
Head of list, or None
of_list [CCHeap.S]
of_list [CCVector]
of_list_map [CCRAL]
Combination of CCRAL.of_list and CCRAL.map
of_list_mult [CCMultiSet.S]
of_map [CCLinq.AdaptMap]
of_nativeint [CCInt64]
of_nativeint_exn [CCInt64]
of_opt [CCResult]
of_opt [CCError]
of_pair [CCSexp]
of_quad [CCSexp]
of_queue [CCLinq]
of_record [CCSexp]
Represent a record by its named fields
of_rev_list [CCSexp]
Reverse the list
of_rev_list [CCPersistentArray]
of_rev_list l is the same as of_list (List.rev l) but more efficient
of_seq [CCLinq]
Query that returns the elements of the given sequence.
of_seq [CCLevenshtein.S.Index]
of_seq [CCHet.Map]
of_seq [CCHet.Tbl]
of_seq [CCImmutArray]
of_seq [CCRAL]
of_seq [CCWBTree.S]
of_seq [CCHashTrie.S]
of_seq [CCHashSet.S]
of_seq [CCGraph.MAP]
of_seq [CCHashconsedSet.S]
of_seq [CCPersistentArray]
of_seq [CCIntMap]
of_seq [CCBV]
of_seq [CCFQueue]
of_seq [CCDeque]
Create a deque from the sequence.
of_seq [CCPersistentHashtbl.S]
Add (replace) bindings from the sequence to the table
of_seq [CCFlatHashtbl.S]
of_seq [CCTrie.S]
of_seq [CCMultiSet.S]
of_seq [CCMultiMap.S]
of_seq [CCMap.S]
of_seq [CCHashtbl.COUNTER]
of_seq s is the same as add_seq (create ())
of_seq [CCHashtbl.S]
From the given bindings, added in order
of_seq [CCHashtbl]
From the given bindings, added in order
of_seq [CCString]
of_seq [CCSet.S]
of_seq [CCList]
of_seq [CCHeap.S]
of_seq [CCVector]
of_seq_count [CCHashtbl.S]
Similar to CCHashtbl.S.add_seq_count, but allocates a new table and returns it
of_seq_count [CCHashtbl]
Similar to CCHashtbl.add_seq_count, but allocates a new table and returns it
of_seq_mult [CCMultiSet.S]
of_set [CCLinq.AdaptSet]
of_slice [CCArray.Sub]
Make a sub-array from a triple (arr, i, len) where arr is the array, i the offset in arr, and len the number of elements of the slice.
of_stack [CCLinq]
of_string [CCLinq]
Traverse the characters of the string
of_string [CCBigstring]
of_string [CCLevenshtein.S]
Build an automaton from a string, with a maximal distance limit.
of_string [CCInt64]
of_string [CCFloat]
of_string [CCInt]
of_string_exn [CCInt64]
of_string_slice [CCBigstring]
of_triple [CCSexp]
of_unit [CCSexp]
of_variant [CCSexp]
of_variant name args is used to encode algebraic variants into a S-expr.
of_yojson [CCArray1]
on_failure [CCPool.Make.Fut]
Attach a handler to be called upon failure.
on_finish [CCPool.Make.Fut]
Attach a handler to be called when the future is evaluated.
on_success [CCPool.Make.Fut]
Attach a handler to be called upon success.
ones [CCArray1.Bool]
opaque_identity [CCFun]
opaque_identity x is like x, but prevents Flambda from using x's definition for optimizing it (flambda is an optimization/inlining pass in OCaml >= 4.03).
opp [CCOrd]
Opposite order
opt [CCApp_parse]
opt x tries to parse x, and returns None otherwise
opt [CCFormat]
opt pp prints options as follows: Some x will become "some foo" if pp x ---> "foo" None will become "none"
opt [CCHash.S]
opt [CCHash]
opt [CCPrint]
opt_unwrap [CCLinq]
option [CCFormat.Dump]
option [CCOrd]
Comparison of optional values.
or_ [CCArray1.Bool]
or_ a b ~into puts the boolean "or" of a and b in into expects length into = max (length a) (length b)
out [CCLinq.IO]
out_lines [CCLinq.IO]
Evaluate the query and print it line by line on the output
output [CCMonadIO.Seq]
output oc seq outputs every value of seq into oc, separated with the optional argument sep (default: None).
output [CCFormat]
output [CCPrint.MakeIO]
Output a single value
output [CCPrint]

P
pad [CCString]
pad n str ensures that str is at least n bytes long, and pads it on the side with c if it's not the case.
pair [CCParse.U]
Parse a pair using OCaml whitespace conventions.
pair [CCFormat.Dump]
pair [CCFormat]
pair [CCOrd]
pair [CCHash.S]
pair [CCHash]
pair [CCPrint]
pairs [CCMultiMap.BIDIR]
Iterate on pairs
parse [CCParse]
parse ~input p applies p on the input, and returns `Ok x if p succeeds with x, or `Error s otherwise
parse [CCApp_parse.S]
Parse the given source using the parser, and returns the parsed value.
parse' [CCApp_parse.S]
Same as CCApp_parse.S.parse, but returns a user-friendly string in case of failure
parse_chan [CCSexpM]
Parse a S-expression from the given channel.
parse_chan_gen [CCSexpM]
Parse a channel into a generator of S-expressions
parse_chan_list [CCSexpM]
parse_exn [CCParse]
parse_exn [CCApp_parse.S]
Unsafe version of CCApp_parse.S.parse.
parse_file [CCSexpM]
Open the file and read a S-exp from it
parse_file [CCParse]
parse_file ~file p parses file with p by opening the file and using CCParse.input_of_chan.
parse_file_exn [CCParse]
Unsafe version of CCParse.parse_file
parse_file_list [CCSexpM]
Open the file and read a S-exp from it
parse_string [CCSexpM]
Parse a string
parse_string [CCParse]
Specialization of CCParse.parse for string inputs
parse_string_exn [CCParse]
partition_map [CCList]
partition_map f l maps f on l and gather results in lists: if f x = `Left y, adds y to the first list, if f x = `Right z, adds z to the second list, if f x = `Drop, ignores x
peek [CCBlockingQueue]
peek q returns Some x if x is the first element of q, otherwise it returns None
peek [CCApp_parse.READER]
peek_back [CCRingBuffer.S]
Get the last value from back of t.
peek_back [CCDeque]
Last value, or
peek_front [CCRingBuffer.S]
First value from front of t.
peek_front [CCDeque]
First value, or
pick_array [CCRandom]
Pick an element at random from the array
pick_list [CCRandom]
Pick an element at random from the list
pop [CCList.Ref]
pop [CCVector]
Remove last element, or None
pop_exn [CCList.Ref]
Unsafe version of CCList.Ref.pop.
pop_exn [CCVector]
Remove last element, or raise a Failure if empty
pow [CCInt]
pow a b = a^b for positive integers a and b.
pp [CCArray1.Bool]
Print the bitvector nicely
pp [CCArray1]
Print the SDR nicely
pp [CCBitField.S]
Print the bitfield using the current list of fields
pp [CCHashSet.S]
pp pp_elt returns a set printer, given a printer for individual elements
pp [CCGraph.Dot]
Print the graph, starting from given vertex, on the formatter
pp [CCPersistentHashtbl.S]
pp [CCKList]
Print the list with the given separator (default ",").
pp [CCKTree.Dot]
Print the graph in DOT
pp [CCResult]
pp [CCChar]
pp [CCMap.S]
pp [CCString.S]
pp [CCSet.S]
pp [CCRef]
pp [CCArray.S]
Print an array of items with printing function
pp [CCFloat]
pp [CCBool]
Printer for booleans
pp [CCInt]
pp [CCPair]
pp [CCOpt]
pp [CCList]
pp [CCError]
pp [CCVector]
pp' [CCResult]
Printer that is generic on the error type
pp' [CCError]
Printer that is generic on the error type
pp_i [CCArray.S]
Print an array, giving the printing function both index and item
pp_seq [CCGraph.Dot]
pp_single [CCKTree.Dot]
prefix [CCString]
prefix ~pre s returns true iff pre is a prefix of s
print [CCSexpM]
Pretty-printer nice on human eyes (including indentation)
print [CCBigstring]
print [CCApp_parse]
Print a parser structure, for debug purpose
print [CCImmutArray]
print [CCRAL]
print [CCWBTree.S]
print [CCHashTrie.S]
print [CCPersistentArray]
print [CCIntMap]
print [CCBV]
Print the bitvector as a string of bits
print [CCFQueue]
print [CCDeque]
Print the elements
print [CCPersistentHashtbl.S]
print [CCKList]
Print the list with the given separator (default ",").
print [CCKTree.Dot]
Printer with indentation, etc.
print [CCKTree]
A pretty-printer using S-expressions and boxes to render the tree.
print [CCResult]
print [CCChar]
print [CCMap.S]
print [CCHashtbl.S]
Printer for tables
print [CCHashtbl]
Printer for table
print [CCString.S]
Print the string within quotes
print [CCSet.S]
print [CCRef]
print [CCArray.S]
Print an array of items with printing function
print [CCFloat]
print [CCBool]
print [CCInt]
print [CCPair]
print [CCOpt]
print [CCList]
print [CCHeap.S]
print [CCError]
print [CCVector]
print' [CCResult]
Printer that is generic on the error type
print' [CCError]
Printer that is generic on the error type
print_binary [CCInt]
prints as "0b00101010".
print_noindent [CCSexpM]
Raw, direct printing as compact as possible
print_to_file [CCKTree.Dot]
print_to_file filename g prints g into a file whose name is filename.
printf [CCPrint]
printl [CCPrint.MakeIO]
Output a value and add a newline "\n" after.
prod [CCArray1.View.S]
product [CCLinq]
Cartesian product
product [CCKList]
Specialization of CCKList.product_with producing tuples
product [CCList]
Cartesian product of the two lists, with the given combinator
product_elt [CCArray1.S]
Efficient product of elements
product_with [CCKList]
Fair product of two (possibly infinite) lists into a new list.
pure [CCMonadIO]
pure [CCLinq]
Synonym to CCLinq.return
pure [CCCat.APPLICATIVE]
pure [CCParse]
Synonym to CCParse.return
pure [CCApp_parse]
Synonym to CCApp_parse.return
pure [CCKList]
pure [CCResult]
Synonym of CCResult.return
pure [CCRandom]
pure [CCOpt]
Alias to CCOpt.return
pure [CCList]
pure [CCError]
Synonym of CCError.return
push [CCBlockingQueue]
push q x pushes x into q, blocking if the queue is full
push [CCList.Ref]
push [CCVector]
Add an element at the end of the vector
push_back [CCRingBuffer.S]
Push value at the back of t.
push_back [CCDeque]
Push value at the back
push_front [CCDeque]
Push value at the front
push_list [CCBlockingQueue]
Push items of the list, one by one
push_list [CCList.Ref]
Add elements of the list at the beginning of the list ref.

Q
quad [CCFormat.Dump]
quad [CCFormat]
quad [CCPrint]
quoted [CCApp_parse]
Quoted string, following OCaml conventions

R
random [CCArray]
random [CCFloat]
random [CCInt]
random [CCOpt]
random [CCList]
random_choose [CCWBTree.S]
Randomly choose a (key,value) pair within the tree, using weights as probability weights
random_choose [CCArray.S]
Choose an element randomly.
random_choose [CCList]
Randomly choose an element in the list.
random_len [CCArray]
random_len [CCList]
random_non_empty [CCArray]
random_non_empty [CCList]
random_range [CCFloat]
random_range [CCInt]
random_sequence [CCList]
random_small [CCFloat]
random_small [CCInt]
range [CCLinq]
range i j goes from i up to j included
range [CCRAL]
range i j is i; i+1; ... ; j or j; j-1; ...; i
range [CCKList]
range [CCList]
range i j iterates on integers from i to j included .
range' [CCList]
Same as CCList.range but the second bound is excluded.
range_by [CCList]
range_by ~step i j iterates on integers from i to j included, where the difference between successive elements is step.
raw [CCArray1.View]
read [CCMonadIO]
Read a chunk into the given string
read [CCApp_parse.INPUT]
read [CCIO.File]
Read the content of the given file
read_all [CCMonadIO]
Read the whole channel into a buffer, then converted into a string
read_all [CCIO]
Read the whole channel into a buffer, then converted into a string.
read_all_bytes [CCIO]
Read the whole channel into a mutable byte array
read_chunks [CCIO]
Read the channel's content into chunks of size size
read_dir [CCMonadIO.File]
read_dir d returns a sequence of files and directory contained in the directory d (or an empty stream if d is not a directory)
read_dir [CCIO.File]
read_dir d returns a sequence of files and directory contained in the directory d (or an empty stream if d is not a directory)
read_exn [CCIO.File]
Read the content of the given file, or raises some exception
read_line [CCMonadIO]
Read a line from the channel.
read_line [CCIO]
Read a line from the channel.
read_lines [CCMonadIO]
Read all lines eagerly
read_lines [CCIO]
Read all lines.
read_lines_l [CCIO]
Read all lines into a list
reduce [CCLinq]
reduce start mix stop q uses start on the first element of q, and combine the result with following elements using mix.
reflect [CCLinq]
reflect q evaluates all values in q and returns a sequence of all those values.
register_printer [CCMonadIO]
register_printer p register p as a possible failure printer.
register_printer [CCError]
release [CCSemaphore]
release n s atomically sets s := !s + n
remove [CCMonadIO.File]
remove [CCLevenshtein.S.Index]
Remove a string (and its associated value, if any) from the index.
remove [CCRAL]
remove l i removes the i-th element of v.
remove [CCWBTree.S]
remove [CCHashTrie.S]
Remove the key, if present.
remove [CCHashSet.S]
Remove the element, if it were in there
remove [CCGraph.MAP]
Remove the vertex and all its outgoing edges.
remove [CCHashconsedSet.S]
remove [CCIntMap]
remove [CCMixmap.S]
Remove the binding for this key
remove [CCMixtbl]
Remove the binding for this key
remove [CCPersistentHashtbl.S]
Remove the key
remove [CCFlatHashtbl.S]
Remove binding
remove [CCTrie.S]
Remove the key, if present
remove [CCMultiSet.S]
remove [CCMultiMap.BIDIR]
Remove a specific binding
remove [CCMultiMap.S]
Remove the binding
remove [CCIO.File]
Like remove_exn but with an error monad.
remove [CCHashtbl.DEFAULT]
Remove the binding for this key.
remove [CCList.Zipper]
remove l removes the current element, if any.
remove [CCList.Assoc]
remove l k removes the first occurrence of k from l.
remove [CCList.Set]
remove x set removes one occurrence of x from set.
remove [CCList.Idx]
Remove element at given index.
remove [CCList]
remove ~x l removes every instance of x from l.
remove [CCVector]
Remove the n-th element of the vector.
remove_all [CCMultiMap.S]
Remove the key from the map
remove_edge [CCGraph.MAP]
remove_exn [CCIO.File]
remove_exn path tries to remove the file at path from the file system.
remove_left [CCMultiMap.BIDIR]
Remove all bindings for the left key
remove_mult [CCMultiSet.S]
remove_mult set x n removes at most n occurrences of x from set
remove_mut [CCHashTrie.S]
Same as CCHashTrie.S.remove, but modifies in place whenever possible
remove_noerr [CCIO.File]
Like remove_exn but do not raise any exception on failure.
remove_right [CCMultiMap.BIDIR]
Remove all bindings for the right key
repeat [CCMonadIO]
Repeat an IO action as many times as required
repeat [CCRAL]
repeat n l is append l (append l ... l) n times
repeat [CCKList]
repeat ~n x repeats x n times then stops.
repeat [CCString]
The same string, repeated n times
repeat [CCList]
Concatenate the list with itself n times
repeat' [CCMonadIO]
Same as CCMonadIO.repeat, but ignores the result
replace [CCPersistentHashtbl.S]
Add the binding to the table, returning a new table.
replace [CCString]
replace ~sub ~by s replaces some occurrences of sub by by in s
replacing [CCCache]
Replacing cache of the given size.
replicate [CCRandom]
replicate n g makes a list of n elements which are all generated randomly using g
replicate [CCList]
Replicate the given element n times
reset [CCThread.Barrier]
Reset to initial (non-triggered) state
reset [CCRingBuffer.S]
Clear the content of the buffer, and also resize it to a default size
reset [CCBV]
Set i-th bit to 0
resize [CCBV]
Resize the BV so that it has at least the given physical length resize bv n should make bv able to store (Sys.word_size - 2)* n bits
retrieve [CCLevenshtein.S.Index]
Lazy list of objects associated to strings close to the query string
retry [CCResult]
retry n f calls f at most n times, returning the first result of f () that doesn't fail.
retry [CCRandom]
retry g calls g until it returns some value, or until the maximum number of retries was reached.
retry [CCError]
retry n f calls f at most n times, returning the first result of f () that doesn't fail.
retry_m [CCResult.Traverse]
retry_m [CCError.Traverse]
return [CCSexpM.MONAD]
return [CCSexp.Traverse]
return [CCMonadIO]
Just return a value
return [CCLinq]
Return one value
return [CCCat.MONAD_BARE]
return [CCPool.Make.Fut]
Future that is already computed
return [CCParse]
Always succeeds, without consuming its input
return [CCApp_parse]
Parser that succeeds with the given value
return [CCRAL]
Singleton
return [CCGraph.Seq]
return [CCLazy_list]
Return a computed value
return [CCKList.MONAD]
return [CCKList]
return [CCResult.MONAD]
return [CCResult]
Successfully return a value
return [CCRandom]
return x is the generator that always returns x.
return [CCFun.Monad]
return [CCOpt]
Monadic return, that is return x = Some x
return [CCList.MONAD]
return [CCList]
return [CCError.MONAD]
return [CCError]
Successfully return a value
return [CCVector]
Singleton vector
rev [CCRAL]
Reverse the list
rev [CCFQueue]
Reverse the queue, O(n) complexity
rev [CCString]
rev s returns the reverse of s
rev [CCArray]
Copy + reverse in place
rev [CCVector]
Reverse the vector
rev' [CCVector]
rev_in_place [CCVector]
Reverse the vector in place
rev_iter [CCVector]
rev_iter f a is the same as iter f (rev a), only more efficient.
rev_map [CCRAL]
rev_map f l is the same as map f (rev l)
reverse [CCLinq.PMap]
Reverse relation of the map, as a multimap
reverse_in_place [CCArray.S]
Reverse the array in place
reverse_multimap [CCLinq.PMap]
Reverse relation of the multimap
rfind [CCString]
Find sub in string from the right, returns its first index or -1.
right [CCString.Split]
Split on the first occurrence of by from the rightmost part of the string
right [CCList.Zipper]
Go to the right, or do nothing if the zipper is already at rightmost pos
right_exn [CCString.Split]
Split on the first occurrence of by from the rightmost part of the string
right_exn [CCList.Zipper]
Go to the right, or
ro [CCArray1]
Change permission (old reference to array might still be mutable!)
round [CCFloat]
round f returns the closest integer value, either above or below
run [CCMonadIO]
Run an IO action.
run [CCLinq.AdaptMap]
run [CCLinq.AdaptSet]
run [CCLinq.Array]
run [CCLinq.List]
run [CCLinq]
Execute the query, possibly returning an error if things go wrong
run [CCPool.Make]
run f schedules f for being executed in the thread pool
run [CCRandom]
Using a random state (possibly the one in argument) run a generator
run1 [CCLinq]
Run the query and return the first value
run1 [CCPool.Make]
run1 f x is similar to run (fun () -> f x)
run2 [CCPool.Make]
run3 [CCPool.Make]
run_exn [CCMonadIO]
Unsafe version of CCMonadIO.run.
run_no_optim [CCLinq]
Run without any optimization

S
sample_without_replacement [CCRandom]
sample_without_replacement n g makes a list of n elements which are all generated randomly using g with the added constraint that none of the generated random values are equal
scalar_add [CCArray1.S]
scalar_mult [CCArray1.S]
scale [CCFloat]
scc [CCGraph]
Strongly connected components reachable from the given vertices.
search [CCKMP.S]
search ~pattern s is a shortcut for find ~pattern s 0.
search' [CCKMP.S]
select [CCArray1.View]
select ~idx v is the view that has length length idx and such that get (select ~idx a) i = get a (get idx i)
select [CCBV]
select arr bv selects the elements of arr whose index corresponds to a true bit in bv.
select_a [CCArray1.View]
select_view [CCArray1.View]
selecti [CCBV]
Same as CCBV.select, but selected elements are paired with their index
sep [CCParse]
sep ~by p parses a list of p separated by by
sep1 [CCParse]
sep1 ~by p parses a non empty list of p, separated by by
seq [CCKMP.S]
iterate on matching positions
seq [CCFormat]
seq [CCString.Split]
seq [CCHash.S]
seq [CCHash]
seq [CCPrint]
seq' [CCKMP.S]
seq_cpy [CCString.Split]
seq_left [CCMultiMap.BIDIR]
seq_right [CCMultiMap.BIDIR]
sequence [CCMonadIO]
Runs operations one by one and gather their results
sequence_a [CCPool.Make.Fut]
Future that waits for all previous futures to terminate.
sequence_l [CCPool.Make.Fut]
Future that waits for all previous futures to terminate.
sequence_l [CCOpt]
sequence_l [x1; x2; ...; xn] returns Some [y1;y2;...;yn] if every xi is Some yi.
sequence_m [CCCat.TRAVERSE]
sequence_m [CCKList.Traverse]
sequence_m [CCResult.Traverse]
sequence_m [CCList.Traverse]
sequence_m [CCError.Traverse]
sequence_map [CCMonadIO]
Generalization of CCMonadIO.sequence
set [CCLock.LockRef]
set [CCLock]
Atomically set the value
set [CCArray1.Bool]
set [CCArray1]
set n-th element
set [CCBigstring]
set [CCImmutArray]
Copy the array and modify its copy
set [CCRAL]
set l i v sets the i-th element of the list to v.
set [CCBitField.S.FIELD]
set [CCMixset]
set ~key v set maps key to v in set.
set [CCPersistentArray]
set a i v sets the element index i from the array a to v.
set [CCRingBuffer.Array.S]
set t i e sets the element at position i to e
set [CCMixtbl]
Bind the key to the value, using inj
set [CCBV]
Set i-th bit.
set [CCHashtbl.DEFAULT]
Replace the current binding for this key
set [CCString]
set s i c creates a new string which is a copy of s, except for index i, which becomes c.
set [CCArray.MONO_ARRAY]
set [CCArray.S]
set [CCList.Assoc]
Add the binding into the list (erase it if already present)
set [CCList.Idx]
Set i-th element (removes the old one), or does nothing if index is too high
set [CCVector]
Modify element at given index, or
set_color_default [CCFormat]
set_color_default b enables color handling on the standard formatters (stdout, stderr) if b = true as well as on CCFormat.sprintf formatters; it disables the color handling if b = false.
set_color_tag_handling [CCFormat]
adds functions to support color tags to the given formatter.
set_exn_handler [CCTimer]
set_exn_handler timer f registers f so that any exception raised by a task scheduled in timer is given to f
set_exn_handler [CCPool.Make]
set_of_cmp [CCKTree]
Build a set structure given a total ordering
show_walk_item [CCIO.File]
shrink [CCVector]
Shrink to the given size (remove elements above this size).
shuffle [CCArray.S]
Shuffle randomly the array, in place
shuffle_with [CCArray.S]
Like shuffle but using a specialized random state
sign [CCInt]
sign i is one of -1, 0, 1
sign_exn [CCFloat]
sign_exn x will return the sign of x as 1, 0 or -1, or raise an exception TrapNaN if x is a NaN.
silent [CCFormat]
Prints nothing
silent [CCPrint]
prints nothing
singleton [CCMonadIO.Seq]
singleton [CCImmutArray]
singleton [CCWBTree.S]
singleton [CCHashTrie.S]
singleton [CCHashSet.S]
singleton x is the singleton {x}
singleton [CCHashconsedSet.S]
singleton [CCIntMap]
singleton [CCFQueue]
singleton [CCMultiSet.S]
singleton [CCKList]
singleton [CCKTree.Dot]
singleton [CCKTree]
Tree with only one label
size [CCLinq.PMap]
size [CCLinq]
size t returns one value, the number of items returned by t
size [CCBlockingQueue]
Number of elements currently in the queue
size [CCBigstring]
Number of bytes
size [CCBloom]
Length of the underlying array.
size [CCFQueue]
Number of elements in the queue (constant time)
size [CCCache]
Size of the cache (number of entries).
size [CCFlatHashtbl.S]
Number of bindings
size [CCTrie.S]
Number of bindings
size [CCMultiMap.S]
Number of keys
size [CCKTree]
Number of elements
size [CCHeap.S]
Number of elements (linear complexity)
size [CCVector]
Number of elements in vector
skip [CCParse]
skip p parses p and ignores its result
skip [CCApp_parse]
Skip 0 or more instances of the given parser
skip [CCRingBuffer.S]
skip b len removes len elements from the front of b.
skip1 [CCApp_parse]
skip_chars [CCParse]
Skip 0 or more chars satisfying the predicate
skip_space [CCParse]
Skip ' ' and '\t'
skip_white [CCParse]
Skip ' ' and '\t' and '\n'
sleep [CCPool.Make.Fut]
Future that returns with success in the given amount of seconds.
slice [CCHash.HASH]
slice s i len state hashes the slice i, ... i+len-1 of s into state
slice [CCVector]
Vector as an array slice.
slice_seq [CCVector]
slice_seq v start len is the sequence of elements from v.(start) to v.(start+len-1).
slurp [CCLinq.IO]
Slurp the whole channel in (blocking), returning the corresponding string.
slurp_file [CCLinq.IO]
Read a whole file (given by name) and return its content as a string
small_float [CCRandom]
A reasonably small float.
small_int [CCRandom]
snd [CCLinq]
snoc [CCFQueue]
Push element at the end of the queue
sort [CCLinq]
Sort items by the given comparison function
sort [CCKList]
Eager sort.
sort [CCVector]
Sort the vector, returning a copy of it that is sorted w.r.t the given ordering.
sort' [CCVector]
Sort the vector in place (modifying it).
sort_generic [CCArray]
Sort the array, without allocating (eats stack space though).
sort_indices [CCArray.S]
sort_indices cmp a returns a new array b, with the same length as a, such that b.(i) is the index of the i-th element of a in sort cmp a.
sort_ranking [CCArray.S]
sort_ranking cmp a returns a new array b, with the same length as a, such that b.(i) is the position in sorted cmp a of the i-th element of a.
sort_uniq [CCKList]
Eager sort that removes duplicate values.
sort_uniq [CCList]
Sort the list and remove duplicate elements
sorted [CCArray.S]
sorted cmp a makes a copy of a and sorts it with cmp.
sorted_insert [CCList]
sorted_insert x l inserts x into l such that, if l was sorted, then sorted_insert x l is sorted too.
sorted_merge [CCList]
Merges elements from both sorted list
sorted_merge_uniq [CCList]
sorted_merge_uniq l1 l2 merges the sorted lists l1 and l2 and removes duplicates
space [CCParse]
Tab or space
spaces [CCApp_parse]
Parse a sequence of '\t' and ' '
spaces1 [CCApp_parse]
Same as CCApp_parse.spaces but requires at least one space
spanning_tree [CCGraph]
spanning_tree ~graph v computes a lazy spanning tree that has v as a root.
spanning_tree_tag [CCGraph]
spawn [CCThread.Arr]
A.spawn n f creates an array res of length n, such that res.(i) = spawn (fun () -> f i)
spawn [CCThread]
spawn f creates a new thread that runs f ()
spawn1 [CCThread]
spawn1 f x is like spawn (fun () -> f x).
spawn2 [CCThread]
spawn2 f x y is like spawn (fun () -> f x y).
split [CCWBTree.S]
split k t returns l, o, r where l is the part of the map with keys smaller than k, r has keys bigger than k, and o = Some v if k, v belonged to the map
split [CCRandom]
Split a positive value n into n1,n2 where n = n1 + n2.
split [CCList]
Synonym to CCList.take_drop
split_list [CCRandom]
Split a value n into a list of values whose sum is n and whose length is length.
sprintf [CCFormat]
Print into a string any format string that would usually be compatible with CCFormat.fprintf.
sprintf [CCPrint]
Print into a string
sprintf_dyn_color [CCFormat]
Similar to CCFormat.sprintf but enable/disable colors depending on colors.
sprintf_no_color [CCFormat]
Similar to CCFormat.sprintf but never prints colors
start [CCLinq]
Start with a single value
state [CCPool.Make.Fut]
State of the future
stats [CCPersistentHashtbl.S]
Statistics on the internal table.
status [CCUnix]
stderr [CCUnix]
stderr [CCFormat]
stdout [CCUnix]
stdout [CCFormat]
stop [CCTimer]
Stop the given timer, cancelling pending tasks.
stop [CCPool.Make]
After calling stop (), Most functions will raise Stopped.
str_of_l [CCApp_parse]
Helper to build strings from lists of chars
string [CCParse]
string s parses exactly the string s, and nothing else
string [CCFormat.Dump]
string [CCFormat]
string [CCHash.S]
string [CCPrint]
string_ [CCOrd]
string_ [CCHash]
string_of_error [CCApp_parse]
string_quoted [CCFormat]
Similar to CCString.print.
sub [CCArray1]
sub a i len takes the slice of length len starting at offset i
sub [CCBigstring]
sub s i len takes a slice of length len from the string s, starting at offset i.
sub [CCRingBuffer.Array.S]
sub t i len gets the subarray of t from position i to i + len
sub [CCString.Sub]
Sub-slice
sub [CCArray.Sub]
Sub-slice
sub [CCFloat]
sub_bytes [CCBigstring]
sub_string [CCBigstring]
submap [CCMultiMap.S]
submap m1 m2 is true iff all bindings of m1 are also in m2
subset [CCHashSet.S]
subset a b returns true if all elements of a are in b
subset [CCList.Set]
Test for inclusion
suffix [CCString]
suffix ~suf s returns true iff suf is a suffix of s
sum [CCLinq]
sum [CCArray1.View.S]
sum_elt [CCArray1.S]
Efficient sum of elements
swap [CCPair]
Swap the components of the tuple
switch_c [CCApp_parse]
switch_c l matches the next char and uses the corresponding parser.
switch_s [CCApp_parse]
switch_s l attempts to match matches any of the strings in l.
symbols [CCApp_parse]
Symbols, such as "!-=_"...

T
tail [CCFQueue]
Queue deprived of its first element.
tail [CCKList]
Tail of the list
tail_exn [CCKList]
Unsafe version of CCKList.tail
take [CCMonadIO.Seq]
take [CCLinq]
Take at most n elements
take [CCBlockingQueue]
Take the first element, blocking if needed
take [CCRAL]
take [CCLazy_list]
Take at most n values.
take [CCKList]
take [CCString]
take n s keeps only the n first chars of s
take [CCList]
Take the n first elements, drop the rest
take [CCHeap.S]
Extract and return the minimum element, and the new heap (without this element), or None if the heap is empty
take_back [CCRingBuffer.S]
Take the last value from back of t, if any
take_back [CCFQueue]
Take last element
take_back [CCDeque]
Take last value, or
take_back_exn [CCRingBuffer.S]
Take the last value from back of t.
take_back_exn [CCFQueue]
take_back_l [CCFQueue]
take_back_l n q removes and returns the last n elements of q.
take_back_while [CCFQueue]
take_drop [CCRAL]
take_drop n l splits l into a, b such that length a = n if length l >= n, and such that append a b = l
take_drop [CCString]
take_drop n s = take n s, drop n s
take_drop [CCList]
take_drop n l returns l1, l2 such that l1 @ l2 = l and length l1 = min (length l) n
take_exn [CCHeap.S]
Same as CCHeap.S.take, but can fail.
take_front [CCRingBuffer.S]
Take the first value from front of t, if any
take_front [CCFQueue]
Get and remove the first element
take_front [CCDeque]
Take first value, or
take_front_exn [CCRingBuffer.S]
Take the first value from front of t.
take_front_exn [CCFQueue]
Same as CCFQueue.take_front, but fails on empty queues.
take_front_l [CCFQueue]
take_front_l n q takes at most n elements from the front of q, and returns them wrapped in a list
take_front_while [CCFQueue]
take_list [CCBlockingQueue]
take_list n q takes n elements out of q
take_while [CCMonadIO.Seq]
take_while [CCLinq]
Take elements while they satisfy a predicate
take_while [CCRAL]
take_while [CCKList]
take_while [CCList]
tap [CCFun]
tap f x evaluates f x, discards it, then returns x.
tee [CCMonadIO.Seq]
tee funs seq behaves like seq, but each element is given to every function f in funs.
tee [CCIO]
tee funs gen behaves like gen, but each element is given to every function f in funs at the time the element is produced.
tl [CCRAL]
Remove the first element from the list, or
to_array [CCLinq.Array]
to_array [CCArray1.View]
to_array v returns a fresh copy of the content of v.
to_array [CCArray1]
to_array [CCRAL]
More efficient than on usual lists
to_array [CCPersistentArray]
to_array t returns a mutable copy of t.
to_array [CCRingBuffer.S]
Create an array from the elements, in order.
to_array [CCKList]
Convert into array.
to_array [CCString]
to_array [CCVector]
to_bigarray [CCArray1]
Obtain the underlying array
to_bool [CCSexp.Traverse]
Expect a boolean
to_buf [CCSexpM]
to_bytes [CCBigstring]
to_chan [CCSexpM]
to_err [CCResult]
to_file [CCSexpM]
to_file [CCLinq.IO]
to_file [CCKTree.Dot]
to_file filename trees makes a graph out of the trees, opens the file filename and prints the graph into the file.
to_file [CCFormat]
Print to the given file
to_file [CCPrint]
Print to the given file
to_file_exn [CCLinq.IO]
to_file_lines [CCLinq.IO]
to_file_lines_exn [CCLinq.IO]
to_file_seq [CCSexpM]
Print the given sequence of expressions to a file
to_float [CCSexp.Traverse]
Expect a float
to_float [CCInt64]
to_gen [CCBigstring]
to_gen [CCLevenshtein.S.Index]
to_gen [CCImmutArray]
to_gen [CCRAL]
to_gen [CCWBTree.S]
to_gen [CCHashTrie.S]
to_gen [CCPersistentArray]
to_gen [CCIntMap]
to_gen [CCDeque]
Iterates on elements of the deque
to_gen [CCLazy_list]
to_gen [CCKList]
to_gen [CCString.S]
to_gen [CCArray.S]
to_gen [CCOpt]
to_gen [CCList]
to_gen [CCHeap.S]
to_gen [CCVector]
to_gen_slice [CCBigstring]
to_hashtbl [CCLinq]
Build a hashtable from the collection
to_int [CCSexp.Traverse]
Expect an integer
to_int [CCInt64]
to_int [CCFloat]
to_int32 [CCInt64]
to_klist [CCLevenshtein.S.Index]
Conversion to an iterator
to_klist [CCIntMap]
to_klist [CCFQueue]
to_klist [CCString.S]
to_klist [CCArray.S]
to_klist [CCList]
to_klist [CCHeap.S]
to_klist [CCVector]
to_list [CCSexp.Traverse]
Expect a list
to_list [CCLinq.List]
to_list [CCLinq.PMap]
to_list [CCArray1]
to_list [CCLevenshtein.S.Index]
Extract a list of pairs from an index
to_list [CCHet.Map]
to_list [CCHet.Tbl]
to_list [CCImmutArray]
to_list [CCRAL]
to_list [CCWBTree.S]
to_list [CCHashTrie.S]
to_list [CCGraph.MAP]
to_list [CCGraph.Seq]
to_list [CCHashconsedSet.S]
to_list [CCPersistentArray]
to_list t returns the list of elements in t.
to_list [CCIntMap]
to_list [CCRingBuffer.S]
Extract the current content into a list
to_list [CCBV]
List of indexes that are true
to_list [CCFQueue]
to_list [CCDeque]
List of elements, in order.
to_list [CCPersistentHashtbl.S]
to_list [CCFlatHashtbl.S]
to_list [CCTrie.S]
to_list [CCMultiSet.S]
to_list [CCLazy_list]
to_list [CCKList]
Gather all values into a list
to_list [CCMap.S]
to_list [CCHashtbl.COUNTER]
to_list [CCHashtbl.S]
List of bindings (order unspecified)
to_list [CCHashtbl]
List of bindings (order unspecified)
to_list [CCString.S]
to_list [CCSet.S]
to_list [CCRef]
to_list [CCArray.Sub]
Convert directly to a list
to_list [CCOpt]
to_list [CCList.Zipper]
Convert the zipper back to a list.
to_list [CCHeap.S]
to_list [CCVector]
to_list_mult [CCMultiSet.S]
to_list_rev [CCLazy_list]
to_list_with [CCSexp.Traverse]
Expect a list, applies f to all the elements of the list, and succeeds only if f succeeded on every element
to_map [CCLinq.AdaptMap]
to_nativeint [CCInt64]
to_opt [CCResult]
to_opt [CCError]
to_pair [CCSexp.Traverse]
Expect a list of two elements
to_pair_with [CCSexp.Traverse]
Same as CCSexp.Traverse.to_pair but applies conversion functions
to_pmap [CCLinq.AdaptMap]
to_queue [CCLinq]
to_rev_list [CCDeque]
Efficient conversion to list, in reverse order
to_rev_list [CCKList]
Convert to a list, in reverse order.
to_rev_list [CCList.Zipper]
Convert the zipper back to a reversed list.
to_seq [CCLinq.PMap]
to_seq [CCLinq]
Build a (re-usable) sequence of elements, which can then be converted into other structures
to_seq [CCCat.FOLDABLE]
to_seq [CCArray1]
to_seq [CCBigstring]
to_seq [CCLevenshtein.S.Index]
to_seq [CCHet.Map]
to_seq [CCHet.Tbl]
to_seq [CCImmutArray]
to_seq [CCRAL]
to_seq [CCWBTree.S]
to_seq [CCHashTrie.S]
to_seq [CCHashSet.S]
to_seq [CCGraph.MAP]
to_seq [CCHashconsedSet.S]
to_seq [CCPersistentArray]
to_seq [CCIntMap]
to_seq [CCBV]
to_seq [CCFQueue]
to_seq [CCDeque]
iterate on the elements
to_seq [CCPersistentHashtbl.S]
Sequence of the bindings of the table
to_seq [CCFlatHashtbl.S]
to_seq [CCTrie.WORD]
to_seq [CCTrie.S]
to_seq [CCMultiSet.S]
to_seq [CCMultiMap.S]
to_seq [CCKList]
to_seq [CCResult]
to_seq [CCMap.S]
to_seq [CCHashtbl.COUNTER]
to_seq tbl returns elements of tbl along with their multiplicity
to_seq [CCHashtbl.DEFAULT]
Pairs of (elem, value) for all elements on which get was called
to_seq [CCHashtbl.S]
Iterate on values in the table
to_seq [CCHashtbl]
Iterate on bindings in the table
to_seq [CCString.S]
to_seq [CCSet.S]
to_seq [CCRef]
to_seq [CCArray.S]
to_seq [CCOpt]
to_seq [CCList]
to_seq [CCHeap.S]
to_seq [CCError]
to_seq [CCVector]
to_seq_mult [CCMultiSet.S]
to_seq_rev [CCVector]
to_seq_rev v returns the sequence of elements of v in reverse order, that is, the last elements of v are iterated on first.
to_seq_slice [CCBigstring]
to_seq_values [CCTrie.S]
to_set [CCLinq.AdaptSet]
to_slice [CCArray.Sub]
Convert into a triple (arr, i, len) where len is the length of the subarray of arr starting at offset i
to_sorted_list [CCBV]
Same as CCBV.to_list, but also guarantees the list is sorted in increasing order
to_stack [CCLinq]
to_string [CCSexpM]
to_string [CCSexp.Traverse]
Expect a string (an atom)
to_string [CCMonadIO.File]
to_string [CCBigstring]
to_string [CCInt64]
to_string [CCIO.File]
to_string [CCFormat]
to_string [CCFloat]
to_string [CCInt]
to_string [CCPrint]
to_string_binary [CCInt]
to_tree [CCTrie.S]
to_tree [CCHeap.S]
to_triple [CCSexp.Traverse]
to_triple_with [CCSexp.Traverse]
to_yojson [CCArray1]
top [CCVector]
Top element, if present
top_exn [CCVector]
Top element, if present
topo_sort [CCGraph]
topo_sort ~graph seq returns a list of vertices l where each element of l is reachable from seq.
topo_sort_tag [CCGraph]
Same as CCGraph.topo_sort but uses an explicit tag set
total_width [CCBitField.S]
Current width of the bitfield
triple [CCParse.U]
Parse a triple using OCaml whitespace conventions.
triple [CCFormat.Dump]
triple [CCFormat]
triple [CCOrd]
triple [CCHash.S]
triple [CCHash]
triple [CCPrint]
try_push [CCBlockingQueue]
try_push q x pushes x into q if q is not full, in which case it returns true.
try_successively [CCRandom]
try_successively l tries each generator of l, one after the other.
try_take [CCBlockingQueue]
Take the first element if the queue is not empty, return None otherwise

U
unbounded [CCCache]
Unbounded cache, backed by a Hash table.
uncapitalize_ascii [CCString]
See String.
uncurry [CCFun]
underlying [CCString.Sub]
underlying [CCArray.Sub]
Underlying array (shared).
unfold [CCKList]
unfold f acc calls f acc and: if f acc = Some (x, acc'), yield x, continue with unfold f acc', if f acc = None, stops
union [CCLinq]
Union of two collections.
union [CCBloom]
The sets MUST have the same set of hash functions
union [CCHashSet.S]
union a b returns a ∪ b
union [CCGraph.MAP]
union [CCHashconsedSet.S]
union [CCIntMap]
union [CCBV]
union bv1 bv2 returns the union of the two sets
union [CCMultiSet.S]
union a b contains as many occurrences of an element x as count a x + count b x.
union [CCMultiMap.S]
Union of multimaps
union [CCList.Set]
List union.
union_into [CCBV]
union ~into bv sets into to the union of itself and bv.
union_mut [CCBloom]
union_mut ~into f changes into into the union of into and f.
union_mut [CCHashSet.S]
union_mut ~into a changes into into a ∪ into
uniq [CCKList]
uniq eq l returns l but removes consecutive duplicates.
uniq [CCList.Set]
List uniq.
uniq_sort [CCVector]
Sort the array and remove duplicates, in place (e.g.
uniq_succ [CCList]
uniq_succ l removes duplicate elements that occur one next to the other.
unit [CCFormat.Dump]
unit [CCFormat]
unit [CCPrint]
unlines [CCLinq.IO]
Join lines together
unlines [CCString]
unlines l concatenates all strings of l, separated with '\n'
unlines_gen [CCString]
unlines_gen g concatenates all strings of g, separated with '\n'
unsafe_get_array [CCVector]
Access the underlying shared array (do not modify!).
unzip [CCKList]
Splits each tuple in the list
update [CCLock.LockRef]
update [CCLock]
update l f replaces the content x of l with f x, atomically
update [CCWBTree.S]
update k f m calls f (Some v) if get k m = Some v, f None otherwise.
update [CCHashTrie.S]
update k ~f m calls f (Some v) if get k m = Some v, f None otherwise.
update [CCIntMap]
update [CCPersistentHashtbl.S]
update tbl key f calls f None if key doesn't belong in tbl, f (Some v) if key -> v otherwise; If f returns None then key is removed, else it returns Some v' and key -> v' is added.
update [CCTrie.S]
Update the binding for the given key.
update [CCMultiSet.S]
update set x f calls f n where n is the current multiplicity of x in set (0 to indicate its absence); the result of f n is the new multiplicity of x.
update [CCMap.S]
update k f m calls f (Some v) if find k m = v, otherwise it calls f None.
update [CCHashtbl.S]
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace
update [CCHashtbl]
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace
update [CCRef]
Update the reference's content with the given function
update [CCList.Assoc]
update l k ~f updates l on the key k, by calling f (get l k) and removing k if it returns None, mapping k to v' if it returns Some v'
update_map [CCLock]
update_map l f computes x', y = f (get l), then puts x' in l and returns y
update_mut [CCHashTrie.S]
Same as CCHashTrie.S.update but with mutability
uppercase_ascii [CCChar]
See Char
uppercase_ascii [CCString]
See String.

V
values [CCIntMap]
values [CCFlatHashtbl.S]
values [CCMultiMap.S]
Some values may occur several times
values [CCMap.S]
Iterate on values only
values [CCHashtbl.S]
Iterate on values in the table
values [CCHashtbl]
Iterate on values in the table
values_list [CCHashtbl.S]
values t is the list of values in t.
values_list [CCHashtbl]
values_list t is the list of values in t.
vbox [CCFormat]
Wrap the printer in a vertical box
vertices [CCGraph.MAP]
vertices_l [CCGraph.MAP]

W
wait [CCThread.Barrier]
wait b waits for barrier b to be activated by activate b.
wait_until_at_least [CCSemaphore]
wait_until_at_least ~n s ~f waits until get s >= n, then calls f () and returns its result.
walk [CCMonadIO.File]
Similar to CCMonadIO.File.read_dir (with recurse=true), this function walks a directory recursively and yields either files or directories.
walk [CCIO.File]
Similar to CCIO.File.read_dir (with recurse=true), this function walks a directory recursively and yields either files or directories.
weight [CCWBTree.KEY]
weight [CCWBTree.S]
white [CCParse]
Tab or space or newline
white [CCApp_parse]
Parse a sequence of '\t', '\n' and ' '
white1 [CCApp_parse]
width [CCBitField.S.FIELD]
with_ [CCAllocCache.Arr]
with_ [CCHashTrie.Transient]
Transient.with_ f creates a transient ID i, calls f i, freezes the ID i and returns the result of f i.
with_acquire [CCSemaphore]
with_acquire ~n s ~f first acquires s with n units, calls f (), and then release s with n units.
with_cache [CCCache]
with_cache c f behaves like f, but caches calls to f in the cache c.
with_cache_rec [CCCache]
with_cache_rec c f is a function that first, applies f to some f' = fix f, such that recursive calls to f' are cached in c.
with_color [CCFormat]
with_color "Blue" pp behaves like the printer pp, but with the given style.
with_color_sf [CCFormat]
with_color_sf "Blue" out "%s %d" "yolo" 42 will behave like CCFormat.sprintf, but wrapping the content with the given style Example:
      CCFormat.with_color_sf "red" "%a" CCFormat.Dump.(list int) [1;2;3] |> print_endline;;
    
status: experimental
with_colorf [CCFormat]
with_colorf "Blue" out "%s %d" "yolo" 42 will behave like Format.fprintf, but wrapping the content with the given style status: experimental
with_connection [CCUnix]
Wrap Unix.open_connection with a handler
with_in [CCUnix]
Open an input file with the given optional flag list, calls the function on the input channel.
with_in [CCMonadIO]
Open an input file with the given optional flag list.
with_in [CCIO]
Open an input file with the given optional flag list, calls the function on the input channel.
with_in_out [CCIO]
Combines CCIO.with_in and CCIO.with_out.
with_lock [CCLock]
with_lock l f runs f x where x is the value protected with the lock l, in a critical section.
with_lock_as_ref [CCLock]
with_lock_as_ref l f calls f with a reference-like object that allows to manipulate the value of l safely.
with_map_file [CCBigstring]
with_map_file name f maps the file into memory, opening it, and call f with a slice pos.... pos+len of the bytes of the file where len is the length of the file if not provided.
with_out [CCUnix]
Same as CCUnix.with_in but for an output channel
with_out [CCMonadIO]
Same as CCMonadIO.with_in but for an output channel
with_out [CCGraph.Dot]
Shortcut to open a file and write to it
with_out [CCIO]
Same as CCIO.with_in but for an output channel
with_out_a [CCMonadIO]
Similar to CCMonadIO.with_out but with the Open_append and Open_creat flags activated
with_out_a [CCIO]
Similar to CCIO.with_out but with the [Open_append; Open_creat; Open_wronly] flags activated, to append to the file
with_process_full [CCUnix]
Open a subprocess and obtain a handle to its channels.
with_process_in [CCUnix]
Open a subprocess and obtain a handle to its stdout
with_process_out [CCUnix]
Open a subprocess and obtain a handle to its stdin
with_temp [CCIO.File]
with_temp ~prefix ~suffix f will call f with the name of a new temporary file (located in temp_dir).
within [CCFormat]
within a b p wraps p inside the strings a and b.
wo [CCArray1]
Change permission
word [CCParse.U]
non empty string of alpha num, start with alpha
word [CCApp_parse]
word parses any identifier not starting with an integer and not containing any whitespace nor delimiter TODO: specify
words [CCMonadIO.Seq]
Split strings into words at " " boundaries.
wrap [CCMonadIO.Raw]
wrap f is the IO action that, when executed, returns f ().
wrap [CCOpt]
wrap f x calls f x and returns Some y if f x = y.
wrap1 [CCResult]
Same as CCResult.guard but gives the function one argument.
wrap1 [CCError]
Same as CCError.guard but gives the function one argument.
wrap2 [CCResult]
Same as CCResult.guard but gives the function two arguments.
wrap2 [CCOpt]
wrap2 f x y is similar to wrap1 but for binary functions.
wrap2 [CCError]
Same as CCError.guard but gives the function two arguments.
wrap3 [CCResult]
Same as CCResult.guard but gives the function three arguments.
wrap3 [CCError]
Same as CCError.guard but gives the function three arguments.
write [CCMonadIO]
write [CCIO.File]
Write the given string into the given file
write [CCPrint.MONAD_IO]
write_buf [CCMonadIO]
write_exn [CCIO.File]
Write the given string into the given file, possibly raising
write_gen [CCIO]
Write the given strings on the output.
write_line [CCMonadIO]
write_line [CCIO]
Write the given string on the channel, followed by "\n"
write_lines [CCIO]
Write every string on the output, followed by "\n".
write_lines_l [CCIO]
write_str [CCMonadIO]

Z
zeroes [CCArray1.Bool]
zip [CCKList]
Combine elements pairwise.