(@) [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 [OptParse.OptParser] |
Add an option to the option parser.
|
add [ExtHashtbl.Hashtbl] | |
add [DynArray] | add darr v appends v onto darr .
|
add [Dllist] | add n a Creates a new node containing data a and inserts it into
the list after node n .
|
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_group [OptParse.OptParser] |
Add a group to the option parser.
|
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 [ExtArray.Array] | |
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 .
|
append [Dllist] | append n a Creates a new node containing data a and inserts it into
the list after node n .
|
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
|
B | |
blit [ExtString.String] | |
blit [ExtArray.Array] | |
blit [DynArray] | blit src srcidx dst dstidx len copies len elements from src
starting with index srcidx to dst starting at dstidx .
|
C | |
callback_option [OptParse.Opt] |
Make a callback option which takes a single argument.
|
capitalize [ExtString.String] | |
cast_output [IO] |
You can safely transform any output to an unit output in a safe way
by using this function.
|
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] | |
clear [DynArray] |
remove all elements from the array and resize it to 0.
|
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 [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 [ExtArray.Array] | |
concat [Enum] | concat e returns an enumeration over all elements of all enumerations
of e .
|
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 [ExtArray.Array] | |
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 [Dllist] |
Copy the list attached to the given node and return the copy of the given
node.
|
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 .
|
count_option [OptParse.StdOpt] |
Create a counting option which increments its value each time the
option is encountered on the command line.
|
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 [ExtArray.Array] | |
create [DynArray] | create() returns a new empty dynamic array.
|
create [Dllist] |
Creates a node.
|
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_matrix [ExtArray.Array] | |
create_out [IO] |
Fully create an output by giving all the needed functions.
|
D | |
decode [Base64] |
Generic base64 decoding over an input.
|
decr_option [OptParse.StdOpt] |
Exactly identical to
count_option ~dest:dest ~increment:(-1) () .
|
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 .
|
delete_range [DynArray] | delete_range darr p len deletes len elements starting at index p .
|
demote [Dllist] | demote n Swaps n with prev n .
|
diff [BitSet] | diff s t returns s -t .
|
differentiate [BitSet] | differentiate s t removes the elements of t from s .
|
differentiate_sym [BitSet] | differentiate_sym s t sets s to the symmetrical difference of the
sets s and t .
|
drop [ExtList.List] | drop n l returns l without the first n elements, or the empty
list if l have less than n elements.
|
drop [Dllist] |
Remove node from the list no matter where it is.
|
drop_bits [IO] |
Drop up to 7 buffered bits and restart to next input character.
|
dropwhile [ExtList.List] | dropwhile f xs returns the list xs with the first
elements satisfying the predicate f dropped.
|
dump [Std] |
represent a runtime value as a string.
|
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 [ExtArray.Array] |
Returns an enumeration of the elements of an array.
|
enum [DynArray] | enum darr returns the enumeration of darr elements.
|
enum [Dllist] |
Create an enum of the list.
|
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.
|
error [OptParse.OptParser] |
Display an error message and exit the program.
|
escaped [ExtString.String] | |
exists [RefList] |
Return
true if an element matches the specified
predicate
|
exists [PMap] |
same as
mem .
|
exists [ExtString.String] | exists str sub returns true if sub is a substring of str or
false otherwise.
|
exists [ExtList.List] | |
exists [ExtHashtbl.Hashtbl] | exists h k returns true is at least one item with key k is
found in the hashtable.
|
exists [ExtArray.Array] | exists p [a1; ...; an] checks if at least one element of
the array satisfies the predicate p .
|
exists2 [ExtList.List] | |
explode [ExtString.String] | explode s returns the list of characters in the string s .
|
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.
|
fast_sort [ExtList.List] | |
fast_sort [ExtArray.Array] | |
fill [OptParse.Formatter] | |
fill [ExtString.String] | |
fill [ExtArray.Array] | |
filter [RefList] |
Remove all elements that do not match the
specified predicate
|
filter [ExtList.List] | |
filter [ExtArray.Array] | filter p a returns all the elements of the array a
that satisfy the predicate p .
|
filter [Enum] | filter f e returns an enumeration over all elements x of e such
as f x returns true .
|
filter [DynArray] | |
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 .
|
finally [Std] |
finally
fend f x calls f x and then fend() even if f x raised
an exception.
|
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 [ExtArray.Array] | find p a returns the first element of array a
that satisfies the predicate p .
|
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_all [ExtArray.Array] | find_all is another name for Array.filter .
|
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
|
findi [ExtList.List] | 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 [ExtArray.Array] | findi p a returns the index of the first element of array a
that satisfies the predicate p .
|
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] | |
float_callback [OptParse.StdOpt] | |
float_option [OptParse.StdOpt] | |
flush [IO] |
Flush an output.
|
flush_bits [IO] |
Flush remaining unwritten bits, adding up to 7 bits which values 0.
|
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 [ExtString.String] | fold_left f a s is
f (... (f (f a s.[0]) s.[1]) ...) s.[n-1]
|
fold_left [ExtList.List] | |
fold_left [ExtArray.Array] | |
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_left [Dllist] |
Accumulate a value over the entire list.
|
fold_left2 [ExtList.List] | |
fold_right [ExtString.String] | fold_right f s b is
f s.[0] (f s.[1] (... (f s.[n-1] b) ...))
|
fold_right [ExtList.List] | |
fold_right [ExtArray.Array] | |
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_right [Dllist] |
Accumulate a value over the entire list.
|
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_all [ExtArray.Array] | for_all p [a1; ...; an] checks if all elements of the array
satisfy the predicate p .
|
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_channel [IO] | |
from_in_chars [IO] | |
from_out_channel [IO] | |
from_out_chars [IO] | |
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 [OptParse.Opt] |
Get the value of an option.
|
get [Global] |
Get the global value contents - raise Global_not_initialized if not
defined.
|
get [ExtString.String] | |
get [ExtArray.Array] | |
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 [Dllist] |
Given a node, get the data associated with that node.
|
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.
|
help_option [OptParse.StdOpt] | help_option () returns the standard help option which
displays a usage message and exits the program when encountered
on the command line.
|
I | |
identity [Std] |
the identity function.
|
implode [ExtString.String] | implode cs returns a string resulting from concatenating
the characters in the list cs .
|
incr_option [OptParse.StdOpt] |
Exactly identical to
count_option ~dest:dest ~increment:1 () .
|
indented_formatter [OptParse.Formatter] |
Create an "indented" formatter with the given options.
|
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.
|
inflate [Unzip] |
wrap an input using "inflate" decompression algorithm.
|
inflate_data [Unzip] | |
inflate_init [Unzip] | |
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 [ExtArray.Array] | |
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 [IO] | input i s p l reads up to l characters from the given input, storing
them in string s , starting at character number p .
|
input_all [Std] |
Return the whole contents of an input channel as a single
string.
|
input_bits [IO] |
Read bits from an input
|
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_file [Std] |
returns the data of a given filename.
|
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_callback [OptParse.StdOpt] | int_callback ?metavar f returns an option which takes a single
integer argument and calls f with that argument when encountered
on the command line.
|
int_of_uchar [UChar] |
Alias of
uint_code
|
int_option [OptParse.StdOpt] | int_option ?default ?metavar () returns an option which takes
a single integer argument.
|
inter [BitSet] | inter s t returns the intersection of sets s and t .
|
intersect [BitSet] | intersect s t sets s to the intersection of the sets s and t .
|
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 otherwise it returns false .
|
is_set [OptParse.Opt] |
Find out if the option has a value (either by default or
from the command line).
|
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 otherwise it returns false .
|
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 [ExtArray.Array] | |
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 .
|
iter [Dllist] | iter f n Apply f to every element in the list, starting at n .
|
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 [ExtArray.Array] | |
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 [ExtArray.Array] | |
length [DynArray] |
Return the number of elements in the array.
|
length [Dllist] |
Returns the length of the list.
|
look [UTF8] | look s i
returns the Unicode character of the location i in the string s .
|
lowercase [ExtString.String] | |
M | |
make [OptParse.OptParser] |
Creates a new option parser with the given options.
|
make [ExtString.String] | |
make [ExtList.List] |
Similar to
String.make , make n x returns a
* list containing n elements x .
|
make [ExtArray.Array] | |
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.
|
make_decoding_table [Base64] |
Create a valid decoding table from an encoding one.
|
make_matrix [ExtArray.Array] | |
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 [ExtArray.Array] | |
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 .
|
map [Dllist] |
Allocate a new list, with entirely new nodes, whose values are
the transforms of the values of the original list.
|
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 [ExtArray.Array] | |
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 [ExtArray.Array] | mem m a is true if and only if m is equal to an element of a .
|
mem_assoc [ExtList.List] | |
mem_assq [ExtList.List] | |
memq [ExtList.List] | |
memq [ExtArray.Array] |
Same as
Array.mem but uses physical equality instead of
structural equality to compare array elements.
|
merge [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.
|
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 .
|
next [Dllist] |
Given a node, get the next element in the list after the node.
|
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 string 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 string 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 an enumeration.
|
of_enum [ExtHashtbl.Hashtbl] |
Create a hashtable from a (key,value) enumeration.
|
of_enum [ExtArray.Array] |
Build an array from an enumeration.
|
of_enum [DynArray] | of_enum e returns an array that holds, in order, the elements of e .
|
of_enum [Dllist] |
Create a dllist from an enum.
|
of_float [ExtString.String] |
Returns the string representation of an float.
|
of_int [ExtString.String] |
Returns the string representation of an int.
|
of_list [RefList] |
Creates a ref list from a list - O(1)
|
of_list [ExtArray.Array] | |
of_list [DynArray] | of_list lst returns a dynamic array with the elements of lst in
it in order.
|
of_list [Dllist] |
Converts from a normal list to a Dllist and returns the first node.
|
opt [OptParse.Opt] |
Get the value of an option as an optional value.
|
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 [IO] | output o s p l writes up to l characters from string s , starting at
offset p .
|
output_bits [IO] |
Write bits to an output
|
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_file [Std] |
creates a filename, write text into it and close it.
|
output_string [IO] |
Create an output that will write into a string in an efficient way.
|
P | |
parse [OptParse.OptParser] |
Parse arguments as if the arguments
args.(first) ,
args.(first+1) , ..., args.(last) had been given on the
command line.
|
parse_argv [OptParse.OptParser] |
Parse all the arguments in
Sys.argv .
|
partition [ExtList.List] | |
partition [ExtArray.Array] | partition p a returns a pair of arrays (a1, a2) , where
a1 is the array of all the elements of a that
satisfy the predicate p , and a2 is the array of all the
elements of a that do not satisfy p .
|
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.
|
pop [RefList] |
Removes and returns the first element or
raises
Empty_list if the ref list is empty
|
pos_in [IO] |
Create an input that provide a count function of the number of bytes
read from it.
|
pos_out [IO] |
Create an output that provide a count function of the number of bytes
written through it.
|
prepend [Dllist] | prepend n a Creates a new node containing data a and inserts it into
the list before node n .
|
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 .
|
prev [Dllist] |
Given a node, get the previous element in the list before the node.
|
print [Std] |
print the representation of a runtime value on stdout.
|
print_bool [Std] |
Print a boolean to stdout.
|
printf [IO] |
The printf function works for any output.
|
promote [Dllist] | promote n Swaps n with next n .
|
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 char from an input or raise
No_more_input if
no input available.
|
read_all [IO] |
read all the contents of the input until
No_more_input is raised.
|
read_bits [IO] |
Read up to 31 bits, raise Bits_error if n < 0 or n > 31
|
read_byte [IO] |
Read an unsigned 8-bit integer.
|
read_double [IO.BigEndian] | |
read_double [IO] |
Read an IEEE double precision floating point value.
|
read_i16 [IO.BigEndian] | |
read_i16 [IO] |
Read a signed 16-bit word.
|
read_i32 [IO.BigEndian] | |
read_i32 [IO] |
Read a signed 32-bit integer.
|
read_i64 [IO.BigEndian] | |
read_i64 [IO] |
Read a signed 64-bit integer as an OCaml int64.
|
read_line [IO] |
Read a LF or CRLF terminated string.
|
read_real_i32 [IO.BigEndian] | |
read_real_i32 [IO] |
Read a signed 32-bit integer as an OCaml int32.
|
read_signed_byte [IO] |
Read an signed 8-bit integer.
|
read_string [IO] |
Read a null-terminated string.
|
read_ui16 [IO.BigEndian] | |
read_ui16 [IO] |
Read an unsigned 16-bit word.
|
really_input [IO] | really_input i s p l reads exactly l characters from the given input,
storing them in the string s , starting at position p .
|
really_nread [IO] | really_nread i n reads a string of exactly n characters
from the input.
|
really_output [IO] | really_output o s p l writes exactly l characters from string s onto
the the output, starting with the character at offset p .
|
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 [Dllist] |
Remove node from the list no matter where it is.
|
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 is similar to remove , but with cmp used
instead of ( = ).
|
replace [ExtString.String] | replace ~str ~sub ~by returns a tuple constisting of a boolean
and a string where the first occurrence of the string sub
within str has been replaced by the string by .
|
replace [ExtHashtbl.Hashtbl] | |
replace_chars [ExtString.String] | replace_chars f s returns a string where all chars c of s have been
replaced by the string returned by f c .
|
reset [UTF8.Buf] |
Empty the buffer and de-allocate the internal storage.
|
rev [RefList] |
Reverses the ref list - O(n)
|
rev [ExtList.List] | |
rev [ExtArray.Array] |
New functions
|
rev [Dllist] |
List reversal.
|
rev_append [ExtList.List] | |
rev_drop [Dllist] |
Remove node from the list no matter where it is.
|
rev_enum [Dllist] |
Create a reverse enum of the list.
|
rev_in_place [ExtArray.Array] |
In-place array reversal.
|
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 | |
set [RefList.Index] |
Change the element at the specified index
raise
Invalid_index if the index is outside 0 ; length-1
|
set [OptParse.Opt] |
Set the value of an option.
|
set [Global] |
Set the global value contents.
|
set [ExtString.String] | |
set [ExtArray.Array] | |
set [DynArray] | set darr idx v sets the element of darr at index idx to value
v .
|
set [Dllist] |
Given a node, set the data associated with that node.
|
set [BitSet] | set s n sets the nth-bit in the bitset s to true.
|
set_resizer [DynArray] |
Change the resizer for this array.
|
skip [Dllist] | skip n i Return the node that is i nodes after node n in the list.
|
slice [ExtString.String] | slice ?first ?last s returns a "slice" of the string
which corresponds to the characters s.[first] ,
s.[first+1] , ..., s[last-1] .
|
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 ).
|
sort [ExtArray.Array] | |
splice [Dllist] | splice n1 n2 Connects n1 and n2 so that
next n1 == n2 && prev n2 == n1 .
|
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.
|
stable_sort [ExtList.List] | |
stable_sort [ExtArray.Array] | |
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.
|
store_const [OptParse.StdOpt] | store_const ?default const returns a flag option which
stores the constant value const when the option is
encountered on the command line.
|
store_false [OptParse.StdOpt] | store_false () returns an option which is set to false when
it is encountered on the command line.
|
store_true [OptParse.StdOpt] | store_true () returns an option which is set to true when
it is encountered on the command line.
|
str_callback [OptParse.StdOpt] | |
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.
|
str_option [OptParse.StdOpt] | |
string_of_char [Std] |
creates a string from a char.
|
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 [ExtArray.Array] | |
sub [DynArray] | sub darr start len returns an array holding the subset of len
elements from darr starting with the element at index idx .
|
sym_diff [BitSet] | sym_diff s t returns the symmetrical difference of s and t .
|
T | |
take [ExtList.List] | take n l returns up to the n first elements from list l , if
available.
|
takewhile [ExtList.List] | takewhile f xs returns the first elements of list xs
which satisfy the predicate f .
|
titled_formatter [OptParse.Formatter] |
Creates a titled formatter which is quite similar to the
indented formatter.
|
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_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 [ExtArray.Array] | |
to_list [DynArray] | to_list darr returns the elements of darr in order as a list.
|
to_list [Dllist] |
Converts a dllist to a normal list.
|
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.
|
union [BitSet] | union s t return the union of sets s and t .
|
unique [Std] |
returns an unique identifier every time it is called.
|
unique [ExtList.List] | unique cmp l returns the list l without any duplicate element.
|
unite [BitSet] | unite 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 [ExtArray.Array] | |
unsafe_get [DynArray] | |
unsafe_set [ExtArray.Array] | |
unsafe_set [DynArray] | |
unset [BitSet] | unset s n sets the nth-bit in the bitset s to false.
|
uppercase [ExtString.String] | |
usage [OptParse.OptParser] |
Display the usage message to the channel
chn (default is
Pervasives.stdout ) and return.
|
V | |
validate [UTF8] | validate s
Succeeds if s is valid UTF-8, otherwise raises Malformed_code.
|
value_option [OptParse.Opt] |
Make an option which takes a single argument.
|
values [ExtHashtbl.Hashtbl] |
Return an enumeration of all the values of a hashtable.
|
version_option [OptParse.StdOpt] | version_option f returns the standard version option which
displays the string returned by f () (and nothing else) on
standard output and exits.
|
W | |
wrap [OptParse.Formatter] | wrap text width reflows the given text paragraph into lines
of width at most width (lines may exceed this if the are
single words that exceed this limit).
|
write [IO] |
Write a single char to an output.
|
write_bits [IO] |
Write up to 31 bits represented as a value, raise Bits_error if nbits < 0
or nbits > 31 or the value representation excess nbits.
|
write_byte [IO] |
Write an unsigned 8-bit byte.
|
write_double [IO.BigEndian] | |
write_double [IO] |
Write an IEEE double precision floating point value.
|
write_i16 [IO.BigEndian] | |
write_i16 [IO] |
Write a signed 16-bit word.
|
write_i32 [IO.BigEndian] | |
write_i32 [IO] |
Write a signed 32-bit integer.
|
write_i64 [IO.BigEndian] | |
write_i64 [IO] |
Write an OCaml int64.
|
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_real_i32 [IO.BigEndian] | |
write_real_i32 [IO] |
Write an OCaml int32.
|
write_string [IO] |
Write a string and append an null character.
|
write_ui16 [IO.BigEndian] | |
write_ui16 [IO] |
Write an unsigned 16-bit word.
|