Index of values

Alias to CCArray1.S.mult

Alias to CCArray1.S.scalar_mult

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

Conjunction on predicates

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

Alias to CCArray1.S.scalar_add

Alias to CCArray1.S.add

Synonym to CCLinq.range

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 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 of integers, either ascending or descending, but excluding right., Example: 1 --^ 10 returns the vector [1;2;3;4;5;6;7;8;9]

Infix synonym to CCLinq.app

Alias to CCPool.Make.Fut.app

Applicative

Synonym to CCApp_parse.app

Alias to CCRAL.app

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

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

a <+> b is choice [a;b], a binary choice

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

Infix version of CCKList.fair_app

a <::> b is app (fun x l -> x::l) a b

a << b parses a, then b, and discards b to return a

Map on the left side of the tuple

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, backtracks and tries to parse b.

a >> b parses a, ignores its result, then parses b

Infix version of CCKList.fair_flat_map

Wait for the result of an action, then use a function to build a new action and execute it

Infix version of CCLinq.bind

Monadic bind

Alias to CCRAL.flat_map

Infix version of CCArray.flat_map

Monadic bind

Infix version of CCVector.flat_map

Map on the right side of the tuple

Same as CCMonadIO.(>>=), but taking the finalizer into account.

Infix version of CCArray.map

Infix synonym of CCLinq.map

Alias to CCPool.Make.Fut.map

Map

Infix version of CCApp_parse.map

Alias to CCRAL.map

Synonym to CCFQueue.map

Infix version of CCArray.map

Infix version of CCOpt.map

Infix version of map with reversed arguments

Infix version of CCVector.map

Cons (alias to CCRAL.cons)

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

Pipeline.

Disjunction on predicates

Negation on predicates

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)

Elementwise sum

Add a pair string/value to the index.

add f x adds x into f

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

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

Synonym to CCHeap.S.insert

Similar to CCHashtbl.COUNTER.add_seq

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_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 pairs

Increment each element of the sequence

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

Boolean conjunction.

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

Parse any of the chars present in the given string

Apply each function to each value

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

Applicative

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

Append two collections together

append a b ~into assumes length a + length b = length into and copies a and b side by side in into

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

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

Apply the operation to the collection.

Apply a hash function to a value.

Flip of CCBatch.S.apply

Apply the operation plus a fold to the collection.

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

bind f a runs the action a and applies f to its result to obtain a new action.

Use the result of a query to build another query and immediately run it.

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 the first array to the second

Blit a slice of the bigstring into another

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

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.

Parse "true" or "false"

New field of type bool

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

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

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

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

Number of elements the vector can contain without being resized

See String.

Number of ones

Number of bindings

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

Number of distinct elements

Number of distinct left keys

Number of distinct right keys

catch e ~ok ~err calls either ok or err depending on the value of e.

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 c parses c and c only

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 l chooses between the parsers, unambiguously

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 one element (if any, otherwise empty) in the collection.

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 l selects a member of l that is a `Ok _ value, or returns `Error l otherwise, where l is the list of errors.

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

Read the channel's content into chunks of size size

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

Clear the content of the vector

Lexicographic order

Lexicographic comparison

Total order

Fast (arbitrary) comparison test O(1)

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.

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

Compile a string into a pattern

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_maybe (Some x) l is x :: l cons_maybe None l is l

const x y = x for any y

contains a x = (count m x > 0)

convolution a ~by:b ~into assumes length into = length a >= length b and computes the boolean convolution of a by b

Fresh copy

Copy of the string

Copy of the filter

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

Make a copy of the substring

Copy into a new array

Shallow copy (may give an immutable or mutable vector)

copy_into ~into s copies all elements of s into into

count c returns a map from elements of c to the number of time those elements occur.

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 bigstring of the given size.

New memoization table

create n makes a new cache of arrays up to length n

create ?hash size creates a filter with given size, and functions.

Create a new, active ID

create n makes a new set with the given capacity n

create ?bounded size creates a new buffer with given size.

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

A counter maps elements to natural numbers (the number of times this element occurred)

create d makes a new table that maps every key to d by default.

Alias to ref

Create a new list reference

Create a new, empty vector

create_default ?hash_len size is the same as create ~hash:(default_hash_funs hash_len) size.

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

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

Similar to create d but here d is a function called to obtain a new default value for each distinct key.

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.

Output the automaton's structure on the given channel.

Atomically decrement the value

Remove one occurrence of the element

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

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

decr_then_get x decrements x, and return its new value

Use Hashtbl.seeded_hash on k seeds

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.

Set difference

diff a b returns a - b

MultiSet difference.

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

Dijkstra algorithm, traverses a graph in increasing distance order.

Remove duplicate elements from the input collection.

n points to all its strict divisors

dot_product a b returns sum_i a(i)*b(i) with the given sum and product, on elt.

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 CCList.Zipper.right then will do nothing), keeping the focused element, if any.

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

Drop every element on the "left" (calling CCList.Zipper.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 collection

Empty string

Empty index

Empty list

Empty bitfields (all bits 0)

Empty set

The empty array

Empty map

Empty bitvector

Empty table.

Empty multimap

Empty list

Empty zipper

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.

Matches the end of input, fails otherwise

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)

Fast equality test O(1)

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.

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

True for some char?

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

Exists a pair of chars?

Exists on pairs of arrays.

Use a specific function that won't be optimized

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.

fail msg fails with the given message.

Future that fails immediately

fail msg fails with the given message.

fail msg fails with the given error message

Fail with an error

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

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

Fair version of CCKList.(<*>)

Fair version of CCKList.flat_map.

Enriched version of CCSexp.Traverse.get_field, with a converter as argument

field_list name f "(... (name a b c d) ...record)" will look for a field based on the given name, and expect it to have a list of arguments dealt with by f (here, "a b c d").

fill a x fills a with x

Fill with a single byte

Filter out values that do not satisfy predicate

filter f p parses the same as p, but fails if the returned value does not satisfy f

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

Filter values.

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.

Filter and map elements at once

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.

find ~pattern s i finds the next occurrence of pattern in s starting at offset i, and returns it, or returns None if the pattern doesn't occur.

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 sub in string, returns its first index or -1.

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

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

Generator on all occurrences of the pattern

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.

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 v returns the first Some y = f x for x in v, or None if f x = None for each x in v

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

Unsafe version of CCList.find_pred

Find all bindings for this given right-key

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

Extract a usable hash value

First set bit, or

First element of the queue

Same as CCFQueue.first but

Fixpoint combinator

fix f makes a fixpoint

Recursion combinators, for building recursive values.

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

Map each value to a sub sequence of values

Same as CCLinq.flat_map but using sequences

Monadic combination of futures

Flat map (map + concatenation)

Monadic flatten + map

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

Alias to CCVector.flat_map_seq

map each element to a collection and flatten the result

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

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

View a multimap as a collection of individual key/value pairs

Concatenates all the sub-arrays

Safe flatten

View a multimap as a list of individual key/value pairs

Flatten the collection by removing options

Flip i-th bit

Flip arguments

Parse a floating point number

Random float within the given range

Inclusive range.

Returns the focused element, if any.

Returns the focused element, or

fold f acc seq folds over seq, consuming it.

Fold on the items of the map

Fold over the collection

Fold over the stored pairs string/value

Fold on the list's elements

Fold on values

Fold on elements, in arbitrary order

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 ~success ~failure e opens e and, if e = `Ok x, returns success x, otherwise e = `Error s and it returns failure s.

Fold on elements of the vector

Fold on two collections at once.

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 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 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_map2 is to fold_map what List.map2 is to List.map.

Fold on the items of the multimap

Fold on the cartesian product

fold f acc seq folds over seq, consuming it.

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

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 on values with their 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?)

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

Fprintf on a monadic output

Print on a channel

Return array to the cache.

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.

Full string

Slice that covers the full array

general_iter f acc seq performs a filter_map over seq, using f.

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

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.

get v i returns the i-th element of v.

Get n-th element

Access the element

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

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

Safe version of find

Number of occurrences for this element

Unfailing retrieval (possibly returns the default value).

Safe version of Hashtbl.find

Safe version of Hashtbl.find

get default x unwraps x, but if x = None it returns default instead.

Find the element

Access element by its index, 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.

Unwrap an option, possibly failing.

Unsafe version of CCRAL.get

Same as CCMixset.get, but can fail

Synonym to CCPersistentHashtbl.S.find with flipped arguments

Extract the value x from Ok x, fails otherwise.

Open the option, possibly failing if it is None

Same as get

Get the i-th element, or

Extract the value x from `Ok x, fails otherwise.

get_field name e, when e = List [(n1,x1); (n2,x2) ... ], extracts the xi such that name = ni, if it can find it.

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

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

get_or k m ~or_ returns the value associated to k if present, and returns or_ otherwise (if k doesn't belong in m)

get_or tbl k ~or_ returns the value associated to k if present, and returns or_ otherwise (if k doesn't belong in tbl)

get_or tbl k ~or_ returns the value associated to k if present, and returns or_ otherwise (if k doesn't belong in tbl)

get_or ~default o extracts the value from o, or returns default if o = None.

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

Select a key from a map and wrap into sequence

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

get_variant l e checks whether e = List (Atom s :: args), and if some pair of l is s, f.

group eq l groups together consecutive elements that satisfy eq.

group_by f takes a collection c as input, and returns a multimap m such that for each x in c, x occurs in m under the key f x.

group_join key2 associates to every element x of the first collection, all the elements y of the second collection such that eq x (key y)

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

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

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 CCError.guard but uses CCError.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.

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

Positive value

Deterministic

Fast (arbitrary, deterministic) hash O(1)

Wrap the printer in an horizontal box

First element of the list, or

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.

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

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

Increment the counter for the given element

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

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

Add or remove several occurrences at once.

incr_then_get x increments x, and return its new value

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

Initialize with given size and initialization function

Initialize with the given function (called at every index)

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.

Analog to Array.init.

Initial value

Similar to Array.init

Init the vector with the given function and size

input_of_chan ic reads lazily the content of ic as parsing goes.

Parse the string

insert s x adds x into s

Insert an element at the current position.

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

Insert a value in the heap

Parse an integer

New field for width bits.

New field of type 2-bits int (same as int ~width:2)

New field of type 3-bits int (same as int ~width:3)

Inclusive range

Intersection of two collections.

The sets MUST have the same set of hash functions

inter a b returns a ∩ b

inter bv1 bv2 returns the intersection of the two sets

Intersection of multimaps

List intersection.

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

inter_mut ~into f changes into into the intersection of into and f into and f MUST have the same set of hash functions

inter_mut ~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)?

Check whether the list is empty

Is the buffer empty (i.e.

Any bit set?

Is the deque empty?

Is the table empty?

Empty multimap?

Evaluates the head

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

is_empty l returns true iff l = []

Is the heap empty?

Is the vector empty?

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

Is the char a digit?

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 stream, with an action for each element

View a multimap as a proper collection

iter a ~f calls f v where get a i = v for each i < length a.

Iterate on the pairs

Iterate on the list's elements

Iterate on values

Iterate on elements, in no particular order

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

Apply the function only in case of `Ok

Iterate on the vector's content

Iterate on two collections at once.

Iterate on pairs of chars

Iterate on two arrays stepwise.

Iterate on all currently present fields

Iterate on the keys of this map

Iterate on the keys of this table

iter_ones ~f a calls f i for every index i such that get a i = true

Iterate on bits set to 1

iter_ones ~f a calls f i for every index i such that get a i = false

iteri ~f v iterates on elements of v with their index

iteri a ~f calls f i v where get a i = v for each i < length a.

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

join key1 key2 ~merge is a binary operation that takes two collections a and b, projects their elements resp.

A.join a joins every thread in a

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

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

Skip next char

Drop the back element from t.

Drop the front element from t.

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

Helper for short lists.

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

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

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

Length of the stream

length v is the number of elements of v

Number of elements

Alias for size.

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

Length of underlying array

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.

Number of distinct elements

Synonym for CCVector.size

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

Lexicographic combination of comparison functions

Synonym to CCMonadIO.map