| (@) [ExtList] | the new implementation for ( @ ) operator, see |
| (@) [ExtLib] | |
A | |
| add [RefList] | Adds an element at the end - O(n) |
| add [PMap] |
|
| add [OptParse.OptParser] | Add an option to the option parser. |
| add [ExtHashtbl.Hashtbl] | |
| add [DynArray] |
|
| add [Dllist] |
|
| add_buffer [UTF8.Buf] |
|
| add_buffer [ExtBuffer.Buffer] | |
| add_bytes [ExtBuffer.Buffer] | |
| add_channel [ExtBuffer.Buffer] | |
| add_char [UTF8.Buf] | Add one Unicode character to the buffer. |
| add_char [ExtBuffer.Buffer] | |
| add_group [OptParse.OptParser] | Add a group to the option parser. |
| add_seq [ExtHashtbl.Hashtbl] | |
| add_seq [ExtBuffer.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. |
| add_string [ExtBuffer.Buffer] | |
| add_subbytes [ExtBuffer.Buffer] | |
| add_substitute [ExtBuffer.Buffer] | |
| add_substring [ExtBuffer.Buffer] | |
| add_utf_16be_uchar [ExtBuffer.Buffer] | |
| add_utf_16le_uchar [ExtBuffer.Buffer] | |
| add_utf_8_uchar [ExtBuffer.Buffer] | |
| append [ExtList.List] | |
| append [ExtArray.Array] | |
| append [Enum] |
|
| append [DynArray] |
|
| append [Dllist] |
|
| assoc [ExtList.List] | |
| assoc_opt [ExtList.List] | |
| assq [ExtList.List] | |
| assq_opt [ExtList.List] | |
| at_index [RefList.Index] | Return the element of ref list at the specified index
raise |
B | |
| blit [ExtString.String] | |
| blit [ExtBuffer.Buffer] | |
| blit [ExtArray.Array] | |
| blit [DynArray] |
|
C | |
| callback_option [OptParse.Opt] | Make a callback option which takes a single argument. |
| capitalize [ExtString.String] | |
| capitalize_ascii [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] |
|
| chr [UChar] |
|
| chr_of_uint [UChar] |
|
| 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 [ExtBuffer.Buffer] | |
| clear [DynArray] | remove all elements from the array and resize it to 0. |
| clone [Enum] |
|
| clone [BitSet] | Same as |
| close_in [IO] | Close the input. |
| close_out [IO] | Close the output and return its accumulator data. |
| code [UChar] |
|
| combine [ExtList.List] | |
| compact [DynArray] |
|
| compare [UTF8] | Code point comparison by the lexicographic order. |
| compare [UChar] |
|
| compare [ExtString.String] | |
| compare [BitSet] |
|
| compare_index [UTF8] |
|
| compare_length_with [ExtList.List] | |
| compare_lengths [ExtList.List] | |
| concat [ExtString.String] | |
| concat [ExtList.List] | |
| concat [ExtArray.Array] | |
| concat [Enum] |
|
| cons [ExtList.List] | |
| conservative_exponential_resizer [DynArray] |
|
| contains [ExtString.String] | |
| contains_from [ExtString.String] | |
| contents [UTF8.Buf] |
|
| contents [ExtBuffer.Buffer] | |
| copy [RefList] | Makes a copy of a ref list - O(1) |
| copy [ExtString.String] | |
| copy [ExtHashtbl.Hashtbl] | |
| copy [ExtArray.Array] | |
| copy [DynArray] |
|
| 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 [BitSet] |
|
| 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 [PMap] | creates a new empty map, using the provided function for key comparison. |
| create [ExtString.String] | |
| create [ExtHashtbl.Hashtbl] | |
| create [ExtBuffer.Buffer] | |
| create [ExtArray.Array.Floatarray] | |
| create [ExtArray.Array] | |
| create [DynArray] |
|
| create [Dllist] | Creates a node. |
| create [BitSet] | Create an empty bitset with an initial size (in number of bits). |
| create_float [ExtArray.Array] | |
| 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. |
| decode_string [Base64] | Decode a string encoded into Base64, raise |
| decr_option [OptParse.StdOpt] | Exactly identical to |
| default [Option] |
|
| default_resizer [DynArray] | The default resizer function the library is using - in this version
of DynArray, this is the |
| delete [DynArray] |
|
| delete_last [DynArray] |
|
| delete_range [DynArray] |
|
| demote [Dllist] |
|
| diff [BitSet] |
|
| differentiate [BitSet] |
|
| differentiate_sym [BitSet] |
|
| drop [ExtList.List] |
|
| 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] |
|
| dump [Std] | represent a runtime value as a string. |
E | |
| empty [RefList] | Returns a new empty ref list |
| empty [PMap] | The empty map, using |
| 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. |
| encode_string [Base64] | Encode a string into Base64. |
| ends_with [ExtString.String] |
|
| 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 [Dllist] | Create an enum of the list. |
| enum [BitSet] |
|
| eq [UChar] | Equality by code point comparison |
| equal [ExtString.String] | |
| equals [BitSet] |
|
| error [OptParse.OptParser] | Display an error message and exit the program. |
| escaped [ExtString.String] | |
| exists [RefList] | Return |
| exists [PMap] | same as |
| exists [ExtString.String] |
|
| exists [ExtList.List] | |
| exists [ExtHashtbl.Hashtbl] |
|
| exists [ExtArray.Array] |
|
| exists2 [ExtList.List] | |
| explode [ExtString.String] |
|
| 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 |
| 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 [Enum] |
|
| filter [DynArray] | |
| filter_map [ExtList.List] |
|
| filter_map [Enum] |
|
| filter_map_inplace [ExtHashtbl.Hashtbl] | |
| finally [Std] |
|
| find [RefList] | Find the first element matching
the specified predicate
raise |
| find [PMap] |
|
| find [ExtString.String] |
|
| find [ExtList.List] | |
| find [ExtHashtbl.Hashtbl] | |
| find [ExtArray.Array] |
|
| find [Enum] |
|
| find_all [ExtList.List] | |
| find_all [ExtHashtbl.Hashtbl] | |
| find_all [ExtArray.Array] |
|
| 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_from [ExtString.String] |
|
| find_map [ExtList.List] |
|
| find_opt [ExtList.List] | |
| find_opt [ExtHashtbl.Hashtbl] | Find a binding for the key, or return |
| find_option [ExtHashtbl.Hashtbl] | compatibility, use |
| findi [ExtList.List] |
|
| findi [ExtArray.Array] |
|
| first [RefList] | Returns the first element or
raises |
| first [ExtList.List] | Returns the first element of the list, or raise |
| 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 [ExtHashtbl.Hashtbl] | |
| fold [Enum] |
|
| fold2 [Enum] |
|
| fold2i [Enum] | |
| fold_left [ExtString.String] |
|
| fold_left [ExtList.List] | |
| fold_left [ExtArray.Array] | |
| fold_left [DynArray] |
|
| fold_left [Dllist] | Accumulate a value over the entire list. |
| fold_left2 [ExtList.List] | |
| fold_right [ExtString.String] |
|
| fold_right [ExtList.List] | |
| fold_right [ExtArray.Array] | |
| fold_right [DynArray] |
|
| fold_right [Dllist] | Accumulate a value over the entire list. |
| fold_right2 [ExtList.List] | |
| foldi [PMap] | Same as |
| foldi [Enum] | |
| for_all [RefList] | Return |
| for_all [ExtList.List] | |
| for_all [ExtArray.Array] |
|
| for_all2 [ExtList.List] | |
| force [Enum] |
|
| from [Enum] |
|
| from_in_channel [IO] | |
| from_in_chars [IO] | |
| from_out_channel [IO] | |
| from_out_chars [IO] | |
G | |
| get [UTF8] |
|
| get [Option] |
|
| 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.Floatarray] | |
| get [ExtArray.Array] | |
| get [Enum] |
|
| get [DynArray] |
|
| 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] | |
| hash_param [ExtHashtbl.Hashtbl] | |
| hd [RefList] | same as |
| hd [ExtList.List] | Returns the first element of the list or raise |
| help_option [OptParse.StdOpt] |
|
I | |
| identity [Std] | the identity function. |
| implode [ExtString.String] |
|
| incr_option [OptParse.StdOpt] | Exactly identical to |
| 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 |
| index [ExtString.String] | |
| index_from [ExtString.String] | |
| index_from_opt [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 |
| index_of [DynArray] |
|
| index_opt [ExtString.String] | |
| inflate [Unzip] | wrap an input using "inflate" decompression algorithm. |
| inflate_data [Unzip] | |
| inflate_init [Unzip] | |
| init [UTF8] |
|
| init [ExtString.String] |
|
| init [ExtList.List] | Similar to |
| init [ExtArray.Array] | |
| init [Enum] |
|
| init [DynArray] |
|
| input [IO] |
|
| input_all [Std] | Return the whole contents of an input channel as a single string. |
| input_bits [IO] | Read bits from an input |
| input_bytes [IO] | Create an input that will read from a byte sequence. |
| 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 |
| 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_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] |
|
| int_callback [OptParse.StdOpt] |
|
| int_of_uchar [UChar] | Alias of |
| int_option [OptParse.StdOpt] |
|
| inter [BitSet] |
|
| intersect [BitSet] |
|
| is_empty [RefList] | Return |
| is_empty [PMap] | returns true if the map is empty. |
| is_empty [Enum] |
|
| is_none [Option] |
|
| is_randomized [ExtHashtbl.Hashtbl] | |
| is_set [OptParse.Opt] | Find out if the option has a value (either by default or from the command line). |
| is_set [BitSet] |
|
| is_some [Option] |
|
| isdef [Global] | Return |
| iter [UTF8] |
|
| iter [RefList] | Apply the given function to all elements of the ref list, in respect with the order of the list |
| iter [PMap] |
|
| iter [ExtString.String] | |
| iter [ExtList.List] | |
| iter [ExtHashtbl.Hashtbl] | |
| iter [ExtArray.Array] | |
| iter [Enum] |
|
| iter [DynArray] |
|
| iter [Dllist] |
|
| iter2 [ExtList.List] | |
| iter2 [ExtArray.Array] |
|
| iter2 [Enum] |
|
| iter2i [Enum] | |
| iteri [ExtString.String] | Call |
| iteri [ExtList.List] |
|
| iteri [ExtArray.Array] | |
| iteri [Enum] | |
| iteri [DynArray] |
|
J | |
| join [ExtString.String] | Same as |
| junk [Enum] |
|
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 |
| last [DynArray] |
|
| lchop [ExtString.String] | Returns the same string but without the first character. |
| length [UTF8] |
|
| 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 [ExtBuffer.Buffer] | |
| length [ExtArray.Array.Floatarray] | |
| length [ExtArray.Array] | |
| length [DynArray] | Return the number of elements in the array. |
| length [Dllist] | Returns the length of the list. |
| look [UTF8] |
|
| lowercase [ExtString.String] | |
| lowercase_ascii [ExtString.String] | |
M | |
| make [OptParse.OptParser] | Creates a new option parser with the given options. |
| make [ExtString.String] | |
| make [ExtList.List] | Similar to |
| make [ExtArray.Array] | |
| make [Enum] | This function creates a fully defined enumeration. |
| make [DynArray] |
|
| make_decoding_table [Base64] | Create a valid decoding table from an encoding one. |
| make_float [ExtArray.Array] | |
| 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 [Option] |
|
| map [ExtString.String] |
|
| map [ExtList.List] | |
| map [ExtHashtbl.Hashtbl] |
|
| map [ExtArray.Array] | |
| map [Enum] |
|
| map [DynArray] |
|
| 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] | |
| map2 [ExtArray.Array] |
|
| map_default [Option] |
|
| map_list [RefList] | Apply a function to all elements and return the list constructed with the function returned values |
| mapi [PMap] | Same as |
| mapi [ExtString.String] |
|
| mapi [ExtList.List] |
|
| mapi [ExtArray.Array] | |
| mapi [Enum] |
|
| mapi [DynArray] |
|
| may [Option] |
|
| mem [PMap] |
|
| mem [ExtList.List] | |
| mem [ExtHashtbl.Hashtbl] | |
| mem [ExtArray.Array] |
|
| mem_assoc [ExtList.List] | |
| mem_assq [ExtList.List] | |
| memq [ExtList.List] | |
| memq [ExtArray.Array] | Same as |
| merge [ExtList.List] | |
| move [UTF8] |
|
N | |
| name [Global] | Retrieve the name of a global. |
| next [UTF8] |
|
| next [Enum] |
|
| 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 |
| nread [IO] |
|
| nread_string [IO] | as |
| nsplit [ExtString.String] |
|
| nth [UTF8] |
|
| nth [ExtList.List] |
|
| nth [ExtBuffer.Buffer] | |
| nth_opt [ExtList.List] | |
| nwrite [IO] | Write a byte sequence to an output. |
| nwrite_string [IO] | Write a string to an output. |
O | |
| of_array [DynArray] |
|
| of_char [UChar] |
|
| 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 |
| 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 [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 [Dllist] | Converts from a normal list to a Dllist and returns the first node. |
| of_seq [ExtString.String] | |
| of_seq [ExtList.List] | |
| of_seq [ExtHashtbl.Hashtbl] | |
| of_seq [ExtBuffer.Buffer] | |
| of_seq [ExtArray.Array] | |
| opt [OptParse.Opt] | Get the value of an option as an optional value. |
| opt [Global] | Return |
| out_of_range [UTF8] |
|
| output [IO] |
|
| output_bits [IO] | Write bits to an output |
| output_buffer [ExtBuffer.Buffer] | |
| output_bytes [IO] | Create an output that will write into a byte sequence in an efficient way. |
| output_channel [IO] | Create an output that will write into a channel. |
| output_enum [IO] | Create an output that will write into an |
| 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. |
| output_strings [IO] | Create an output that will write into a string in an efficient way. |
P | |
| parse [OptParse.OptParser] | Parse arguments as if the arguments |
| parse_argv [OptParse.OptParser] | Parse all the arguments in |
| partition [ExtList.List] | |
| partition [ExtArray.Array] |
|
| peek [Enum] |
|
| pipe [IO] | Create a pipe between an input and an ouput. |
| pop [RefList] | Removes and returns the first element or
raises |
| pos_in [IO] | Create an input that provide a count function of the number of Bytes.t read from it. |
| pos_out [IO] | Create an output that provide a count function of the number of Bytes.t written through it. |
| prepend [Dllist] |
|
| prerr_bool [Std] | Print a boolean to stderr. |
| prev [UTF8] |
|
| 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] |
|
| push [RefList] | Adds an element at the head - O(1) |
| push [Enum] |
|
| put [BitSet] |
|
R | |
| randomize [ExtHashtbl.Hashtbl] | |
| 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 |
| read_all [IO] | read all the contents of the input until |
| 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_bytes [IO] | Read a null-terminated byte sequence. |
| read_double [IO.BigEndian] | |
| read_double [IO] | Read an IEEE double precision floating point value (64 bits). |
| read_float32 [IO.BigEndian] | |
| read_float32 [IO] | Read an IEEE single precision floating point value (32 bits). |
| read_i16 [IO.BigEndian] | |
| read_i16 [IO] | Read a signed 16-bit word. |
| read_i31 [IO.BigEndian] | |
| read_i31 [IO] | Read a signed 32-bit integer. |
| read_i32 [IO.BigEndian] | |
| read_i32 [IO] | Deprecated, same as read_i31 |
| read_i32_as_int [IO.BigEndian] | |
| read_i32_as_int [IO] | Read a signed 32-bit integer, represented as OCaml integer, wrapping around 31-bit int on 32-bit architecture |
| 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_nread [IO] |
|
| really_nread_string [IO] | as |
| really_output [IO] |
|
| remove [RefList] | Remove an element from the ref list
raise |
| remove [PMap] |
|
| remove [ExtList.List] |
|
| 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 [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 |
| remove_if [RefList] | Remove the first element matching the
specified predicate
raise |
| remove_if [ExtList.List] |
|
| replace [ExtString.String] |
|
| replace [ExtHashtbl.Hashtbl] | |
| replace_chars [ExtString.String] |
|
| replace_seq [ExtHashtbl.Hashtbl] | |
| reset [UTF8.Buf] | Empty the buffer and de-allocate the internal storage. |
| reset [ExtHashtbl.Hashtbl] | |
| reset [ExtBuffer.Buffer] | |
| 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] | |
| rev_map2 [ExtList.List] | |
| rfind [RefList] | Find the first element in the reversed ref list matching
the specified predicate
raise |
| rfind [ExtList.List] |
|
| rindex [ExtString.String] | |
| rindex_from [ExtString.String] | |
| rindex_from_opt [ExtString.String] | |
| rindex_opt [ExtString.String] | |
S | |
| scanf [IO] | The scanf function works for any input. |
| seeded_hash [ExtHashtbl.Hashtbl] | |
| seeded_hash_param [ExtHashtbl.Hashtbl] | |
| set [RefList.Index] | Change the element at the specified index
raise |
| set [OptParse.Opt] | Set the value of an option. |
| set [Global] | Set the global value contents. |
| set [ExtString.String] | |
| set [ExtArray.Array.Floatarray] | |
| set [ExtArray.Array] | |
| set [DynArray] |
|
| set [Dllist] | Given a node, set the data associated with that node. |
| set [BitSet] |
|
| set_resizer [DynArray] | Change the resizer for this array. |
| skip [Dllist] |
|
| slice [ExtString.String] |
|
| sort [RefList] | Sort elements using the specified comparator or compare as default comparator |
| sort [ExtList.List] | Sort the list using optional comparator (by default |
| sort [ExtArray.Array] | |
| sort_uniq [ExtList.List] | Same as |
| splice [Dllist] |
|
| split [ExtString.String] |
|
| split [ExtList.List] | |
| split_nth [ExtList.List] |
|
| split_on_char [ExtString.String] | |
| stable_sort [ExtList.List] | |
| stable_sort [ExtArray.Array] | |
| starts_with [ExtString.String] |
|
| stats [ExtHashtbl.Hashtbl] | |
| step_resizer [DynArray] | The stepwise resizer- another example of a resizer function, this time of a parameterized resizer. |
| store_const [OptParse.StdOpt] |
|
| store_false [OptParse.StdOpt] |
|
| store_true [OptParse.StdOpt] |
|
| str_callback [OptParse.StdOpt] | |
| str_decode [Base64] | erroneous interface, kept for compatibility use |
| str_encode [Base64] | erroneous interface, kept for compatibility use |
| 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 [ExtBuffer.Buffer] | |
| sub [ExtArray.Array] | |
| sub [DynArray] |
|
| substring [UTF8] |
|
| sym_diff [BitSet] |
|
T | |
| take [ExtList.List] |
|
| takewhile [ExtList.List] |
|
| 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 |
| tl [ExtList.List] | Returns the list without its first elements or raise |
| to_array [DynArray] |
|
| to_bytes [ExtBuffer.Buffer] | |
| 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 |
| to_list [RefList] | Returns the current elements as a list - O(1) |
| to_list [ExtArray.Array] | |
| to_list [DynArray] |
|
| to_list [Dllist] | Converts a dllist to a normal list. |
| to_seq [ExtString.String] |
|
| to_seq [ExtList.List] |
|
| to_seq [ExtHashtbl.Hashtbl] |
|
| to_seq [ExtBuffer.Buffer] |
|
| to_seq [ExtArray.Array] |
|
| to_seq_keys [ExtHashtbl.Hashtbl] | |
| to_seq_values [ExtHashtbl.Hashtbl] | |
| to_seqi [ExtString.String] | |
| to_seqi [ExtBuffer.Buffer] | |
| to_seqi [ExtArray.Array] | |
| toggle [BitSet] |
|
| transform [RefList] | transform all elements in the ref list using a function. |
| trim [ExtString.String] | Return a copy of the argument, without leading and trailing whitespace. |
| truncate [ExtBuffer.Buffer] | |
U | |
| uchar_of_int [UChar] | Alias of |
| uint_code [UChar] |
|
| uncapitalize [ExtString.String] | |
| uncapitalize_ascii [ExtString.String] | |
| undef [Global] | Reset the global value contents to undefined. |
| union [BitSet] |
|
| unique [Std] | returns an unique identifier every time it is called. |
| unique [ExtList.List] |
|
| unite [BitSet] |
|
| unsafe_chr_of_uint [UChar] | Unsafe version of |
| unsafe_get [ExtArray.Array.Floatarray] | |
| unsafe_get [ExtArray.Array] | |
| unsafe_get [DynArray] | |
| unsafe_set [ExtArray.Array.Floatarray] | |
| unsafe_set [ExtArray.Array] | |
| unsafe_set [DynArray] | |
| unset [BitSet] |
|
| uppercase [ExtString.String] | |
| uppercase_ascii [ExtString.String] | |
| usage [OptParse.OptParser] | Display the usage message to the channel |
V | |
| validate [UTF8] |
|
| 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] |
|
W | |
| wrap [OptParse.Formatter] |
|
| 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_bytes [IO] | Write a byte sequence and append an null character. |
| write_double [IO.BigEndian] | |
| write_double [IO] | Write an IEEE double precision floating point value (64 bits). |
| write_float32 [IO.BigEndian] | |
| write_float32 [IO] | Write an IEEE single precision floating point value (32 bits). |
| write_i16 [IO.BigEndian] | |
| write_i16 [IO] | Write a signed 16-bit word. |
| write_i31 [IO.BigEndian] | |
| write_i31 [IO] | Write a signed 31-bit integer as 4 bytes. |
| 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. |