Index of values


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

A
add [RefList]
Adds an element at the end - O(n)
add [PMap]
add x y m returns a map containing the same bindings as m, plus a binding of x to y.
add [ExtHashtbl.Hashtbl]
add [DynArray]
add darr v appends v onto darr.
add [Dbi.Decimal]
add n m returns the sum of n and m.
add_buffer [UTF8.Buf]
add_buffer b1 b2 adds the contents of b2 to b1.
add_char [UTF8.Buf]
Add one Unicode character to the buffer.
add_sort [RefList]
Adds an element in a sorted list, using optional comparator or 'compare' as default.
add_string [UTF8.Buf]
Add the UTF-8 string to the buffer.
append [ExtList.List]
append [Enum]
append e1 e2 returns an enumeration that will enumerate over all elements of e1 followed by all elements of e2.
append [DynArray]
append src dst adds all elements of src to the end of dst.
assoc [ExtList.List]
assq [ExtList.List]
at_index [RefList.Index]
Return the element of ref list at the specified index raise Invalid_index if the index is outside 0 ; length-1
available [IO]
returns the number of available single tokens, or raise Not_implemented if the IO can't deal with it.

B
blit [ExtString.String]
blit [DynArray]
blit src srcidx dst dstidx len copies len elements from src starting with index srcidx to dst starting at dstidx.

C
capitalize [ExtString.String]
char_of [UChar]
char_of u returns the Latin-1 representation of u.
chr [UChar]
code n returns the Unicode character with the code number n.
chr_of_uint [UChar]
chr_of_uint n returns the Unicode character of the code number n.
clear [UTF8.Buf]
Empty the buffer, but retains the internal storage which was holding the contents
clear [RefList]
Removes all elements
clear [ExtHashtbl.Hashtbl]
clone [Enum]
clone e creates a new enumeration that is copy of e.
clone [BitSet]
Same as copy
close_in [IO]
Close the input.
close_out [IO]
Close the output and return its accumulator data.
code [UChar]
code u returns the Unicode code number of u.
combine [ExtList.List]
compact [DynArray]
compact darr ensures that the space allocated by the array is minimal.
compare [UTF8]
Code point comparison by the lexicographic order.
compare [UChar]
compare u1 u2 returns, a value > 0 if u1 has a larger Unicode code number than u2, 0 if u1 and u2 are the same Unicode character, a value < 0 if u1 has a smaller Unicode code number than u2.
compare [ExtString.String]
compare [Dbi.Decimal]
compare n m returns 0 if x=y, a negative integer if x<y, and a positive integer if x>y.
compare [BitSet]
compare s1 s2 compares two bitsets.
compare_index [UTF8]
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.
concat [ExtString.String]
concat [ExtList.List]
concat [Enum]
concat e returns an enumeration over all elements of all enumerations of e.
connect [Dbi.Factory]
Connect to a specific type of database.
conservative_exponential_resizer [DynArray]
conservative_exponential_resizer is an example resizer function which uses the oldlength parameter.
contains [ExtString.String]
contains_from [ExtString.String]
contents [UTF8.Buf]
contents buf returns the contents of the buffer.
copy [RefList]
Makes a copy of a ref list - O(1)
copy [ExtString.String]
copy [ExtHashtbl.Hashtbl]
copy [DynArray]
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 [BitSet]
Copy a bitset : further modifications of first one will not affect the copy.
copy_enum [RefList]
Makes a copy of a enum
copy_list [RefList]
Makes a copy of a list - O(1)
count [Enum]
count e returns the number of remaining elements in e without consuming the enumeration.
count [BitSet]
count s returns the number of bits set in the bitset s.
create [UTF8.Buf]
create n creates a buffer with the initial size n-bytes.
create [PMap]
creates a new empty map, using the provided function for key comparison.
create [ExtString.String]
create [ExtHashtbl.Hashtbl]
create [DynArray]
create() returns a new empty dynamic array.
create [BitSet]
Create an empty bitset with an initial size (in number of bits).
create_in [IO]
Fully create an input by giving all the needed functions.
create_out [IO]
Fully create an output by giving all the needed functions.

D
database_types [Dbi.Factory]
Returns a list of registered database types.
decode [Base64]
Generic base64 decoding over an input.
default [Option]
default x (Some v) returns v and default x None returns x.
default_resizer [DynArray]
The default resizer function the library is using - in this version of DynArray, this is the exponential_resizer but should change in next versions.
delete [DynArray]
delete darr idx deletes the element of darr at idx.
delete_last [DynArray]
delete_last darr deletes the last element of darr.
differentiate [BitSet]
intersect s t removes the elements of t from s.
differentiate_sym [BitSet]
intersect s t sets s to the symmetrical difference of the sets s and t.
div [Dbi.Decimal]
div n m returns the division of n by m.

E
empty [RefList]
Returns a new empty ref list
empty [PMap]
The empty map, using compare as key comparison function.
empty [Global]
Returns an new named empty global.
empty [Enum]
The empty enumeration : contains no element
empty [DynArray]
Return true if the number of elements in the array is 0.
empty [BitSet]
Create an empty bitset of size 0, the bitset will automatically expand when needed.
encode [Base64]
Generic base64 encoding over an output.
ends_with [ExtString.String]
ends_with s x returns true if the string s is ending with x.
enum [RefList]
Returns an enumeration of current elements in the ref list
enum [PMap]
creates an enumeration for this map.
enum [ExtString.String]
Returns an enumeration of the characters of a string.
enum [ExtList.List]
Returns an enumeration of the elements of a list.
enum [ExtHashtbl.Hashtbl]
Return an enumeration of (key,value) pairs of a hashtable.
enum [DynArray]
enum darr returns the enumeration of darr elements.
enum [BitSet]
enum s returns an enumeration of bits which are set in the bitset s.
eq [UChar]
Equality by code point comparison
equals [BitSet]
equals s1 s2 returns true if, and only if, all bits values in s1 are the same as in s2.
escaped [ExtString.String]
exists [RefList]
Return true if an element matches the specified predicate
exists [PMap]
same as mem.
exists [ExtList.List]
exists [ExtHashtbl.Hashtbl]
exists h k returns true is at least one item with key k is found in the hashtable.
exists2 [ExtList.List]
exponential_resizer [DynArray]
The exponential resizer- The default resizer except when the resizer is being copied from some other darray.

F
fast_count [Enum]
For users worried about the speed of count you can call the fast_count function that will give an hint about count implementation.
fill [ExtString.String]
filter [RefList]
Remove all elements that do not match the specified predicate
filter [ExtList.List]
filter [Enum]
filter f e returns an enumeration over all elements x of e such as f x returns true.
filter_map [ExtList.List]
filter_map f l call (f a0) (f a1).... (f an) where a0..an are the elements of l.
filter_map [Enum]
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.
find [RefList]
Find the first element matching the specified predicate raise Not_found if no element is found
find [PMap]
find x m returns the current binding of x in m, or raises Not_found if no such binding exists.
find [ExtString.String]
find s x returns the starting index of the string x within the string s or raises Invalid_string if x is not a substring of s.
find [ExtList.List]
find [ExtHashtbl.Hashtbl]
find [Enum]
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_all [ExtList.List]
find_all [ExtHashtbl.Hashtbl]
find_default [ExtHashtbl.Hashtbl]
Find a binding for the key, and return a default value if not found
find_exc [RefList]
Same as find but takes an exception to be raised when no element is found as additional parameter
find_exc [ExtList.List]
find_exc p e l returns the first element of l such as p x returns true or raises e if such element as not been found.
find_option [ExtHashtbl.Hashtbl]
Find a binding for the key, or return None if no value is found
first [RefList]
Returns the first element or raises Empty_list if the ref list is empty
first [ExtList.List]
Returns the first element of the list, or raise Empty_list if the list is empty (similar to hd).
flatten [ExtList.List]
flush [IO]
Flush an output.
fold [PMap]
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 [ExtHashtbl.Hashtbl]
fold [Enum]
fold f v e returns v if e is empty, otherwise f (... (f (f v a1) a2) ...) aN where a1..N are the elements of e.
fold2 [Enum]
fold2 is similar to fold but will fold over two enumerations at the same time until one of the two enumerations ends.
fold2i [Enum]
fold_left [ExtList.List]
fold_left [DynArray]
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.
fold_left2 [ExtList.List]
fold_right [ExtList.List]
fold_right [DynArray]
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.
fold_right2 [ExtList.List]
foldi [PMap]
Same as fold, but the function receives as arguments both the key and the associated value for each binding of the map.
foldi [Enum]
for_all [RefList]
Return true if all elements match the specified predicate
for_all [ExtList.List]
for_all2 [ExtList.List]
force [Enum]
force e forces the application of all lazy functions and the enumeration of all elements, exhausting the enumeration.
from [Enum]
from next creates an enumeration from the next function.
from_in [IOO]
from_in_channel [IOO]
from_out [IOO]
from_out_channel [IOO]
from_poly_in_channel [IOO]
from_poly_out_channel [IOO]
from_str_in_channel [IOO]
from_str_out_channel [IOO]

G
get [UTF8]
get s n returns n-th Unicode character of s.
get [Option]
get (Some x) returns x and get None raises No_value.
get [Global]
Get the global value contents - raise Global_not_initialized if not defined.
get [ExtString.String]
get [Enum]
get e returns None if e is empty or Some x where x is the next element of e, in which case the element is removed from the enumeration.
get [DynArray]
get darr idx gets the element in darr at index idx.
get_resizer [DynArray]
Get the current resizer function for a given array

H
hash [ExtHashtbl.Hashtbl]
hd [RefList]
same as first
hd [ExtList.List]
Returns the first element of the list or raise Empty_list if the list is empty.

I
index [RefList.Index]
Return the index (position : 0 starting) of an element in a ref list, using the specified comparator raise Not_found if no element was found
index [ExtString.String]
index_from [ExtString.String]
index_of [RefList.Index]
Return the index (position : 0 starting) of an element in a ref list, using ( = ) for testing element equality raise Not_found if no element was found
index_of [DynArray]
index_of f darr returns the index of the first element x in darr such as f x returns true or raise Not_found if not found.
init [UTF8]
init len f returns a new string which contains len Unicode characters.
init [ExtString.String]
init l f returns the string of length l with the chars f 0 , f 1 , f 2 ...
init [ExtList.List]
Similar to Array.init, init n f returns the list containing the results of (f 0),(f 1)....
init [Enum]
init n f creates a new enumeration over elements f 0, f 1, ..., f (n-1)
init [DynArray]
init n f returns an array of n elements filled with values returned by f 0 , f 1, ... f (n-1).
input_all [Std]
Return the whole contents of an input channel as a single string.
input_bits [IO]
Enable read from an input on a bit-basis.
input_channel [IO]
Create an input that will read from a channel.
input_chars [Std]
Returns an enumeration over characters of an input channel.
input_enum [IO]
Create an input that will read from an enum.
input_lines [Std]
Returns an enumeration over lines of an input channel, as read by the input_line function.
input_list [Std]
Returns the list of lines read from an input channel.
input_string [IO]
Create an input that will read from a string.
insert [DynArray]
insert darr idx v inserts v into darr at index idx.
int_of_uchar [UChar]
Alias of uint_code
intersect [BitSet]
intersect s t sets s to the intersection of the sets s and t.
intoption [Dbi]
intoption(Some i) returns `Int i and intoption None returns `Null.
is_empty [RefList]
Return true if a ref list is empty
is_empty [PMap]
returns true if the map is empty.
is_empty [Enum]
is_empty e returns true if e does not contains any element.
is_none [Option]
is_none None returns true or false either.
is_set [BitSet]
is_set s n returns true if nth-bit in the bitset s is set, or false otherwise.
is_some [Option]
is_some (Some x) returns true or false either.
isdef [Global]
Return true if the global value has been set.
iter [UTF8]
iter f s applies f to all Unicode characters in s.
iter [RefList]
Apply the given function to all elements of the ref list, in respect with the order of the list
iter [PMap]
iter f m applies f to all bindings in map m.
iter [ExtString.String]
iter [ExtList.List]
iter [ExtHashtbl.Hashtbl]
iter [Enum]
iter f e calls the function f with each elements of e in turn.
iter [DynArray]
iter f darr calls the function f on every element of darr.
iter2 [ExtList.List]
iter2 [Enum]
iter2 f e1 e2 calls the function f with the next elements of e and e2 repeatedly until one of the two enumerations ends.
iter2i [Enum]
iteri [ExtList.List]
iteri f l will call (f 0 a0);(f 1 a1) ... (f n an) where a0..an are the elements of the list l.
iteri [Enum]
iteri [DynArray]
iter f darr calls the function f on every element of darr.

J
join [ExtString.String]
Same as concat
junk [Enum]
junk e removes the first element from the enumeration, if any.

K
keys [ExtHashtbl.Hashtbl]
Return an enumeration of all the keys of a hashtable.

L
last [UTF8]
The position of the head of the last Unicode character.
last [RefList]
Returns the last element - O(n) or raises Empty_list if the ref list is empty
last [ExtList.List]
Returns the last element of the list, or raise Empty_list if the list is empty.
last [DynArray]
last darr returns the last element of darr.
lchop [ExtString.String]
Returns the same string but without the first character.
length [UTF8]
length s returns the number of Unicode characters contained in s
length [RefList]
Returns the number of elements - O(n)
length [ExtString.String]
length [ExtList.List]
length [ExtHashtbl.Hashtbl]
Return the number of elements inserted into the Hashtbl (including duplicates)
length [DynArray]
Return the number of elements in the array.
look [UTF8]
look s i returns the Unicode character of the location i in the string s.
lowercase [ExtString.String]

M
make [ExtString.String]
make [Enum]
This function creates a fully defined enumeration.
make [DynArray]
make count returns an array with some memory already allocated so up to count elements can be stored into it without resizing.
map [RefList]
Apply a function to all elements and return the ref list constructed with the function returned values
map [PMap]
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a.
map [Option]
map f (Some x) returns Some (f x) and map None returns None.
map [ExtString.String]
map f s returns a string where all characters c in s have been replaced by f c.
map [ExtList.List]
map [ExtHashtbl.Hashtbl]
map f x creates a new hashtable with the same keys as x, but with the function f applied to all the values
map [Enum]
map f e returns an enumeration over (f a1, f a2, ... , f aN) where a1...N are the elements of e.
map [DynArray]
map f darr applies the function f to every element of darr and creates a dynamic array from the results - similar to List.map or Array.map.
map2 [ExtList.List]
map_default [Option]
map_default f x (Some v) returns f v and map_default f x None returns x.
map_list [RefList]
Apply a function to all elements and return the list constructed with the function returned values
mapi [PMap]
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [ExtList.List]
mapi f l will build the list containing (f 0 a0);(f 1 a1) ... (f n an) where a0..an are the elements of the list l.
mapi [Enum]
mapi is similar to map except that f is passed one extra argument which is the index of the element in the enumeration, starting from 0.
mapi [DynArray]
mapi f darr applies the function f to every element of darr and creates a dynamic array from the results - similar to List.mapi or Array.mapi.
may [Option]
may f (Some x) calls f x and may f None does nothing.
mem [PMap]
mem x m returns true if m contains a binding for x, and false otherwise.
mem [ExtList.List]
mem [ExtHashtbl.Hashtbl]
mem_assoc [ExtList.List]
mem_assq [ExtList.List]
memq [ExtList.List]
move [UTF8]
move s i n returns n-th Unicode character after i if n >= 0, n-th Unicode character before i if n < 0.
mul [Dbi.Decimal]
mul n m returns the product of n and m.

N
name [Global]
Retrieve the name of a global.
next [UTF8]
next s i returns the position of the head of the Unicode character located immediately after i.
npop [RefList]
Removes and returns the n first elements or raises Empty_list if the ref list does not contain enough elements
nread [IO]
nread i n reads a token-buffer of size up to n from an input.
nsplit [ExtString.String]
nsplit s sep splits the string s into a list of strings which are separated by sep.
nth [UTF8]
nth s n returns the position of the n-th Unicode character.
nth [ExtList.List]
nth l n returns the n-th element of the list l or raise Invalid_index is the index is outside of l bounds.
nwrite [IO]
Write a token-buffer to an output.

O
of_array [DynArray]
of_array arr returns an array with the elements of arr in it in order.
of_char [UChar]
of_char c returns the Unicode character of the Latin-1 character c
of_char [ExtString.String]
Returns a string containing one given character.
of_enum [RefList]
Creates a ref list from an enumeration
of_enum [PMap]
creates a map from an enumeration, using the specified function for key comparison or compare by default.
of_enum [ExtString.String]
Creates a string from a character enumeration.
of_enum [ExtList.List]
Build a list from and enumeration.
of_enum [ExtHashtbl.Hashtbl]
Create a hashtable from a (key,value) enumeration.
of_enum [DynArray]
of_enum e returns an array that holds, in order, the elements of e.
of_float [ExtString.String]
Returns the string representation of an float.
of_int [ExtString.String]
Returns the string representation of an int.
of_int [Dbi.Decimal]
of_int ?scale i returns the decimal number i * 10**(-scale).
of_list [RefList]
Creates a ref list from a list - O(1)
of_list [DynArray]
of_list lst returns a dynamic array with the elements of lst in it in order.
of_string [Dbi.Decimal]
of_string ?scale s returns the decimal number represented by the string s.
opt [Global]
Return None if the global is undefined, else Some v where v is the current global value contents.
out_of_range [UTF8]
out_of_range s i tests whether i is a position inside of s.
output_bits [IO]
Enable writing to an output on a bit-basis.
output_channel [IO]
Create an output that will write into a channel.
output_enum [IO]
Create an output that will write into an enum.
output_string [IO]
Create an output that will write into a string in an efficient way.

P
partition [ExtList.List]
peek [Enum]
peek e returns None if e is empty or Some x where x is the next element of e.
pipe [IO]
Create a pipe between an input and an ouput.
placeholders [Dbi]
placeholders n returns a string of the form "(?, ?, ..., ?)" containing * n question marks.
pop [RefList]
Removes and returns the first element or raises Empty_list if the ref list is empty
pos_in [IO]
Returns the number of tokens read, or raise Not_implemented if the IO can't deal with it.
pos_out [IO]
Return the number of tokens written, or raise Not_implemented if the IO can't deal with it.
prerr_bool [Std]
Print a boolean to stderr.
prev [UTF8]
prev s i returns the position of the head of the Unicode character located immediately before i.
print_bool [Std]
Print a boolean to stdout.
printf [IO]
The printf function works for any output where token-buffer is string.
push [RefList]
Adds an element at the head - O(1)
push [Enum]
push e x will add x at the beginning of e.
put [BitSet]
put s v n sets the nth-bit in the bitset s to v.

R
rchop [ExtString.String]
Returns the same string but without the last character.
rcontains_from [ExtString.String]
read [IO]
Read a single token from an input or raise No_more_input if no token available.
read_byte [IO]
Read an unsigned 8-bit byte.
read_i16 [IO]
Read a signed 16-bit word.
read_i32 [IO]
Read a signed 32-bit integer.
read_line [IO]
Read a LF or CRLF terminated string.
read_string [IO]
Read a null-terminated string.
read_ui16 [IO]
Read an unsigned 16-bit word.
register [Dbi.Factory]
Specific database drivers register themselves on load (or Dynlink) by calling this function.
remove [RefList]
Remove an element from the ref list raise Not_found if the element is not found
remove [PMap]
remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map.
remove [ExtList.List]
remove l x returns the list l without the first element x found or returns l if no element is equal to x.
remove [ExtHashtbl.Hashtbl]
remove_all [RefList]
Remove all elements equal to the specified element from the ref list
remove_all [ExtList.List]
remove_all l x is similar to remove but removes all elements that are equal to x and not only the first one.
remove_all [ExtHashtbl.Hashtbl]
Remove all bindings for the given key
remove_assoc [ExtList.List]
remove_assq [ExtList.List]
remove_at [RefList.Index]
Remove the element at the specified index raise Invalid_index if the index is outside 0 ; length-1
remove_if [RefList]
Remove the first element matching the specified predicate raise Not_found if no element has been removed
remove_if [ExtList.List]
remove_if cmp l x is similar to remove, but with cmp used instead of ( = ).
replace [ExtHashtbl.Hashtbl]
reset [UTF8.Buf]
Empty the buffer and de-allocate the internal storage.
rev [RefList]
Reverses the ref list - O(n)
rev [ExtList.List]
rev_append [ExtList.List]
rev_map [ExtList.List]
rfind [RefList]
Find the first element in the reversed ref list matching the specified predicate raise Not_found if no element is found
rfind [ExtList.List]
rfind p l returns the last element x of l such as p x returns true or raises Not_found if such element as not been found.
rindex [ExtString.String]
rindex_from [ExtString.String]

S
sdebug [Dbi]
sdebug ss can be used to debug the return value from a #fetch1, * #map or other query.
set [RefList.Index]
Change the element at the specified index raise Invalid_index if the index is outside 0 ; length-1
set [Global]
Set the global value contents.
set [ExtString.String]
set [DynArray]
set darr idx v sets the element of darr at index idx to value v.
set [BitSet]
set s n sets the nth-bit in the bitset s to true.
set_resizer [DynArray]
Change the resizer for this array.
shuffle [RefList]
Randomly shuffles the elements using the module Random - O(n^2)
shuffle [ExtList.List]
Returns the shuffled list, using Random module.
sort [RefList]
Sort elements using the specified comparator or compare as default comparator
sort [ExtList.List]
Sort the list using optional comparator (by default compare).
split [ExtString.String]
split s sep splits the string s between the first occurrence of sep.
split [ExtList.List]
split_nth [ExtList.List]
split_nth n l returns two lists l1 and l2, l1 containing the first n elements of l and l2 the others.
sql_t_to_string [Dbi]
sql_t_to_string t returns a string representation of t * following the Ocaml conventions.
starts_with [ExtString.String]
starts_with s x return true if s is starting with x.
step_resizer [DynArray]
The stepwise resizer- another example of a resizer function, this time of a parameterized resizer.
str_decode [Base64]
Decode a string encoded into Base64, raise Invalid_char if a character in the input string is not a valid one.
str_encode [Base64]
Encode a string into Base64.
string_escaped [Dbi]
escape_string s escapes the string s according to SQL rules * and surrounds it with single quotes.
stringoption [Dbi]
stringoption(Some s) returns `String s and * stringoption None returns `Null.
strip [ExtString.String]
Returns the string without the chars if they are at the beginning or at the end of the string.
sub [ExtString.String]
sub [DynArray]
sub darr start len returns an array holding the subset of len elements from darr starting with the element at index idx.
sub [Dbi.Decimal]
sub n m returns the difference of n by m.

T
tl [RefList]
Returns a ref list containing the same elements but without the first one or raises Empty_list if the ref list is empty
tl [ExtList.List]
Returns the list without its first elements or raise Empty_list if the list is empty.
to_array [DynArray]
to_array darr returns the elements of darr in order as an array.
to_float [ExtString.String]
Returns the float represented by the given string or raises Invalid_string if the string does not represent a float.
to_float [Dbi.Decimal]
to_float n returns the closer float to n.
to_int [ExtString.String]
Returns the integer represented by the given string or raises Invalid_string if the string does not represent an integer.
to_list [RefList]
Returns the current elements as a list - O(1)
to_list [DynArray]
to_list darr returns the elements of darr in order as a list.
to_string [Dbi.Decimal]
to_string n returns a string representation of the decimal number n.
toggle [BitSet]
toggle s n changes the nth-bit value in the bitset s.
transform [RefList]
transform all elements in the ref list using a function.

U
uchar_of_int [UChar]
Alias of chr_of_uint
uint_code [UChar]
uint_code u returns the Unicode code number of u.
uncapitalize [ExtString.String]
undef [Global]
Reset the global value contents to undefined.
unique [ExtList.List]
unique cmp l returns the list l without any duplicate element.
unite [BitSet]
intersect s t sets s to the union of the sets s and t.
unsafe_chr_of_uint [UChar]
Unsafe version of UChar.chr_of_uint.
unsafe_get [DynArray]
unsafe_set [DynArray]
unset [BitSet]
unset s n sets the nth-bit in the bitset s to false.
uppercase [ExtString.String]

V
validate [UTF8]
validate s Succeeds if s is valid UTF-8, otherwise raises Malformed_code.
values [ExtHashtbl.Hashtbl]
Return an enumeration of all the values of a hashtable.

W
write [IO]
Write a single token to an output.
write_byte [IO]
Write an unsigned 8-bit byte.
write_i16 [IO]
Write a signed 16-bit word.
write_i32 [IO]
Write a signed 32-bit integer.
write_line [IO]
Write a line and append a LF (it might be converted to CRLF on some systems depending on the underlying IO).
write_string [IO]
Write a string and append an null character.
write_ui16 [IO]
Write an unsigned 16-bit word.