S (melange.Vec

type elt;

type t;

let length: t => int;

let compact: t => unit;

let singleton: elt => t;

let empty: unit => t;

let make: int => t;

let init: int => (int => elt) => t;

let is_empty: t => bool;

let of_sub_array: array(elt) => int => int => t;

let unsafe_internal_array: t => array(elt);

Exposed for some APIs which only take array as input, when exposed

let reserve: t => int => unit;

let push: t => elt => unit;

let delete: t => int => unit;

let pop: t => unit;

let get_last_and_pop: t => elt;

let delete_range: t => int => int => unit;

let get_and_delete_range: t => int => int => t;

let clear: t => unit;

let reset: t => unit;

let to_list: t => list(elt);

let of_list: list(elt) => t;

let to_array: t => array(elt);

let of_array: array(elt) => t;

let copy: t => t;

let reverse_in_place: t => unit;

let iter: t => (elt => unit) => unit;

let iteri: t => (int => elt => unit) => unit;

let iter_range: t => from:int => to_:int => (elt => unit) => unit;

let iteri_range: t => from:int => to_:int => (int => elt => unit) => unit;

let map: (elt => elt) => t => t;

let mapi: (int => elt => elt) => t => t;

let map_into_array: (elt => 'f) => t => array('f);

let map_into_list: (elt => 'f) => t => list('f);

let fold_left: ('f => elt => 'f) => 'f => t => 'f;

let fold_right: (elt => 'g => 'g) => t => 'g => 'g;

let filter: (elt => bool) => t => t;

let inplace_filter: (elt => bool) => t => unit;

let inplace_filter_with: 
  (elt => bool) =>
  cb_no:(elt => 'a => 'a) =>
  'a =>
  t =>
  'a;

let inplace_filter_from: int => (elt => bool) => t => unit;

let equal: (elt => elt => bool) => t => t => bool;

let get: t => int => elt;

let unsafe_get: t => int => elt;

let last: t => elt;

let capacity: t => int;

let exists: (elt => bool) => t => bool;

let sub: t => int => int => t;