Index of values

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

Adds an element at the end - O(n)

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

Add an option to the option parser.

add darr v appends v onto darr.

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

add_buffer b1 b2 adds the contents of b2 to b1.

Add one Unicode character to the buffer.

Add a group to the option parser.

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

Add the UTF-8 string to the buffer.

add_*int* functions were introduced in OCaml 4.08.0, and are _not_ implemented in extlib for older OCaml versions

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

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

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

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

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

Make a callback option which takes a single argument.

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

char_of u returns the Latin-1 representation of u.

code n returns the Unicode character with the code number n.

chr_of_uint n returns the Unicode character of the code number n.

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

Removes all elements

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

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

Same as copy

Close the input.

Close the output and return its accumulator data.

code u returns the Unicode code number of u.

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

Code point comparison by the lexicographic order.

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 cmp [a1; ...; an] [b1; ...; bm] performs a lexicographic comparison of the two input lists, using the same 'a -> 'a -> int interface as Stdlib.compare:

compare s1 s2 compares two bitsets.

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 e returns an enumeration over all elements of all enumerations of e.

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

contents buf returns the contents of the buffer.

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

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

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

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

Makes a copy of a enum

Makes a copy of a list - O(1)

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

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

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

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

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

create() returns a new empty dynamic array.

Creates a node.

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

Fully create an input by giving all the needed functions.

Fully create an output by giving all the needed functions.

Generic base64 decoding over an input.

Decode a string encoded into Base64, raise Invalid_char if a character in the input string is not a valid one.

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

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

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 darr idx deletes the element of darr at idx.

delete_last darr deletes the last element of darr.

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

demote n Swaps n with prev n.

diff s t returns s-t.

differentiate s t removes the elements of t from s.

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

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

Remove node from the list no matter where it is.

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

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

represent a runtime value as a string.

Returns a new empty ref list

The empty map, using compare as key comparison function.

Returns an new named empty global.

The empty enumeration : contains no element

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

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

Generic base64 encoding over an output.

Encode a string into Base64.

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

Returns an enumeration of current elements in the ref list

creates an enumeration for this map.

Returns an enumeration of the characters of a string.

Returns an enumeration of the elements of a list.

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

Returns an enumeration of the elements of an array.

enum darr returns the enumeration of darr elements.

Create an enum of the list.

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

Equality by code point comparison

equal eq [a1; ...; an] [b1; ..; bm] holds when the two input lists have the same length, and for each pair of elements ai, bi at the same position we have eq ai bi.

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

Display an error message and exit the program.

Return true if an element matches the specified predicate

same as mem.

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

exists h k returns true is at least one item with key k is found in the hashtable.

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

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

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

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

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

See OptParse.Formatter.wrap.

Remove all elements that do not match the specified predicate

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

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

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

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.

Same as ExtList.List.filter, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.

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

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

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

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 p a returns the first element of array a that satisfies the predicate p.

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 is another name for ExtArray.Array.filter.

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

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

find_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 s i x returns the starting index of the string x within the string s (starting search from position i) or raises Invalid_string if no such substring exists.

same as find_map_opt

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

same as find_map_exn but returning option

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

compatibility, use find_opt

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

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

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

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

See OptParse.StdOpt.int_callback.

See OptParse.StdOpt.int_option.

Flush an output.

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

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

fold f v e returns v if e is empty, otherwise f aN (... (f a2 (f a1 v)) ...) where a1..N are the elements of e.

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

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

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

Accumulate a value over the entire list.

fold_left_map is a combination of fold_left and map that threads an accumulator through calls to f

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

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

Accumulate a value over the entire list.

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

Return true if all elements match the specified predicate

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

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

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

from next creates an enumeration from the next function.

get s n returns n-th Unicode character of s.

get (Some x) returns x and get None raises No_value.

Get the value of an option.

Get the global value contents - raise Global_not_initialized if not defined.

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 darr idx gets the element in darr at index idx.

Given a node, get the data associated with that node.

Get the current resizer function for a given array

same as first

Returns the first element of the list or raise Empty_list if the list is empty.

help_option () returns the standard help option which displays a usage message and exits the program when encountered on the command line.

the identity function.

implode cs returns a string resulting from concatenating the characters in the list cs.

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

Create an "indented" formatter with the given options.

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

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

wrap an input using "inflate" decompression algorithm.

init len f returns a new string which contains len Unicode characters.

init l f returns the string of length l with the chars f 0 , f 1 , f 2 ...

Similar to Array.init, init n f returns the list containing the results of (f 0),(f 1)....

init n f creates a new enumeration over elements f 0, f 1, ..., f (n-1)

init n f returns an array of n elements filled with values returned by f 0 , f 1, ... f (n-1).

input i b p l reads up to l characters from the given input, storing them in buffer b, starting at character number p.

Return the whole contents of an input channel as a single string.

Read bits from an input

Create an input that will read from a byte sequence.

Create an input that will read from a channel.

Returns an enumeration over characters of an input channel.

Create an input that will read from an enum.

returns the data of a given filename.

Returns an enumeration over lines of an input channel, as read by the input_line function.

Returns the list of lines read from an input channel.

Create an input that will read from a string.

insert darr idx v inserts v into darr at index idx.

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.

Alias of uint_code

int_option ?default ?metavar () returns an option which takes a single integer argument.

inter s t returns the intersection of sets s and t.

intersect s t sets s to the intersection of the sets s and t.

Return true if a ref list is empty

returns true if the map is empty.

is_empty e returns true if e does not contains any element.

is_none None returns true otherwise it returns false.

Find out if the option has a value (either by default or from the command line).

is_set s n returns true if nth-bit in the bitset s is set, or false otherwise.

is_some (Some x) returns true otherwise it returns false.

Return true if the global value has been set.

iter f s applies f to all Unicode characters in s.

Apply the given function to all elements of the ref list, in respect with the order of the list

iter f m applies f to all bindings in map m.

iter f e calls the function f with each elements of e in turn.

iter f darr calls the function f on every element of darr.

iter f n Apply f to every element in the list, starting at n.

Array.iter2 f [|a1; ...; an|] [|b1; ...; bn|] performs calls f a1 b1; ...; f an bn in that order.

iter2 f e1 e2 calls the function f with the next elements of e and e2 repeatedly until one of the two enumerations ends.

Call f i s.[i] for every position i in string

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 f darr calls the function f on every element of darr.

Same as concat

junk e removes the first element from the enumeration, if any.

Return an enumeration of all the keys of a hashtable.

The position of the head of the last Unicode character.

Returns the last element - O(n) or raises Empty_list if the ref list is empty

Returns the last element of the list, or raise Empty_list if the list is empty.

last darr returns the last element of darr.

Returns the same string but without the first character.

length s returns the number of Unicode characters contained in s

Returns the number of elements - O(n)

Return the number of elements inserted into the Hashtbl (including duplicates)

Return the number of elements in the array.

Returns the length of the list.

look s i returns the Unicode character of the location i in the string s.

Creates a new option parser with the given options.

Similar to String.make, make n x returns a * list containing n elements x.

This function creates a fully defined enumeration.

make count returns an array with some memory already allocated so up to count elements can be stored into it without resizing.

Create a valid decoding table from an encoding one.

Apply a function to all elements and return the ref list constructed with the function returned values

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 f (Some x) returns Some (f x) and map None returns None.

map f s returns a string where all characters c in s have been replaced by f c.

map f x creates a new hashtable with the same keys as x, but with the function f applied to all the values

map f e returns an enumeration over (f a1, f a2, ... , f aN) where a1...N are the elements of e.

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.

Allocate a new list, with entirely new nodes, whose values are the transforms of the values of the original list.

Array.map2 f [|a1; ...; an|] [|b1; ...; bn|] creates new array [|f a1 b1; ...; f an bn|].

map_default f x (Some v) returns f v and map_default f x None returns x.

Apply a function to all elements and return the list constructed with the function returned values

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

map f s returns a string where all characters c in s have been replaced by f i s.[i].

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 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 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 f (Some x) calls f x and may f None does nothing.

mem x m returns true if m contains a binding for x, and false otherwise.

mem m a is true if and only if m is equal to an element of a.

Same as ExtArray.Array.mem but uses physical equality instead of structural equality to compare array elements.

move s i n returns n-th Unicode character after i if n >= 0, n-th Unicode character before i if n < 0.

Retrieve the name of a global.

next s i returns the position of the head of the Unicode character located immediately after i.

next e returns the next element of e (and removes it from enumeration).

Given a node, get the next element in the list after the node.

Removes and returns the n first elements or raises Empty_list if the ref list does not contain enough elements

nread i n reads a byte sequence of size up to n from an input.

as nread, but reads a string.

nsplit s sep splits the string s into a list of strings which are separated by sep.

nth s n returns the position of the n-th Unicode character.

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

Write a byte sequence to an output.

Write a string to an output.

of_array arr returns an array with the elements of arr in it in order.

of_char c returns the Unicode character of the Latin-1 character c

Returns a string containing one given character.

Creates a ref list from an enumeration

creates a map from an enumeration, using the specified function for key comparison or compare by default.

Creates a string from a character enumeration.

Build a list from an enumeration.

Create a hashtable from a (key,value) enumeration.

Build an array from an enumeration.

of_enum e returns an array that holds, in order, the elements of e.

Create a dllist from an enum.

Returns the string representation of an float.

Returns the string representation of an int.

Creates a ref list from a list - O(1)

of_list lst returns a dynamic array with the elements of lst in it in order.

Converts from a normal list to a Dllist and returns the first node.

Get the value of an option as an optional value.

Return None if the global is undefined, else Some v where v is the current global value contents.

out_of_range s i tests whether i is a position inside of s.

output o b p l writes up to l characters from byte sequence b, starting at offset p.

Write bits to an output

Create an output that will write into a byte sequence in an efficient way.

Create an output that will write into a channel.

Create an output that will write into an enum.

creates a filename, write text into it and close it.

Create an output that will write into a string in an efficient way.

Create an output that will write into a string in an efficient way.

Parse arguments as if the arguments args.(first), args.(first+1), ..., args.(last) had been given on the command line.

Parse all the arguments in Sys.argv.

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 e returns None if e is empty or Some x where x is the next element of e.

Create a pipe between an input and an ouput.

Removes and returns the first element or raises Empty_list if the ref list is empty

Create an input that provide a count function of the number of Bytes.t read from it.

Create an output that provide a count function of the number of Bytes.t written through it.

prepend n a Creates a new node containing data a and inserts it into the list before node n.

Print a boolean to stderr.

prev s i returns the position of the head of the Unicode character located immediately before i.

Given a node, get the previous element in the list before the node.

print the representation of a runtime value on stdout.

Print a boolean to stdout.

The printf function works for any output.

promote n Swaps n with next n.

Adds an element at the head - O(1)

push e x will add x at the beginning of e.

put s v n sets the nth-bit in the bitset s to v.

Returns the same string but without the last character.

Read a single char from an input or raise No_more_input if no input available.

read all the contents of the input until No_more_input is raised.

Read up to 31 bits, raise Bits_error if n < 0 or n > 31

Read an unsigned 8-bit integer.

Read a null-terminated byte sequence.

Read an IEEE double precision floating point value (64 bits).

Read an IEEE single precision floating point value (32 bits).

Read a signed 16-bit word.

Read a signed 32-bit integer.

Deprecated, same as read_i31

Read a signed 32-bit integer, represented as OCaml integer, wrapping around 31-bit int on 32-bit architecture

Read a signed 64-bit integer as an OCaml int64.

Read a LF or CRLF terminated string.

Read a signed 32-bit integer as an OCaml int32.

Read an signed 8-bit integer.

Read a null-terminated string.

Read an unsigned 16-bit word.

really_input i b p l reads exactly l characters from the given input, storing them in the buffer b, starting at position p.

really_nread i n reads a byte sequence of exactly n characters from the input.

as really_nread, but reads a string.

really_output o b p l writes exactly l characters from byte sequence b onto the the output, starting with the character at offset p.

Remove an element from the ref list raise Not_found if the element is not found

remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map.

remove l x returns the list l without the first element x found or returns l if no element is equal to x.

Remove node from the list no matter where it is.

Remove all elements equal to the specified element from the ref 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 bindings for the given key

Remove the element at the specified index raise Invalid_index if the index is outside 0 ; length-1

Remove the first element matching the specified predicate raise Not_found if no element has been removed

remove_if cmp l is similar to remove, but with cmp used instead of ( = ).

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_chars f s returns a string where all chars c of s have been replaced by the string returned by f c.

Empty the buffer and de-allocate the internal storage.

Reverses the ref list - O(n)

New functions

List reversal.

Remove node from the list no matter where it is.

Create a reverse enum of the list.

In-place array reversal.

Find the first element in the reversed ref list matching the specified predicate raise Not_found if no element is found

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.

The scanf function works for any input.

Change the element at the specified index raise Invalid_index if the index is outside 0 ; length-1

Set the value of an option.

Set the global value contents.

set darr idx v sets the element of darr at index idx to value v.

Given a node, set the data associated with that node.

set s n sets the nth-bit in the bitset s to true.

Change the resizer for this array.

skip n i Return the node that is i nodes after node n in the list.

slice ?first ?last s returns a "slice" of the string which corresponds to the characters s.[first], s.[first+1], ..., s[last-1].

Sort elements using the specified comparator or compare as default comparator

Sort the list using optional comparator (by default compare).

Same as ExtList.List.sort, but also remove duplicates.

splice n1 n2 Connects n1 and n2 so that next n1 == n2 && prev n2 == n1.

split s sep splits the string s between the first occurrence of sep.

split_nth n l returns two lists l1 and l2, l1 containing the first n elements of l and l2 the others.

starts_with s x return true if s is starting with x.

The stepwise resizer- another example of a resizer function, this time of a parameterized resizer.

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 () returns an option which is set to false when it is encountered on the command line.

store_true () returns an option which is set to true when it is encountered on the command line.

See OptParse.StdOpt.int_callback.

erroneous interface, kept for compatibility use decode_string instead

erroneous interface, kept for compatibility use encode_string instead

See OptParse.StdOpt.int_option.

creates a string from a char.

Returns the string without the chars if they are at the beginning or at the end of the string.

sub darr start len returns an array holding the subset of len elements from darr starting with the element at index idx.

substring s i len returns the substring made of the Unicode locations i to i + len - 1 inclusive.

sym_diff s t returns the symmetrical difference of s and t.

take n l returns up to the n first elements from list l, if available.

takewhile f xs returns the first elements of list xs which satisfy the predicate f.

Creates a titled formatter which is quite similar to the indented formatter.

Returns a ref list containing the same elements but without the first one or raises Empty_list if the ref list is empty

Returns the list without its first elements or raise Empty_list if the list is empty.

to_array darr returns the elements of darr in order as an array.

Returns the float represented by the given string or raises Invalid_string if the string does not represent a float.

Returns the integer represented by the given string or raises Invalid_string if the string does not represent an integer.

Returns the current elements as a list - O(1)

to_list darr returns the elements of darr in order as a list.

Converts a dllist to a normal list.

*_seq functions were introduced in OCaml 4.07.0, and are _not_ implemented in extlib for older OCaml versions

*_seq functions were introduced in OCaml 4.07.0, and are _not_ implemented in extlib for older OCaml versions

*_seq functions were introduced in OCaml 4.07.0, and are _not_ implemented in extlib for older OCaml versions

*_seq functions were introduced in OCaml 4.07.0, and are _not_ implemented in extlib for older OCaml versions

*_seq functions were introduced in OCaml 4.07.0, and are _not_ implemented in extlib for older OCaml versions

toggle s n changes the nth-bit value in the bitset s.

transform all elements in the ref list using a function.

Return a copy of the argument, without leading and trailing whitespace.

Alias of chr_of_uint

uint_code u returns the Unicode code number of u.

Reset the global value contents to undefined.

union s t return the union of sets s and t.

returns an unique identifier every time it is called.

unique cmp l returns the list l without any duplicate element.

unite s t sets s to the union of the sets s and t.

Unsafe version of UChar.chr_of_uint.

unset s n sets the nth-bit in the bitset s to false.

Display the usage message to the channel chn (default is Pervasives.stdout) and return.

validate s Succeeds if s is valid UTF-8, otherwise raises Malformed_code.

Make an option which takes a single argument.

Return an enumeration of all the values of a hashtable.

version_option f returns the standard version option which displays the string returned by f () (and nothing else) on standard output and exits.

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 a single char to an output.

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 an unsigned 8-bit byte.

Write a byte sequence and append an null character.

Write an IEEE double precision floating point value (64 bits).

Write an IEEE single precision floating point value (32 bits).

Write a signed 16-bit word.

Write a signed 31-bit integer as 4 bytes.

Write a signed 32-bit integer.

Write an OCaml int64.

Write a line and append a LF (it might be converted to CRLF on some systems depending on the underlying IO).

Write an OCaml int32.

Write a string and append an null character.

Write an unsigned 16-bit word.