Index of values

Map on both sides of a tuple

a *> b parses a, then parses b into x, and returns x.

a <* b parses a into x, parses b and ignores its result, and returns x

Mathematical composition

Alias to compose

f &&& g is fun x -> f x, g x.

Alias to CCRAL.range

a -- b is the integer range from a to b, both included.

a -- b is the range of integers containing a and b (therefore, never empty)

Range array

Infix alias for range

Range array

Alias to CCInt.range

Infix alias for range

Range of integers, either ascending or descending (both included, therefore the result is never empty).

a -- b is the integer range from a to b, where b is excluded.

a -- b is the integer range from a to b, where b is excluded.

a -- b is the integer range from a to b, where b is excluded.

Range array, excluding right bound

Infix alias for range'

Range array, excluding right bound

Alias to CCInt.range'

Infix alias for range'

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]

Alias to CCPool.Make.Fut.app

Alias to CCRAL.app

Applicative

a <*> b evaluates a and b, and, in case of success, returns Ok (a b).

a <+> b is a if a is Some _, b otherwise

Infix version of CCKList.fair_app

Alias to CCSimple_queue.snoc

Map on the left side of the tuple

a <?> msg behaves like a, but if a fails without consuming any input, it fails with msg instead.

a <?> b is a choice operator.

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.

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.

Infix version of CCKList.fair_flat_map

Alias to CCRAL.flat_map

Infix version of CCArrayLabels.flat_map

Monadic bind

Infix version of CCArray.flat_map

Monadic bind

Infix version of CCVector.flat_map

Map on the right side of the tuple

Infix version of CCArrayLabels.map

Infix version of CCArray.map

Alias to CCPool.Make.Fut.map

Alias to CCSimple_queue.map

Alias to CCRAL.map

Synonym to CCFQueue.map

Infix equivalent of CCEqual.map

Infix version of CCArrayLabels.map

Infix version of map with reversed arguments

Map

Infix equivalent of CCOrd.map

Infix version of CCArray.map

Infix version of CCOpt.map

Infix version of map with reversed arguments

Infix version of CCVector.map

Alias to CCSimple_queue.append

Cons (alias to CCRAL.cons)

f @@ x is the same as f x, but right-associative.

Pipeline.

Infix version of CCUnix.call

Infix version of CCUnix.async_call

All bindings whose key is bigger or equal to the given key, in ascending order

acquire n s blocks until get s >= n, then atomically sets s := !s - n

activate b unblocks all threads that were waiting on b

activated b returns true iff activate b was called, and reset b was not called since.

Returns true until stop t has been called.

active () is true as long as stop() has not been called yet

active i is not (frozen i)

Add a vertex, possibly with no outgoing edge

Bind the key to the value, using inj

Add the binding to the table, returning a new table.

add tbl k v adds k -> v to tbl, possibly replacing the old value associated with k.

Add a binding to the trie (possibly erasing the previous one)

Add a binding (left,right)

Add a key/value binding

Synonym to CCHeap.S.insert

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 format_message is similar to CCResult.add_ctx but with Format for printing the message (eagerly).

add_list tbl x y adds y to the list x is bound to.

add_list tbl x y adds y to the list x is bound to.

Add the elements of the list to the heap.

add_mult set x n adds n occurrences of x to set

add_mut ~id k v m behaves like add k v m, except it will mutate in place whenever possible.

add_nodup x set adds x to set if it was not already present.

add_nodup x set adds x to set if it was not already present.

Add pairs

Add the corresponding pairs to the table, using Hashtbl.add.

Add the corresponding pairs to the table, using Hashtbl.add.

add_seq_back q seq adds elements of seq into the back of q, in order.

add_seq_count tbl seq increments the count of each element of seq by calling CCHashtbl.S.incr.

add_seq_count tbl seq increments the count of each element of seq by calling CCHashtbl.Poly.incr.

add_seq_front q seq adds elements of seq into the front of q, in reverse order.

Call the callback f after the given number of seconds.

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 l returns Some l' if all elements of l are of the form Some x, or None otherwise.

Wait for the first future to succeed, then launch the second

app f x applies the result of f to the result of x

app f x applies the result of f to the result of x, in a separated job scheduled in the pool

Append two queues.

Append the two arrays

append b ~into copies all data from b and adds it at the end of into.

Append two queues.

Lazy concatenation

Safe version of append

Append the given string into the given file

Safe version of append

append a b adds all elements of b to a

Same as append, with an array

append_back ~into q adds all elements of q at the back of into.

Append the given string into the given file, possibly raising

append_front ~into q adds all elements of q at the front of into O(length q) in time

Append content of generator

Append content of list

Append content of sequence

Commutative version of CCHash.array.

Graph view of the map

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

Spawns a subprocess, like CCUnix.call, but the subprocess's channels are line generators and line sinks (for stdin).

Create a future that evaluates to () at the given Unix timestamp

Build an atom directly from a string

All bindings whose key is smaller or equal to the given key, in decreasing order

Breadth-first traversal of the tree

Iterate on all bindings

Iterate on all bindings

All the bindings that come from the corresponding injection

All the bindings that come from the corresponding injection

blit t s arr i len copies len elements from arr starting at i to position s from t

blit from i into j len copies len elements from the first array to the second.

blit from i into j len copies len elements from the first array to the second.

Similar to String.blit.

blit from i into j len copies len elements from the first array to the second.

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 buf to_buf o len copies at most len elements from buf into to_buf starting at offset o in s.

both a b, in case of success, returns Ok (o, o') with the ok values of a and b.

bsearch ?cmp key arr finds the index of the object key in the array arr, provided arr is sorted using cmp.

bsearch ?cmp x arr finds the index of the object x in the array arr, provided arr is sorted using cmp.

bsearch ?cmp x arr finds the index of the object x in the array arr, provided arr is sorted using cmp.

call cmd is similar to call_full cmd but returns a tuple stdout, stderr, errcode instead of an object.

call_full cmd wraps the result of Unix.open_process_full cmd into an object.

Number of values the queue can hold

Length of the inner buffer.

The number of bits this bitvector can store without resizing.

Number of elements the vector can contain without being resized

See String.

cardinal s returns the number of elements in s

Number of mappings

Number of bindings in the map.

Number of bindings

Number of bits set to one, seen as a set of bits.

Number of distinct elements

Number of distinct left keys

Number of distinct right keys

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 e ~ok ~err calls either ok or err depending on the value of e.

char c parses the char c and nothing else

char_if f parses a character c if f c = true

Same as CCParse.chars_if, but only non-empty strings

chars_if f parses a string of chars that satisfy f

choice returns the first non-None element of the list, or None

choice_seq s is similar to CCOpt.choice, but works on sequences.

choose l selects a member of l that is a Ok _ value, or returns Error l otherwise, where l is the list of errors.

Choose a generator within the list.

Choose among those futures (the first to terminate).

Same as CCRandom.choose but without option.

Choose among those futures (the first to terminate).

Choose among the list

chop_pref ~pre s removes pre from s if pre really is a prefix of s, returns None otherwise

chop_suffix ~suf s removes suf from s if suf really is a suffix of s, returns None otherwise

clear s removes all elements from s

Clear the content of the buffer.

Clear content of the hashtable

Set every bit to 0

Remove all elements

Clear the content of the cache

Remove all elements

Remove all elements

Clear the content of the vector

Similar to List.combine but tail-recursive.

Lazy version of CCList.combine.

Lexicographic comparison

Total order between maps; the precise order is unspecified .

compare a b compares lexicographically a and b

Total order on multimaps

Lexicographic comparison.

Polymorphic "magic" comparison

Total ordering on booleans, similar to Pervasives.compare

Total ordering on vectors.

Natural Sort Order, comparing chunks of digits as natural numbers.

compare_versions a b compares version strings a and b, considering that numbers are above text.

Composition

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 ~sep g concatenates all strings of g, separated with sep.

Add an element at the front of the list

Push element at the front of the queue

cons x l is x::l

cons x l is x::l

cons_maybe (Some x) l is x :: l cons_maybe None l is l

cons_maybe (Some x) l is x :: l cons_maybe None l is l

const pp x is a unit printer that uses pp on x

return h hashes any value into h.

const x y = x for any y

contains a x = (count m x > 0)

Fresh copy

copy a returns a fresh copy of a.

Make a fresh copy of the buffer.

copy t makes a fresh copy of the array t

Copy of the table

Copy of bitvector

Fresh copy, O(n) in time

Fresh copy of the table; the underlying structure is not shared anymore, so using both tables alternatively will be efficient

Copy into a new array

Make a copy of the substring

Shallow copy (may give an immutable or mutable vector)

copy_into ~into s copies all elements of s into into

Number of bindings for this key

A new timer.

Create a new queue of size n.

Create a barrier

create n creates a semaphore with initial value n

Create a new protected value

Create a new, active ID

create n makes a new set with the given capacity n

create size creates a new bounded buffer with given size.

Make an array of the given size, filled with dummy elements

create n creates a hash table of initial size n.

Create a bitvector of given size, with given default value

New deque

Create a new hashtable, with the given initial capacity

Create a new table of the given initial capacity

Create a new list reference

Alias to ref

Create a new list reference

Create a new, empty vector

Return a value that works for a given type of values.

Return a value that works for a given type of values.

Create a new vector, using the given value as a filler.

Cut the tree at the given depth, so it becomes finite.

Cycle through the iterator infinitely.

Atomically decrement the value

Same as CCHashtbl.S.incr but substract 1 (or the value of by).

Same as CCHashtbl.Poly.incr but substract 1 (or the value of by).

decr_then_get x decrements x, and return its new value

Delay evaluation.

detach f is the same as ignore (spawn f)

Full version of DFS.

Depth-first traversal of the tree

Full version of DFS using integer tags

All pairs of distinct positions of the list.

All pairs of distinct positions of the list.

diff a b returns a - b

diff t1 t2 Return those bits found t1 but not in t2.

MultiSet difference.

Difference of maps, ie bindings of the first that are not in the second

diff ~into t Modify into with only the bits set but not in t.

Dijkstra algorithm, traverses a graph in increasing distance order.

n points to all its strict divisors

Drop the n first elements, keep the rest

drop n s removes the n first chars of s

Drop the n first elements, keep the rest

Drop every element on the "right" (calling CCZipper.right then will do nothing), keeping the focused element, if any.

Drop every element on the "right" (calling CCZipper.right then will do nothing), including the focused element if it is present.

Drop every element on the "left" (calling CCZipper.left then will do nothing).

Dummy cache, never stores any value

dup x = (x,x) (duplicate the value)

dup_map f x = (x, f x).

Edition distance between two strings.

List of elements

Empty zipper

Empty list

Empty bitfields (all bits 0)

Empty set

Empty map

Empty bitvector

Empty table.

Empty multimap

Empty list

Empty heap

Parses '\n'

Hint to the vector that it should have at least the given capacity.

Hint to the vector that it should have at least the given capacity.

Expect the end of input, fails otherwise

Compare two keys that have compatible types

Equality between IDs

equal a b is extensional equality (a and b have the same elements)

equal ~eq a b checks whether a and b have the same set of pairs (key, value), comparing values with eq

equal a b checks whether a and b contain the same sequence of elements.

Same multimap

Equality step by step.

Comparison without respect to ascii lowercase.

Equality with allowed error up to a non negative epsilon value

Returns true iff the two comparison results are the same

Escape a string so it can be a shell argument.

Listen on the address and calls the handler in a blocking fashion.

every timer n ~f calls f () every n seconds.

Remove given index, obtaining the list of the other elements

Remove given index, obtaining the list of the other elements

True for some char?

Existential test (is there an element that satisfies the predicate?)

Exists on pairs of arrays.

Exists on pairs of arrays.

Exists a pair of chars?

Exists on pairs of arrays.

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 m returns k, v, m' where k,v is the pair with the smallest key in m, and m' does not contain k.

Future that fails immediately

fail msg fails with the given message.

Fail with an error

fail_printf format uses format to obtain an error message and then returns Error msg

fail_printf format uses format to obtain an error message and then returns Error msg

Format.sprintf version of CCParse.fail

Fair version of CCKList.(<*>)

Fair version of CCKList.flat_map.

filter bv p only keeps the true bits of bv whose index satisfies p index

Filter values.

Filter elements out of the array.

Safe version of List.filter

Filter elements out of the array.

Filter on 0 or 1 element

Safe version of List.filter

Filter values, only retaining the ones that satisfy the predicate.

Filter elements from the vector.

Filter elements in place.

Map each element into another value, or discard it

Map and remove elements at the same time

Map each element into another value, or discard it

Map and remove elements at the same time

Map elements with a function, possibly filtering some of them out

finally h f calls f () and returns its result.

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

Safe version of CCHashSet.S.find_exn

Find the value for the given key, which must be of the right type.

Find the value for the given key, which must be of the right type.

Find the value for this key, or fails

Find the value associated with the key, if any

List of values for this key

Look for an element that maps to Some _

find f a returns Some y if there is an element x such that f x = Some y, else it returns None

find f a returns Some y if there is an element x such that f x = Some y, else it returns None

Search for pattern in the string, left-to-right

Find sub in string, returns its first index or -1.

Alias to CCArray.find_map

Find an element that satisfies the predicate

like CCMultiMap.BIDIR.find_left but returns at most one value

like CCMultiMap.BIDIR.find_right but returns at most one value

find_all ~sub s finds all occurrences of sub in s, even overlapping instances.

find_all ~sub s finds all occurrences of sub in s and returns them in a list

find_exn s x returns y if x and y are equal, and mem s y.

Same as CCIntMap.find but unsafe

Same as CCTrie.S.find but can fail.

Find an element that satisfies the predicate, or

find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds.

find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds.

find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds.

find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds.

find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds.

Iterate on bindings for this key

Find all bindings for this given left-key

find_map f l traverses l, applying f to each element.

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 f l traverses l, applying f to each element.

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

Like CCArray.find_map, but also pass the index to the predicate function.

Like CCListLabels.find_map, but also pass the index to the predicate function.

Like CCList.find_map, but also pass the index to the predicate function.

Find minimal element

Same as CCHeap.S.find_min but can fail

find_pred p l finds the first element of l that satisfies p, or returns None if no element satisfies p

find_pred p l finds the first element of l that satisfies p, or returns None if no element satisfies p

Unsafe version of CCListLabels.find_pred

Unsafe version of CCList.find_pred

Find all bindings for this given right-key

Like CCArrayLabels.find, but also pass the index to the predicate function.

Like CCArray_slice.find, but also pass the index to the predicate function.

Alias to CCArray.find_map_i

First set bit, or return None.

First element of the queue

First set bit, or

Same as CCFQueue.first but

Fixpoint combinator

Recursion combinators, for building recursive values.

Same as CCParse.fix, but the fixpoint is memoized.

Monadic combination of futures

Flat map (map + concatenation)

Monadic flatten + map

Transform each element into an array, then flatten

Map and flatten at the same time (safe).

Map each chars to a string, then concatenates them all

Transform each element into an array, then flatten

Flip version of >>=

Map and flatten at the same time (safe).

Map each element to a sub-vector

Like CCVector.flat_map, but using list for intermediate collections.

Like CCVector.flat_map, but using CCVector.sequence for intermediate collections.

Concatenates all the sub-arrays

Safe flatten

Safe flatten

Flip i-th bit, extending the bitvector if needed.

Flip arguments

Random float within the given range

Inclusive range.

floor_div a n is integer division rounding towards negative infinity.

Alias to Format.pp_print_flush.

Returns the focused element, if any.

Returns the focused element, or

Fold on the list's elements

Fold on values

Fold on elements

Fold over bindings

Fold on key/value bindings.

Fold on pairs

Fold on all key/value

Fold on values

Fold on values in no specified order.

fold ~ok ~error e opens e and, if e = Ok x, returns ok x, otherwise e = Error s and it returns error s.

Fold on chars by increasing index.

Synonym to CCPair.merge

Fold on 0 or 1 element

Fold on all values

Fold on elements of the vector

Fold on two collections at once.

Fold on two arrays stepwise.

Fold on two arrays stepwise.

Fold on pairs of chars

Fold on two arrays stepwise.

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 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 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 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 over the keys

Fold over the keys

fold_map f acc l is a fold_left-like function, but it also maps the list to another list.

fold_map f acc a is a fold_left-like function, but it also maps the array to another array.

fold_map f acc l is a fold_left-like function, but it also maps the list to another list.

fold_map2 is to fold_map what List.map2 is to List.map.

fold_map2 is to fold_map what List.map2 is to List.map.

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 on the cartesian product

Fold on the cartesian product

Fold on the list's elements, in reverse order (starting from the tail)

Fold on the elements of the array.

Safe version of fold_right

Safe version of fold_right

More efficient version of CCTrie.S.fold, that doesn't keep keys

Fold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator

Fold until a stop condition via ('a, `Stop) is indicated by the accumulator

Fold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator

Fold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator

Fold until a stop condition via ('a, `Stop) is indicated by the accumulator

Fold left on array, with index

Fold on list, with index

Fold left on array, with index

Fold left on array, with index

Fold on list, with index

True for all chars?

Universal test (do all the elements satisfy the predicate?)

Forall on pairs of arrays.

Forall on pairs of arrays.

All pairs of chars respect the predicate?

Forall on pairs of arrays.

force t evaluates t completely and returns a regular tree structure

Alias to Format.fprintf

Similar to CCFormat.fprintf but enable/disable colors depending on colors

freeze i makes i unusable for new modifications.

Prevent new fields from being added.

Make an immutable vector (no copy! Don't use the old version)

Copy the vector into an immutable version

Remove and return the first element of the list

Unsafe version of CCRAL.front.

frozen i returns true if freeze i was called before.

fsign x is one of -1., -0., +0., +1., or nan if x is NaN.

Slice that covers the full array

Full string

Traversal of the given graph, starting from a sequence of vertices, using the given bag to choose the next vertex to explore.

One-shot traversal of the graph using a tag set and the given bag

Current value

Atomically get the value in the lock.

Blocking get: wait for the future to be evaluated, and get the value, or the exception that failed the future is returned.

Access the element

get l i accesses the i-th element of the list.

Get the value of this field

get ~key set obtains the value for key in set, if any.

get a i returns the element with index i from the array a.

get t i gets the element at position i

Get the value corresponding to this key, if it exists and belongs to the same key

Get the value corresponding to this key, if it exists and belongs to the same key

Is the i-th bit true? Returns false if the index is too high

Safe version of !

get k tbl recovers the value for k in tbl, or returns None if k doesn't belong

Find the element

Safe version of find

Safe version of Hashtbl.find

Safe version of Hashtbl.find

get s i gets the i-th element, or fails

Find the element

Access element by its index, or

Get the i-th element, or

Get the i-th element, or

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.

Reflects the current column number

Unsafe version of CCRAL.get

Same as CCMixset.get, but can fail

Synonym to CCPersistentHashtbl.S.find with flipped arguments

Same as get, but unsafe

Extract the value x from Ok x, fails otherwise.

Open the option, possibly failing if it is None

Same as get, but unsafe

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 default_fn x unwraps x, but if x = None it returns default_fn () instead.

Reflects the current line number

get_or e ~default returns x if e = Ok x, default otherwise

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 tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl)

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 ~default o extracts the value from o, or returns default if o = None.

get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists.

get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists.

Reflects the current (line, column) numbers

get_rank k m looks for the rank of k in m, i.e.

get_safe a i returns Some a.(i) if i is a valid index

get_safe a i returns Some a.(i) if i is a valid index

get_safe a i returns Some a.(i) if i is a valid index

get_then_clear b sets b to false, and return the old value

get_then_decr x decrements x, and return its previous value

get_then_incr x increments x, and return its previous value

get_then_incr r increments r and returns its old value, think r++

get_then_set b sets b to true, and return the old value

group eq l groups together consecutive elements that satisfy eq.

group_succ ~eq l groups together consecutive elements that are equal according to eq

group_succ ~eq l groups together consecutive elements that are equal according to eq

guard f runs f () and returns its result wrapped in Ok.

Same as CCResult.guard but uses CCResult.of_exn to print the exception.

Same as CCResult.guard_str but uses CCResult.of_exn_trace instead of CCResult.of_exn so that the stack trace is printed.

Positive value

Wrap the printer in an horizontal box

First element of the list, or

hd_tl (x :: l) returns hd, l.

hd_tl (x :: l) returns hd, l.

Evaluate head, return it, or None if the list is empty

Head of the list

Unsafe version of CCKList.head

First element.

First element.

Length of the longest path to empty leaves

Wrap the printer in a horizontal or vertical box

Wrap the printer in a horizontal/vertical box

Identity function

Decide which hash function to use depending on the boolean

if_ f x is Some x if f x, None otherwise

Atomically increment the value

incr ?by tbl x increments or initializes the counter associated with x.

incr ?by tbl x increments or initializes the counter associated with x.

incr_then_get x increments x, and return its new value

incr_then_get r increments r and returns its new value, think ++ r

init n f makes the array [| f 0; f 1; ... ; f (n-1) |].

make n f returns a persistent array of length n, with element i initialized to the result of f i.

Queue deprived of its last element.

Similar to Array.init

Analog to Array.init.

Similar to Array.init

Init the vector with the given function and size

Insert an element at the current position.

insert s x adds x into s

Insert a value in the heap

Insert at i-th position, between the two existing elements.

Insert at i-th position, between the two existing elements.

Inclusive range

inter a b returns a ∩ b

inter bv1 bv2 returns the intersection of the two sets

Intersection of multimaps

List intersection.

List intersection.

inter ~into bv sets into to the intersection of itself and bv

inter_mut ~into a changes into into a ∩ into

Fair interleaving of both streams.

intersection a b is a multiset such that count (intersection a b) x = min (count a x) (count b x)

Is the char a letter?

is_dag ~graph vs returns true if the subset of graph reachable from vs is acyclic.

Is the future evaluated (success/failure)?

Empty zipper? Returns true iff the two lists are empty.

Check whether the list is empty

Is the buffer empty (i.e.

Are there any true bits?

Is the deque empty?

Is the table empty?

Empty multimap?

Evaluates the head

is_empty l returns true iff l = []

is_empty l returns true iff l = []

Is the heap empty?

Is the vector empty?

Return true if Error

Is the zipper focused on some element? That is, will CCZipper.focused return a Some v?

true if pushing an element would erase another element.

Is the char a digit?

Return true if Ok

is_sorted l returns true iff l is sorted (according to given order)

is_sorted l returns true iff l is sorted (according to given order)

True on ' ' and '\t'

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

True on ' ' and '\t' and '\n'

Iterate on the list's elements

Iterate on values

iter b ~f calls f i t for each element t in buf

iter f t iterates over the array t invoking f with the current element, in array order

Iterate on all bits

Iterate on elements

Iterate over bindings

Iterate on cached values.

Same as CCTrie.S.fold, but for effectful functions

Iterate on all key/value

Apply the function only in case of Ok

Alias to String.iter

Call the function on the content of the reference

Iterate on 0 or 1 element

Iterate on elements

Iterate on the vector's content

Iterate on two collections at once.

Iterate on two arrays stepwise.

Iterate on two arrays stepwise.

Iterate on pairs of chars

Iterate on two arrays stepwise.

Iterate on the keys of this map

Iterate on the keys of this table

Iterate on bits set to 1

iter f t applies function f to all elements of the persistent array, in order from element 0 to element length t - 1.

iteri b ~f calls f i t for each element t in buf, with i being its relative index within buf.

Iterate with index (starts at 0)

Iter on chars with their index

Iterate on the vector, with indexes

Iterate on pairs of chars with their index

A.join a joins every thread in a

join t, in case of success, returns Ok o from Ok (Ok o).

Remove first element.

Drop the back element from t.

Drop the front element from t.

filter_some l retains only elements of the form Some x.

filter_some l retains only elements of the form Some x.

Iterate on keys only

Iterate on keys (similar order as Hashtbl.iter)

Iterate on keys (similar order as Hashtbl.iter)

keys t is the list of keys in t.

keys_list t is the list of keys in t.

All the keys

All the keys

ksprintf fmt ~f formats using fmt, in a way similar to CCFormat.sprintf, and then calls f on the resulting string.

Last element of the queue

last n l takes the last n elements of l (or less if l doesn't have that many elements

last n l takes the last n elements of l (or less if l doesn't have that many elements

Last element.

Last element.

Go to the left, or do nothing if the zipper is already at leftmost pos

Split on the first occurrence of by from the leftmost part of the string

Go to the left, or

Split on the first occurrence of by from the leftmost part of the string

Number of elements in the queue (linear in time)

Number of elements.

Returns the length of the persistent array.

Number of elements currently stored in the buffer.

length t gets the total number of elements currently in t

Number of bindings

Size of underlying bitvector.

Number of elements used to be linear time, now constant time

Number of bindings

length l returns the number of elements in l, eagerly (linear time).

Number of elements in the list.

Synonym for CCVector.size

leq x y shall return true iff x is lower or equal to y

Lexicographic combination of comparison functions

Apply a list function to the content

Apply a list function to the content

Linear cache with the given size.

lines s returns a list of the lines of s (splits along '\n')

lines_gen s returns a generator of the lines of s (splits along '\n')

list p parses a list of p, with the OCaml conventions for start token "", stop token "" and separator ";".

Lexicographic combination on lists

Eplit the given string along the given separator by.

Commutative version of CCHash.list.

Build random lists from lists of random generators

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 the index of some value in a sorted array.

Lookup the index of some value in a sorted array.

Lookup the index of some value in a sorted array.

Same as CCArrayLabels.lookup_exn, but

Same as CCArray_slice.lookup, but

Same as CCArray.lookup, but

See Char

See String.

LRU cache of the given size ("Least Recently Used": keys that have not been used recently are deleted first).

trim space on the left (see String.trim for more details)

Create a future, representing a value that will be computed by the function.

Create a zipper pointing at the first element of the list

make n x makes an array of n times x

Make a graph by providing the children function

make n x returns a persistent array of length n, with x.

Create a slice from given offset and length..

Build a file representation from a path (absolute or relative)

Make a tuple from its components

make n x makes a vector of size n, filled with x

many p parses a list of p, eagerly (as long as possible)

parses a non empty list

Maps the value inside the future.

Map values

Map on elements

Map values, giving only the value.

Map values

Map all values

Map values, giving only the value.

Lazy map

map f eq is the equality function that, given objects x and y, projects x and y using f (e.g.

Safe version of map

Map on success

Map chars

map f ord is the comparison function that, given objects x and y, projects x and y using f (e.g.

Transform the value

Transform the element inside, if any

Safe version of map

Map elements of the vector, yielding a new vector

Map on two collections at once.

Map on two arrays stepwise.

Same as CCResult.map, but also with a function that can transform the error message in case of failure

Map pairs of chars

Map on two arrays stepwise.

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.

Maps the value inside the future, to be computed in a separated job.

Map on the error variant