A | |
| add_buffer [Nopres_intf.Buffer] | add_buffer b1 b2 appends the current contents of buffer b2
at the end of buffer b1.
|
| add_channel [Nopres_intf.Buffer] | add_channel b ic n reads exactly n character from the
input channel ic and stores them at the end of buffer b.
|
| add_char [Nopres_intf.Buffer] | add_char b c appends the character c at the end of
the buffer b.
|
| add_full_channel [Nopres_intf.Buffer] | |
| add_full_channel_f [Nopres_intf.Buffer] | |
| add_one [Weak_impl.Make] | |
| add_one [Weak_intf.T] | add_one ra el adds element el to resizable array ra,
possibly causing a reallocation.
|
| add_one [Pres_intf.T] | add_one ra el adds element el to resizable array ra,
possibly causing a reallocation.
|
| add_one [Pres_impl.Make] | |
| add_one [Nopres_intf.T] | add_one ra el adds element el to resizable array ra,
possibly causing a reallocation.
|
| add_one [Nopres_impl.Make] | |
| add_string [Nopres_intf.Buffer] | add_string b s appends the string s at the end of
the buffer b.
|
| add_substring [Nopres_intf.Buffer] | add_substring b s ofs len takes len characters from offset
ofs in string s and appends them at the end of the buffer
b.
|
| append [Weak_impl.Make] | |
| append [Weak_intf.T] | append ra1 ra2
|
| append [Pres_intf.T] | append ra1 ra2
|
| append [Pres_impl.Make] | |
| append [Nopres_intf.T] | append ra1 ra2
|
| append [Nopres_impl.Make] | |
B | |
| blit [Weak_impl.Make] | |
| blit [Weak_intf.T] | blit ra1 ofs1 ra2 ofs2 len blits resizable array ra1 onto
ra2 reading len elements from offset ofs1 and writing them
to ofs2, possibly adding elements at the end of ra2.
|
| blit [Pres_intf.T] | blit ra1 ofs1 ra2 ofs2 len blits resizable array ra1 onto
ra2 reading len elements from offset ofs1 and writing them
to ofs2, possibly adding elements at the end of ra2.
|
| blit [Pres_impl.Make] | |
| blit [Nopres_intf.T] | blit ra1 ofs1 ra2 ofs2 len blits resizable array ra1 onto
ra2 reading len elements from offset ofs1 and writing them
to ofs2, possibly adding elements at the end of ra2.
|
| blit [Nopres_impl.Make] | |
C | |
| check [Weak_impl.Make] | |
| check [Weak_intf.T] | check ra n
|
| clear [Weak_impl.Make] | |
| clear [Weak_intf.T] | clear ra removes all elements from resizable array ra,
possibly causing a reallocation.
|
| clear [Pres_intf.T] | clear ra removes all elements from resizable array ra,
possibly causing a reallocation.
|
| clear [Pres_impl.Make] | |
| clear [Nopres_intf.T] | clear ra removes all elements from resizable array ra,
possibly causing a reallocation.
|
| clear [Nopres_impl.Make] | |
| concat [Weak_impl.Make] | |
| concat [Weak_intf.T] | concat l
|
| concat [Pres_intf.T] | concat l
|
| concat [Pres_impl.Make] | |
| concat [Nopres_intf.T] | concat l
|
| concat [Nopres_impl.Make] | |
| concat_aux [Weak_impl.Make] | |
| concat_aux [Pres_impl.Make] | |
| concat_aux [Nopres_impl.Make] | |
| contents [Nopres_intf.Buffer] | contents b
|
| copy [Weak_impl.Make] | |
| copy [Weak_intf.T] | copy ra
|
| copy [Pres_intf.T] | copy ra
|
| copy [Pres_impl.Make] | |
| copy [Nopres_intf.T] | copy ra
|
| copy [Nopres_impl.Make] | |
| create [Weak_impl.Make] | |
| create [Weak_intf.T] | create n same as screate but uses default strategy.
|
| create [Pres_intf.T] | create n el same as screate but uses default strategy.
|
| create [Pres_impl.Make] | |
| create [Nopres_intf.T] | create n same as screate but uses default strategy.
|
| create [Nopres_impl.Implementation] | |
| create [Nopres_impl.Make] | |
| create_fresh [Weak_impl.Make] | |
| create_fresh [Pres_impl.Make] | |
| create_fresh [Nopres_impl.Make] | |
| create_from [Weak_impl.Make] | |
| create_from [Pres_impl.Make] | |
| create_from [Nopres_impl.Make] | |
| creator [Weak_impl.Make] | |
| creator [Pres_impl.Make] | |
| creator [Nopres_impl.Make] | |
D | |
| default [Strat.T] |
Default strategy of this strategy implementation.
|
E | |
| empty [Weak_impl.Make] | |
| empty [Weak_intf.T] | empty () same as sempty but uses default strategy.
|
| empty [Pres_intf.T] | empty () same as sempty but uses default strategy.
|
| empty [Pres_impl.Make] | |
| empty [Nopres_intf.T] | empty () same as sempty but uses default strategy.
|
| empty [Nopres_impl.Make] | |
| empty_ar [Nopres_impl.Make] | |
| enforce_strategy [Weak_impl.Make] | |
| enforce_strategy [Weak_intf.T] | enforce_strategy ra forces a reallocation if necessary
(e.g.
|
| enforce_strategy [Pres_intf.T] | enforce_strategy ra forces a reallocation if necessary
(e.g.
|
| enforce_strategy [Pres_impl.Make] | |
| enforce_strategy [Nopres_intf.T] | enforce_strategy ra forces a reallocation if necessary
(e.g.
|
| enforce_strategy [Nopres_impl.Make] | |
| exists [Weak_impl.Make] | |
| exists [Weak_intf.T] | exists p ra
|
| exists [Pres_intf.T] | exists p ra
|
| exists [Pres_impl.Make] | |
| exists [Nopres_intf.T] | exists p ra
|
| exists [Nopres_impl.Make] | |
| exists_aux [Weak_impl.Make] | |
| exists_aux [Pres_impl.Make] | |
| exists_aux [Nopres_impl.Make] | |
F | |
| failwith [Weak_impl.Make] | |
| failwith [Pres_impl.Make] | |
| failwith [Nopres_impl.Make] | |
| fill [Weak_impl.Make] | |
| fill [Weak_intf.T] | fill ra ofs len el fills resizable array ra from offset
ofs with len elements el, possibly adding elements at the
end.
|
| fill [Pres_intf.T] | fill ra ofs len el fills resizable array ra from offset
ofs with len elements el, possibly adding elements at the
end.
|
| fill [Pres_impl.Make] | |
| fill [Nopres_intf.T] | fill ra ofs len el fills resizable array ra from offset
ofs with len elements el, possibly adding elements at the
end.
|
| fill [Nopres_impl.Make] | |
| filter [Weak_impl.Make] | |
| filter [Weak_intf.T] | filter p ra
|
| filter [Pres_intf.T] | filter p ra
|
| filter [Pres_impl.Make] | |
| filter [Nopres_intf.T] | filter p ra
|
| filter [Nopres_impl.Make] | |
| filter_in_place [Weak_impl.Make] | |
| filter_in_place [Weak_intf.T] | filter_in_place p ra as filter, but filters in place.
|
| filter_in_place [Pres_intf.T] | filter_in_place p ra as filter, but filters in place.
|
| filter_in_place [Pres_impl.Make] | |
| filter_in_place [Nopres_intf.T] | filter_in_place p ra as filter, but filters in place.
|
| filter_in_place [Nopres_impl.Make] | |
| find [Weak_impl.Make] | |
| find [Weak_intf.T] | find p ra
|
| find [Pres_intf.T] | find p ra
|
| find [Pres_impl.Make] | |
| find [Nopres_intf.T] | find p ra
|
| find [Nopres_impl.Make] | |
| find_all [Weak_impl.Make] | |
| find_all [Weak_intf.T] | find_all p ra is the same as filter
|
| find_all [Pres_intf.T] | find_all p ra is the same as filter
|
| find_all [Pres_impl.Make] | |
| find_all [Nopres_intf.T] | find_all p ra is the same as filter
|
| find_all [Nopres_impl.Make] | |
| find_aux [Weak_impl.Make] | |
| find_aux [Pres_impl.Make] | |
| find_aux [Nopres_impl.Make] | |
| find_index [Weak_impl.Make] | |
| find_index [Weak_intf.T] | find_index p ra pos
|
| find_index [Pres_intf.T] | find_index p ra pos
|
| find_index [Pres_impl.Make] | |
| find_index [Nopres_intf.T] | find_index p ra pos
|
| find_index [Nopres_impl.Make] | |
| find_index_aux [Weak_impl.Make] | |
| find_index_aux [Pres_impl.Make] | |
| find_index_aux [Nopres_impl.Make] | |
| fold_left [Weak_impl.Make] | |
| fold_left [Weak_intf.T] | fold_left f a ra left-folds values in resizable array ra
using function f and start accumulator a.
|
| fold_left [Pres_intf.T] | fold_left f a ra left-folds values in resizable array ra
using function f and start accumulator a.
|
| fold_left [Pres_impl.Make] | |
| fold_left [Nopres_intf.T] | fold_left f a ra left-folds values in resizable array ra
using function f and start accumulator a.
|
| fold_left [Nopres_impl.Make] | |
| fold_right [Weak_impl.Make] | |
| fold_right [Weak_intf.T] | fold_right f a ra right-folds values in resizable array ra
using function f and start accumulator a.
|
| fold_right [Pres_intf.T] | fold_right f a ra right-folds values in resizable array ra
using function f and start accumulator a.
|
| fold_right [Pres_impl.Make] | |
| fold_right [Nopres_intf.T] | fold_right f a ra right-folds values in resizable array ra
using function f and start accumulator a.
|
| fold_right [Nopres_impl.Make] | |
| for_all [Weak_impl.Make] | |
| for_all [Weak_intf.T] | for_all p ra
|
| for_all [Pres_intf.T] | for_all p ra
|
| for_all [Pres_impl.Make] | |
| for_all [Nopres_intf.T] | for_all p ra
|
| for_all [Nopres_impl.Make] | |
| for_all_aux [Weak_impl.Make] | |
| for_all_aux [Pres_impl.Make] | |
| for_all_aux [Nopres_impl.Make] | |
G | |
| get [Weak_impl.Make] | |
| get [Weak_intf.T] | get ra n
|
| get [Pres_intf.T] | get ra n
|
| get [Pres_impl.Make] | |
| get [Nopres_intf.T] | get ra n
|
| get [Nopres_impl.Make] | |
| get_copy [Weak_impl.Make] | |
| get_copy [Weak_intf.T] | get_copy ra n see documentation of module Weak in the standard
distribution.
|
| get_strategy [Weak_impl.Make] | |
| get_strategy [Weak_intf.T] | get_strategy ra
|
| get_strategy [Pres_intf.T] | get_strategy ra
|
| get_strategy [Pres_impl.Make] | |
| get_strategy [Nopres_intf.T] | get_strategy ra
|
| get_strategy [Nopres_impl.Make] | |
| grow [Strat.T] | grow strat new_len
|
| guarantee_ix [Weak_impl.Make] | |
| guarantee_ix [Pres_impl.Make] | |
| guarantee_ix [Nopres_impl.Make] | |
I | |
| init [Weak_impl.Make] | |
| init [Weak_intf.T] | init n f sames as sinit but uses default strategy.
|
| init [Pres_intf.T] | init n f sames as sinit but uses default strategy.
|
| init [Pres_impl.Make] | |
| init [Nopres_intf.T] | init n f sames as sinit but uses default strategy.
|
| init [Nopres_impl.Make] | |
| invalid_arg [Weak_impl.Make] | |
| invalid_arg [Pres_impl.Make] | |
| invalid_arg [Nopres_impl.Make] | |
| iter [Weak_impl.Make] | |
| iter [Weak_intf.T] | iter f ra applies the unit-function f to each element in
resizable array ra.
|
| iter [Pres_intf.T] | iter f ra applies the unit-function f to each element in
resizable array ra.
|
| iter [Pres_impl.Make] | |
| iter [Nopres_intf.T] | iter f ra applies the unit-function f to each element in
resizable array ra.
|
| iter [Nopres_impl.Make] | |
| iteri [Weak_impl.Make] | |
| iteri [Weak_intf.T] | iteri f ra applies the unit-function f to each index and
element in resizable array ra.
|
| iteri [Pres_intf.T] | iteri f ra applies the unit-function f to each index and
element in resizable array ra.
|
| iteri [Pres_impl.Make] | |
| iteri [Nopres_intf.T] | iteri f ra applies the unit-function f to each index and
element in resizable array ra.
|
| iteri [Nopres_impl.Make] | |
L | |
| length [Weak_impl.Make] | |
| length [Weak_intf.T] | length ra
|
| length [Pres_intf.T] | length ra
|
| length [Pres_impl.Implementation] | |
| length [Pres_impl.Make] | |
| length [Nopres_intf.T] | length ra
|
| length [Nopres_impl.Implementation] | |
| length [Nopres_impl.Make] | |
| lix [Weak_impl.Make] | |
| lix [Weak_intf.T] | lix ra
|
| lix [Pres_intf.T] | lix ra
|
| lix [Pres_impl.Make] | |
| lix [Nopres_intf.T] | lix ra
|
| lix [Nopres_impl.Make] | |
M | |
| make [Weak_impl.Make] | |
| make [Pres_intf.T] | make n el same as create.
|
| make [Pres_impl.Implementation] | |
| make [Pres_impl.Make] | |
| make [Nopres_intf.T] | make n el same as smake but uses default strategy.
|
| make [Nopres_impl.Implementation] | |
| make [Nopres_impl.Make] | |
| make_matrix [Pres_intf.T] | make_matrix sx sy el creates a (resizable) matrix of
dimensions sx and sy containing element el only.
|
| make_matrix [Pres_impl.Make] | |
| map [Pres_intf.T] | map f ra
|
| map [Pres_impl.Make] | |
| map [Nopres_intf.T] | map f ra
|
| map [Nopres_impl.Make] | |
| mapi [Pres_intf.T] | mapi f ra
|
| mapi [Pres_impl.Make] | |
| mapi [Nopres_intf.T] | mapi f ra
|
| mapi [Nopres_impl.Make] | |
| maybe_grow_ix [Weak_impl.Make] | |
| maybe_grow_ix [Pres_impl.Make] | |
| maybe_grow_ix [Nopres_impl.Make] | |
| mem [Weak_impl.Make] | |
| mem [Weak_intf.T] | mem el ra
|
| mem [Pres_intf.T] | mem el ra
|
| mem [Pres_impl.Make] | |
| mem [Nopres_intf.T] | mem el ra
|
| mem [Nopres_impl.Make] | |
| mem_aux [Weak_impl.Make] | |
| mem_aux [Pres_impl.Make] | |
| mem_aux [Nopres_impl.Make] | |
| memq [Weak_impl.Make] | |
| memq [Weak_intf.T] | memq el ra
|
| memq [Pres_intf.T] | memq el ra
|
| memq [Pres_impl.Make] | |
| memq [Nopres_intf.T] | memq el ra
|
| memq [Nopres_impl.Make] | |
| memq_aux [Weak_impl.Make] | |
| memq_aux [Pres_impl.Make] | |
| memq_aux [Nopres_impl.Make] | |
N | |
| name [Weak_impl.Make] | |
| name [Pres_impl.Implementation] | |
| name [Pres_impl.Make] | |
| name [Nopres_impl.Implementation] | |
| name [Nopres_impl.Make] | |
O | |
| of_array [Pres_intf.T] | of_array ar converts a standard array to a resizable one
using the default strategy.
|
| of_array [Pres_impl.Make] | |
| of_array [Nopres_intf.T] | of_array ar converts a standard array to a resizable one
using the default strategy.
|
| of_array [Nopres_impl.Make] | |
| of_list [Weak_impl.Make] | |
| of_list [Weak_intf.T] | of_list l creates a resizable array using the default
strategy and the elements in list l.
|
| of_list [Pres_intf.T] | of_list l creates a resizable array using the default
strategy and the elements in list l.
|
| of_list [Pres_impl.Make] | |
| of_list [Nopres_intf.T] | of_list l creates a resizable array using the default
strategy and the elements in list l.
|
| of_list [Nopres_impl.Make] | |
| of_list_aux [Weak_impl.Make] | |
| of_list_aux [Pres_impl.Make] | |
| of_list_aux [Nopres_impl.Make] | |
| of_std [Weak_impl.Make] | |
| of_std [Weak_intf.T] | of_std ar converts a standard weak array to a resizable one
using the default strategy.
|
| of_string [Nopres_intf.Buffer] | of_string ar converts a string to a resizable buffer using
the default strategy.
|
| output_buffer [Nopres_intf.Buffer] | output_buffer oc b writes the current contents of buffer b
on the output channel oc.
|
P | |
| partition [Weak_impl.Make] | |
| partition [Weak_intf.T] | partition p ra
|
| partition [Pres_intf.T] | partition p ra
|
| partition [Pres_impl.Make] | |
| partition [Nopres_intf.T] | partition p ra
|
| partition [Nopres_impl.Make] | |
| pos [Weak_impl.Make] | |
| pos [Weak_intf.T] | pos el ra
|
| pos [Pres_intf.T] | pos el ra
|
| pos [Pres_impl.Make] | |
| pos [Nopres_intf.T] | pos el ra
|
| pos [Nopres_impl.Make] | |
| pos_aux [Weak_impl.Make] | |
| pos_aux [Pres_impl.Make] | |
| pos_aux [Nopres_impl.Make] | |
| posq [Weak_impl.Make] | |
| posq [Weak_intf.T] | posq el ra
|
| posq [Pres_intf.T] | posq el ra
|
| posq [Pres_impl.Make] | |
| posq [Nopres_intf.T] | posq el ra
|
| posq [Nopres_impl.Make] | |
| posq_aux [Weak_impl.Make] | |
| posq_aux [Pres_impl.Make] | |
| posq_aux [Nopres_impl.Make] | |
| put_strategy [Weak_impl.Make] | |
| put_strategy [Weak_intf.T] | put_strategy ra s sets the reallocation strategy of
resizable array ra to s.
|
| put_strategy [Pres_intf.T] | put_strategy ra s sets the reallocation strategy of
resizable array ra to s.
|
| put_strategy [Pres_impl.Make] | |
| put_strategy [Nopres_intf.T] | put_strategy ra s sets the reallocation strategy of
resizable array ra to s.
|
| put_strategy [Nopres_impl.Make] | |
R | |
| real_length [Weak_impl.Make] | |
| real_length [Weak_intf.T] | real_length ra
|
| real_length [Pres_intf.T] | real_length ra
|
| real_length [Pres_impl.Make] | |
| real_length [Nopres_intf.T] | real_length ra
|
| real_length [Nopres_impl.Make] | |
| real_lix [Weak_impl.Make] | |
| real_lix [Weak_intf.T] | real_lix ra
|
| real_lix [Pres_intf.T] | real_lix ra
|
| real_lix [Pres_impl.Make] | |
| real_lix [Nopres_intf.T] | real_lix ra
|
| real_lix [Nopres_impl.Make] | |
| remove_n [Weak_impl.Make] | |
| remove_n [Weak_intf.T] | remove_n ra n removes the last n elements of resizable
array ra, possibly causing a reallocation.
|
| remove_n [Pres_intf.T] | remove_n ra n removes the last n elements of resizable
array ra, possibly causing a reallocation.
|
| remove_n [Pres_impl.Make] | |
| remove_n [Nopres_intf.T] | remove_n ra n removes the last n elements of resizable
array ra, possibly causing a reallocation.
|
| remove_n [Nopres_impl.Make] | |
| remove_one [Weak_impl.Make] | |
| remove_one [Weak_intf.T] | remove_one ra removes the last element of resizable array
ra, possibly causing a reallocation.
|
| remove_one [Pres_intf.T] | remove_one ra removes the last element of resizable array
ra, possibly causing a reallocation.
|
| remove_one [Pres_impl.Make] | |
| remove_one [Nopres_intf.T] | remove_one ra removes the last element of resizable array
ra, possibly causing a reallocation.
|
| remove_one [Nopres_impl.Make] | |
| remove_range [Weak_impl.Make] | |
| remove_range [Weak_intf.T] | remove_range ra ofs len removes len elements from resizable
array ra starting at ofs and possibly causing a
reallocation.
|
| remove_range [Pres_intf.T] | remove_range ra ofs len removes len elements from resizable
array ra starting at ofs and possibly causing a
reallocation.
|
| remove_range [Pres_impl.Make] | |
| remove_range [Nopres_intf.T] | remove_range ra ofs len removes len elements from resizable
array ra starting at ofs and possibly causing a
reallocation.
|
| remove_range [Nopres_impl.Make] | |
| reset [Nopres_intf.Buffer] | reset b just clears the buffer, possibly resizing it.
|
| resizer [Weak_impl.Make] | |
| resizer [Pres_impl.Make] | |
| resizer [Nopres_impl.Make] | |
S | |
| screate [Weak_impl.Make] | |
| screate [Weak_intf.T] | screate s n el
|
| screate [Pres_intf.T] | screate s n el
|
| screate [Pres_impl.Make] | |
| screate [Nopres_intf.T] | screate s n
|
| screate [Nopres_impl.Make] | |
| screate_fresh [Weak_impl.Make] | |
| screate_fresh [Pres_impl.Make] | |
| sempty [Weak_impl.Make] | |
| sempty [Weak_intf.T] | sempty s
|
| sempty [Pres_intf.T] | sempty s
|
| sempty [Pres_impl.Make] | |
| sempty [Nopres_intf.T] | sempty s
|
| sempty [Nopres_impl.Make] | |
| set [Weak_impl.Make] | |
| set [Weak_intf.T] | set ra n sets the nth element of ra.
|
| set [Pres_intf.T] | set ra n sets the nth element of ra.
|
| set [Pres_impl.Make] | |
| set [Nopres_intf.T] | set ra n sets the nth element of ra.
|
| set [Nopres_impl.Make] | |
| set_strategy [Weak_impl.Make] | |
| set_strategy [Weak_intf.T] | set_strategy ra s sets the reallocation strategy of
resizable array ra to s, possibly causing an immediate
reallocation.
|
| set_strategy [Pres_intf.T] | set_strategy ra s sets the reallocation strategy of
resizable array ra to s, possibly causing an immediate
reallocation.
|
| set_strategy [Pres_impl.Make] | |
| set_strategy [Nopres_intf.T] | set_strategy ra s sets the reallocation strategy of
resizable array ra to s, possibly causing an immediate
reallocation.
|
| set_strategy [Nopres_impl.Make] | |
| shrink [Strat.T] | shrink strat ~real_len ~new_len
|
| sinit [Weak_impl.Make] | |
| sinit [Weak_intf.T] | sinit s n f
|
| sinit [Pres_intf.T] | sinit s n f
|
| sinit [Pres_impl.Make] | |
| sinit [Nopres_intf.T] | sinit s n f
|
| sinit [Nopres_impl.Make] | |
| smake [Weak_impl.Make] | |
| smake [Pres_intf.T] | smake s n el same as screate.
|
| smake [Pres_impl.Make] | |
| smake [Nopres_intf.T] | smake s n el
|
| smake [Nopres_impl.Make] | |
| sof_array [Pres_intf.T] | sof_array s ar converts a standard array to a resizable one,
using strategy s.
|
| sof_array [Pres_impl.Make] | |
| sof_array [Nopres_intf.T] | sof_array s ar converts a standard array to a resizable one,
using strategy s.
|
| sof_array [Nopres_impl.Make] | |
| sof_list [Pres_intf.T] | sof_list s l creates a resizable array using strategy s and
the elements in list l.
|
| sof_list [Pres_impl.Make] | |
| sof_list [Nopres_intf.T] | sof_list s l creates a resizable array using strategy s and
the elements in list l.
|
| sof_list [Nopres_impl.Make] | |
| sof_std [Weak_impl.Make] | |
| sof_std [Weak_intf.T] | sof_std s ar converts a standard weak array to a resizable
one, using strategy s.
|
| sof_string [Nopres_intf.Buffer] | sof_string s ar converts a string to a resizable buffer
using strategy s.
|
| sub [Weak_impl.Make] | |
| sub [Weak_intf.T] | sub ra ofs len
|
| sub [Pres_intf.T] | sub ra ofs len
|
| sub [Pres_impl.Make] | |
| sub [Nopres_intf.T] | sub ra ofs len
|
| sub [Nopres_impl.Make] | |
| swap [Weak_impl.Make] | |
| swap [Weak_intf.T] | swap ra n m swaps elements at indices n and m.
|
| swap [Pres_intf.T] | swap ra n m swaps elements at indices n and m.
|
| swap [Pres_impl.Make] | |
| swap [Nopres_intf.T] | swap ra n m swaps elements at indices n and m.
|
| swap [Nopres_impl.Make] | |
| swap_in_last [Weak_impl.Make] | |
| swap_in_last [Weak_intf.T] | swap_in_last ra n swaps the last element with the one at
position n.
|
| swap_in_last [Pres_intf.T] | swap_in_last ra n swaps the last element with the one at
position n.
|
| swap_in_last [Pres_impl.Make] | |
| swap_in_last [Nopres_intf.T] | swap_in_last ra n swaps the last element with the one at
position n.
|
| swap_in_last [Nopres_impl.Make] | |
T | |
| to_array [Pres_intf.T] | to_array ra converts a resizable array to a standard one.
|
| to_array [Pres_impl.Make] | |
| to_array [Nopres_intf.T] | to_array ra converts a resizable array to a standard one.
|
| to_array [Nopres_impl.Make] | |
| to_list [Weak_impl.Make] | |
| to_list [Weak_intf.T] | to_list ra converts resizable array ra to a list.
|
| to_list [Pres_intf.T] | to_list ra converts resizable array ra to a list.
|
| to_list [Pres_impl.Make] | |
| to_list [Nopres_intf.T] | to_list ra converts resizable array ra to a list.
|
| to_list [Nopres_impl.Make] | |
| to_list_aux [Weak_impl.Make] | |
| to_list_aux [Pres_impl.Make] | |
| to_list_aux [Nopres_impl.Make] | |
| to_std [Weak_impl.Make] | |
| to_std [Weak_intf.T] | to_std ra converts a resizable weak array to a standard one.
|
U | |
| unsafe_blit [Weak_impl.Make] | |
| unsafe_blit [Weak_intf.T] | |
| unsafe_blit [Pres_intf.T] | |
| unsafe_blit [Pres_impl.Make] | |
| unsafe_blit [Nopres_intf.T] | |
| unsafe_blit [Nopres_impl.Implementation] | |
| unsafe_blit [Nopres_impl.Make] | |
| unsafe_blit_on_other [Weak_impl.Make] | |
| unsafe_blit_on_other [Pres_impl.Make] | |
| unsafe_blit_on_other [Nopres_impl.Make] | |
| unsafe_fill [Weak_impl.Make] | |
| unsafe_fill [Weak_intf.T] | |
| unsafe_fill [Pres_intf.T] | |
| unsafe_fill [Pres_impl.Make] | |
| unsafe_fill [Nopres_intf.T] | |
| unsafe_fill [Nopres_impl.Make] | |
| unsafe_get [Weak_impl.Make] | |
| unsafe_get [Weak_intf.T] | |
| unsafe_get [Pres_intf.T] | |
| unsafe_get [Pres_impl.Implementation] | |
| unsafe_get [Pres_impl.Make] | |
| unsafe_get [Nopres_intf.T] | |
| unsafe_get [Nopres_impl.Implementation] | |
| unsafe_get [Nopres_impl.Make] | |
| unsafe_get_ar [Pres_impl.Make] | |
| unsafe_remove_n [Weak_impl.Make] | |
| unsafe_remove_n [Weak_intf.T] | |
| unsafe_remove_n [Pres_intf.T] | |
| unsafe_remove_n [Pres_impl.Make] | |
| unsafe_remove_n [Nopres_intf.T] | |
| unsafe_remove_n [Nopres_impl.Make] | |
| unsafe_remove_one [Weak_impl.Make] | |
| unsafe_remove_one [Weak_intf.T] | |
| unsafe_remove_one [Pres_intf.T] | |
| unsafe_remove_one [Pres_impl.Make] | |
| unsafe_remove_one [Nopres_intf.T] | |
| unsafe_remove_one [Nopres_impl.Make] | |
| unsafe_remove_range [Weak_impl.Make] | |
| unsafe_remove_range [Pres_impl.Make] | |
| unsafe_remove_range [Nopres_impl.Make] | |
| unsafe_set [Weak_impl.Make] | |
| unsafe_set [Weak_intf.T] | |
| unsafe_set [Pres_intf.T] | |
| unsafe_set [Pres_impl.Implementation] | |
| unsafe_set [Pres_impl.Make] | |
| unsafe_set [Nopres_intf.T] | |
| unsafe_set [Nopres_impl.Implementation] | |
| unsafe_set [Nopres_impl.Make] | |
| unsafe_set_ar [Pres_impl.Make] | |
| unsafe_sub [Weak_impl.Make] | |
| unsafe_sub [Weak_intf.T] | |
| unsafe_sub [Pres_intf.T] | |
| unsafe_sub [Pres_impl.Make] | |
| unsafe_sub [Nopres_intf.T] | |
| unsafe_sub [Nopres_impl.Make] | |
| unsafe_swap [Weak_impl.Make] | |
| unsafe_swap [Weak_intf.T] | |
| unsafe_swap [Pres_intf.T] | |
| unsafe_swap [Pres_impl.Make] | |
| unsafe_swap [Nopres_intf.T] | |
| unsafe_swap [Nopres_impl.Make] | |
| unsafe_swap_in_last [Weak_impl.Make] | |
| unsafe_swap_in_last [Weak_intf.T] | |
| unsafe_swap_in_last [Pres_intf.T] | |
| unsafe_swap_in_last [Pres_impl.Make] | |
| unsafe_swap_in_last [Nopres_intf.T] | |
| unsafe_swap_in_last [Nopres_impl.Make] |