Index of values


(<<) [MParser]
p << q is equivalent to p >>= (fun x -> q >> return x).
(<?>) [MParser]
p <?> label attaches the label label to p.
(<??>) [MParser]
p <??> label behaves like p <?> label, but if p fails after consuming input, the error message of p is wrapped inside a Compound_error.
(<|>$) [MParser]
p <|>$ x is equivalent to p <|> return x.
(<|>) [MParser]
p <|> q first applies p.
(>>$) [MParser]
p >>$ x is equivalent to p >> return x.
(>>) [MParser]
p >> q is equivalent to p >>= (fun _ -> q).
(>>=) [MParser]
p >>= f first applies the parser p, then applies f to the resulting value, and finally applies the resulting parser.
(>>?) [MParser]
p >>? q behaves like p >> q, but if q fails without consuming input, it backtracks and pretends not having consumed input, even if p has consumed input.
(|>) [Fun]
x |> f is equivalent to f x.
(|>>) [MParser]
p |>> f is equivalent to p >>= (fun x -> return (f x)).

A
add [PriorityQueue.S]
Adds an elements to the queue.
add [PriorityQueue]
Adds an elements to the queue.
add [FSet.S]
add x s returns the union of the set s and the one-element set containing only x.
add [FSet]
add x s returns the union of the set s and the one-element set containing only x.
add [FMap.S]
add x y m returns a map that maps x to y and all other elements to the values they are mapped to by m.
add [FMap]
add x y m returns a map that maps x to y and all other elements to the values they are mapped to by m.
add [ExtList.List]
add x s returns the union of s and {x}.
add [DynArray]
add a x adds x to the end of a.
advance_state [MParser]
advance_state s n returns the state s with the position advanced by n characters if the current position of s is a valid position.
advance_state_nl [MParser]
advance_state_nl s n returns the state s with the position advanced by n characters and the line counter increased by one if the current position of s is a valid position.
alphanum [MParser]
Parses an english letter or a decimal digit and returns it.
any_char [MParser]
Parses any character and returns it.
any_char_or_nl [MParser]
any_char_or_nl is equivalent to newline <|> any_char.
any_index_from [ExtString.String]
any_index_from s start chars returns Some i where i is the index of the first occurrence of a character in chars in the string s starting at start, or None if no character from chars occurs in s starting at start.
any_of [MParser]
any_of str parses any char occurring in the string str and returns it.
any_string [MParser]
any_string n parses any string of n characters and returns it.
append [ExtList.List]
append [ExtArray.Array]
append [DynArray]
append a b appends the elements of a to the end of b.
apply [FMap.S]
apply m x returns the value x is mapped to by m (the same as find).
apply [FMap]
apply m x returns the value x is mapped to by m (the same as find).
assoc [ExtList.List]
assoc_map [ExtList.List]
assoc_map f [(a1, b1), ..., (an, bn)] applies the function f to the elements b1, ..., bn and returns the list [(a1, f b1), ..., (an, f bn)].
assq [ExtList.List]
attempt [MParser]
attempt p behaves like p, but if p fails after consuming input, it backtracks and pretends not having consumed input.

B
backtrack_error [MParser]
Creates a Backtrack_error.
between [MParser]
between left right p is equivalent to left >> p << right.
binary [MParser.Tokens]
Parses a binary natural number as defined in the OCaml language (prefixed with "0b" or "0B") and returns it as an integer value.
blank [MParser]
Parses a space or a tab character (' ' or '\t' and returns it.
blit [ExtString.String]
blit [ExtArray.Array]
blit [DynArray]
blit a i b j n replaces n elements of array b starting at index j by n elements of array a starting at index i.
bounded_fix [Fun]
bounded_fix f x bound returns the fixed point of the function f with starting point x if it is reached within bound iterations.
bounded_fix_cmp [Fun]
bounded_fix_cmp eq f x bound returns the fixed point of the function f with starting point x if it is reached within bound iterations.
braces [MParser.Tokens]
braces p parses p between curly braces '{' and '}'.
brackets [MParser.Tokens]
brackets p parses p between angle brackets '<' and '>'.

C
capitalize [ExtString.String]
cardinal [FSet.S]
Returns the number of elements in a set (same as size).
cardinal [FSet]
Returns the number of elements in a set (same as size).
chain_left [MParser]
chain_left p op x parses zero or more occurrences of p, separated by op.
chain_left1 [MParser]
chain_left p op parses one or more occurrences of p, separated by op.
chain_right [MParser]
chain_right p op x parses zero or more occurrences of p, separated by op.
chain_right1 [MParser]
chain_right1 p op parses one or more occurrences of p, separated by op.
char [MParser]
char c parses the character c.
char_literal [MParser.Tokens]
Parses a character literal as defined in the OCaml language and returns the character.
choice [MParser]
choice [p1; p2; ...; pn ] is equivalent to p1 <|> p2 <|> ... <|> pn <|> zero.
choose [FSet.S]
Returns an element of a set.
choose [FSet]
Returns an element of a set.
chr [ExtChar.Char]
clear [PriorityQueue.S]
Removes all elements from a queue.
clear [PriorityQueue]
Removes all elements from a queue.
clear [DynArray]
clear a removes all elements from a.
code [ExtChar.Char]
collect [ExtString.String]
collect l returns a string with the characters in the list l.
colon [MParser.Tokens]
Parses a colon ':'.
combine [ExtList.List]
comma [MParser.Tokens]
Parses a comma ','.
comma_sep [MParser.Tokens]
comma_sep p parses zero or more occurrences of p, separated by ','.
comma_sep1 [MParser.Tokens]
comma_sep1 p parses one or more occurrences of p, separated by ','.
compare [FSet.OrderedType]
A function defining a total ordering on the type t.
compare [FSet.S]
Defines a total ordering on sets.
compare [FSet]
Defines a total ordering on sets.
compare [FMap.OrderedType]
A function defining a total ordering on the type t.
compare [FMap.S]
equal cmp m1 m2 tests whether the maps m1 and m2 are equal.
compare [FMap]
compare cmp returns a total ordering on maps using cmp to compare values.
compare [ExtString.String]
compare [ExtChar.Char]
compose [Fun]
compose f g composes the functions f and g such that (compose f g) x = f (g x) for all x.
compound_error [MParser]
Creates a Compound_error.
concat [ExtString.String]
concat [ExtList.List]
concat [ExtArray.Array]
concat_conj [ExtString.String]
concat_conj sep conj strings concatenates the elements of strings using the separator sep and the conjunction conj according to the rules of the English language.
cons [ExtList.List]
The list constructor :: in functional form.
const [Fun]
const c is the function that maps every value to c.
contains [ExtString.String]
contains_from [ExtString.String]
copy [ExtString.String]
copy [ExtArray.Array]
copy [DynArray]
copy a returns a new dynamic array containing the same elements as a.
count [MParser]
count n p parses exactly n occurrences of p and returns a list of the results returned by p.
create [ExtString.String]
create [ExtArray.Array]
create_matrix [ExtArray.Array]
curry [Fun]
Function currying; (curry f) x y = f (x, y) for all x and y.

D
decimal [MParser.Tokens]
Parses a decimal natural number and returns it as an integer value.
diff [FSet.S]
diff s1 s2 returns the difference of the sets s1 and s2.
diff [FSet]
diff s1 s2 returns the difference of the sets s1 and s2.
diff [ExtList.List]
diff s1 s2 returns the difference of s1 and s2.
digit [MParser]
Parses a decimal digit and returns it.
dot [MParser.Tokens]
Parses a dot '.'.
doubling_resizer_with_shrinking [DynArray]
A resizer that grows and shrinks an array by doubling or halving the size of the array as necessary.
doubling_resizer_without_shrinking [DynArray]
A resizer that grows an array by doubling the size of the array as necessary.

E
elements [FSet.S]
Returns a list containing the elements of a set in increasing order (same as to_list).
elements [FSet]
Returns a list containing the elements of a set in increasing order (same as to_list).
empty [FSet.S]
The empty set.
empty [FSet]
The empty set.
empty [FMap.S]
The empty map.
empty [FMap]
The empty map.
end_by [MParser]
end_by p sep parses zero or more occurrences of p, separated and ended by sep.
end_by1 [MParser]
end_by1 p sep parses one or more occurrences of p, separated and ended by sep.
eof [MParser]
Parses the end of the input.
equal [PriorityQueue.HashedType]
The equality predicate on the element type.
equal [FSet.S]
Tests whether two sets contain the same elements.
equal [FSet]
Tests whether two sets contain the same elements.
equal [FMap.S]
compare cmp returns a total ordering on maps using cmp to compare values.
equal [FMap]
equal cmp m1 m2 tests whether the maps m1 and m2 are equal.
escaped [ExtString.String]
escaped [ExtChar.Char]
exists [FSet.S]
for_all p s returns true if p a = true for some element a of the set s, and false otherwise.
exists [FSet]
for_all p s returns true if p a = true for some element a of the set s, and false otherwise.
exists [FMap.S]
for_all p m returns true if p x y = true some element (x, y) of m, and false otherwise.
exists [FMap]
for_all p m returns true if p x y = true some element (x, y) of m, and false otherwise.
exists [ExtString.String]
exists p s returns true if p c = true for some character c of s, and false otherwise.
exists [ExtList.List]
exists [ExtArray.Array]
exists p [a1; ...; an] returns true if p ai = true for some i, and false otherwise.
exists [DynArray]
exists p a returns true if p x = true for some element x of the array a, and false otherwise.
exists2 [ExtList.List]
exists2 [ExtArray.Array]
exists2 p [a1; ...; an] [b1; ...; bn] returns true if p ai bi = true for some i, and false otherwise.
exists2 [DynArray]
exists2 p a b returns true if p x y = true for some pair of elements x and y where x has the same index in a as y in b.
exists_pair [ExtList.List]
exists_pair p [a1; ...; am] [b1; ...; bn] returns true if p ai bj = true for some i and j, and false otherwise.
expected_error [MParser]
Creates an Expected_error.
explode [ExtString.String]
explode s returns a list with the characters of the string s.
expression [MParser]
expression operators term parses any well-formed expression that can built from the basic terms parsed by term and the operators specified in the operator table operators.

F
fail [MParser]
fail msg always fails with a Message_error with error message msg.
fast_sort [ExtList.List]
fast_sort [ExtArray.Array]
fill [ExtString.String]
fill [ExtArray.Array]
fill [DynArray]
fill a i n x replaces the elements of the array a with indices i, ..., i + n - 1 by n copies of the value x.
filter [FSet.S]
filter p s returns a set containing all elements of the set s that satisfy the predicate p.
filter [FSet]
filter p s returns a set containing all elements of the set s that satisfy the predicate p.
filter [ExtList.List]
find [FMap.S]
find x m returns the value x is mapped to by m.
find [FMap]
find x m returns the value x is mapped to by m.
find [ExtList.List]
find2 [ExtList.List]
find2 p l1 l2 returns the first pair (a, b) such that a = nth l1 i and b = nth l2 i for some index i and p a b = true.
find_all [ExtList.List]
first [PriorityQueue.S]
first q returns an element with maximal priority contained in the queue q.
first [PriorityQueue]
first q returns an element with maximal priority contained in the queue q.
first [DynArray]
first a returns Some x if x is the first element (the element with index 0) of a, or None if the array is empty.
fix [Fun]
fix f x returns the fixed point of the function f with starting point x if it exists, or loops forever if f does not converge.
fix_cmp [Fun]
fix_cmp eq f x returns the fixed point of the function f with starting point x if it exists, or loops forever if f does not converge.
flatten [ExtList.List]
float [MParser.Tokens]
Parses floating-point literal as defined in the OCaml language and returns its value.
fold [FSet.S]
fold f s a returns (f an ... (f a2 (f a1 a)) ... ), where a1, ..., an are the elements of s in increasing order.
fold [FSet]
fold f s a returns (f an ... (f a2 (f a1 a)) ... ), where a1, ..., an are the elements of s in increasing order.
fold [FMap.S]
fold f m a returns (f xn yn ... (f x2 y2 (f x1 y1 a)) ... ), where (x1, y1), ..., (xn, yn) are the elements of m in increasing domain order.
fold [FMap]
fold f m a returns (f xn yn ... (f x2 y2 (f x1 y1 a)) ... ), where (x1, y1), ..., (xn, yn) are the elements of m in increasing domain order.
fold_left [ExtString.String]
fold_left f a s returns f (... (f (f a c1) c2) ...) cn, where c1, ..., cn are the characters of s.
fold_left [ExtList.List]
fold_left [ExtArray.Array]
fold_left [DynArray]
fold_left f x a returns f (... (f (f x a1) a2) ...) an, where a1, ..., an are the elements of a.
fold_left1 [ExtList.List]
fold_left1 f [a1; ...; an] returns f (... (f (f a1 a2) a3) ...) an), and fold_left1 f [a] returns a.
fold_left2 [ExtList.List]
fold_left2 [ExtArray.Array]
fold_left2 f a [|b1; ...; bn|] [|c1; ...; cn|] returns f ( ... (f (f a b1 c1) b2 c2) ... ) bn cn.
fold_left2 [DynArray]
fold_left2 f x a b returns f ( ... (f (f x a1 b1) a2 b2) ... ) an bn, where a1, ..., an are the elements of a, and b1, ..., bn are the elements of b.
fold_map [ExtList.List]
fold_map f a [b1; ...; bn] returns (an, [c1; ...; cn], where a1 = fst (f a b1), a(i+1) = fst (f ai b(i+1)), c1 = snd (f a b1), and c(i+1) = snd (f ai b(i+1)).
fold_right [ExtString.String]
fold_right f s a returns f c1 (f c2 (... (f cn a) ...)), where c1, ..., cn are the characters of s.
fold_right [ExtList.List]
fold_right [ExtArray.Array]
fold_right [DynArray]
fold_right f a x returns f a1 (f a2 (... (f an x) ...)), where a1, ..., an are the elements of a.
fold_right1 [ExtList.List]
fold_right1 f [a1; ...; an] returns f a1 (f a2 (... (f a(n-1) an) ...)), and fold_right1 f [a] returns a.
fold_right2 [ExtList.List]
fold_right2 [ExtArray.Array]
fold_right2 f [|a1; ...; an|] [|b1; ...; bn|] c returns f a1 b1 (f a2 b2 ( ... (f an bn c) ... )).
fold_right2 [DynArray]
fold_right2 f a b x returns f a1 b1 (f a2 b2 ( ... (f an bn x) ... )), where a1, ..., an are the elements of a, and b1, ..., bn are the elements of b.
followed_by [MParser]
followed_by p msg succeeds without consuming input and returns () if p succeeds at the current position.
for_all [FSet.S]
for_all p s returns true if p a = true for all elements a of the set s, and false otherwise.
for_all [FSet]
for_all p s returns true if p a = true for all elements a of the set s, and false otherwise.
for_all [FMap.S]
for_all p m returns true if p x y = true for all elements (x, y) of m, and false otherwise.
for_all [FMap]
for_all p m returns true if p x y = true for all elements (x, y) of m, and false otherwise.
for_all [ExtString.String]
for_all p s returns true if p c = true for all characters c of s, and false otherwise.
for_all [ExtList.List]
for_all [ExtArray.Array]
for_all p [a1; ...; an] returns true if p ai = true for all i, and false otherwise.
for_all [DynArray]
for_all p a returns true if p x = true for all elements x of the array a, and false otherwise.
for_all2 [ExtList.List]
for_all2 [ExtArray.Array]
for_all2 p [a1; ...; an] [b1; ...; bn] returns true if p ai bi = true for all i, and false otherwise.
for_all2 [DynArray]
for_all2 p a b returns true if p x y = true for all pairs of elements x and y where x has the same index in a as y in b.
for_all_pairs [ExtList.List]
for_all_pairs p [a1; ...; am] [b1; ...; bn] returns true if p ai bj = true for all i and j, and false otherwise.
from_channel [CharStream]
from_channel ?block_size ?block_overlap ?min_rspace chn creates a character stream that contains the characters of the input channel chn.
from_string [CharStream]
from_string s creates a character stream that contains the characters of the string s.

G
generate [ExtList.List]
generate f a b returns the list [f a; f (a+1); ...; f b] if a <= b, and [] if a > b.
get [ExtString.String]
get [ExtArray.Array]
get [DynArray]
get a i returns the element with index i of a.
get_index [MParser]
Returns the current index into the input.
get_input [MParser]
Returns the input stream.
get_pos [MParser]
Returns the current position.
get_user_state [MParser]
Returns the current user state of the parser.

H
hash [PriorityQueue.HashedType]
A hash function on the elements.
hd [ExtList.List]
hex_digit [MParser]
Parses a hexadecimal digit and returns it.
hexadecimal [MParser.Tokens]
Parses a hexadecimal natural number as defined in the OCaml language (prefixed with "0x" or "0X") and returns it as an integer value.

I
identity [Fun]
The identity funcrion.
index [ExtString.String]
index_from [ExtString.String]
init [MParser]
init input user returns an initial parser state using the input string input and the initial user state user.
init [ExtArray.Array]
init [DynArray]
init n f returns a new dynamic array of length n where the element with index i is equal to f i.
input [Io]
input chn buffer pos length reads up to length characters from the channel chn and stores them in the string buffer, starting at position pos.
input_all [Io]
input_all ?block_size chn reads the remaining input from the channel chn and returns it as a string.
input_lines [Io]
input_lines chn reads all remaining lines from the channel chn and returns a list of strings containing these lines without the newline character '\n' at the line ends.
insert [DynArray]
insert a x i inserts x into the array a at index i.
insert_range [DynArray]
insert_range a1 i1 a2 i2 n inserts the subarray sub a2 i2 n into the array a1 at index i1.
integer [MParser.Tokens]
Parses a decimal integer number and returns its value.
inter [FSet.S]
inter s1 s2 returns the intersection of the sets s1 and s2.
inter [FSet]
inter s1 s2 returns the intersection of the sets s1 and s2.
inter [ExtList.List]
inter s1 s2 returns the intersection of s1 and s2.
is_alphanum [ExtChar.Char]
Returns true if the given character is a letter or a digit.
is_blank [ExtChar.Char]
Returns true if the given character is a space or a tab (' ' or '\t').
is_consumed [MParser]
is_consumed reply returns true if reply is Consumed_failed or Consumed_ok, and false otherwise.
is_defined [FMap.S]
is_defined x m tests whether m is defined at x (the same as mem).
is_defined [FMap]
is_defined x m tests whether m is defined at x (the same as mem).
is_digit [ExtChar.Char]
Returns true if the given character is a decimal digit.
is_empty [PriorityQueue.S]
Tests whether a queue is empty.
is_empty [PriorityQueue]
Tests whether a queue is empty.
is_empty [MParser]
is_consumed reply returns true if reply is Empty_failed or Empty_ok, and false otherwise.
is_empty [FSet.S]
Tests whether a set is empty.
is_empty [FSet]
Tests whether a set is empty.
is_empty [FMap.S]
Tests whether a map has an empty domain.
is_empty [FMap]
Tests whether a map has an empty domain.
is_empty [DynArray]
Tests whether an array is empty.
is_eof [MParser]
is_eof s returns true if the current position of s is not a valid position, and false otherwise.
is_error [MParser]
is_error reply returns true if reply is Empty_failed or Consumed_failed, and false otherwise.
is_hex_digit [ExtChar.Char]
Returns true if the given character is a hexadecimal digit.
is_letter [ExtChar.Char]
Returns true if the given character is an english letter.
is_lowercase [ExtChar.Char]
Returns true if the given character is an english lowercase letter.
is_newline [ExtChar.Char]
Returns true if the given character is a newline ('\n' or '\r').
is_oct_digit [ExtChar.Char]
Returns true if the given character is an octal digit.
is_ok [MParser]
is_error reply returns true if reply is Empty_ok or Consumed_ok, and false otherwise.
is_operator [ExtChar.Char]
Returns true if the given character is an operator character as defined in the OCaml language (i.e, one of '+', '-', '*', '/', '^' '>', '<', '=', '~', '#', '|', '&', '@', '$', ':' '?', '!', or '\').
is_uppercase [ExtChar.Char]
Returns true if the given character is an english uppercase letter.
is_whitespace [ExtChar.Char]
Returns true if the given character is a space, a tab or a newline (' ', '\t', '\n', or '\r').
iter [FSet.S]
iter f s applies f to all elements of the set s.
iter [FSet]
iter f s applies f to all elements of the set s.
iter [FMap.S]
iter f m applies f to all pairs x and y, where (x, y) is an element of m.
iter [FMap]
iter f m applies f to all pairs x and y, where (x, y) is an element of m.
iter [ExtString.String]
iter [ExtList.List]
iter [ExtArray.Array]
iter [DynArray]
iter f a applies the function f successively to all elements of a.
iter2 [ExtList.List]
iter_pairs [ExtList.List]
iter_pairs f [a1; ...; am] [b1; ...; bn] applies the function f successively to all elements ai and bj.
iterate [Fun]
Function power; iterate f n = f^n.
iteri [ExtString.String]
iteri f s applies the function f successively to all characters of s and their indices.
iteri [ExtList.List]
iteri f [a1; ...; an] applies the function f successively to the elements a1, ..., an and their indices.
iteri [ExtArray.Array]
iteri [DynArray]
iteri f a applies the function f successively to all elements of a and their indices.

L
last [DynArray]
last a returns Some x if x is the last element (the element with index length a - 1) of a, or None if the array is empty.
length [PriorityQueue.S]
Returns the number of elements in a queue.
length [PriorityQueue]
Returns the number of elements in a queue.
length [ExtString.String]
length [ExtList.List]
length [ExtArray.Array]
length [DynArray]
Returns the length of an array.
length [CharStream]
length s returns the number of characters in the stream s.
letter [MParser]
Parses an english letter and returns it.
lexicographic_compare [ExtList.List]
lexicographic_compare cmp l1 l2 compares the lists l1 and l2 lexicographically using the element order cmp.
lexicographic_compare [ExtArray.Array]
lexicographic_compare cmp a1 a2 compares the arrays a1 and a2 lexicographically using the element order cmp.
look_ahead [MParser]
look_ahead p behaves like p, but restores the original state after parsing.
lowercase [MParser]
Parses an english lowercase letter and returns it.
lowercase [ExtString.String]
lowercase [ExtChar.Char]

M
make [PriorityQueue.S]
make ord creates a new priority queue with order ord.
make [PriorityQueue]
make ord creates a new priority queue with order ord.
make [ExtString.String]
make [ExtArray.Array]
make [DynArray]
make n x returns a new dynamic array of length n that is initialized with n copies of x.
make_failed [MParser]
make_failed consumed error returns Empty_failed error if consumed = false, and Consumed_failed error of consumed = true.
make_matrix [ExtArray.Array]
make_ok [MParser]
make_ok consumed result state error returns Empty_ok (result, state, error) if consumed = false, and Consumed_ok (result, state, error) if consumed = true.
make_regexp [MParser]
Creates a regular expression from a string.
many [MParser]
many p parses zero or more occurrences of p and returns a list of the results returned by p.
many1 [MParser]
many1 p parses one or more occurrences of p and returns a list of the results returned by p.
many1_chars [MParser]
many1_chars p parses one or more occurrences of p and returns a string of the results returned by p.
many1_fold_left [MParser]
many1_fold_left f a p is equivalent to many1 p |>> List.fold_left f a.
many1_rev [MParser]
many1_rev p is equivalent to many1 p |>> List.rev.
many1_rev_fold_left [MParser]
many1_rev_fold_left f a p is equivalent to many1 p |>> List.rev |>> List.fold_left f a.
many1_satisfy [MParser]
many1_satisfy p is equivalent to many1 (satisfy p).
many_chars [MParser]
many_chars p parses zero or more occurrences of p and returns a string of the results returned by p.
many_chars_until [MParser]
many_chars_until p q parses zero or more occurrences of p until q succeeds and returns a string of the results returned by p.
many_fold_left [MParser]
many_fold_left f a p is equivalent to many p |>> List.fold_left f a.
many_rev [MParser]
many_rev p is equivalent to many p |>> List.rev.
many_rev_fold_left [MParser]
many_rev_fold_left f a p is equivalent to many p |>> List.rev |>> List.fold_left f a.
many_satisfy [MParser]
many_satisfy p is equivalent to many (satisfy p).
many_until [MParser]
many_until p q parses zero or more occurrences of p until q succeeds and returns a list of the results returned by p.
map [FSet.S]
map f s returns a set with elements f a1, ...
map [FSet]
map f s returns a set with elements f a1, ...
map [FMap.S]
map f m returns a map that has the same domain as m and maps all elements x in its domain to f (find x m).
map [FMap]
map f m returns a map that has the same domain as m and maps all elements x in its domain to f (find x m).
map [ExtList.List]
map [ExtArray.Array]
map [DynArray]
map f a returns an array with elements f a1, ..., f an, where a1, ..., an are the elements of a.
map2 [ExtList.List]
mapi [FMap.S]
mapi f m returns a map that has the same domain as m and maps all elements x in its domain to f x (find x m).
mapi [FMap]
mapi f m returns a map that has the same domain as m and maps all elements x in its domain to f x (find x m).
mapi [ExtArray.Array]
mapi [DynArray]
mapi f a returns an array with elements f 0 a1, ..., f (n - 1) an, where a1, ..., an are the elements of a.
match_char [MParser]
match_char s c returns true if c ist the char at the current position, and false otherwise.
match_char [CharStream]
match_char s pos c is equivalent to read_char s pos = Some c.
match_regexp [MParser]
match_regexp s rex matches the regular expression rex against the input.
match_regexp [CharStream]
match_regexp s pos rex matches the regular expression rex against the characters in s starting at position pos.
match_string [MParser]
match_string s str returns true if the input starting at the current position matches the string str, and false otherwise.
match_string [CharStream]
match_string s pos str is equivalent to read_string s pos (String.length str) = str.
match_sub [ExtString.String]
match_sub s start pat returns true if the string s contains the string pat as a substring starting at position start, and false otherwise.
match_sub2 [ExtString.String]
match_sub2 s1 start1 s2 start2 len returns true if sub s1 start1 len = sub s2 start2 len, and false otherwise.
max_elt [FSet.S]
max_elt s returns Some x if x is the maximum element of s, or None if s is empty.
max_elt [FSet]
max_elt s returns Some x if x is the maximum element of s, or None if s is empty.
max_elt [ExtList.List]
max_elt l returns Some x if x is the maximum element of l with respect to Pervasives.max, or None if l is empty.
mem [PriorityQueue.S]
Tests whether a queue contains a given element.
mem [PriorityQueue]
Tests whether a queue contains a given element.
mem [FSet.S]
mem x s test whether the set s contains the element x.
mem [FSet]
mem x s test whether the set s contains the element x.
mem [FMap.S]
mem x m tests whether m is defined at x.
mem [FMap]
mem x m tests whether m is defined at x.
mem [ExtList.List]
mem_assoc [ExtList.List]
mem_assq [ExtList.List]
memq [ExtList.List]
merge [ExtList.List]
merge_errors [MParser]
Merges two errors.
message [MParser]
message msg always fails with a Message_error with error message msg without consuming input, so that the error message is merged with other errors generated for the same input position.
message_error [MParser]
Creates a Message_error.
min_elt [FSet.S]
min_elt s returns Some x if x is the minimum element of s, or None if s is empty.
min_elt [FSet]
min_elt s returns Some x if x is the minimum element of s, or None if s is empty.
min_elt [ExtList.List]
min_elt l returns Some x if x is the minimum element of l with respect to Pervasives.min, or None if l is empty.

N
newline [MParser]
Parses a newline ('\n', '\r', or the sequence '\r', '\n').
next_char [MParser]
next_char s returns Some c where c is the character after the current position, or None if this position is not a valid position.
next_char_satisfies [MParser]
next_char_satisfies p succeeds without consuming input if p returns true for the character after the current position.
next_state [MParser]
advance s returns the state s with the position advanced by one character if the current position of s is a valid position.
non [Fun]
non p returns the negation of the predicate p, i.e., non p x = not (p x).
none_of [MParser]
none_of str parses any char not occurring in the string str and returns it.
not_followed_by [MParser]
not_followed_by p msg succeeds without consuming input and returns () if p does not succeed at the current position.
nsatisfy [MParser]
nsatisfy n p parses the next n characters if p returns true for each of them.
nth [ExtList.List]

O
oct_digit [MParser]
Parses an octal digit and returns it.
octal [MParser.Tokens]
Parses an octal natural number as defined in the OCaml language (prefixed with "0o" or "0O") and returns it as an integer value.
of_array [DynArray]
of_array a returns a new dynamic array containing the same elements as a.
of_list [FSet.S]
Returns a set containing the elements of a list.
of_list [FSet]
Returns a set containing the elements of a list.
of_list [FMap.S]
Creates a map from an association list.
of_list [FMap]
Creates a map from an association list.
of_list [ExtArray.Array]
of_list [DynArray]
of_list l returns a dynamic array containing the elements of l.
opt [MParser]
opt x p is equivalent to p <|>$ x.
option [MParser]
option p is equivalent to p >>= (fun r -> return (Some r)) <|>$ None.
optional [MParser]
optional p is equivalent to p >>$ () <|>$ ().

P
pair [MParser]
pair p q is equivalent to p >>= (fun x -> q >>= (fun y -> return (x, y))).
parens [MParser.Tokens]
parens p parses p between parentheses '(' and ')'.
parse [MParser]
parse p input user runs the parser p on the input input using the initial user state user.
parse_channel [MParser]
parse_string p chn user runs the parser p on the input channel chn using the initial user state user.
parse_string [MParser]
parse_string p str user runs the parser p on the string str using the initial user state user.
partition [FSet.S]
partition p s returns a pair (s1, s2) of sets, such that s1 contains the elements of s that satisfy the predicate p, and s2 contains the elements of s that do not satisfy the predicate p.
partition [FSet]
partition p s returns a pair (s1, s2) of sets, such that s1 contains the elements of s that satisfy the predicate p, and s2 contains the elements of s that do not satisfy the predicate p.
partition [ExtList.List]
peek_char [MParser]
Returns the character at the position after the current position or fails if this is not a valid position.
pipe2 [MParser]
A variant of (|>>) for functions with two parameters.
pipe3 [MParser]
A variant of (|>>) for functions with three parameters.
pipe4 [MParser]
A variant of (|>>) for functions with four parameters.
prev_char [MParser]
prev_char s returns Some c where c is the character before the current position, or None if this position is not a valid position.
prev_char_satisfies [MParser]
prev_char_satisfies p succeeds without consuming input if p returns true for the character before the current position.
proper_subset [ExtList.List]
proper_subset s1 s2 returns true if s1 is a proper subset of s2.

R
range [ExtList.List]
range a b returns the list [a; a+1; ...; b] if a <= b, and [] if a > b.
rcontains_from [ExtString.String]
read_char [MParser]
read_char s returns Some c where c is the character at the current position, or None if this position is not a valid position.
read_char [CharStream]
read_char s pos returns Some c if c is the character at position pos in s, or None if this position is not a valid position in s.
read_index [MParser]
read_char s returns Some c where c is the character at the current position, or None if this position is not a valid position.
read_string [MParser]
read_string s maxlen returns a string containing the next n characters, where n is the minimum of maxlen and the number of characters remaining from the current position.
read_string [CharStream]
read_string s pos maxlen returns a string containing the next n characters in s, where n is the minimum of maxlen and the number of characters remaining from position pos.
regexp [MParser]
regexp rex parses any string matching the regular expression rex and returns it.
regexp_substrings [MParser]
regexp rex parses any string matching the regular expression rex and returns an array containing all matched substrings.
register_nl [MParser]
register_nl lines chars_after_nl increases the line counter by lines and sets the beginning of the current line to chars_after_nl chars before the current index.
remove [PriorityQueue.S]
remove q x removes the element x from the queue q.
remove [PriorityQueue]
remove q x removes the element x from the queue q.
remove [FSet.S]
remove x s returns the difference of the set s and the set containing only x.
remove [FSet]
remove x s returns the difference of the set s and the set containing only x.
remove [FMap.S]
remove x m returns a map that is undefined at x and maps all other elements to the values they are mapped to by m.
remove [FMap]
remove x m returns a map that is undefined at x and maps all other elements to the values they are mapped to by m.
remove [DynArray]
remove a i removes the element with index i from a.
remove_all [DynArray]
remove_all a removes all elements from a.
remove_assoc [ExtList.List]
remove_assq [ExtList.List]
remove_dup [ExtList.List]
Returns a list with all successive duplicate elements removed.
remove_first [PriorityQueue.S]
remove_first q removes the element returned by first q from the queue q.
remove_first [PriorityQueue]
remove_first q removes the element returned by first q from the queue q.
remove_last [DynArray]
remove_last a removes the element with index length a - 1 from a.
remove_range [DynArray]
remove_range a i n removes the elements with indices i, ..., i + n - 1 from a.
reorder_down [PriorityQueue.S]
reorder_down q x notifies the queue q that the priority of the element x has decreased.
reorder_down [PriorityQueue]
reorder_down q x notifies the queue q that the priority of the element x has decreased.
reorder_up [PriorityQueue.S]
reorder_up q x notifies the queue q that the priority of the element x has increased.
reorder_up [PriorityQueue]
reorder_up q x notifies the queue q that the priority of the element x has increased.
return [MParser]
return x always succeeds with the result x without consuming any input.
rev [ExtList.List]
rev_append [ExtList.List]
rev_fold [FSet.S]
rev_fold f s a returns (f a1 ... (f a(n-1) (f an a)) ... ), where a1, ..., an are the elements of s in increasing order.
rev_fold [FSet]
rev_fold f s a returns (f a1 ... (f a(n-1) (f an a)) ... ), where a1, ..., an are the elements of s in increasing order.
rev_fold [FMap.S]
fold f m a returns (f x1 y1 (f x2 y2 ... (f xn yn a)) ... ), where (x1, y1), ..., (xn, yn) are the elements of m in increasing domain order.
rev_fold [FMap]
fold f m a returns (f x1 y1 (f x2 y2 ... (f xn yn a)) ... ), where (x1, y1), ..., (xn, yn) are the elements of m in increasing domain order.
rev_iter [FSet.S]
rev_iter f s applies f to all elements of the set s.
rev_iter [FSet]
rev_iter f s applies f to all elements of the set s.
rev_iter [ExtString.String]
rev_iter f s applies the function f successively to all characters of s in reverse direction.
rev_iter [ExtArray.Array]
rev_iter f a applies the function f successively to the elements of a in reverse direction.
rev_iter [DynArray]
rev_iter f a applies the function f successively to all elements of a in reverse direction.
rev_iteri [ExtString.String]
rev_iteri f s applies the function f successively to all characters in reverse direction of s and their indices.
rev_iteri [ExtArray.Array]
rev_iter f a applies the function f successively to the elements of a in reverse direction and their indices.
rev_iteri [DynArray]
rev_iteri f a applies the function f successively to all elements of a in reverse direction and their indices.
rev_map [ExtList.List]
rev_map2 [ExtList.List]
rindex [ExtString.String]
rindex_from [ExtString.String]

S
satisfy [MParser]
satisfy p parses a character for which p returns true and returns the character.
satisfy_l [MParser]
satisfy_l p label is equivalent to satisfy p <?> label.
seek [CharStream]
seek s pos prepares the stream for reading from position pos.
semi [MParser.Tokens]
Parses a semicolon ';'.
semi_end [MParser.Tokens]
semi_end p parses zero or more occurrences of p, separated and ended by ';'.
semi_end1 [MParser.Tokens]
semi_sep_end1 p parses one or more occurrences of p, separated and ended by ';'.
semi_sep [MParser.Tokens]
semi_sep p parses zero or more occurrences of p, separated by ';'.
semi_sep1 [MParser.Tokens]
semi_sep1 p parses one or more occurrences of p, separated by ';'.
semi_sep_end [MParser.Tokens]
semi_sep_end p parses zero or more occurrences of p, separated and optionally ended by ';'.
semi_sep_end1 [MParser.Tokens]
semi_sep_end1 p parses one or more occurrences of p, separated and optionally ended by ';'.
sep_by [MParser]
sep_by p sep parses zero or more occurrences of p, separated by sep.
sep_by1 [MParser]
sep_by1 p sep parses one or more occurrences of p, separated by sep.
sep_end_by [MParser]
sep_end_by p sep parses zero or more occurrences of p, separated and optionally ended by sep.
sep_end_by1 [MParser]
sep_end_by1 p sep parses one or more occurrences of p, separated and optionally ended by sep.
set [ExtString.String]
set [ExtArray.Array]
set [DynArray]
set a i x replaces the element with index i of a by the value x.
set_default_resizer [DynArray]
Sets the default resizer function.
set_error [MParser]
set_error reply error returns reply with the error message replaced by error.
set_map [ExtList.List]
set_map f s is equal to setify (map f s).
set_resizer [DynArray]
Sets the resizer function of an array.
set_user_state [MParser]
Sets the current user state of the parser.
setify [ExtList.List]
Returns a setified list, i.e., a sorted list without any duplicate elements.
singleton [FSet.S]
singleton x returns the one-element set containing only x.
singleton [FSet]
singleton x returns the one-element set containing only x.
singleton [ExtList.List]
singleton a returns the list [a].
size [FSet.S]
Returns the number of elements in a set.
size [FSet]
Returns the number of elements in a set.
size [FMap.S]
Returns the size of the domain of a map.
size [FMap]
Returns the size of the domain of a map.
skip [MParser]
skip n skips n characters of the input.
skip_any_char [MParser]
Parses any character and returns ().
skip_any_char_or_nl [MParser]
skip_any_char_or_nl is equivalent to newline <|> skip_any_char.
skip_char [MParser]
char c parses the character c and returns ().
skip_count [MParser]
skip_count n p parses exactly n occurrences of p and returns ().
skip_many [MParser]
skip_many p is equivalent to many p |>> ignore.
skip_many1 [MParser]
skip_many1 p is equivalent to many1 p |>> ignore.
skip_many1_chars [MParser]
skip_many1_chars p is equivalent to many_chars p |>> ignore.
skip_many1_satisfy [MParser]
skip_many1_satisfy p is equivalent to skip_many1 (satisfy p).
skip_many_chars [MParser]
skip_many_chars p is equivalent to many_chars p |>> ignore.
skip_many_chars_until [MParser]
skip_many_until p q parses zero or more occurrences of p until q succeeds and returns ().
skip_many_satisfy [MParser]
skip_many_satisfy p is equivalent to skip_many (satisfy p).
skip_many_until [MParser]
skip_many_until p q parses zero or more occurrences of p until q succeeds and returns ().
skip_satisfy [MParser]
skip_satisfy p is equivalent to satisfy |>> ignore.
skip_satisfy_l [MParser]
skip_satisfy_l p label is equivalent to satisfy_l p label |>> ignore.
skip_string [MParser]
string s parses the string s and returns ().
skip_symbol [MParser.Tokens]
skip_symbol sym parses the literal string sym and returns ().
sort [ExtList.List]
sort [ExtArray.Array]
space [MParser]
Parses a space (' '), a tab ('\t') or a newline ('\n', '\r', or the sequence '\r', '\n').
spaces [MParser]
spaces is equivalent to skip_many_chars space.
spaces1 [MParser]
spaces is equivalent to skip_many_chars1 space.
split [FSet.S]
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x, r is the set of elements of s that are strictly greater than x, and present is true if s contains an element equal to x and false otherwise.
split [FSet]
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x, r is the set of elements of s that are strictly greater than x, and present is true if s contains an element equal to x and false otherwise.
split [ExtList.List]
squares [MParser.Tokens]
squares p parses p between square brackets '[' and ']'.
stable_sort [ExtList.List]
stable_sort [ExtArray.Array]
string [MParser]
string s parses the string s and returns it.
string_literal [MParser.Tokens]
Parses a string literal as defined in the OCaml language and returns the string.
sub [ExtString.String]
sub [ExtArray.Array]
sub [DynArray]
sub a i n returns a new dynamic array containing the elements with indices i, ..., i + n - 1 of a.
subset [FSet.S]
subset s1 s2 tests whether s1 is a subset of the set s2.
subset [FSet]
subset s1 s2 tests whether s1 is a subset of the set s2.
subset [ExtList.List]
subset s1 s2 returns true if s1 is a subset of s2.
swap [ExtArray.Array]
swap a i j swaps the elements of a at indices i and j.
symbol [MParser.Tokens]
symbol sym parses the literal string sym and returns it.

T
tab [MParser]
Parses a tab character ('\t') and returns it.
tl [ExtList.List]
to_array [DynArray]
to_array a returns a new standard OCaml array containing the same elements as a.
to_list [FSet.S]
Returns a list containing the elements of a set in increasing order.
to_list [FSet]
Returns a list containing the elements of a set in increasing order.
to_list [FMap.S]
Returns an association list containing all element of the map in increasing order of the domain elements.
to_list [FMap]
Returns an association list containing all element of the map in increasing order of the domain elements.
to_list [ExtArray.Array]
to_list [DynArray]
to_list a returns a list containing the elements of a.
try_return [MParser]
try_return f x msg s0 succeeds with the result f x without consuming input if f x does not raise an exception.
try_return2 [MParser]
A variant of try_return for functions with two parameters.
try_return3 [MParser]
A variant of try_return for functions with three parameters.
try_skip [MParser]
try_skip p is equivalent to p >>$ true <|>$ false.

U
uncapitalize [ExtString.String]
uncurry [Fun]
Function uncurrying; (uncurry f) (x, y) = f x y for all x and y.
unexpected_error [MParser]
Creates an Unexpected_error.
union [FSet.S]
union s1 s2 returns the union of the sets s1 and s2.
union [FSet]
union s1 s2 returns the union of the sets s1 and s2.
union [ExtList.List]
union s1 s2 returns the union of s1 and s2.
unknown_error [MParser]
Creates an Unknown_error.
update_user_state [MParser]
update_user_state f applies f to the user state of the parser.
uppercase [MParser]
Parses an english uppercase letter and returns it.
uppercase [ExtString.String]
uppercase [ExtChar.Char]

Z
zero [MParser]
zero always fails with an Unknown_error without consuming input.