# Index of values

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 `n`th element of `ra`.
set [Pres_intf.T] | `set ra n` sets the `n`th element of `ra`.
set [Pres_impl.Make] |
set [Nopres_intf.T] | `set ra n` sets the `n`th 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] |