Index of values

Multiplication.

Multiplication.

a ** b computes a^b

a ** b computes a^b

Function pairing.

Function pairing.

Function application.

As zero_plus without arguments.

Prefix operator that converts primitive string to ustring.

!r returns the current contents of reference r.

Applying two functions to the same argument.

Applying two functions to the same argument.

The boolean ``and''.

Addition.

Addition.

Substraction.

Subtraction.

Enumerate numbers.

Enumerate an interval.

Enumerate an interval.

Enumerate an interval.

Enumerate an interval.

As range, without the label.

Produce the enumeration of a segment of characters.

As --, but accepts enumerations in reverse order.

Enumerate an interval.

Enumerate an interval.

Enumerate an interval.

Enumerate an interval.

As --, but accepts enumerations in reverse order.

(a, step) --. b) creates a float enumeration from a to b with an increment of step between elements.

(a, step) --. b) creates a float enumeration from a to b with an increment of step between elements.

Enumerate numbers, without the right endpoint

As (--) but without the right endpoint

As ( -- ), but for characters.

As ( -- ), but for characters.

Function composition.

Function composition.

Integer division.

Integer division.

Filtering (pronounce this operator name "such that").

Filtering (pronounce this operator name "such that").

basepath//@relpath catenates two paths.

path/:name is a path of name located in a directory path.

r := a stores the value of a in reference r.

Comparaison: a < b is true if and only if a is strictly smaller than b.

Comparaison: a <= b is true if and only if a is smaller or equalto b.

Comparaison: a <> b is true if and only if a and b have different values.

Function application.

Accept one of two parsers

Comparaison: a = b if and only if a and b have the same value.

Comparaison: a > b is true if and only if a is strictly greater than b.

As cons

Comparaison: a >= b is true if and only if a is greater or equal to b.

as bind

As bind

As bind, but ignoring the result

List concatenation.

the new implementation for ( @ ) operator, see List.append.

Mapping operators.

Mapping operators.

As cons: x^:^l is the lazy list with head x and tail l

As lazy append

p ^^ n is the same thing as times n p

As BatRope.append

Function composition.

Function composition.

Operators

Function application.

The boolean ``or''.

As one_plus

As maybe

Return the absolute value of its argument.

Return the absolute value of its argument.

Return the absolute value of its argument.

Return the absolute value of its argument.

Return the absolute value of its argument.

The absolute value of a floating point number.

The absolute value of a floating point number.

abs c returns the module of this complex number, i.e.

See BatFloat.Safe_float.atan2.

See BatFloat.atan2.

add x s returns a set containing all elements of s, plus x.

Adds an element at the end - O(n)

add x q adds the element x at the end of the queue q.

add x s returns a set containing all elements of s, plus x.

add x y m returns a map containing the same bindings as m, plus a binding of x to y.

Add an option to the option parser.

Addition.

add x y m returns a map containing the same bindings as m, plus a binding of x to y.

add x y m returns a map containing the same bindings as m, plus a binding of x to y.

Addition.

Addition.

Addition.

Addition.

Weaktbl.add tbl x y adds a binding of x to y in table tbl.

Hashtbl.add tbl x y adds a binding of x to y in table tbl.

Hashtbl.add tbl x y adds a binding of x to y in table tbl.

add darr v appends v onto darr.

add n a Creates a new node containing data a and inserts it into the list after node n.

Addition

add_buffer b1 b2 adds the contents of b2 to b1.

add_carry k v m adds the binding (k,v) to m, returning the new map and optionally the previous value bound to k.

Add one Unicode character to the buffer.

Add a group to the option parser.

add_input b ic n reads exactly n character from the input ic and stores them at the end of buffer b.

Addition of a small integer to a big integer.

Adds an element in a sorted list, using optional comparator or 'compare' as default.

Add the UTF-8 string to the buffer.

Advance by one char.

Advance by one char.

all s is the substring (s, 0, size s).

Accept any singleton value.

apnd fla flb equals [<fla;flb>].

append c r returns a new vect with the c element at the end in amortized O(1) time.

append c r returns a new vect with the c element at the end in amortized O(1) time.

Concatenate two UTF8 strings

append s1 s2 returns the sequence which first returns all elements of s1 then all elements of s2.

append r u concatenates the r and u ropes.

Alternative name for BatPathGen.PathType.Operators.(/:)

Catenate two lists.

Lazy append

append e1 e2 returns an enumeration that will enumerate over all elements of e1 followed by all elements of e2.

append src dst adds all elements of src to the end of dst.

append n a Creates a new node containing data a and inserts it into the list after node n.

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

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

append_char c r returns a new rope with the c character at the end in amortized O(1) time.

approx n return the integer closest to n

Approximate a number by a decimal.

See Num.approx_num_exp.

Argument.

An enumeration of the arguments passed to this program through the command line.

An enumeration of the arguments passed to this program through the command line.

Return the one-dimensional big array corresponding to the given generic big array.

Return the two-dimensional big array corresponding to the given generic big array.

Return the three-dimensional big array corresponding to the given generic big array.

as_encoded x enc returns an element of type t used to mark that x is encoded with encoding enc.

See BatFloat.Safe_float.atan2.

See BatFloat.atan2.

assoc a s returns the value associated with key a in the sequence of pairs s.

assoc a l returns Some b where b is the value associated with key a in the list of pairs l.

assoc a l returns Some b where b is the value associated with key a in the list of pairs l.

assoc a l returns the value associated with key a in the list of pairs l.

assoc_inv b l returns Some a where a is the key associated with value a in the list of pairs l.

assoc_inv b l returns the key associated with value b in the list of pairs l.

As BatList.Exceptionless.assoc but with physical equality.

As BatLazyList.Exceptionless.assoc but with physical equality

As BatLazyList.assoc but with physical equality

as get

at l n returns the n-th element of the sequence l or raise Invalid_argument is the index is outside of l bounds.

If n is inside the bounds of l, at l n returns Ok x, where x is the n-th element of the list l.

at l n returns the n-th element of the list l or raise Invalid_index is the index is outside of l bounds.

If n is inside the bounds of l, at l n returns `Ok x, where x is the n-th element of the list l.

at l n returns the n-th element of the list l or raise Invalid_index is the index is outside of l bounds.

Return the element of ref list at the specified index raise Invalid_index if the index is outside 0 ; length-1

See BatFloat.Safe_float.atan2.

See BatFloat.atan2.

The usual trigonometric functions.

The usual trigonometric functions.

Returns an enumeration of the elements of a vector, from last to first.

As String.backwards

Returns an enumeration of the characters of a string, from last to first.

Return an enumeration of all elements of the given set.

Returns an enumeration of the characters of a rope, from last to first.

Returns an enumeration of current elements in the ref list, going from last to first

Returns an enumeration of the elements of a list.

Returns an enumeration of the elements of an array, from end to start.

Returns an enumeration of the elements of an array, from last to first.

balance r returns a balanced copy of the r vect.

balance r returns a balanced copy of the r vect.

balance r returns a balanced copy of the r rope.

base sus is the concrete triple (s, i, n), where sus = (s, i, n).

Scanning.beginning_of_input ib tests the beginning of input condition of the given scanning buffer.

belongs base sub is true when sub descends from base, i.e.

Convert a small integer to a big integer.

Convert a string to a big integer, in decimal.

Monadic composition.

Monadic-style combination:

bind m f combines the calculation result m with the function f.

bind f (Some x) returns f x and bind f None returns None.

Monadic binding.

bind m f takes the result of the monadic computation m, puts the f function in the monadic context passing it the result of m and then returning a monadic result.

Return 30 random bits in a nonnegative integer.

Read an enumeration of bits

Return the internal representation of the given float according to the IEEE 754 floating-point ``double format'' bit layout.

Return the internal representation of the given float according to the IEEE 754 floating-point ``single format'' bit layout.

blit src srcoff dst dstoff len returns a copy of dst in which len characters have been copied from rope src, starting at character number srcoff, to rope dst, starting at character number dstoff.

blit src srcidx dst dstidx len copies len elements from src starting with index srcidx to dst starting at dstidx.

Buffer.blit b srcoff dst dstoff len copies len characters from the current contents of the buffer b starting at offset off, starting at character number srcoff, to string dst, starting at character number dstoff.

Copy the first big array to the second big array.

Copy the first big array to the second big array.

Copy the first big array to the second big array.

Copy all elements of a big array in another big array.

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.

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.

Same as BatStr.Str.bounded_split_delim, but returns the delimiters as well as the substrings contained between delimiters.

Same as BatStr.Str.split, but splits into at most n substrings, where n is the extra integer parameter.

Same as BatStr.Str.bounded_split, but occurrences of the delimiter at the beginning and at the end of the string are recognized and returned as empty strings in the result.

As BatPrintf.fprintf, but with buffers instead of outputs.

This function behaves as BatPrint.fprintf but prints into a buffer rather than into an output.

As BatInnerIO.Printf.fprintf, but with buffers instead of outputs.

As BatPrintf.printf but writes to a buffer instead of printing to the output.

As BatInnerIO.Printf.printf but writes to a buffer instead of printing to the output.

Negated span.

browse s opens the platform's default www browser to browse url s.

bscanf ib fmt r1 ... rN f reads arguments for the function f, from the scanning buffer ib, according to the format string fmt, and applies f to these values.

bscanf_format ib fmt f reads a format string token from the scannning buffer ib, according to the given format string fmt, and applies f to the resulting format string value.

Returns an enumeration of the UTF-8 encoded strings of a rope.

bulk_filter_map f l calls (f a0) (f a1).... (f an) where a0..an are the UTF-encoded strings of l.

As BatRope.fold but over larger chunks of data.

as iter but over larger chunks of data

as iteri but over larger chunks of data.

map f s returns a rope where all ropes c in s have been replaced by f c.

Read an enumeration of unsigned 8-bit integers.

Make a callback option which takes a single argument.

Return a copy of the argument, with the first character set to uppercase.

Return the number of elements of a set.

Return the number of elements of a set.

Different from List.combine, this returns every pair of elements formed out of the two lists.

As char, but case-insensitive

As char, but case-insensitive

As rope, but case-insensitive

true if the language is case-sensitive, false otherwise.

As string, but case-insensitive

As case_string, but case-insensitive

As ustring, but case-insensitive

You can safely transform any output to an unit output in a safe way by using this function.

You can safely transform any output to an unit output in a safe way by using this function.

Execute a function and catch any exception as a !result

Determine to which category the character belongs.

See BatFloat.Safe_float.floor.

See BatFloat.floor.

If len is nonnegative, Digest.channel ic len reads len characters from channel ic and returns their digest, or raises End_of_file if end-of-file is reached before len characters are read.

Recognize exactly one char

Return a random Latin-1 character.

Low-level API

Recognize exactly one char

As shown by the types of the values above, big arrays of kind float32_elt and float64_elt are accessed using the Caml type float.

Accepts a character literal, i.e.

Read an enumeration of Latin-1 characters.

As BatFile.set_permissions

choice e returns a randomly-chosen element of e.

Return one element of the given set, or raise Not_found if the set is empty.

returns one binding of the given map, deterministically.

returns one pair of the given map, deterministically

return an implementation defined (key,value) pair.

Read an input as an enumeration of strings of given maximal length.

Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.

Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.

Empty the buffer, but retains the internal storage which was holding the contents

Removes all elements

Discard all elements from a queue.

Empty a hash table.

Empty a hash table.

Empty a hash table.

remove all elements from the array and resize it to 0.

clone e creates a new enumeration that is copy of e.

Same as copy

Close all outputs.

Close the given channel.

Close the input.

Close the input.

Same as close_in, but ignore all errors.

Close the given channel, flushing all buffered write operations.

Close the output and return its accumulator data.

Close the output and return its accumulator data.

Same as close_out, but ignore all errors.

Close input/output opened by Unix.open_process, wait for the associated command to terminate, and return its termination status.

Close i/o opened by Unix.open_process_full, wait for the associated command to terminate, and return its termination status.

Close input opened by Unix.open_process_in, wait for the associated command to terminate, and return its termination status.

Close output opened by Unix.open_process_out, wait for the associated command to terminate, and return its termination status.

clump size add get e runs add on size (or less at the end) elements of e and then runs get to produce value for the result enumeration.

comb transform a pair of stream into a stream of pairs of corresponding elements.

Transform a pair of sequences into a sequence of pairs.

Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].

Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].

combine (a,b) creates a new output c such that writing to c will actually write to both a and b

combine transform a pair of stream into a stream of pairs of corresponding elements.

Construct a new command, i.e.

compact darr ensures that the space allocated by the array is minimal.

Compare two units.

Code point comparison by lexicographic order.

compare (sus1, sus2) performs lexicographic comparison, using the standard ordering Char.compare on the characters.

The comparison function for strings, with the same specification as Pervasives.compare.

Total ordering between sets.

The comparison function for ropes, with the same specification as Pervasives.compare.

Usual comparison function.

Compare two pairs in lexicographic order, possibly using custom comparators for the two fields

The comparison function for native integers, with the same specification as Pervasives.compare.

Total ordering between maps.

A total ordering function This is a two-argument function f such that f e1 e2 is zero if the values e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2.

The comparison function for 64-bit integers, with the same specification as Pervasives.compare.

The comparison function for 32-bit integers, with the same specification as Pervasives.compare.

The comparison function for integers, with the same specification as Pervasives.compare.

The comparison function for integers, with the same specification as Pervasives.compare.

A total order on outputs

A total order on inputs

compare cmp a b compares enumerations a and b by lexicographical order using comparison cmp.

compare s1 s2 compares two bitsets.

compare_big_int a b returns 0 if a and b are equal, 1 if a is greater than b, and -1 if a is smaller than b.

compare_index s i1 i2 returns a value < 0 if i1 is the position located before i2, 0 if i1 and i2 points the same location, a value > 0 if i1 is the position located after i2.

Partial ordering between sets as generated by subset

See Bigarray.char.

See Bigarray.char.

Compose two lock systems into a third lock system.

concat r u concatenates the r and u vects.

concat r u concatenates the r and u vects.

concat sep [a;b;c...] returns the concatenation of a, sep, b, sep, c, sep...

concat suss returns a string consisting of the concatenation of the substrings.

concatenate a stream of streams

concat s returns the sequence which returns all the elements of all the elements of s, in the same order.

concat sep sl concatenates the list of ropes sl, inserting the separator rope sep between each.

concat e returns an enumeration over all elements of all enumerations of e.

Alternative name for BatPathGen.PathType.Operators.(//@)

Concatenate a list of lists.

Lazy concatenation of a lazy list of lazy lists

concat e returns an enumeration over all elements of all enumerations of e.

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

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

concat_with_separators sep lst catenates all n elements of lst inserting (n-1) copies of sep in between.

Conjugate: given the complex x + i.y, returns x - i.y.

cons x stream equals [<'x; stream>].

cons e s = fun () -> Cons(e, s)

cons p q applies parser p then parser q and conses the results into a list.

cons h t returns the list starting with h and continuing as t

Build a list from a head and a tail.

conservative_exponential_resizer is an example resizer function which uses the oldlength parameter.

Ignore its second argument.

Ignore its second argument.

As String.contains

contains s c tests if character c appears in the rope s.

contains_from s start c tests if character c appears in the subrope of s starting from start to the end of s.

contents buf returns the contents of the buffer.

Makes a copy of a ref list - O(1)

copy r returns a new reference with the same initial content as r.

Return a copy of the given state.

Return a copy of the given queue.

Oo.copy o returns a copy of object o, that is a fresh object with the same methods and instance variables as o

Return a copy of the given hashtable.

Read everything from an input and copy it to an output.

Return a copy of the given hashtable.

Return a copy of the given hashtable.

copy src returns a fresh copy of src, such that no modification of src affects the copy, or vice versa (all new memory is allocated for the copy).

Copy the list attached to the given node and return the copy of the given node.

Copy a bitset : further modifications of first one will not affect the copy.

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

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

Makes a copy of a enum.

Makes a copy of a list - O(1)

See BatFloat.Safe_float.atan2.

See BatFloat.atan2.

See BatFloat.Safe_float.tanh.

See BatFloat.tanh.

count e returns the number of remaining elements in e without consuming the enumeration.

count s returns the number of bits set in the bitset s.

Create a counting option which increments its value each time the option is encountered on the command line.

create n creates the buffer with the initial size n-bytes.

Return a new mutex.

Return a new queue, initially empty.

Creates a new empty set, using the provided function for key comparison.

creates a new empty map, using the provided function for key comparison.

Return a new mutex.

creates a new empty map, using the provided function for key comparison.

Weaktbl.create n creates a new, empty hash table, with initial size n.

Hashtbl.create n creates a new, empty hash table, with initial size n.

Hashtbl.create n creates a new, empty hash table, with initial size n.

create() returns a new empty dynamic array.

Creates a node.

Create a lock from a pair of locking/unlocking functions

Create an empty bitset with an initial size (in number of bits).

Array3.create kind layout dim1 dim2 dim3 returns a new bigarray of three dimension, whose size is dim1 in the first dimension, dim2 in the second dimension, and dim3 in the third.

Array2.create kind layout dim1 dim2 returns a new bigarray of two dimension, whose size is dim1 in the first dimension and dim2 in the second dimension.

Array1.create kind layout dim returns a new bigarray of one dimension, whose size is dim.

Genarray.create kind layout dimensions returns a new big array whose element kind is determined by the parameter kind (one of float32, float64, int8_signed, etc) and whose layout is determined by the parameter layout (one of c_layout or fortran_layout).

Create a full bitset with an initial size (in number of bits).

Fully create an input by giving all the needed functions.

Fully create an input by giving all the needed functions.

Fully create an output by giving all the needed functions.

Fully create an output by giving all the needed functions.

Turn a function that takes a pair into a function that takes its arguments one at a time.

Convert a function which accepts a pair of arguments into a function which accepts two arguments.

cycle is similar to repeat, except that the content to fill is a subenum rather than a single element.

dbg_formatter is a debug formatter that outputs log events to stderr using the same format as make_dbg_formatter.

If set to true, debugging information will be printed to the standard error.

Generic base64 decoding over an input.

As Array.decorate_sort, but uses fast_sort internally

decorate_sort f a returns a sorted copy of a such that if f x < f y then x is earlier in the result than y.

Exactly identical to count_option ~dest:dest ~increment:(-1) ().

default x (Some v) returns v and default x None returns x.

The default size of buffers.

The default size for internal buffers.

Default permissions.

The default resizer function the library is using - in this version of DynArray, this is the exponential_resizer but should change in next versions.

Forward slash and code zero are considered invalid.

delay (fun () -> e) produces an enumeration which behaves as e.

delete darr idx deletes the element of darr at idx.

delete_last darr deletes the last element of darr.

delete_range darr p len deletes len elements starting at index p.

demote n Swaps n with prev n.

Return the descriptor corresponding to an input.

Return the descriptor corresponding to an output.

destructive_set n e v sets the element of index n in the v vect to e.

Set difference.

diff s t returns s-t.

differentiate s t removes the elements of t from s.

differentiate_sym s t sets s to the symmetrical difference of the sets s and t.

Recognizes one decimal digit

Recognizes one decimal digit

Return the size (dimension) of the given one-dimensional big array.

Return the first dimension of the given three-dimensional big array.

Return the first dimension of the given two-dimensional big array.

Return the second dimension of the given three-dimensional big array.

Return the second dimension of the given two-dimensional big array.

Return the third dimension of the given three-dimensional big array.

Genarray.dims a returns all dimensions of the big array a, as an array of integers of length Genarray.num_dims a.

Integer division.

Integer division.

Integer division.

Integer division.

Integer division.

Division

A path to the root of the documentation.

Read an enumeration of IEEE double precision floating point values.

Read an enumeration of IEEE double precision floating point values.

Return drive letter of the given absolute path.

drop n stream returns the suffix of stream after the first n elements, or a empty stream if n is greater than the length of stream

drop n s returns s without the first n elements, or the empty sequence if s have less than n elements.

drop n l returns l without the first n elements, or the empty list if l have less than n elements.

drop n l returns l without the first n elements, or the empty list if l have less than n elements.

drop n e removes the first n element from the enumeration, if any.

Remove node from the list no matter where it is.

Drop up to 7 buffered bits and restart to next input character.

drop_while test stream returns the remaining suffix of take_while test stream.

drop_while test stream returns the remaining suffix of take_while test stream.

drop_while f s returns the sequence s with the first elements satisfying the predicate f dropped.

dropwhile f xs returns the list xs with the first elements satisfying the predicate f dropped.

drop_while f xs returns the list xs with the first elements satisfying the predicate f dropped.

drop_while p e produces a new enumeration in which only all the first elements such that f e have been junked.

dropl p sus drops the longest prefix (left substring) of sus all of whose characters satisfy predicate p.

dropr p sus drops the longest suffix (right substring) of sus all of whose characters satisfy predicate p.

obsolete, as BatList.drop_while

represent a runtime value as a string.

Attempt to convert a value to a string.

dup stream returns a pair of streams which are identical to stream.

dup stream returns a pair of streams which are identical to stream.

Evaluate a list and append another list after this one.

Eager conversion from lists.

Accept one of several parsers.

Return the list of all elements of the given set.

The empty vect.

The empty vect.

The empty UTF8 string

The empty set.

The empty rope.

Returns a new empty ref list

The empty set, using compare as comparison function

The empty map, using compare as key comparison function.

The empty map, using compare as key comparison function.

The empty map.

Returns an new named empty global.

The empty enumeration : contains no element

Return true if the number of elements in the array is 0.

Create an empty bitset of size 0, the bitset will automatically expand when needed.

Generic base64 encoding over an output.

encoded_as t returns the x such that t = as_encoded x enc.

Return the encoding of a t.

Scanning.end_of_input ib tests the end-of-input condition of the given scanning buffer.

ends_with s x returns true if the string s is ending with x, false otherwise.

ends_with s x returns true if the rope s is ending with x, false otherwise.

Returns an enumeration of the elements of the vector.

As String.enum

Conversions

Convert an enumeration to a stream.

enum s returns a destructive enumeration of the elements of stack s, from the most recently entered to the least recently entered.

Return an enumeration of all elements of the given set.

enum s returns the enumeration of all element of s.

Returns an enumeration of the characters of a rope.

Returns an enumeration of current elements in the ref list

enum q returns a destructive enumeration of the elements of queue q, from the least recently entered to the most recently entered.

builds a two-element enum of a pair

Return an enumeration of all elements of the given set.

creates an enumeration for this map.

enum (Some x) returns the singleton x, while enum None returns the empty enumeration

creates an enumeration for this map.

Return an enumeration of (key, value) pairs of a map.

Returns an enumeration of the elements of a list.

Lazy conversion to enumeration

Return an enumeration of (key,value) pairs of a hashtable.

Return an enumeration of (key,value) pairs of a hashtable.

Return an enumeration of the elements of the data structure

identity : added for consistency with the other data structures

enum darr returns the enumeration of darr elements.

Create an enum of the list.

Produce the enumeration of all characters

Returns an enumeration of the characters of a buffer.

enum s returns an enumeration of bits which are set in the bitset s.

enum e returns an enumeration on the elements of e.

enum e returns an enumeration on the elements of e.

enum e returns an enumeration on the elements of e.

enum e returns an enumeration on the elements of e.

Returns an enumeration of the elements of an array.

Returns an enumeration of the elements of an array.

Accept the end of an enumeration.

The usual eprintf function, prints to the standard error output stderr, used to display warnings and errors.

eprintf fmt args behaves as printf fmt args but prints the result on the error out put BatIO.stderr rather on the screen.

The usual eprintf function, prints to the standard error output BatInnerIO.stderr, used to display warnings and errors.

The smallest positive float x such that 1.0 +. x <> 1.0.

The smallest positive float x such that 1.0 +. x <> 1.0.

equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal 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.

The equality predicate used to compare keys.

equals s1 s2 returns true if, and only if, all bits values in s1 are the same as in s2.

A formatter to use with formatting functions below for output to standard error.

Display an error message and exit the program.

Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of Objective Caml.

Establish a server on the given address.

An infinite list of nothing

Singletons

The name of the current executable.

The name of the current executable.

exists p [a1; ...; an] checks if at least one element of the array satisfies the predicate p.

exists str sub returns true if sub is a substring of str or false otherwise.

exists p s checks if at least one element of the set satisfies the predicate p.

exists p (cons a1 (... an)) checks if at least one element of the sequence satisfies the predicate p.

exists str sub returns true if sub is a subrope of str or false otherwise.

Return true if an element matches the specified predicate

exists f e returns true if there is some x in e such that f x

exists p s checks if at least one element of the set satisfies the predicate p.

same as mem.

Eager existential.

exists f e returns true if there is some x in e such that f x

exists p [a1; ...; an] checks if at least one element of the array satisfies the predicate p.

exists p [a1; ...; an] checks if at least one element of the array satisfies the predicate p.

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

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

As Array.exists but on two arrays.

Tests whether some key value pair satisfies some predicate function

Exponential.

Exponential.

Exponentiation.

explode sus returns the list of characters of sus, that is, s(i), s(i+1), ..., s(i+n-1) where sus = (s, i, n).

explode s returns the list of characters in the string s.

explode s returns the list of characters in the rope s.

The exponential resizer- The default resizer except when the resizer is being copied from some other darray.

Returns extension of the name of the object the pathname points to.

extract(s, i, NONE) creates the substring (s, i, size s-i) consisting of the tail of s starting at i.

extract k m removes the current binding of k from m, returning the value k was bound to and the updated m.

Always fail, without consuming anything.

For users worried about the speed of count you can call the fast_count function that will give an hint about count implementation.

Same as Array.sort or Array.stable_sort, whichever is faster on typical input.

Same as Array.sort or Array.stable_sort, whichever is faster on typical input.

Drop comments, present reserved operators and reserved names as Kwd, operators and identifiers as Ident, integer numbers as Int, floating-point numbers as Float and characters as Char.

fields p sus returns the list of fields in sus, from left to right, where a field is a (possibly empty) maximal substring of sus not containing any delimiter, and a delimiter is a character satisfying p.

As readdir but the results are presented as an enumeration of names.

fill s start len c returns the rope in which characters number start to start + len - 1 of s has been replaced by c.

See OptParse.Formatter.wrap.

Fill the given big array with the given value.

Fill the given big array with the given value.

Fill the given big array with the given value.

Set all elements of a big array to a given value.

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

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

filter f v returns a vect with the elements x from v such that f x returns true.

filter f v returns a vect with the elements x from v such that f x returns true.

As String.filter

filter f s returns a copy of string s in which only characters c such that f c = true remain.

filter test stream picks all the elements satisfying test from stream and return the results in the same order as a stream.

filter test stream picks all the elements satisfying test from stream and return the results in the same order as a stream.

filter p s returns the set of all elements in s that satisfy predicate p.

filter p s returns the sequence of elements of s satisfying p.

filter f s returns a copy of rope s in which only characters c such that f c = true remain.

Remove all elements that do not match the specified predicate

filter f e returns an enumeration over all elements x of e such as f x returns true.

filter f p is only accepts values x such that p accepts x and f (p x) is true

filter p s returns the set of all elements in s that satisfy predicate p.

filter f m returns a map where only the values a of m such that f a = true remain.

filter f m returns a map where only the values a of m such that f a = true remain.

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

Lazy filtering.

filter f m returns a new hashtable where only the values a of m such that f a = true remain.

filter f m returns a new hashtable where only the values a of m such that f a = true remain.

filter f e returns an enumeration over all elements x of e such as f x returns true.

filter p a returns all the elements of the array a that satisfy the predicate p.

filter p l returns a new list, with entirely new nodes, whose values are all the elements of the list l that satisfy the predicate p.

filter p a returns all the elements of the array a that satisfy the predicate p.

filter p a returns all the elements of the array a that satisfy the predicate p.

filter_map f e returns a vect consisting in all elements x such that f y returns Some x , where y is an element of e.

filter_map f e returns a vect consisting in all elements x such that f y returns Some x , where y is an element of e.

As String.filter_map

filter_map f s calls (f a0) (f a1).... (f an) where a0..an are the characters of s.

filter_map f m combines the features of filter and map.

filter_map f s returns the sequence of elements filtered and mapped by f.

filter_map f l calls (f a0) (f a1).... (f an) where a0..an are the characters of l.

filter_map f m combines the features of filter and map.

filter_map f m combines the features of filteri and map.

filter_map f m combines the features of filteri and map.

filter_map f l calls (f a0) (f a1).... (f an) where a0..an are the elements of l.

Lazily eliminate some elements and transform others.

filter_map f m combines the features of filteri and map.

filter_map f m combines the features of filteri and map.

filter_map f e returns an enumeration over all elements x such as f y returns Some x , where y is an element of e.

filter_map f e returns an array consisting in all elements x such that f y returns Some x , where y is an element of e.

filter_map f l calls (f a0) (f a1).... (f an) where a0..an are the elements of l.

filter_map f e returns an array consisting in all elements x such that f y returns Some x , where y is an element of e.

filter_map f e returns an array consisting in all elements x such that f y returns Some x , where y is an element of e.

filter f m returns a map where only the (key, value) pairs key, a of m such that f key a = true remain.

filter f m returns a map where only the key, values pairs key, a of m such that f key a = true remain.

filter f m returns a map where only the key, values pairs key, a of m such that f key a = true remain.

filter f m returns a map where only the key, values pairs key, a of m such that f key a = true remain.

finally fend f x calls f x and then fend() even if f x raised an exception.

finally fend f x calls f x and then fend() even if f x raised an exception.

find p a returns the first element of array a that satisfies the predicate p.

find s x returns the starting index of the first occurrence of string x within string s.

find p s returns the first element of s such as p e returns true, if any.

find s x returns the starting index of the first occurrence of rope x within rope s.

Find the first element matching the specified predicate raise Not_found if no element is found

find f e returns the first element x of e such that f x returns true, consuming the enumeration up to and including the found element, or, raises Not_found if no such element exists in the enumeration, consuming the whole enumeration in the search.

find x m returns the current binding of x in m, or raises Not_found if no such binding exists.

find x m returns the current binding of x in m

find x m returns the current binding of x in m, or raises Not_found if no such binding exists.

find p l returns Some x where x is the first element of l such as p x returns true or None if such an element has not been found.

rfind p l returns Some x where x is the first element of l such that p x returns true or None if such element as not been found.

find p l returns the first element of l such as p x returns true or raises Not_found if such an element has not been found.

Weaktbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.

Hashtbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.

Hashtbl.find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.

find f e returns Some x where x is the first element x of e such that f x returns true, consuming the enumeration up to and including the found element, or None if no such element exists in the enumeration, consuming the whole enumeration in the search.

find f e returns the first element x of e such that f x returns true, consuming the enumeration up to and including the found element, or, raises Not_found if no such element exists in the enumeration, consuming the whole enumeration in the search.

find p a returns Some x, where x is the first element of array a that satisfies the predicate p, or None if there is no such element.

find p a returns Some x, where x is the first element of array a that satisfies the predicate p, or None if there is no such element.

find p a returns the first element of array a that satisfies the predicate p.

find p a returns the first element of array a that satisfies the predicate p.

find_all is another name for Array.filter.

find_all is another name for Array.filter.

find_all is another name for List.filter.

Weaktbl.find_all tbl x returns the list of all data associated with x in tbl.

Hashtbl.find_all tbl x returns the list of all data associated with x in tbl.

Hashtbl.find_all tbl x returns the list of all data associated with x in tbl.

find_all is another name for Array.filter.

find_all is another name for Array.filter.

Find a binding for the key, and return a default value if not found

Find a binding for the key, and return a default value if not found

Same as find but takes an exception to be raised when no element is found as additional parameter

find_exn p e l returns the first element of l such as p x returns true or raises e if such an element has not been found.

find_exn p e l returns the first element of l such as p x returns true or raises e if such an element has not been found.

find_from s ofs x behaves as find s x but starts searching at offset ofs.

find_from s ofs x behaves as find s x but starts searching at offset ofs.

find_map p s finds the first element of s for which p e returns Some r, if any.

find_map pred list finds the first element of list for which pred element returns Some r.

Find a binding for the key, or return None if no value is found

Find a binding for the key, or return None if no value is found

findi p a returns the index of the first element of array a that satisfies the predicate p.

findi p e l returns Some (i, ai) where ai and i are respectively the first element of l and its index, such that p i ai is true, or None if no such element has been found.

findi p e l returns the first element ai of l along with its index i such that p i ai is true, or raises Not_found if no such element has been found.

findi p e l returns Some (i, ai) where ai and i are respectively the first element of l and its index, such that p i ai is true, or None if no such element has been found.

findi p e l returns the first element ai of l along with its index i such that p i ai is true, or raises Not_found if no such element has been found.

findi p a returns Some n, where n is the index of the first element of array a that satisfies the predicate p, or None if there is no such element.

findi p a returns Some n, where n is the index of the first element of array a that satisfies the predicate p, or None if there is no such element.

findi p a returns the index of the first element of array a that satisfies the predicate p.

findi p a returns the index of the first element of array a that satisfies the predicate p.

Convenience Functions

first sus returns SOME c where c is the first character in sus, if sus is non-empty; otherwise returns NONE.

Projection of a pair to its first element.

Same as BatSeq.hd

Returns the first element or raises Empty_list if the ref list is empty

Apply a function to the first element of a pair.

Returns the first element of the list, or raise Empty_list if the list is empty (similar to hd).

As hd

first_chars s n returns the first n characters of s.

Same as BatSeq.concat.

Same as concat.

Lazy concatenation of a list of lazy lists

Synonym of BatEnum.concat

Argument flipping.

Argument flipping.

Random.float bound returns a random floating-point number between 0 (inclusive) and bound (exclusive).

Parse a floating-point number.

See Bigarray.char.

See Bigarray.char.

See OptParse.StdOpt.int_callback.

Returns a floating-point number approximating the given big integer.

Return the floating-point number whose internal representation, according to the IEEE 754 floating-point ``double format'' bit layout, is the given int64.

Return the floating-point number whose internal representation, according to the IEEE 754 floating-point ``single format'' bit layout, is the given int32.

See OptParse.StdOpt.int_option.

Round the given float to an integer value.

Round the given float to an integer value.

Flush the buffer associated with the given output, performing all pending writes on that channel.

Flush an output.

Flush an output.

Write all pending data to output channels, ignore all errors.

Flush all outputs.

Flush all outputs, ignore errors.

Flush remaining unwritten bits, adding up to 7 bits which values 0.

as fold_left

fold f a r computes f (... (f (f a r0) r1)...) rN-1 where rn = Vect.get n r and N = length r.

fold is foldl without initialization value, where the first element of stream is taken as init.

fold is foldl without initialization value, where the first element of stream is taken as init.

fold f s a computes (f xN ... (f x2 (f x1 a))...), where x1 ... xN are the elements of s, in increasing order.

Rope.fold f a r computes f (... (f (f a r0) r1)...) rN-1 where rn = Rope.get n r and N = length r.

fold f accu q is equivalent to List.fold_left f accu l, where l is the list of q's elements.

Transformation loop on an enumeration, used to build a single value from an enumeration.

fold f s a computes (f xN ... (f x2 (f x1 a))...), where x1 ... xN are the elements of s, in increasing order.

fold f m a computes (f kN dN ... (f k1 d1 a)...), where k1 ... kN are the keys of all bindings in m, and d1 ... dN are the associated data.

fold f m a computes (f kN dN ... (f k1 d1 a)...), where k1 ... kN are the keys of all bindings in m, and d1 ... dN are the associated data.

fold f m a computes (f kN dN ... (f k1 d1 a)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.

Weaktbl.fold f tbl init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values.

Hashtbl.fold f tbl init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values.

Hashtbl.fold f tbl init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values.

A general loop on an enumeration.

fold2 is similar to fold but will fold over two enumerations at the same time until one of the two enumerations ends.

fold_left f a r computes f (... (f (f a r0) r1)...) rN-1 where rn = Vect.get n r and N = length r.

fold_left f a r computes f (... (f (f a r0) r1)...) rN-1 where rn = Vect.get n r and N = length r.

foldl f e sus folds f over sus from left to right.

fold_left f a s is f (... (f (f a s.[0]) s.[1]) ...) s.[n-1]

fold_left f a (cons b1 (... bn)) is f (... (f (f a b1) b2) ...) bn.

List.fold_left f a [b1; ...; bn] is f (... (f (f a b1) b2) ...) bn.

Eager fold_left

fold_left f x darr computes f ( ... ( f ( f (get darr 0) x) (get darr 1) ) ... ) (get darr n-1), similar to Array.fold_left or List.fold_left.

Accumulate a value over the entire list.

Array.fold_left f x a computes f (... (f (f x a.(0)) a.(1)) ...) a.(n-1), where n is the length of the array a.

Array.fold_left f x a computes f (... (f (f x a.(0)) a.(1)) ...) a.(n-1), where n is the length of the array a.

List.fold_left2 f a [b1; ...; bn] [c1; ...; cn] is f (... (f (f a b1 c1) b2 c2) ...) bn cn.

fold_left2 f a [b1; ...; bn] [c1; ...; cn] is f (... (f (f a b1 c1) b2 c2) ...) bn cn.

fold_monad f init e does a folding of the enumeration e applying step by step the function f that gives back results in the Mon monad, with the init initial element.

fold_right f r a computes f (r0 ... (f rN-2 (f rN-1 a)) ...)) where rn = Vect.get n r and N = length r.

fold_right f r a computes f (r0 ... (f rN-2 (f rN-1 a)) ...)) where rn = Vect.get n r and N = length r.

foldr f e sus folds f over sus from right to left.

fold_right f s b is f s.[0] (f s.[1] (... (f s.[n-1] b) ...))

fold_right f (cons a1 (... an)) b is f a1 (f a2 (... (f an b) ...)).

List.fold_right f [a1; ...; an] b is f a1 (f a2 (... (f an b) ...)).

List.fold_right f [a1; ...; an] b is f a1 (f a2 (... (f an b) ...)).

Eager fold_right

fold_right f darr x computes f (get darr 0) (f (get darr 1) ( ... ( f (get darr n-1) x ) ... ) ) similar to Array.fold_right or List.fold_right.

Accumulate a value over the entire list.

Array.fold_right f a x computes f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...)), where n is the length of the array a.

Array.fold_right f a x computes f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...)), where n is the length of the array a.

List.fold_right2 f [a1; ...; an] [b1; ...; bn] c is f a1 b1 (f a2 b2 (... (f an bn c) ...)).

fold_right2 f [a1; ...; an] [b1; ...; bn] c is f a1 b1 (f a2 b2 (... (f an bn c) ...)).

As BatVect.fold, but with the position of each value passed to the folding function

Same as fold, but the function receives as arguments both the key and the associated value for each binding of the map.

Same as fold, but the function receives as arguments both the key and the associated value for each binding of the map.

foldl f init stream is a lazy fold_left.

foldl f init stream is a lazy fold_left.

foldr f init stream is a lazy fold_right.

foldr f init stream is a lazy fold_right.

for_all p [a1; ...; an] checks if all elements of the array satisfy the predicate p.

for_all p s checks if all elements of the set satisfy the predicate p.

for_all p (cons a1 (... an)) checks if all elements of the given sequence satisfy the predicate p.

Return true if all elements match the specified predicate

exists f e returns true if for every x in e, f x is true

Returns whether the given predicate applies to all elements in the set

Tests whether all key value pairs satisfy some predicate function

Eager universal.

for_all f e returns true if for every x in e, f x is true

Predicates

for_all p [a1; ...; an] checks if all elements of the array satisfy the predicate p.

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

Same as BatLazyList.for_all, but for a two-argument predicate.

As Array.for_all but on two arrays.

force e forces the application of all lazy functions and the enumeration of all elements, exhausting the enumeration.

Imperative loop on an enumeration.

format_from_string s fmt converts a string argument to a format string, according to the given format string fmt.

format_timestamp oc timestamp prints an ISO-8601 formatted timestamp (extended to specify higher-resolution seconds) to the output channel, oc.

formatter_of_out_channel oc returns a new formatter that writes to the corresponding channel oc.

formatter_of_output out returns a new formatter that writes to the corresponding output out.

General function.

General formatting function.

General function.

frexp f returns the pair of the significant and the exponent of f.

frexp f returns the pair of the significant and the exponent of f.

from next creates a (possibly infinite) lazy list from the successive results of next.

from next creates an enumeration from the next function.

Bufferized file reading in text mode.

Bufferized file reading in binary mode.

Scanning.from_function f returns a scanning buffer with the given function as its reading method.

Scanning.from_channel ic returns a scanning buffer which reads from the input channel ic, starting at the current reading position.

Create a lexer buffer on the given input Lexing.from_input inp returns a lexer buffer which reads from the input inp, at the current reading position.

from_loop data next creates a (possibly infinite) lazy list from the successive results of applying next to data, then to the result, etc.

from_loop data next creates a (possibly infinite) enumeration from the successive results of applying next to data, then to the result, etc.

Scanning.from_string s returns a scanning buffer which reads from the given string.

from next creates a (possibly infinite) lazy list from the successive results of next.

from_while next creates an enumeration from the next function.

Same as Scanf.bscanf, but reads from the given channel.

sum l returns the sum of the elements of l

Same as Random.init but takes more data as seed.

Same as BatStr.Str.split_delim, but returns the delimiters as well as the substrings contained between delimiters.

Return the generic big array corresponding to the given one-dimensional big array.

Return the generic big array corresponding to the given two-dimensional big array.

Return the generic big array corresponding to the given three-dimensional big array.

get n r returns the (n+1)th element from the vect r; i.e.

get v n returns the (n+1)th element from the vect v; i.e.