Index of values

v ++ u is append v u.

add_first e v is singleton e ++ v.

add_last v e is v ++ singleton e.

append v u is the vector resulting from appending u to v.

break_left n v is (take_left n v, drop_left n v).

break_right n v is (drop_right n v, take_right n v).

chunk_left size v is v, in order, chunked into vectors of exactly size elements except maybe for the last one.

chunk_right size v is v, in order, chunked into vectors of exactly size elements except maybe for the first one.

compare ~cmp u v is the lexicographic order betwen u and v using cmp to compare elements.

concat ~sep vs is the concatenation of the vectors of vs, separated by sep (defaults to Pvec.empty): vs.(0) ++ sep ++ vs.(2) ++ ...

concat_list ~sep vs is concat ~sep (of_list vs).

cut_left sep v is either the pair Some (l, r) of the two (possibly empty) vectors of v that are delimited by the first match of the non empty separator vector sep or None if sep can't be matched in v.

cut_right sep v is like Pvec.cut_right but matching starts on the right.

cuts_left ~drop_empty ~sep v is the vector of subvectors of v that are delimited by matches of the non empty separator vector sep.

cuts_right ~drop_empty ~sep v is like Pvec.cuts_left but matching starts from the right.

drop_left n v has the elements of v without the first n elements.

drop_right n v has the elements of v without the last n elements.

dump pp_v ppf v prints an unspecified representation of v on ppf using pp_v to print the elements.

edit_distance ~eq u v is the number of single element edits (insertion, deletion, substitution) that are needed to change u into v.

el v i is the element v.(i), if any; in particular this is None on i < 0.

empty is the empty vector.

equal ~eq u v is true iff u and v have the same length and for all indices i of u, eq u.(0) v.(1).

exists p is true iff there exists an index i of v with p v.(i) = true.

fields ~drop_empty ~is_sep v is the vector of (possibly empty) subvectors that are delimited by elements for which is_sep is true.

fill ~pad u i e is: set u i e if i is a valid index of u., set (u ++ (v len:(i + 1 - length v) pad)) i e otherwise.

fill_first v e is set v 0 e or singleton e if v is empty.

fill_last v e is set v (length v - 1) e or singleton e if v is empty.

filter sat v is fst (partition sat v).

filter_map f s is filter_mapi (fun _ e -> f e) v.

filter_map f s is the vector made of the elements of v as (and if) mapped by f, in the same order.

first_el v is el v 0.

fold_left f acc v is foldi_left (fun acc _ e -> f acc) acc v.

fold_right f v acc is foldi_right (fun _ e acc -> f acc) v acc.

foldi_left f acc v is f (... (f (f acc 0 v.(0)) 1 v.(1)) ...) m s.(m) with m = length v - 1 or acc if v is empty.

fold_right f v acc is f 0 v.(0) (f 1 v.(1) (... (f m v.(m) acc) ..)) with m = length v - 1 or acc if v is empty.

for_all p v is true iff for all indices i of v, p v.(i) = true.

get v i is v.(i).

get_first v is get v 0.

get_last v is get v (length v - 1).

indices v is mapi (fun i _ -> i).

init ~len f is a vector v of length len with v.(i) = f i for all valid indices i of v.

ints n is the sequence of integers from start (defaults to 0) to n (included).

is_empty v is true iff length v = 0.

is_filled v i is true iff v.(i) exists.

is_infix ~eq ~affix v is true iff affix can be found in v that is iff there exists an index j in v such that for all valid indices i of affix, eq affix.(i) v.(j + i) = true.

is_prefix ~eq ~affix v is true iff affix is a prefix of v that is iff eq affix.(i) v.(i) = true for all valid indices i of affix.

is_suffix ~eq ~affix v is true iff affix is a suffix of v that is iff eq affix.(n - i) v.(m - i) = true for all indices i of affix with n = length affix - 1 and m = last_index v.

iter_left f v is iteri_left (fun _ e -> f e) v.

iter_right f v is iteri_right (fun _ e -> f e) v.

iteri_left f v is f 0 v.(0); f 1 v.(1); ...; f m v.(m) with m = length v - 1 or () if v is empty.

iteri_right f v is f m v.(m); f (m-1) v.(m-1); ...; f 0 v.(0) with m = length v - 1 or () if v is empty.

keep_left sat v has the first consecutive sat satisfying elements of v.

keep_right sat v has the last consecutive sat satisfying elements of v.

last_el v is el v (length v - 1).

left_find ~start sat v is Some (i, v.(i)) with i the smallest index i, if any, greater or equal to start such that sat v.(i) is true.

length v is the number of elements in v.

lose_left sat v has the elements of v without the first consecutive sat satisfying elements of v.

lose_right sat v has the elements of v without the last consecutive sat satisfying elements of v.

map f v is mapi (fun _ e -> f e) v.

mapi f v is u with u.(i) = f i v.(i) for all indices i of v or the empty vector if v is empty.

max_length is the maximal vector length.

of_array a is a as a persistent vector.

of_bytes bytes is bytes as a persistent vector.

of_list l is l as a persistent vector.

of_string s is s as a persistent vector.

partition sat v is a pair of vectors (vt, vf) with vt the elements that satisfy sat and vf the elements that do not.

pop_first v is Some (get_first v, drop_left 1 v) or None if v is empty.

pop_last v is Some (drop_right 1 v, get_last v) or None if v is empty.

pp ~sep pp_v ppf v formats v's elements.

pp_chars is pp ~sep:(fun _ _ -> ()) Format.pp_print_char.

range ~first ~last v is u defined as the consecutive elements of v whose indices exist in the range [first;last], in the same order.

rem v i is rem_range ~first:i ~last:i v.

rem_first v is rem v 0.

rem_last v is rem v (length v - 1).

rem_range ~first ~last v is v without the elements of v that exist in the range [first;last].

rev v is u the vector with elements of v reversed, u.(i) = v.(length v - 1 - i) for all indices i of v or the empty vector if v is empty.

right_find ~start sat v is Some (i, v.(i)) with i the greatest index i, if any, smaller or equal to start such that sat v.(i) is true.

set v i e is v with the element at index i equal to e.

set_first v e is set v 0 e.

set_last v e is set v (length v - 1) e.

shuffle rand v is a random permutation of v's elements.

singleton e is v ~len:1 e.

sort_uniq compare v is like Pvec.stable_sort except duplicates are removed.

span_left sat v is (keep_left sat v, lose_left sat v).

span_right sat v is (lose_right sat v, keep_right sat v).

splice ~into ~first ~last v replaces the elements of into in range [first; last] with those of v or inserts v at first if the range is empty.

stable_sort compare v is v with its elements sorted according to compare.

suggest ~dist candidates v are the elements of candidates whose Pvec.edit_distance is the smallest to s and at most at distance dist of s (defaults to 2).

take_left n v has the first n elements of v.

take_right n v has the last n elements of v.

to_array v is v as an array.

to_string v is v as bytes

to_list v is v as a list.

to_string v is v as a string.

transpose v is u such that u.(i).(j) = v.(j).(i) for all indices i of v and j of its subvectors.

trim drop v is lose_right drop (lose_left drop v).

unstutter ~eq v is v without consecutive equal elements.

v len e is a vector u of length len with u.(i) = e for all valid indices i of u.