Index of values


( * ) [CCInt64]
( *** ) [CCPair]
Map on both sides of a tuple
( *> ) [CCParse.Infix]
( *> ) [CCParse]
a *> b parses a, then parses b into x, and returns x.
( <* ) [CCParse.Infix]
( <* ) [CCParse]
a <* b parses a into x, parses b and ignores its result, and returns x
(%) [CCFun]
Mathematical composition
(%>) [CCFun]
Alias to compose
(&&&) [CCPair]
f &&& g is fun x -> f x, g x.
(+) [CCInt64]
(-) [CCInt64]
(--) [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)
(--) [CCArrayLabels]
Range array
(--) [CCListLabels.Infix]
(--) [CCListLabels]
Infix alias for range
(--) [CCArray]
Range array
(--) [CCInt.Infix]
Alias to CCInt.range
(--) [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.
(--^) [CCArrayLabels]
Range array, excluding right bound
(--^) [CCListLabels.Infix]
(--^) [CCListLabels]
Infix alias for range'
(--^) [CCArray]
Range array, excluding right bound
(--^) [CCInt.Infix]
Alias to CCInt.range'
(--^) [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]
(<$>) [CCListLabels.Infix]
(<$>) [CCListLabels]
(<$>) [CCOpt.Infix]
(<$>) [CCOpt]
(<$>) [CCList.Infix]
(<$>) [CCList]
(<) [CCFloat.Infix]
(<) [CCInt.Infix]
(<*>) [CCPool.Make.Fut.Infix]
(<*>) [CCPool.Make.Fut]
(<*>) [CCRAL.Infix]
Alias to CCRAL.app
(<*>) [CCKList.Infix]
(<*>) [CCKList]
(<*>) [CCListLabels.Infix]
(<*>) [CCListLabels]
(<*>) [CCParse.Infix]
(<*>) [CCParse]
Applicative
(<*>) [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]
(<+>) [CCOpt.Infix]
(<+>) [CCOpt]
a <+> b is a if a is Some _, b otherwise
(<.>) [CCKList.Infix]
(<.>) [CCKList]
Infix version of CCKList.fair_app
(<::) [CCSimple_queue.Infix]
(<<<) [CCPair]
Map on the left side of the tuple
(<=) [CCFloat.Infix]
(<=) [CCInt.Infix]
(<>) [CCFloat.Infix]
(<>) [CCInt.Infix]
(<?>) [CCParse.Infix]
(<?>) [CCParse]
a <?> msg behaves like a, but if a fails without consuming any input, it fails with msg instead.
(<?>) [CCRandom]
a <?> b is a choice operator.
(<?>) [CCOrd.Infix]
(<?>) [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.Infix]
(<|>) [CCParse]
a <|> b tries to parse a, and if a fails without consuming any input, backtracks and tries to parse b, otherwise it fails as a.
(=) [CCFloat.Infix]
(=) [CCInt.Infix]
(>) [CCFloat.Infix]
(>) [CCInt.Infix]
(>=) [CCFloat.Infix]
(>=) [CCInt.Infix]
(>>) [CCPool.Make.Fut.Infix]
(>>) [CCPool.Make.Fut]
(>>-) [CCKList.Infix]
(>>-) [CCKList]
Infix version of CCKList.fair_flat_map
(>>=) [CCPool.Make.Fut.Infix]
(>>=) [CCPool.Make.Fut]
(>>=) [CCRAL.Infix]
Alias to CCRAL.flat_map
(>>=) [CCGraph.Seq]
(>>=) [CCLazy_list.Infix]
(>>=) [CCKList.MONAD]
(>>=) [CCKList.Infix]
(>>=) [CCKList]
(>>=) [CCArrayLabels]
Infix version of CCArrayLabels.flat_map
(>>=) [CCListLabels.MONAD]
(>>=) [CCListLabels.Infix]
(>>=) [CCListLabels]
(>>=) [CCParse.Infix]
(>>=) [CCParse]
Monadic bind
(>>=) [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]
(>>=) [CCVector]
Infix version of CCVector.flat_map
(>>>) [CCPair]
Map on the right side of the tuple
(>>|) [CCArrayLabels]
Infix version of CCArrayLabels.map
(>>|) [CCArray]
Infix version of CCArray.map
(>|=) [CCPool.Make.Fut.Infix]
(>|=) [CCPool.Make.Fut]
(>|=) [CCSimple_queue.Infix]
(>|=) [CCRAL.Infix]
Alias to CCRAL.map
(>|=) [CCFQueue]
Synonym to CCFQueue.map
(>|=) [CCLazy_list.Infix]
(>|=) [CCKList.Infix]
(>|=) [CCKList]
(>|=) [CCKTree]
(>|=) [CCEqual.Infix]
(>|=) [CCEqual]
Infix equivalent of CCEqual.map
(>|=) [CCArrayLabels]
Infix version of CCArrayLabels.map
(>|=) [CCListLabels.Infix]
(>|=) [CCListLabels]
Infix version of map with reversed arguments
(>|=) [CCParse.Infix]
(>|=) [CCParse]
Map
(>|=) [CCResult.Infix]
(>|=) [CCResult]
(>|=) [CCRandom]
(>|=) [CCOrd.Infix]
(>|=) [CCOrd]
Infix equivalent of CCOrd.map
(>|=) [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
(>|=) [CCVector]
Infix version of CCVector.map
(@) [CCSimple_queue.Infix]
(@) [CCListLabels.Infix]
(@) [CCListLabels]
(@) [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.
(~-) [CCInt64]
?| [CCUnix.Infix]
Infix version of CCUnix.call
?|& [CCUnix.Infix]
Infix version of CCUnix.async_call
__ocaml_lex_tables [CCSexp_lex]
__ocaml_lex_token_rec [CCSexp_lex]

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 [CCHet.Map]
add [CCHet.Tbl]
add [CCWBTree.S]
add [CCHashTrie.S]
add [CCGraph.MAP]
Add a vertex, possibly with no outgoing edge
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 -> 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 [CCHeap.S]
Synonym to CCHeap.S.insert
add_array [CCRAL]
add_ctx [CCResult]
add_ctx msg leaves Ok x untouched, but transforms Error s into Error s' where s' contains the additional context given by msg
add_ctxf [CCResult]
add_ctxf format_message is similar to CCResult.add_ctx but with Format for printing the message (eagerly).
add_edge [CCGraph.MAP]
add_gen [CCSimple_queue]
add_gen [CCRAL]
add_gen [CCWBTree.S]
add_gen [CCHashTrie.S]
add_gen [CCIntMap]
add_gen [CCHeap.S]
add_gen_mut [CCHashTrie.S]
add_klist [CCSimple_queue]
add_klist [CCIntMap]
add_klist [CCHeap.S]
add_list [CCHet.Map]
add_list [CCHet.Tbl]
add_list [CCSimple_queue]
add_list [CCRAL]
add_list [CCWBTree.S]
add_list [CCHashTrie.S]
add_list [CCGraph.MAP]
add_list [CCIntMap]
add_list [CCPersistentHashtbl.S]
add_list [CCMap.S]
add_list [CCHashtbl.S]
add_list tbl x y adds y to the list x is bound to.
add_list [CCHashtbl.Poly]
add_list tbl x y adds y to the list x is bound to.
add_list [CCSet.S]
add_list [CCHeap.S]
Add the elements of the list to the heap.
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_nodup [CCListLabels]
add_nodup x set adds x to set if it was not already present.
add_nodup [CCList]
add_nodup x set adds x to set if it was not already present.
add_pairs [CCMultiMap.BIDIR]
Add pairs
add_seq [CCHet.Map]
add_seq [CCHet.Tbl]
add_seq [CCSimple_queue]
add_seq [CCRAL]
add_seq [CCWBTree.S]
add_seq [CCHashTrie.S]
add_seq [CCHashSet.S]
add_seq [CCGraph.MAP]
add_seq [CCIntMap]
add_seq [CCPersistentHashtbl.S]
add_seq [CCMap.S]
add_seq [CCHashtbl.S]
Add the corresponding pairs to the table, using Hashtbl.add.
add_seq [CCHashtbl.Poly]
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.Poly]
add_seq_count tbl seq increments the count of each element of seq by calling CCHashtbl.Poly.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.
all_ok [CCList]
all_ok l returns Ok l' if all elements of l are of the form Ok x, or Error e otherwise (with the first error met).
all_some [CCList]
all_some l returns Some l' if all elements of l are of the form Some x, or None otherwise.
and_then [CCPool.Make.Fut]
Wait for the first future to succeed, then launch the second
app [CCPool.Make.Fut]
app f x applies the result of f to the result of x
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 [CCImmutArray]
append [CCSimple_queue]
Append two queues.
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 [CCListLabels]
Safe version of append
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
array [CCEqual]
array [CCFormat.Dump]
array [CCFormat]
array [CCOrd]
array [CCHash]
array_comm [CCHash]
Commutative version of CCHash.array.
arrayi [CCFormat]
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

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]
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 [CCRingBuffer.Array.S]
blit t s arr i len copies len elements from arr starting at i to position s from t
blit [CCArrayLabels]
blit from i into j len copies len elements from the first array to the second.
blit [CCArray_slice]
blit from i into j len copies len elements from the first array to the second.
blit [CCString.S]
Similar to String.blit.
blit [CCArray]
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.
bool [CCEqual]
bool [CCFormat.Dump]
bool [CCFormat]
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.
bsearch [CCArrayLabels]
bsearch ?cmp key arr finds the index of the object key in the array arr, provided arr is sorted using cmp.
bsearch [CCArray_slice]
bsearch ?cmp x arr finds the index of the object x in the array arr, provided arr is sorted using cmp.
bsearch [CCArray]
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 is similar to call_full cmd but returns a tuple stdout, stderr, errcode instead of an object.
call_full [CCUnix]
call_full cmd wraps the result of Unix.open_process_full cmd into an object.
call_stdout [CCUnix]
capacity [CCBlockingQueue]
Number of values the queue can hold
capacity [CCRingBuffer.S]
Length of the inner buffer.
capacity [CCBV]
The number of bits this bitvector can store without resizing.
capacity [CCVector]
Number of elements the vector can contain without being resized
capitalize_ascii [CCString]
See String.
cardinal [CCHet.Map]
cardinal [CCWBTree.S]
cardinal [CCHashTrie.S]
cardinal [CCHashSet.S]
cardinal s returns the number of elements in 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 to one, seen as a set of bits.
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
cartesian_product [CCList]
For example:
     # cartesian_product [[1;2];[3];[4;5;6]] =
     [[1;3;4];[1;3;5];[1;3;6];[2;3;4];[2;3;5];[2;3;6]];;
     # cartesian_product [[1;2];[];[4;5;6]] = [];;
     # cartesian_product [[1;2];[3];[4];[5];[6]] =
     [[1;3;4;5;6];[2;3;4;5;6]];;
   
invariant: cartesian_product l = map_product id l.
catch [CCResult]
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 [CCFormat.Dump]
char [CCFormat]
char [CCHash]
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 [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 [CCWBTree.S]
choose [CCHashTrie.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_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 [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
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 [CCListLabels.Ref]
Remove all elements
clear [CCList.Ref]
Remove all elements
clear [CCVector]
Clear the content of the vector
combine [CCHash]
combine [CCList]
Similar to List.combine but tail-recursive.
combine2 [CCHash]
combine3 [CCHash]
combine4 [CCHash]
combine_gen [CCList]
Lazy version of CCList.combine.
compare [CCSexp]
compare [CCRAL]
Lexicographic comparison
compare [CCWBTree.ORD]
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 [CCArrayLabels]
compare [CCListLabels]
compare [CCArray_slice]
compare [CCResult]
compare [CCChar]
compare [CCInt64]
compare [CCString]
compare [CCOrd]
Polymorphic "magic" comparison
compare [CCRef]
compare [CCArray]
compare [CCFloat]
compare [CCBool]
Total ordering on booleans, similar to Pervasives.compare
compare [CCInt]
compare [CCPair]
compare [CCOpt]
compare [CCList]
compare [CCVector]
Total ordering on vectors.
compare_natural [CCString]
Natural Sort Order, comparing chunks of digits as natural numbers.
compare_versions [CCString]
compare_versions a b compares version strings a and b, considering that numbers are above text.
compile [CCString.Find]
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 [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 [CCListLabels]
cons x l is x::l
cons [CCList]
cons x l is x::l
cons_maybe [CCListLabels]
cons_maybe (Some x) l is x :: l cons_maybe None l is l
cons_maybe [CCList]
cons_maybe (Some x) l is x :: l cons_maybe None l is l
const [CCFormat]
const pp x is a unit printer that uses pp on x
const [CCHash]
return h hashes any value into h.
const [CCFun]
const x y = x for any y
contains [CCMultiSet.S]
contains a x = (count m x > 0)
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 [CCArray_slice]
Copy into a new array
copy [CCString.Sub]
Make a copy of the substring
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 [CCMultiSet.S]
count [CCMultiMap.S]
Number of bindings for this key
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 [CCHet.Tbl]
create [CCHet.Key]
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 size creates a new bounded buffer with given size.
create [CCRingBuffer.Array.S]
Make an array of the given size, filled with dummy elements
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 [CCListLabels.Ref]
Create a new list reference
create [CCRef]
Alias to ref
create [CCList.Ref]
Create a new list reference
create [CCVector]
Create a new, empty vector
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 [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
decr [CCLock]
Atomically decrement the value
decr [CCHashtbl.S]
Same as CCHashtbl.S.incr but substract 1 (or the value of by).
decr [CCHashtbl.Poly]
Same as CCHashtbl.Poly.incr but substract 1 (or the value of by).
decr_then_get [CCLock]
decr_then_get x decrements x, and return its new value
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 [CCListLabels]
All pairs of distinct positions of the list.
diagonal [CCList]
All pairs of distinct positions of the list.
diff [CCHashSet.S]
diff a b returns a - b
diff [CCBV]
diff t1 t2 Return those bits found t1 but not in t2.
diff [CCMultiSet.S]
MultiSet difference.
diff [CCMultiMap.S]
Difference of maps, ie bindings of the first that are not in the second
diff_into [CCBV]
diff ~into t Modify into with only the bits set but not in t.
dijkstra [CCGraph.Traverse]
Dijkstra algorithm, traverses a graph in increasing distance order.
dijkstra_tag [CCGraph.Traverse]
divisors_graph [CCGraph]
n points to all its strict divisors
doubleton [CCImmutArray]
doubleton [CCIntMap]
doubleton [CCFQueue]
drop [CCRAL]
drop [CCKList]
drop [CCListLabels]
Drop the n first elements, keep the rest
drop [CCString]
drop n s removes the n first chars of s
drop [CCList]
Drop the n first elements, keep the rest
drop_after [CCZipper]
Drop every element on the "right" (calling CCZipper.right then will do nothing), keeping the focused element, if any.
drop_after_and_focused [CCZipper]
Drop every element on the "right" (calling CCZipper.right then will do nothing), including the focused element if it is present.
drop_before [CCZipper]
Drop every element on the "left" (calling CCZipper.left then will do nothing).
drop_while [CCRAL]
drop_while [CCKList]
drop_while [CCListLabels]
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 [CCString]
Edition distance between two strings.
elements [CCHashSet.S]
List of elements
empty [CCZipper]
Empty zipper
empty [CCHet.Map]
empty [CCImmutArray]
empty [CCSimple_queue]
empty [CCRAL]
Empty list
empty [CCWBTree.S]
empty [CCHashTrie.S]
empty [CCBitField.S]
Empty bitfields (all bits 0)
empty [CCGraph.MAP]
empty [CCMixset]
Empty set
empty [CCIntMap]
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 [CCArrayLabels]
empty [CCListLabels]
empty [CCArray_slice]
empty [CCArray]
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.
eoi [CCParse]
Expect the end of input, fails otherwise
epsilon [CCFloat]
equal [CCSexp]
equal [CCHet.Key]
Compare two keys that have compatible types
equal [CCSimple_queue]
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 [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 [CCArrayLabels]
equal [CCListLabels]
equal [CCArray_slice]
equal [CCResult]
equal [CCChar]
equal [CCInt64]
equal [CCString]
equal [CCRef]
equal [CCArray]
equal [CCFloat]
equal [CCBool]
equal [CCInt]
equal [CCPair]
equal [CCOpt]
equal [CCList]
equal [CCVector]
equal_caseless [CCString]
Comparison without respect to ascii lowercase.
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]
error [CCSexp_lex]
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 [CCArrayLabels]
Remove given index, obtaining the list of the other elements
except_idx [CCArray]
Remove given index, obtaining the list of the other elements
exists [CCImmutArray]
exists [CCHashSet.S]
exists [CCPersistentHashtbl.S]
exists [CCArrayLabels]
exists [CCArray_slice]
exists [CCIO.File]
exists [CCString]
True for some char?
exists [CCArray]
exists [CCOpt]
exists [CCVector]
Existential test (is there an element that satisfies the predicate?)
exists2 [CCKList]
exists2 [CCArrayLabels]
Exists on pairs of arrays.
exists2 [CCArray_slice]
Exists on pairs of arrays.
exists2 [CCString]
Exists a pair of chars?
exists2 [CCArray]
Exists on pairs of arrays.
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 [CCPool.Make.Fut]
Future that fails immediately
fail [CCParse]
fail msg fails with the given message.
fail [CCResult]
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
failf [CCParse]
Format.sprintf version of CCParse.fail
fair_app [CCKList]
Fair version of CCKList.(<*>)
fair_flat_map [CCKList]
Fair version of CCKList.flat_map.
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 [CCArrayLabels]
Filter elements out of the array.
filter [CCListLabels]
Safe version of List.filter
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 [CCRAL]
filter_map [CCGraph.Seq]
filter_map [CCPersistentHashtbl.S]
filter_map [CCKList]
filter_map [CCArrayLabels]
Map each element into another value, or discard it
filter_map [CCListLabels]
Map and remove elements at the same time
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 [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 [CCArrayLabels]
find f a returns Some y if there is an element x such that f x = Some y, else it returns None
find [CCArray_slice]
find f a returns Some y if there is an element x such that f x = Some y, else it returns None
find [CCString.Find]
Search for pattern in the string, left-to-right
find [CCString]
Find sub in string, returns its first index or -1.
find [CCArray]
Alias to CCArray.find_map
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 [CCString]
find_all ~sub s finds all occurrences of sub in s, even overlapping instances.
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 [CCArrayLabels]
find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds.
find_idx [CCListLabels]
find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds.
find_idx [CCArray_slice]
find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds.
find_idx [CCArray]
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 [CCListLabels]
find_map f l traverses l, applying f to each element.
find_map [CCArray]
find_map f a returns Some y if there is an element x such that f x = Some y, else it returns None
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_map_i [CCArray]
Like CCArray.find_map, but also pass the index to the predicate function.
find_mapi [CCListLabels]
Like CCListLabels.find_map, but also pass the index to the predicate function.
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 [CCListLabels]
find_pred p l finds the first element of l that satisfies p, or returns None if no element satisfies p
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 [CCListLabels]
Unsafe version of CCListLabels.find_pred
find_pred_exn [CCList]
Unsafe version of CCList.find_pred
find_right [CCMultiMap.BIDIR]
Find all bindings for this given right-key
findi [CCArrayLabels]
Like CCArrayLabels.find, but also pass the index to the predicate function.
findi [CCArray_slice]
Like CCArray_slice.find, but also pass the index to the predicate function.
findi [CCArray]
first [CCBV]
First set bit, or return None.
first [CCFQueue]
First element of the queue
first_exn [CCBV]
First set bit, or
first_exn [CCFQueue]
Same as CCFQueue.first but
fix [CCParse]
Fixpoint combinator
fix [CCRandom]
Recursion combinators, for building recursive values.
fix_memo [CCParse]
Same as CCParse.fix, but the fixpoint is memoized.
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 [CCArrayLabels]
Transform each element into an array, then flatten
flat_map [CCListLabels]
Map and flatten at the same time (safe).
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 [CCVector]
Map each element to a sub-vector
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 [CCRAL]
flatten [CCPersistentArray]
Concatenates all the sub-arrays
flatten [CCKList]
flatten [CCListLabels]
Safe flatten
flatten [CCList]
Safe flatten
flip [CCBV]
Flip i-th bit, extending the bitvector if needed.
flip [CCFun]
Flip arguments
float [CCEqual]
float [CCFormat.Dump]
float [CCFormat]
float [CCRandom]
Random float within the given range
float [CCOrd]
float3 [CCFormat]
float_range [CCRandom]
Inclusive range.
floor_div [CCInt]
floor_div a n is integer division rounding towards negative infinity.
flush [CCFormat]
Alias to Format.pp_print_flush.
fmap [CCKList]
focused [CCZipper]
Returns the focused element, if any.
focused_exn [CCZipper]
Returns the focused element, or
fold [CCImmutArray]
fold [CCSimple_queue]
fold [CCRAL]
Fold on the list's elements
fold [CCWBTree.S]
fold [CCHashTrie.S]
fold [CCHashSet.S]
Fold on values
fold [CCGraph.Seq]
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 [CCArrayLabels]
fold [CCArray_slice]
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]
fold [CCPair]
Synonym to CCPair.merge
fold [CCOpt]
Fold on 0 or 1 element
fold [CCHeap.S]
Fold on all values
fold [CCVector]
Fold on elements of the vector
fold2 [CCKList]
Fold on two collections at once.
fold2 [CCArrayLabels]
Fold on two arrays stepwise.
fold2 [CCArray_slice]
Fold on two arrays stepwise.
fold2 [CCString]
Fold on pairs of chars
fold2 [CCArray]
Fold on two arrays stepwise.
fold_filter_map [CCListLabels]
fold_filter_map f acc l is a fold_left-like function, but also generates a list of output in a way similar to CCListLabels.filter_map
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 [CCListLabels]
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_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_left [CCPersistentArray]
fold_m [CCKList.Traverse]
fold_m [CCListLabels.Traverse]
fold_m [CCResult.Traverse]
fold_m [CCList.Traverse]
fold_map [CCListLabels]
fold_map f acc l is a fold_left-like function, but it also maps the list to another list.
fold_map [CCArray]
fold_map f acc a is a fold_left-like function, but it also maps the array to another array.
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 [CCListLabels]
fold_map2 is to fold_map what List.map2 is to List.map.
fold_map2 [CCList]
fold_map2 is to fold_map what List.map2 is to List.map.
fold_ok [CCResult]
fold_ok f acc r will compute f acc x if r=Ok x, and return acc otherwise, as if the result were a mere option.
fold_product [CCListLabels]
Fold on the cartesian product
fold_product [CCList]
Fold on the cartesian product
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 [CCListLabels]
Safe version of fold_right
fold_right [CCList]
Safe version of fold_right
fold_seq [CCResult]
fold_v [CCGraph.Lazy_tree]
fold_values [CCTrie.S]
More efficient version of CCTrie.S.fold, that doesn't keep keys
fold_while [CCArrayLabels]
Fold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator
fold_while [CCListLabels]
Fold until a stop condition via ('a, `Stop) is indicated by the accumulator
fold_while [CCArray_slice]
Fold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator
fold_while [CCArray]
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 [CCImmutArray]
foldi [CCArrayLabels]
Fold left on array, with index
foldi [CCListLabels]
Fold on list, with index
foldi [CCArray_slice]
Fold left on array, with index
foldi [CCArray]
Fold left on array, with index
foldi [CCList]
Fold on list, with index
for_all [CCImmutArray]
for_all [CCHashSet.S]
for_all [CCPersistentHashtbl.S]
for_all [CCArrayLabels]
for_all [CCArray_slice]
for_all [CCString]
True for all chars?
for_all [CCArray]
for_all [CCOpt]
for_all [CCVector]
Universal test (do all the elements satisfy the predicate?)
for_all2 [CCKList]
for_all2 [CCArrayLabels]
Forall on pairs of arrays.
for_all2 [CCArray_slice]
Forall on pairs of arrays.
for_all2 [CCString]
All pairs of chars respect the predicate?
for_all2 [CCArray]
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_dyn_color [CCFormat]
Similar to CCFormat.fprintf but enable/disable colors depending on colors
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.
full [CCArray_slice]
Slice that covers the full array
full [CCString.Sub]
Full string

G
gen [CCString.Split]
gen [CCHash]
gen_cpy [CCString.Split]
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 [CCSemaphore]
Current value
get [CCLock.LockRef]
get [CCLock]
Atomically 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 [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]
Get the value of this 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 [CCArrayLabels.MONO_ARRAY]
get [CCArrayLabels]
get [CCListLabels.Assoc]
Find the element
get [CCArray_slice]
get [CCMap.S]
Safe version of find
get [CCHashtbl.S]
Safe version of Hashtbl.find
get [CCHashtbl.Poly]
Safe version of Hashtbl.find
get [CCString.Sub]
get s i gets the i-th element, or fails
get [CCArray.MONO_ARRAY]
get [CCArray]
get [CCList.Assoc]
Find the element
get [CCVector]
Access element by its index, or
get_at_idx [CCListLabels]
get_at_idx [CCList]
get_at_idx_exn [CCListLabels]
Get the i-th element, or
get_at_idx_exn [CCList]
Get the i-th element, 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_cnum [CCParse]
Reflects the current column number
get_edge [CCGraph.Traverse.Event]
get_edge_kind [CCGraph.Traverse.Event]
get_enter [CCGraph.Traverse.Event]
get_exit [CCGraph.Traverse.Event]
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 [CCListLabels.Assoc]
Same as get, but unsafe
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, but unsafe
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_lnum [CCParse]
Reflects the current line number
get_or [CCResult]
get_or e ~default returns x if e = Ok x, default otherwise
get_or [CCMap.S]
get_or k m ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in m)
get_or [CCHashtbl.S]
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl)
get_or [CCHashtbl.Poly]
get_or tbl k ~default returns the value associated to k if present, and returns default 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_or_add [CCHashtbl.S]
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists.
get_or_add [CCHashtbl.Poly]
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists.
get_pos [CCParse]
Reflects the current (line, column) numbers
get_rank [CCWBTree.S]
get_rank k m looks for the rank of k in m, i.e.
get_safe [CCArrayLabels]
get_safe a i returns Some a.(i) if i is a valid index
get_safe [CCArray_slice]
get_safe a i returns Some a.(i) if i is a valid index
get_safe [CCArray]
get_safe a i returns Some a.(i) if i is a valid index
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_vertex [CCGraph.Traverse.Event]
group [CCKList]
group eq l groups together consecutive elements that satisfy eq.
group_succ [CCListLabels]
group_succ ~eq l groups together consecutive elements that are equal according to eq
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_str [CCResult]
Same as CCResult.guard but uses CCResult.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.

H
hash [CCSexp]
hash [CCHashTrie.KEY]
hash [CCHashSet.ELEMENT]
Positive value
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 [CCListLabels]
hd_tl (x :: l) returns hd, l.
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 [CCListLabels]
First element.
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 [CCFun]
Identity function
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.S]
incr ?by tbl x increments or initializes the counter associated with x.
incr [CCHashtbl.Poly]
incr ?by tbl x increments or initializes the counter associated with x.
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 [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 [CCListLabels]
Similar to Array.init
init [CCString]
Analog to Array.init.
init [CCList]
Similar to Array.init
init [CCVector]
Init the vector with the given function and size
insert [CCZipper]
Insert an element at the current position.
insert [CCHashSet.S]
insert s x adds x into s
insert [CCHeap.S]
Insert a value in the heap
insert_at_idx [CCListLabels]
Insert at i-th position, between the two existing elements.
insert_at_idx [CCList]
Insert at i-th position, between the two existing elements.
int [CCEqual]
int [CCParse.U]
int [CCFormat.Dump]
int [CCFormat]
int [CCRandom]
int [CCOrd]
int [CCHash]
int32 [CCFormat.Dump]
int32 [CCFormat]
int32 [CCHash]
int64 [CCFormat.Dump]
int64 [CCFormat]
int64 [CCHash]
int_range [CCRandom]
Inclusive range
inter [CCHashSet.S]
inter a b returns a ∩ b
inter [CCIntMap]
inter [CCBV]
inter bv1 bv2 returns the intersection of the two sets
inter [CCMultiMap.S]
Intersection of multimaps
inter [CCListLabels]
List intersection.
inter [CCList]
List intersection.
inter_into [CCBV]
inter ~into bv sets into to the intersection of itself and bv
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 [CCIO.File]
is_done [CCPool.Make.Fut]
Is the future evaluated (success/failure)?
is_empty [CCZipper]
Empty zipper? Returns true iff the two lists are empty.
is_empty [CCSimple_queue]
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]
Are there any true bits?
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 [CCListLabels]
is_empty l returns true iff l = []
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_error [CCResult]
Return true if Error
is_focused [CCZipper]
Is the zipper focused on some element? That is, will CCZipper.focused return a Some v?
is_full [CCRingBuffer.S]
true if pushing an element would erase another element.
is_nan [CCFloat]
is_none [CCOpt]
is_num [CCParse]
Is the char a digit?
is_ok [CCResult]
Return true if Ok
is_some [CCOpt]
is_sorted [CCListLabels]
is_sorted l returns true iff l is sorted (according to given order)
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 [CCHet.Map]
iter [CCHet.Tbl]
iter [CCImmutArray]
iter [CCSimple_queue]
iter [CCRAL]
Iterate on the list's elements
iter [CCWBTree.S]
iter [CCHashTrie.S]
iter [CCHashSet.S]
Iterate on values
iter [CCGraph.Seq]
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 [CCArrayLabels]
iter [CCArray_slice]
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]
iter [CCPair]
iter [CCOpt]
Iterate on 0 or 1 element
iter [CCHeap.S]
Iterate on elements
iter [CCVector]
Iterate on the vector's content
iter2 [CCKList]
Iterate on two collections at once.
iter2 [CCArrayLabels]
Iterate on two arrays stepwise.
iter2 [CCArray_slice]
Iterate on two arrays stepwise.
iter2 [CCString]
Iterate on pairs of chars
iter2 [CCArray]
Iterate on two arrays stepwise.
iter_keys [CCMixmap.S]
Iterate on the keys of this map
iter_keys [CCMixtbl]
Iterate on the keys of this table
iter_true [CCBV]
Iterate on bits set to 1
iter_values [CCTrie.S]
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 [CCArrayLabels]
iteri [CCListLabels]
iteri [CCArray_slice]
iteri [CCString]
Iter on chars with their index
iteri [CCArray]
iteri [CCList]
iteri [CCVector]
Iterate on the vector, with indexes
iteri2 [CCString]
Iterate on pairs of chars with their index

J
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).
junk [CCSimple_queue]
Remove first element.
junk_back [CCRingBuffer.S]
Drop the back element from t.
junk_front [CCRingBuffer.S]
Drop the front element from t.

K
keep_ok [CCList]
filter_some l retains only elements of the form Some x.
keep_some [CCList]
filter_some l retains only elements of the form Some x.
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.Poly]
Iterate on keys (similar order as Hashtbl.iter)
keys_list [CCHashtbl.S]
keys t is the list of keys in t.
keys_list [CCHashtbl.Poly]
keys_list t is the list of keys in t.
keys_seq [CCMixmap.S]
All the keys
keys_seq [CCMixtbl]
All the keys
klist [CCString.Split]
klist [CCHash]
klist_cpy [CCString.Split]
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 [CCListLabels]
last n l takes the last n elements of l (or less if l doesn't have that many elements
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 [CCListLabels]
Last element.
last_opt [CCList]
Last element.
left [CCZipper]
Go to the left, or do nothing if the zipper is already at leftmost pos
left [CCString.Split]
Split on the first occurrence of by from the leftmost part of the string
left_exn [CCZipper]
Go to the left, or
left_exn [CCString.Split]
Split on the first occurrence of by from the leftmost part of the string
length [CCHet.Map]
length [CCHet.Tbl]
length [CCImmutArray]
length [CCSimple_queue]
Number of elements in the queue (linear in time)
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]
Size of underlying bitvector.
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 [CCArrayLabels.MONO_ARRAY]
length [CCArrayLabels]
length [CCArray_slice]
length [CCString.S]
length [CCArray.MONO_ARRAY]
length [CCArray]
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 [CCListLabels.Ref]
Apply a list function to the content
lift [CCList.Ref]
Apply a list function to the content
linear [CCCache]
Linear cache with the given size.
lines [CCString]
lines s returns a list of the lines of s (splits along '\n')
lines_gen [CCString]
lines_gen s returns a generator of the lines of s (splits along '\n')
list [CCEqual]
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 [CCOrd]
Lexicographic combination on lists
list [CCHash]
list_ [CCString.Split]
Eplit the given string along the given separator by.
list_comm [CCHash]
Commutative version of CCHash.list.
list_cpy [CCString.Split]
list_seq [CCRandom]
Build random lists from lists of random generators
lnot [CCInt64]
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 [CCArrayLabels]
Lookup the index of some value in a sorted array.
lookup [CCArray_slice]
Lookup the index of some value in a sorted array.
lookup [CCArray]
Lookup the index of some value in a sorted array.
lookup_exn [CCArrayLabels]
lookup_exn [CCArray_slice]
Same as CCArray_slice.lookup, but
lookup_exn [CCArray]
Same as CCArray.lookup, 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).
ltrim [CCString]
trim space on the left (see String.trim for more details)

M
make [CCPool.Make.Fut]
Create a future, representing a value that will be computed by the function.
make [CCZipper]
Create a zipper pointing at the first element of the list
make [CCImmutArray]
make n x makes an array of n times x
make [CCRAL]
make [CCGraph]
Make a graph by providing the children function
make [CCPersistentArray]
make n x returns a persistent array of length n, with x.
make [CCKTree.Dot]
make [CCArray_slice]
Create a slice from given offset and length..
make [CCIO.File]
Build a file representation from a path (absolute or relative)
make [CCString.Sub]
make [CCPair]
Make a tuple from its components
make [CCVector]
make n x makes a vector of size n, filled with x
make1 [CCPool.Make.Fut]
make2 [CCPool.Make.Fut]
many [CCParse]
many p parses a list of p, eagerly (as long as possible)
many1 [CCParse]
parses a non empty list
map [CCPool.Make.Fut]
Maps the value inside the future.
map [CCImmutArray]
map [CCSimple_queue]
Map values
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 [CCEqual]
map f eq is the equality function that, given objects x and y, projects x and y using f (e.g.
map [CCArrayLabels]
map [CCListLabels]
Safe version of map
map [CCParse]
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 [CCVector]
Map elements of the vector, yielding a new vector
map1 [CCPair]
map2 [CCKList]
Map on two collections at once.
map2 [CCArrayLabels]
Map on two arrays stepwise.
map2 [CCParse]
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]
map3 [CCParse]
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_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_lazy [CCOpt]
map_lazy default_fn f o if f o if o = Some x, default_fn () otherwise
map_list [CCHashtbl.S]
Map on a hashtable's items, collect into a list
map_list [CCHashtbl.Poly]
Map on a hashtable's items, collect into a list
map_m [CCKList.Traverse]
map_m [CCListLabels.Traverse]
map_m [CCResult.Traverse]
map_m [CCList.Traverse]
map_m_par [CCListLabels.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_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_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_product_l [CCList]
map_product_l f l maps each element of l to a list of objects of type 'b using f.
map_same [CCPair]
map_snd [CCPair]
Compose the given function with snd.
map_v [CCGraph.Lazy_tree]
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 [CCListLabels]
mapi [CCString]
Map chars with their index
mapi [CCList]
max [CCMultiSet.S]
Maximal element w.r.t the total ordering on elements
max [CCFloat]
max [CCInt]
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
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 [CCHashTrie.S]
mem [CCHashSet.S]
mem s x returns true iff x is in 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 [CCListLabels.Assoc]
mem x l returns true iff x is a key in l
mem [CCListLabels]
Membership to the list.
mem [CCString]
mem ~sub s is true iff sub is a substring of s
mem [CCList.Assoc]
mem x l returns true iff x is a key in l
mem [CCList]
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 [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]
mk_field [CCBitField.S]
Make a new field
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 [CCZipper]
Modify the current element, if any, by returning a new element, or returning None if the element is to be deleted
mutex [CCLock]
Underlying mutex

N
nan [CCFloat]
nativeint [CCFormat.Dump]
nativeint [CCFormat]
nativeint [CCHash]
neg [CCFloat]
neg [CCInt]
neg i = - i
negate [CCBV]
negate t returns a copy of t with all of the bits flipped.
negate [CCBool]
Negation on booleans (functional version of not)
negate_self [CCBV]
negate_self t flips all of the bits in t.
newkey [CCMixset]
newkey () creates a new unique key that can be used to access a 'a value in a set.
newline [CCFormat]
Force newline (see Format.pp_force_newline)
next [CCSexp.Decoder]
Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression
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 ()
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

O
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_unsafe [CCImmutArray]
Take ownership of the given array.
of_bool [CCSexp]
of_chan [CCFormat]
Alias to Format.formatter_of_out_channel
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_trace [CCResult]
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]
Alias to Int64.of_float
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 [CCImmutArray]
of_gen [CCSimple_queue]
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 [CCListLabels]
of_gen [CCString]
of_gen [CCList]
of_gen [CCHeap.S]
of_gen [CCVector]
of_hashtbl [CCGraph]
of_hashtbl tbl makes a graph from a hashtable that maps vertices to lists of children
of_int [CCSexp]
of_int [CCChar]
Safe version of CCChar.of_int
of_int [CCInt64]
of_int [CCFloat]
Alias to float_of_int
of_int32 [CCInt64]
of_int32_exn [CCInt64]
Alias to Int64.of_int32
of_int_exn [CCChar]
Alias to Char.chr
of_int_exn [CCInt64]
Alias to Int64.of_int
of_klist [CCSimple_queue]
of_klist [CCIntMap]
of_klist [CCFQueue]
of_klist [CCListLabels]
of_klist [CCString]
of_klist [CCList]
of_klist [CCHeap.S]
of_klist [CCVector]
of_lexbuf [CCSexp.Decoder]
of_list [CCSexp]
of_list [CCHet.Map]
of_list [CCHet.Tbl]
of_list [CCImmutArray]
of_list [CCSimple_queue]
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 [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]
Build a map from the given list of bindings k_i -> v_i, added in order using add.
of_list [CCHashtbl.S]
Build a table from the given list of bindings k_i -> v_i, added in order using add.
of_list [CCHashtbl.Poly]
Build a table from the given list of bindings k_i -> v_i, added in order using add.
of_list [CCString]
of_list [CCSet.S]
Build a set from the given list of elements, added in order using add.
of_list [CCOpt]
Head of list, or None
of_list [CCHeap.S]
of_list l = add_list empty l
of_list [CCVector]
of_list_map [CCRAL]
Combination of CCRAL.of_list and CCRAL.map
of_list_mult [CCMultiSet.S]
of_nativeint [CCInt64]
of_nativeint_exn [CCInt64]
Alias to Int64.of_nativeint
of_opt [CCResult]
of_pair [CCSexp]
of_quad [CCSexp]
of_record [CCSexp]
Represent a record by its named fields
of_result [CCOpt]
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 [CCHet.Map]
of_seq [CCHet.Tbl]
of_seq [CCImmutArray]
of_seq [CCSimple_queue]
of_seq [CCRAL]
of_seq [CCWBTree.S]
of_seq [CCHashTrie.S]
of_seq [CCHashSet.S]
of_seq [CCGraph.MAP]
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 [CCListLabels]
of_seq [CCMap.S]
Same as CCMap.S.of_list
of_seq [CCHashtbl.S]
From the given bindings, added in order
of_seq [CCHashtbl.Poly]
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.Poly]
Similar to CCHashtbl.Poly.add_seq_count, but allocates a new table and returns it
of_seq_mult [CCMultiSet.S]
of_slice [CCArray_slice]
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_string [CCInt64]
of_string [CCFloat]
Alias to float_of_string.
of_string [CCInt]
of_string_exn [CCInt64]
of_string_exn [CCFloat]
Alias to float_of_string
of_to_string [CCFormat]
of_to_string f converts its input to a string using f, then prints the string
of_triple [CCSexp]
of_unit [CCSexp]
of_variant [CCSexp]
of_variant name args is used to encode algebraic variants into a S-expr.
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.
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 [CCFormat]
opt pp prints options as follows: Some x will become "some foo" if pp x ---> "foo" None will become "none"
opt [CCHash]
option [CCEqual]
option [CCFormat.Dump]
option [CCOrd]
Comparison of optional values.
or_ [CCOpt]
or_ ~else_ a is a if a is Some _, else_ otherwise
or_lazy [CCOpt]
or_lazy else_ a is a if a is Some _, else_ () otherwise
output [CCFormat]

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 [CCEqual]
pair [CCParse.U]
Parse a pair using OCaml whitespace conventions.
pair [CCFormat.Dump]
pair [CCFormat]
pair [CCOrd]
pair [CCHash]
pairs [CCMultiMap.BIDIR]
Iterate on pairs
parse [CCParse]
parse p st applies p on the input, and returns Ok x if p succeeds with x, or Error s otherwise
parse_chan [CCSexp]
Parse a S-expression from the given channel.
parse_chan_gen [CCSexp]
Parse a channel into a generator of S-expressions
parse_chan_list [CCSexp]
parse_exn [CCParse]
Unsafe version of CCParse.parse
parse_file [CCSexp]
Open the file and read a S-exp from it
parse_file [CCParse]
parse_file p file parses file with p by opening the file and reading it whole.
parse_file_exn [CCParse]
parse_file_list [CCSexp]
Open the file and read a S-exp from it
parse_string [CCSexp]
Parse a string
parse_string [CCParse]
Specialization of CCParse.parse for string inputs
parse_string_exn [CCParse]
parsing [CCParse]
parsing s p behaves the same as p, with the information that we are parsing s, if p fails
partition_map [CCListLabels]
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
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 [CCSimple_queue]
First element of the queue
peek_back [CCRingBuffer.S]
Get the last value from back of t, without modification.
peek_back [CCDeque]
Last value, or
peek_back_exn [CCRingBuffer.S]
Get the last value from back of t, without modification.
peek_exn [CCSimple_queue]
Same as CCSimple_queue.peek but
peek_front [CCRingBuffer.S]
First value from front of t, without modification.
peek_front [CCDeque]
First value, or
peek_front_exn [CCRingBuffer.S]
First value from front of t, without modification.
pick_array [CCRandom]
Pick an element at random from the array
pick_list [CCRandom]
Pick an element at random from the list
poly [CCEqual]
Standard polymorphic equality
poly [CCHash]
the regular polymorphic hash function
pop [CCSimple_queue]
Get and remove the first element
pop [CCListLabels.Ref]
pop [CCList.Ref]
pop [CCVector]
Remove last element, or None
pop_exn [CCSimple_queue]
Same as CCSimple_queue.pop, but fails on empty queues.
pop_exn [CCListLabels.Ref]
Unsafe version of CCListLabels.Ref.pop.
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 [CCSexp]
Pretty-printer nice on human eyes (including indentation)
pp [CCSimple_queue]
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]
Printer to DOT with indentation, etc.
pp [CCKTree]
A pretty-printer using S-expressions and boxes to render the tree.
pp [CCArrayLabels]
Print an array of items with printing function
pp [CCListLabels]
pp [CCArray_slice]
Print an array of items with printing function
pp [CCResult]
pp [CCChar]
pp [CCMap.S]
pp [CCString.S]
pp [CCSet.S]
pp [CCRef]
pp [CCArray]
Print an array of items with printing function
pp [CCFloat]
pp [CCBool]
pp [CCInt]
pp [CCPair]
pp [CCOpt]
pp [CCList]
pp [CCVector]
pp' [CCResult]
Printer that is generic on the error type
pp_binary [CCInt]
prints as "0b00101010".
pp_i [CCArrayLabels]
Print an array, giving the printing function both index and item
pp_i [CCArray_slice]
Print an array, giving the printing function both index and item
pp_i [CCArray]
Print an array, giving the printing function both index and item
pp_noindent [CCSexp]
Raw, direct printing as compact as possible
pp_seq [CCGraph.Dot]
pp_single [CCKTree.Dot]
prefix [CCString]
prefix ~pre s returns true iff pre is a prefix of s
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 [CCChar]
print [CCHashtbl.S]
Printer for tables
print [CCHashtbl.Poly]
Printer for table
print [CCString.S]
Print the string within quotes
print [CCHeap.S]
print_to_file [CCKTree.Dot]
print_to_file filename g prints g into a file whose name is filename.
product [CCKList]
Specialization of CCKList.product_with producing tuples
product [CCListLabels]
Cartesian product of the two lists, with the given combinator
product [CCList]
Cartesian product of the two lists, with the given combinator
product_with [CCKList]
Fair product of two (possibly infinite) lists into a new list.
pure [CCKList]
pure [CCListLabels]
pure [CCParse]
Synonym to CCParse.return
pure [CCResult]
Synonym of CCResult.return
pure [CCRandom]
pure [CCOpt]
Alias to CCOpt.return
pure [CCList]
push [CCBlockingQueue]
push q x pushes x into q, blocking if the queue is full
push [CCSimple_queue]
Push element at the end of the queue
push [CCListLabels.Ref]
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 [CCListLabels.Ref]
Add elements of the list at the beginning of the list ref.
push_list [CCList.Ref]
Add elements of the list at the beginning of the list ref.

Q
quad [CCFormat.Dump]
quad [CCFormat]
quad [CCHash]

R
random [CCArrayLabels]
random [CCListLabels]
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 [CCArrayLabels]
Choose an element randomly.
random_choose [CCListLabels]
Randomly choose an element in the list.
random_choose [CCArray_slice]
Choose an element randomly.
random_choose [CCArray]
Choose an element randomly.
random_choose [CCList]
Randomly choose an element in the list.
random_len [CCArrayLabels]
random_len [CCListLabels]
random_len [CCArray]
random_len [CCList]
random_non_empty [CCArrayLabels]
random_non_empty [CCListLabels]
random_non_empty [CCArray]
random_non_empty [CCList]
random_range [CCFloat]
random_range [CCInt]
random_sequence [CCListLabels]
random_sequence [CCList]
random_small [CCFloat]
random_small [CCInt]
range [CCRAL]
range i j is i; i+1; ... ; j or j; j-1; ...; i
range [CCKList]
range [CCListLabels]
range i j iterates on integers from i to j included .
range [CCInt]
range i j iterates on integers from i to j included .
range [CCList]
range i j iterates on integers from i to j included .
range' [CCListLabels]
Same as CCListLabels.range but the second bound is excluded.
range' [CCInt]
Same as CCInt.range but the second bound is excluded.
range' [CCList]
Same as CCList.range but the second bound is excluded.
range_by [CCListLabels]
range_by ~step i j iterates on integers from i to j included, where the difference between successive elements is step.
range_by [CCInt]
range_by ~step i j iterates on integers from i to j included, where the difference between successive elements is step.
range_by [CCList]
range_by ~step i j iterates on integers from i to j included, where the difference between successive elements is step.
rcompile [CCString.Find]
read [CCIO.File]
Read the content of the given file
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 [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 [CCIO]
Read a line from the channel.
read_lines [CCIO]
Read all lines.
read_lines_l [CCIO]
Read all lines into a list
release [CCSemaphore]
release n s atomically sets s := !s + n
rem [CCInt]
rem a n is the remainder of dividing a by n, with the same sign as n.
remove [CCZipper]
remove l removes the current element, if any.
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 [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 [CCListLabels.Assoc]
remove x l removes the first occurrence of k from l.
remove [CCListLabels]
remove ~key l removes every instance of key from l.
remove [CCIO.File]
Like remove_exn but with an error monad.
remove [CCList.Assoc]
remove x l removes the first occurrence of k from l.
remove [CCList]
remove ~x l removes every instance of x from l.
remove [CCVector]
Remove the n-th element of the vector.
remove_all [CCMultiSet.S]
remove_all set x removes all occurrences of x from set
remove_all [CCMultiMap.S]
Remove the key from the map
remove_at_idx [CCListLabels]
Remove element at given index.
remove_at_idx [CCList]
Remove element at given index.
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_one [CCListLabels]
remove_one x set removes one occurrence of x from set.
remove_one [CCList]
remove_one x set removes one occurrence of x from set.
remove_quotes [CCSexp_lex]
remove_right [CCMultiMap.BIDIR]
Remove all bindings for the right key
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 [CCListLabels]
Concatenate the list with itself n times
repeat [CCString]
The same string, repeated n times
repeat [CCList]
Concatenate the list with itself n times
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 [CCListLabels]
Replicate the given element n times
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 [CCBV]
Set i-th bit to 0, extending the bitvector if needed.
resize [CCBV]
Resize the BV so that it has the specified length.
result [CCFormat.Dump]
result' [CCFormat.Dump]
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_m [CCResult.Traverse]
return [CCPool.Make.Fut]
Future that is already computed
return [CCRAL]
Singleton
return [CCGraph.Seq]
return [CCLazy_list]
Return a computed value
return [CCKList.MONAD]
return [CCKList]
return [CCListLabels.MONAD]
return [CCListLabels]
return [CCParse]
Always succeeds, without consuming its input
return [CCResult.MONAD]
return [CCResult]
Successfully return a value
return [CCFormat]
return "some_format_string" takes a argument-less format string and returns a printer actionable by ().
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 [CCVector]
Singleton vector
rev [CCSimple_queue]
Reverse the queue.
rev [CCRAL]
Reverse the list
rev [CCFQueue]
Reverse the queue, O(n) complexity
rev [CCArrayLabels]
Copy + reverse in place
rev [CCString]
rev s returns the reverse of s
rev [CCArray]
Copy + reverse in place
rev [CCVector]
Reverse the vector
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_in_place [CCArrayLabels]
Reverse the array in place
reverse_in_place [CCArray_slice]
Reverse the array in place
reverse_in_place [CCArray]
Reverse the array in place
rfind [CCString.Find]
Search for pattern in the string, right-to-left
rfind [CCString]
Find sub in string from the right, returns its first index or -1.
right [CCZipper]
Go to the right, or do nothing if the zipper is already at rightmost pos
right [CCString.Split]
Split on the first occurrence of by from the rightmost part of the string
right_exn [CCZipper]
Go to the right, or
right_exn [CCString.Split]
Split on the first occurrence of by from the rightmost part of the string
round [CCFloat]
round f returns the closest integer value, either above or below
rtrim [CCString]
trim space on the right (see String.trim for more details)
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 [CCPool.Make]
run1 f x is similar to run (fun () -> f x)
run2 [CCPool.Make]
run3 [CCPool.Make]

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
scale [CCFloat]
scan_left [CCArray]
scan_left f acc a returns the array [|acc; f acc x0; f (f acc a.(0)) a.(1); …|]
scan_left [CCList]
scan_left f acc l returns the list [acc; f acc x0; f (f acc x0) x1; …] where x0, x1, etc.
scc [CCGraph]
Strongly connected components reachable from the given vertices.
select [CCBV]
select arr bv selects the elements of arr whose index corresponds to a true bit in bv.
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 [CCFormat]
seq [CCString.Split]
seq [CCHash]
seq_cpy [CCString.Split]
seq_left [CCMultiMap.BIDIR]
seq_right [CCMultiMap.BIDIR]
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 [CCKList.Traverse]
sequence_m [CCListLabels.Traverse]
sequence_m [CCResult.Traverse]
sequence_m [CCList.Traverse]
set [CCLock.LockRef]
set [CCLock]
Atomically set the value
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]
Set the value of this 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, extending the bitvector if needed.
set [CCArrayLabels.MONO_ARRAY]
set [CCArrayLabels]
set [CCListLabels.Assoc]
Add the binding into the list (erase it if already present)
set [CCArray_slice]
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]
set [CCList.Assoc]
Add the binding into the list (erase it if already present)
set [CCVector]
Modify element at given index, or
set_at_idx [CCListLabels]
Set i-th element (removes the old one), or does nothing if index is too high
set_at_idx [CCList]
Set i-th element (removes the old one), or does nothing if index is too high
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 [CCArrayLabels]
Shuffle randomly the array, in place
shuffle [CCArray_slice]
Shuffle randomly the array, in place
shuffle [CCArray]
Shuffle randomly the array, in place
shuffle_with [CCArrayLabels]
Like shuffle but using a specialized random state
shuffle_with [CCArray_slice]
Like shuffle but using a specialized random state
shuffle_with [CCArray]
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
singleton [CCImmutArray]
singleton [CCWBTree.S]
singleton [CCHashTrie.S]
singleton [CCHashSet.S]
singleton x is the singleton {x}
singleton [CCIntMap]
singleton [CCFQueue]
singleton [CCMultiSet.S]
singleton [CCKList]
singleton [CCKTree.Dot]
singleton [CCKTree]
Tree with only one label
size [CCBlockingQueue]
Number of elements currently in the queue
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 [CCRingBuffer.S]
skip b len removes len elements from the front of b.
skip [CCParse]
skip p parses zero or more times p and ignores its result
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]
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).
small_float [CCRandom]
A reasonably small float.
small_int [CCRandom]
snoc [CCSimple_queue]
Flip version of CCSimple_queue.push
snoc [CCFQueue]
Push element at the end of the queue
some [CCFormat]
some pp will print options as follows: Some x is printed using pp on x, None is not printed at all
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 [CCArrayLabels]
Sort the array, without allocating (eats stack space though).
sort_generic [CCArray]
Sort the array, without allocating (eats stack space though).
sort_indices [CCArrayLabels]
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_indices [CCArray_slice]
sort_indices cmp a returns a new array b, with the same length as a, such that b.(i) is the index at which the i-th element of sorted cmp a appears in a.
sort_indices [CCArray]
sort_indices cmp a returns a new array b, with the same length as a, such that b.(i) is the index at which the i-th element of sorted cmp a appears in a.
sort_ranking [CCArrayLabels]
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_ranking [CCArray_slice]
sort_ranking cmp a returns a new array b, with the same length as a, such that b.(i) is the index at which the i-the element of a appears in sorted cmp a.
sort_ranking [CCArray]
sort_ranking cmp a returns a new array b, with the same length as a, such that b.(i) is the index at which the i-the element of a appears in sorted cmp a.
sort_uniq [CCKList]
Eager sort that removes duplicate values.
sort_uniq [CCListLabels]
Sort the list and remove duplicate elements
sort_uniq [CCList]
Sort the list and remove duplicate elements
sorted [CCArrayLabels]
sorted cmp a makes a copy of a and sorts it with cmp.
sorted [CCArray_slice]
sorted cmp a makes a copy of a and sorts it with cmp.
sorted [CCArray]
sorted cmp a makes a copy of a and sorts it with cmp.
sorted_insert [CCListLabels]
sorted_insert x l inserts x into l such that, if l was sorted, then sorted_insert x l is sorted too.
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 [CCListLabels]
Merges elements from both sorted list
sorted_merge [CCList]
Merges elements from both sorted list
sorted_merge_uniq [CCListLabels]
sorted_merge_uniq l1 l2 merges the sorted lists l1 and l2 and removes duplicates
sorted_merge_uniq [CCList]
sorted_merge_uniq l1 l2 merges the sorted lists l1 and l2 and removes duplicates
space [CCParse]
Tab or 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 [CCString]
split [CCRandom]
Split a positive value n into n1,n2 where n = n1 + n2.
split [CCList]
A tail-recursive version of List.split.
split_list [CCRandom]
Split a value n into a list of values whose sum is n and whose length is length.
split_on_char [CCString]
Split the string along the given char
sprintf [CCFormat]
Print into a string any format string that would usually be compatible with CCFormat.fprintf.
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
state [CCPool.Make.Fut]
State of the future
state_of_string [CCParse]
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.
string [CCEqual]
string [CCParse]
string s parses exactly the string s, and nothing else
string [CCFormat.Dump]
string [CCFormat]
string [CCOrd]
string [CCHash]
string_of_branch [CCParse]
string_quoted [CCFormat]
Similar to CCString.print.
sub [CCRingBuffer.Array.S]
sub t i len gets the subarray of t from position i to i + len
sub [CCArray_slice]
Sub-slice
sub [CCString.Sub]
Sub-slice
sub [CCFloat]
sublists_of_len [CCList]
sublists_of_len n l returns sub-lists of l that have length n.
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 [CCListLabels]
Test for inclusion
subset [CCList]
Test for inclusion
substring [CCFormat]
Print the substring (s,i,len), where i is the offset in s and len the number of bytes in the substring.
suffix [CCString]
suffix ~suf s returns true iff suf is a suffix of s
suspend [CCParse]
suspend f is the same as f (), but evaluates f () only when needed
swap [CCArray]
swap arr i j swaps elements at indices i and j.
swap [CCPair]
Swap the components of the tuple

T
tail [CCFQueue]
Queue deprived of its first element.
tail [CCKList]
Tail of the list
tail_exn [CCKList]
Unsafe version of CCKList.tail
take [CCBlockingQueue]
Take the first element, blocking if needed
take [CCRAL]
take [CCLazy_list]
Take at most n values.
take [CCKList]
take [CCListLabels]
Take the n first elements, drop the rest
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 and remove 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 and remove the last value from back of t.
take_back_exn [CCFQueue]
Same as CCFQueue.take_back, but fails on empty queues.
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 [CCListLabels]
take_drop n l returns l1, l2 such that l1 @ l2 = l and length l1 = min (length l) n
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_drop_while [CCList]
take_drop_while p l = take_while p l, drop_while p l
take_exn [CCHeap.S]
Same as CCHeap.S.take, but can fail.
take_front [CCRingBuffer.S]
Take and remove 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 and remove 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 [CCRAL]
take_while [CCKList]
take_while [CCListLabels]
take_while [CCList]
tap [CCFun]
tap f x evaluates f x, discards it, then returns x.
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.
tee [CCFormat]
tee a b makes a new formatter that writes in both a and b.
text [CCFormat]
Print string, but replacing spaces with breaks and newlines with CCFormat.newline.
tl [CCRAL]
Remove the first element from the list, or
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_buf [CCSexp]
to_chan [CCSexp]
to_err [CCResult]
to_file [CCSexp]
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_seq [CCSexp]
Print the given sequence of expressions to a file
to_float [CCInt64]
to_gen [CCImmutArray]
to_gen [CCSimple_queue]
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 [CCArrayLabels]
to_gen [CCListLabels]
to_gen [CCArray_slice]
to_gen [CCString.S]
to_gen [CCArray]
to_gen [CCOpt]
to_gen [CCList]
to_gen [CCHeap.S]
to_gen [CCVector]
to_int [CCChar]
Alias to Char.code
to_int [CCInt64]
to_int [CCFloat]
Alias to int_of_float.
to_int32 [CCInt64]
to_klist [CCSimple_queue]
to_klist [CCIntMap]
to_klist [CCFQueue]
to_klist [CCArrayLabels]
to_klist [CCListLabels]
to_klist [CCArray_slice]
to_klist [CCString.S]
to_klist [CCArray]
to_klist [CCList]
to_klist [CCHeap.S]
to_klist [CCVector]
to_list [CCZipper]
Convert the zipper back to a list.
to_list [CCHet.Map]
to_list [CCHet.Tbl]
to_list [CCImmutArray]
to_list [CCSimple_queue]
to_list [CCRAL]
to_list [CCWBTree.S]
to_list [CCHashTrie.S]
to_list [CCGraph.MAP]
to_list [CCGraph.Seq]
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 [CCArray_slice]
Convert directly to a list
to_list [CCMap.S]
to_list [CCHashtbl.S]
List of bindings (order unspecified)
to_list [CCHashtbl.Poly]
List of bindings (order unspecified)
to_list [CCString.S]
to_list [CCSet.S]
to_list [CCRef]
to_list [CCOpt]
to_list [CCHeap.S]
Return the elements of the heap, in no particular order.
to_list [CCVector]
to_list_mult [CCMultiSet.S]
to_list_rev [CCLazy_list]
to_list_sorted [CCHeap.S]
Return the elements in increasing order
to_nativeint [CCInt64]
to_opt [CCResult]
to_result [CCOpt]
to_result_lazy [CCOpt]
to_rev_list [CCZipper]
Convert the zipper back to a reversed list.
to_rev_list [CCDeque]
Efficient conversion to list, in reverse order
to_rev_list [CCKList]
Convert to a list, in reverse order.
to_seq [CCHet.Map]
to_seq [CCHet.Tbl]
to_seq [CCImmutArray]
to_seq [CCSimple_queue]
to_seq [CCRAL]
to_seq [CCWBTree.S]
to_seq [CCHashTrie.S]
to_seq [CCHashSet.S]
to_seq [CCGraph.MAP]
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 [CCArrayLabels]
to_seq [CCListLabels]
to_seq [CCArray_slice]
to_seq [CCResult]
to_seq [CCMap.S]
to_seq [CCHashtbl.S]
Iterate on values in the table
to_seq [CCHashtbl.Poly]
Iterate on bindings in the table
to_seq [CCString.S]
to_seq [CCSet.S]
to_seq [CCRef]
to_seq [CCArray]
to_seq [CCOpt]
to_seq [CCList]
to_seq [CCHeap.S]
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_sorted [CCHeap.S]
Iterate on the elements, in increasing order
to_seq_values [CCTrie.S]
to_slice [CCArray_slice]
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_string [CCSexp]
to_string [CCInt64]
to_string [CCIO.File]
to_string [CCFormat.Dump]
to_string [CCFormat]
to_string [CCFloat]
to_string [CCInt]
to_string_binary [CCInt]
to_tree [CCTrie.S]
to_tree [CCHeap.S]
token [CCSexp_lex]
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 [CCEqual]
triple [CCParse.U]
Parse a triple using OCaml whitespace conventions.
triple [CCFormat.Dump]
triple [CCFormat]
triple [CCOrd]
triple [CCHash]
try_ [CCParse]
try_ p tries to parse like p, but backtracks if p fails.
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
try_with_lock [CCLock]
try_with_lock l f runs f x in a critical section if l is not locked.

U
unbounded [CCCache]
Unbounded cache, backed by a Hash table.
uncapitalize_ascii [CCString]
See String.
uncurry [CCFun]
underlying [CCArray_slice]
Underlying array (shared).
underlying [CCString.Sub]
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 [CCHashSet.S]
union a b returns a ∪ b
union [CCGraph.MAP]
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 [CCListLabels]
List union.
union [CCList]
List union.
union_into [CCBV]
union ~into bv sets into to the union of itself and bv.
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 [CCListLabels]
Remove duplicates w.r.t the equality predicate.
uniq [CCList]
Remove duplicates w.r.t the equality predicate.
uniq_sort [CCVector]
Sort the array and remove duplicates, in place (e.g.
uniq_succ [CCListLabels]
uniq_succ l removes duplicate elements that occur one next to the other.
uniq_succ [CCList]
uniq_succ l removes duplicate elements that occur one next to the other.
unit [CCEqual]
unit [CCFormat.Dump]
unit [CCFormat]
Prints "()"
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, None otherwise.
update [CCHashTrie.S]
update k ~f m calls f (Some v) if get k m = Some v, None otherwise.
update [CCIntMap]
update [CCPersistentHashtbl.S]
update tbl key f calls 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 [CCListLabels.Assoc]
update k ~f l 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 [CCMap.S]
update k f m calls f (Some v) if find k m = v, otherwise it calls 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 -> v' is inserted using Hashtbl.replace
update [CCHashtbl.Poly]
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 -> v' is inserted using Hashtbl.replace
update [CCRef]
Update the reference's content with the given function
update [CCList.Assoc]
update k ~f l 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.Poly]
Iterate on values in the table
values_list [CCHashtbl.S]
values t is the list of values in t.
values_list [CCHashtbl.Poly]
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 [CCIO.File]
Similar to CCIO.File.read_dir (with recurse=true), this function walks a directory recursively and yields either files or directories.
walk_l [CCIO.File]
Same as CCIO.File.walk but returns a list (therefore it's eager and might take some time on large directories)
weight [CCWBTree.KEY]
weight [CCWBTree.S]
white [CCParse]
Tab or space or newline
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_ksf [CCFormat]
with_color_ksf "Blue" ~f "%s %d" "yolo" 42 will behave like CCFormat.ksprintf, but wrapping the content with the given style Example: the following with raise Failure with a colored message
      CCFormat.with_color_ksf "red" ~f:failwith "%a" CCFormat.Dump.(list int) [1;2;3];;
    
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_file_lock [CCUnix]
with_file_lock ~kind filename f puts a lock on the offset 0 of the file named filename, calls f and returns its result after the file is unlocked.
with_in [CCUnix]
Open an input file with the given optional flag list, calls the function on the input channel.
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_out [CCUnix]
Same as CCUnix.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 [CCIO]
Similar to CCIO.with_out but with the [Open_appendOpen_creatOpen_wronly] flags activated, to append to the file.
with_out_chan [CCFormat]
with_out_chan oc f turns oc into a formatter fmt, and call f fmt.
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
      CCUnix.with_process_in "ls /tmp" ~f:CCIO.read_lines_l;;
    
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.
word [CCParse.U]
non empty string of alpha num, start with alpha
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.
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.
wrap3 [CCResult]
Same as CCResult.guard but gives the function three arguments.
write [CCIO.File]
Write the given string into the given file
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 [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]

Z
zip [CCKList]
Combine elements pairwise.