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

add t i add i to the set

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

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.

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.

Array.blit v1 o1 v2 o2 len copies len elements from array v1, starting at element number o1, to array v2, starting at element number o2.

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

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_heap_property h asserts that h has the heap property: that all nodes are less than their children by h's comparison function.

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

Total ordering between maps.

Types for use as markers in phantom types.

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.

cond_pop heap cond

cond_pop_heap_el heap cond

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 heap

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 f l is the number of elements in l that satisfy the predicate f.

Return (minor_words, promoted_words, major_words).

create name to_sexp if the type 'a doesn't support sexp conversion, then a good practice is to use sexp_of_opaque as the converter.

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 ~name defines a new type identity.

create () returns an empty stack.

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

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

Returns version of queue with top element removed.

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

drop ?n t back_or_front drop n elements (default 1) from the back_or_front 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

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.

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

predicates

fast equality function on strings, doesn't use compare_val

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

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)

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.

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.

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

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.