Index of values

get and (!) are two names for the same function.

mod and div operators that have the right behavior on negative numbers, that is, x % y always returns a value between 0 and y-1.

( / ) t mul scales t by 1/mul

float division of integers

( // ) t1 t2 returns the ratio of t1 to t2

t >>= f returns a computation that sequences the computations represented by two monad elements.

t >>| f is t >>= (fun a -> return (f a)).

A 'pipe' operator.

Functions from fn.ml

A pipe operator, equivalent to |!, but this notation is more broadly accepted

Returns the absolute value of the argument.

add t i add i to the set

add t a returns a new set with a added to t, or returns t if mem t a.

returns a new map with the specified new binding; if the key was already bound, its previous binding disappears.

add t v adds v to the bag t, returning an element that can later be removed from the bag.

adds the specified key and data to the tree destructively (previous t's are no longer valid) using the specified comparison function.

add_buffer b1 b2 appends the current contents of buffer b2 at the end of buffer b1.

add_char b c appends the character c at the end of the buffer b.

if key is not present then add a singleton list, otherwise, cons data on the head of the existing list.

add_multi t ~key ~data if key is present in the table then cons data on the list, otherwise add key with a single element list.

add_range t i j add all the numbers between i and j (inclusive) to the set.

add_removable t v adds v to t, returning a token that can be used to delete v from t in lg(n) amortized time.

add_string b s appends the string s at the end of the buffer b.

add_substitute b f s appends the string pattern s at the end of the buffer b with substitution.

add_substring b s ofs len takes len characters from offset ofs in string s and appends them at the end of the buffer b.

Align the documentation strings by inserting spaces at the first space, according to the length of the keyword.

Validates an association list, naming each element using a user-defined function for computing the name.

Combine a list of validation functions into one that does all validations.

all () returns all pretty printers that have been registered.

Return the total number of bytes allocated since the program was started.

allow_intersecting says whether to allow intersecting known flags.

generator that always returns given value

E.g.

Array.append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.

apply x f run optional function on argument and return an option

apply_n_times ~n f x is the n-fold application of f to x.

ascending is identical to compare.

ascending is identical to compare.

back_index t return the index of the back item in t.

back_index_exn t throws an exception if t is empty, otherwise returns the index of the back item in t

Printexc.get_backtrace

Return a copy of the current contents of the buffer as a bigstring.

Note that the sexps are not directly inferred from the type above -- there are lots of fancy shortcuts.

binary_search ?pos ?len t ~compare v returns the index in t holding a value equal to v according to compare.

bind t f = t >>= f

These functions are the same as the basic functions, except that they use (and update) the given PRNG state instead of the default one.

Return 30 random bits in a nonnegative integer.

Random.bool () returns true or false with probability 0.5 each.

Create a validation function from a function that produces a bool

like bot_exn, but returns result optionally, without exception.

returns the bottom (most-recently enqueued element).

bytes t returns the number of bytes on the heap taken by heap block t, including the header.

call x f run optional function on argument

capacity returns the maximum number of tuples that the pool can hold.

capacity t returns the length of the array backing t.

capacity t returns the length of the array backing t.

ceil_pow2 x returns the smallest power of 2 that is greater than or equal to x.

character generator

change map key f updates the given map by changing the value stored under key according to f.

change t key f updates the given table by changing the value stored under key according to f, just like Map.change (see that for example).

check_args ~loc ~pos ~len bstr checks the position and length arguments pos and len for bigstrings bstr.

check_field is used when checking invariants using Fields.iter.

check_pos_len_exn ~pos ~len ~length raises unless pos >= 0 && len >= 0 && pos + len <= length.

returns an arbitrary element, or None if the set is empty.

choose t returns some element in the bag.

chop_prefix s ~pref returns a copy s without the leading pref

chop_suffix s ~suf returns a copy s without the trailing suff

clear t discards all elements from t.

clear the queue

clear t removes all elements from t.

clear t removes all elements from the list in constant time.

clear t removes all elements from t.

clear t discards all elements from t.

Empty the buffer.

clear t removes all elements from the bag.

we have our own version of these two, the INRIA version doesn't release the runtime lock.

combine ar combines two arrays to an array of pairs.

combine_errors ts returns Ok if every element in ts is Ok, else it returns Error with all the errors in ts.

combine_errors_unit returns Ok if every element in ts is Ok (), else it returns Error with all the errors in ts, like combine_errors.

Perform a full major collection and compact the heap.

lexicographic

compare_direct t1 t2 compares the sets t1 and t2.

Total ordering between maps.

compose f g x is f (g x)

concatanate all strings in the list using separator sep (default sep "")

Concatenate a list of lists.

Same as Array.append, but concatenates a list of arrays.

concat_array sep ar like String.concat, but operates on arrays

Like map, but allows replacement of a single character with zero or two or more characters.

concat_map t ~f is concat (map t ~f), except that there is no guarantee about the order in which f is applied to the elements of t.

concat_mapi t ~f is like concat_map, but passes the index as an argument

Same as concat but faster and without preserving any ordering (ie for lists that are essentially viewed as multi-sets.

produces a function that just returns its first argument

contains_dup True if there are any two elements in the list which are the same.

Return a copy of the current contents of the buffer.

conv t x uses the type equality t : (a, b) t as evidence to safely cast x from type a to type b.

copy t returns a copy of t.

copy t returns a new array with the same elements as t.

copy t returns a shallow copy

copy a returns a shallow copy of a, that is, a fresh array containing the same elements as a.

copy t returns a copy of t.

copy t returns a copy of t.

Array.copy a returns a copy of a, that is, a fresh array containing the same elements as a.

count t returns the number of elements of t for which f returns true.

count f l is the number of elements in l that satisfy the predicate f.

Returns the number of elements for which the provided function evaluates to true.

Returns the number of elements for which the provided function evaluates to true.

Returns the number of elements for which the provided function evaluates to true.

Returns the number of elements for which the provided function evaluates to true.

Returns the number of elements for which the provided function evaluates to true.

Return (minor_words, promoted_words, major_words).

create v returns a new object in its own equivalence class that has value v.

Always returns a value that is not equal to any other value created with create.

create () returns an empty stack.

create slots ~capacity creates an empty pool that can hold up to capacity N-tuples.

create slots ~capacity ~dummy creates an empty pool that can hold up to capacity N-tuples.

create ~len returns an obj-array of length len, all of whose indices have value Obj.repr 0.

create ?pos ?len base creates a substring of the base sequence of * length len starting at position pos, i.e.

For create msg z sexp_of_z, be careful to use only immutable values for z, or be aware that z will be lazily converted to a sexp at a later point in time, which will pick up the then-current state of z.

create ?min_size ~cmp returns a new min-heap that can store min_size elements without reallocations, using ordering function cmp.

create v returns Some t if v is a heap block, where t is physically equal to v

create () returns an empty queue.

create f creates a new force_once

create ?capacity slots creates an empty queue with capacity at least the supplied capacity.

create slots ~len init creates an array of flat tuples, whose slots are initialized to the slots of init, which is an ordinary OCaml tuple.

create ~bit:n creates a flag with the nth bit set.

creating doubly-linked lists

create ?initial_length ?never_shrink () create a new t.

create () returns an empty queue.

create ~len x creates an array of length len with the value x populated in each element

create measure value creates a t from value units of the given measure.

create ~num_keys ~key_to_int returns a table where the keys can map to 0 ..

create length

create n returns a fresh buffer, initially empty.

create () returns an empty bag.

create_alarm f will arrange for f to be called at the end of each major GC cycle, starting with the current cycle or the next one.

create_bin_prot reader returns an unpacker that reads the "size-prefixed" bin_prot encoding, in which a value is encoded by first writing the length of the bin_prot data as a 64-bit int, and then writing the data itself.

create_bin_prot reader returns an unpack buffer that unpacks the "size-prefixed" bin_prot encoding, in which a value is encoded by first writing the length of the bin_prot data as a 64-bit int, and then writing the bin_prot data itself.

Position (in Sys.argv) of the argument being processed.

returns list of data in map

filter_inplace t ~f removes all the elements from t that don't satisfy f.

debug controls whether invariants are checked at each call.

set debug := true to turn on debugging, including potentially slow invariant checking.

dedup (de-duplicate).

delete_alarm a will stop the calls to the function associated to a.

dequeue t returns the front element of the queue.

Like dequeue_exn, but returns result optionally, without exception.

dequeue t back_or_front remove and return the back_or_front of t

dequeue t returns None if t is empty, otherwise it removes and returns the front of t

dequeue_all t ~f dequeues every element of the queue and applies f to each one.

dequeue_exn t removes and returns the front of t, raising Empty if t is empty.

dequeue_with_key t returns the front element of the queue and its key

tuple2 and detuple2 convert between equality on a 2-tuple and its components.

diff t1 t2 computes the set difference t1 - t2, i.e., the set containing all elements in t1 that are not in t2.

Returns version of queue with top element removed.

does_match t id returns true iff t was created by create id v.

does_raise f returns true iff f () raises.

drop ?n t back_or_front drop n elements (default 1) from the back_or_front of t.

drop_front ?n t drops the the first n elements of t.

drop_prefix s n drops the longest prefix of s of length less than or equal to n

drop_suffix s n drops the longest suffix of s of length less than or equal to n

drop_while l ~f drops the longest prefix of l for which f is true.

Same as Core_set.to_list.

The empty queue

Creates an empty set based on the provided comparator.

the empty map

empty () creates an empty array

enqueue t k v adds the key-value pair (k, v) to the end of the queue, returning `Ok if the pair was added, or `Key_already_present if there is already a (k, v') in the queue.

enqueue t x returns a queue with adds x to the end of t.

enqueue t back_or_front v push v onto the back_or_front of t.

enqueue t x adds x to the end of t.

There is an enqueueN function for each possible arity of a flat queue.

enqueue a single element on the *top* of the queue.

eprint message prints to stderr message, followed by a newline and flush.

eprintf message arg1 ... argn prints to stderr message, with sprintf-style format characters instantiated, followed by a newline and flush.

eprints message a sexp_of_a prints to stderr message and a as a sexp, followed by a newline and flush.

predicates

fast equality function on strings, doesn't use compare_val

equal t1 t2 returns true iff the two sets have the same elements.

equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data.

equal t1 t2 f and similar t1 t2 f both return true iff t1 and t2 have the same keys and for all keys k, f (find_exn t1 k) (find_exn t2 k).

of_bool is used to generate two distinct values of type t, used in unit tests.

error message value sexp_of_value constructs an Error.t and returns it as a Result.Error.

Or_error.error

error_string message is Error (Error.of_string message)

errorf format arg1 arg2 ... is Error (sprintf format arg1 arg2 ...).

Returns a list of formatted error strings, which include both the error message and the path to the error.

escape ~escapeworthy ~escape_char s is

        escape_gen_exn ~escapeworthy_map:(List.zip_exn escapeworthy escapeworthy)
          ~escape_char
      

.

escape_gen_exn escapeworthy_map escape_char returns a function that will escape a string s as follows: if (c1,c2) is in escapeworthy_map, then all occurences of c1 are replaced by escape_char concatenated to c2.

Warning: Only returns a copy if changes are necessary! Special characters are represented by escape sequences, following the lexical conventions of Objective Caml.

Return a string representing the given character, with special characters escaped following the lexical conventions of Objective Caml.

eval t f evaluates the proposition t relative to an environment f that assigns truth values to base propositions.

exists t ~f returns true iff there exists an a in t for which f a.

Returns true if and only if there exists an element for which the provided function evaluates to true.

Returns true if and only if there exists an element for which the provided function evaluates to true.

Returns true if and only if there exists an element for which the provided function evaluates to true.

Returns true if and only if there exists an element for which the provided function evaluates to true.

Returns true if and only if there exists an element for which the provided function evaluates to true.

Same as List.exists, but for a two-argument predicate.

print to stderr; exit 1

exn_if_dup ?compare ?context t ~to_sexp will run find_a_dup on t, and raise Duplicate_found if a duplicate is found.

A result containing a single error

fail_fn err returns a function that always returns fail, with err as the error message.

Like sprintf or failwithf but produces a t instead of a string or exception

e.g.

raises Failure

failwiths message value sexp_of_value raises an exception with the supplied message and value, by constructing an Error.t and using Error.raise.

feed t buf ?pos ?len adds the specified substring of buf to t's buffer.

float generator (no nan, inf, etc.)

Used for validating an individual field.

Creates a function for use in a Fields.fold.

Array.fill a ofs len x modifies the array a in place, storing x in elements number ofs to ofs + len - 1.

filter s ~f:predicate discards characters not satisfying predicate

filter t ~f returns the subset of t for which f evaluates to true.

filter p l returns all the elements of the list l that satisfy the predicate p.

filter ~f array removes the elements for which f returns false.

filter_inplace t ~f removes all elements of t that don't satisfy f.

filter_inplace t ~f removes all elements of t that don't satisfy f.

Like Core_set.map, except elements for which f returns None will be dropped.

returns new map with bound values filtered by f applied to the bound values

filter_map f l is the sublist of l containing only elements for which f returns Some e.

returns new map with bound values filtered by f applied to the bound values

filter_map ~f array maps f over array and filters None out of the results.

like filter_map, but function takes both key and data as arguments

filter_mapi is just like filter_map, but it also passes in the index of each element as the first argument to the mapped function.

like filter_map, but function takes both key and data as arguments

Same as filter_map but uses Array.mapi.

filter_opt l is the sublist of l containing only elements which are Some e.

filter_opt array returns a new array where None entries are omitted and Some x entries are replaced with x.

Like filter except f also receives the index.

find t f returns an element of t for which f returns true, with no guarantee as to which element is returned.

returns the value bound to the given key, raising Not_found if none such exists

find t k returns Some (the current binding) of k in t, or None if no such binding exists

Returns as an option the first element for which f evaluates to true.

Returns as an option the first element for which f evaluates to true.

Returns as an option the first element for which f evaluates to true.

Returns as an option the first element for which f evaluates to true.

Returns as an option the first element for which f evaluates to true.

find ?pos ?len char t returns Some i for the smallest i >= pos such that t.{i} = char, or None if there is no such i.

if the specified key exists in the tree, return the corresponding value.

find_a_dup returns a duplicate from the list (no guarantees about which duplicate you get), or None if there are no dups.

find_and_remove t k returns Some (the current binding) of k in t and removes it, or None is no such binding exists

find_consecutive_duplicate t ~equal returns the first pair of consecutive elements (a1, a2) in t such that equal a1 a2.

find_consecutive_duplicate t ~equal returns the first pair of consecutive elements (a1, a2) in t such that equal a1 a2.

find_elt t ~f.

find_elt t ~f finds the first element in t that satisfies f, by testing each of element of t in turn until f succeeds.

find_elt t ~f looks at elements in the bag one-by-one until it finds one elt such that f (Elt.value elt), in which case it returns Some elt.

Like find, but throws an exception on failure.