rust/src/lib/vec.rs

385 lines
9.8 KiB
Rust
Raw Normal View History

import option::none;
import option::some;
import util::orb;
2011-08-11 22:26:37 -05:00
export vbuf;
export empty_mut;
export init_fn;
export init_fn_mut;
export init_elt;
export init_elt_mut;
export buf;
export len;
export print_debug_info;
export slice;
export pop;
export push;
export foldl;
export reversed;
export member;
export map;
export map2;
export filter_map;
export empty;
export position;
export position_pred;
export reverse;
type vbuf = rustrt::vbuf;
2010-06-23 23:03:09 -05:00
type operator2[T, U, V] = fn(&T, &U) -> V ;
type array[T] = vec[mutable? T];
2010-06-23 23:03:09 -05:00
native "rust" mod rustrt {
type vbuf;
2011-07-27 07:19:39 -05:00
fn vec_buf[T](v: vec[T], offset: uint) -> vbuf;
fn vec_len[T](v: vec[T]) -> uint;
/**
* Sometimes we modify the vec internal data via vec_buf and need to
* update the vec's fill length accordingly.
*/
fn vec_len_set[T](v: vec[T], n: uint);
/**
* The T in vec_alloc[T, U] is the type of the vec to allocate. The
* U is the type of an element in the vec. So to allocate a vec[U] we
* want to invoke this as vec_alloc[vec[U], U].
*/
fn vec_alloc[T, U](n_elts: uint) -> vec[U];
fn vec_alloc_mut[T, U](n_elts: uint) -> vec[mutable U];
fn refcount[T](v: vec[T]) -> uint;
fn vec_print_debug_info[T](v: vec[T]);
fn vec_from_vbuf[T](v: vbuf, n_elts: uint) -> vec[T];
fn unsafe_vec_to_mut[T](v: vec[T]) -> vec[mutable T];
}
fn alloc[T](n_elts: uint) -> vec[T] {
ret rustrt::vec_alloc[vec[T], T](n_elts);
2010-06-23 23:03:09 -05:00
}
2011-07-27 07:19:39 -05:00
fn alloc_mut[T](n_elts: uint) -> vec[mutable T] {
ret rustrt::vec_alloc_mut[vec[mutable T], T](n_elts);
}
2011-07-27 07:19:39 -05:00
fn refcount[T](v: array[T]) -> uint {
let r = rustrt::refcount[T](v);
if r == dbg::const_refcount { ret r; } else { ret r - 1u; }
}
2011-07-27 07:19:39 -05:00
fn vec_from_vbuf[T](v: vbuf, n_elts: uint) -> vec[T] {
ret rustrt::vec_from_vbuf[T](v, n_elts);
}
// FIXME: Remove me; this is a botch to get around rustboot's bad typechecker.
fn empty[T]() -> vec[T] { ret alloc[T](0u); }
// FIXME: Remove me; this is a botch to get around rustboot's bad typechecker.
fn empty_mut[T]() -> vec[mutable T] { ret alloc_mut[T](0u); }
type init_op[T] = fn(uint) -> T ;
fn init_fn[@T](op: &init_op[T], n_elts: uint) -> vec[T] {
2011-07-27 07:19:39 -05:00
let v: vec[T] = alloc[T](n_elts);
let i: uint = 0u;
while i < n_elts { v += [op(i)]; i += 1u; }
ret v;
}
fn init_fn_mut[@T](op: &init_op[T], n_elts: uint) -> vec[mutable T] {
2011-07-27 07:19:39 -05:00
let v: vec[mutable T] = alloc_mut[T](n_elts);
let i: uint = 0u;
while i < n_elts { v += [mutable op(i)]; i += 1u; }
ret v;
}
2011-06-28 20:46:46 -05:00
// init_elt: creates and returns a vector of length n_elts, filled with
// that many copies of element t.
fn init_elt[@T](t: &T, n_elts: uint) -> vec[T] {
/**
* FIXME (issue #81): should be:
*
* fn elt_op[T](&T x, uint i) -> T { ret x; }
* let init_op[T] inner = bind elt_op[T](t, _);
* ret init_fn[T](inner, n_elts);
*/
2011-07-27 07:19:39 -05:00
let v: vec[T] = alloc[T](n_elts);
let i: uint = n_elts;
while i > 0u { i -= 1u; v += [t]; }
ret v;
2010-06-23 23:03:09 -05:00
}
fn init_elt_mut[@T](t: &T, n_elts: uint) -> vec[mutable T] {
2011-07-27 07:19:39 -05:00
let v: vec[mutable T] = alloc_mut[T](n_elts);
let i: uint = n_elts;
while i > 0u { i -= 1u; v += [mutable t]; }
ret v;
}
2011-07-27 07:19:39 -05:00
fn buf[T](v: array[T]) -> vbuf { ret rustrt::vec_buf[T](v, 0u); }
2011-07-27 07:19:39 -05:00
fn len[T](v: array[T]) -> uint { ret rustrt::vec_len[T](v); }
2010-06-23 23:03:09 -05:00
2011-07-27 07:19:39 -05:00
fn len_set[T](v: array[T], n: uint) { rustrt::vec_len_set[T](v, n); }
2011-07-27 07:19:39 -05:00
fn buf_off[T](v: array[T], offset: uint) -> vbuf {
assert (offset < len[T](v));
ret rustrt::vec_buf[T](v, offset);
2010-06-23 23:03:09 -05:00
}
2011-07-27 07:19:39 -05:00
fn print_debug_info[T](v: array[T]) { rustrt::vec_print_debug_info[T](v); }
// FIXME: typestate precondition (list is non-empty)
// Returns the last element of v.
fn last[@T](v: array[T]) -> option::t[T] {
2011-07-27 07:19:39 -05:00
let l = len[T](v);
if l == 0u { ret none[T]; }
ret some[T](v.(l - 1u));
}
// Returns elements from [start..end) from v.
fn slice[@T](v: array[T], start: uint, end: uint) -> vec[T] {
assert (start <= end);
assert (end <= len[T](v));
2011-07-27 07:19:39 -05:00
let result = alloc[T](end - start);
let i: uint = start;
while i < end { result += [v.(i)]; i += 1u; }
ret result;
}
// FIXME: Should go away eventually.
fn slice_mut[@T](v: array[T], start: uint, end: uint) -> vec[mutable T] {
assert (start <= end);
assert (end <= len[T](v));
2011-07-27 07:19:39 -05:00
let result = alloc_mut[T](end - start);
let i: uint = start;
while i < end { result += [mutable v.(i)]; i += 1u; }
ret result;
}
fn shift[@T](v: &mutable array[T]) -> T {
2011-07-27 07:19:39 -05:00
let ln = len[T](v);
assert (ln > 0u);
2011-07-27 07:19:39 -05:00
let e = v.(0);
v = slice[T](v, 1u, ln);
ret e;
}
fn pop[@T](v: &mutable array[T]) -> T {
2011-07-27 07:19:39 -05:00
let ln = len[T](v);
assert (ln > 0u);
ln -= 1u;
2011-07-27 07:19:39 -05:00
let e = v.(ln);
v = slice[T](v, 0u, ln);
ret e;
}
fn top[@T](v: &array[T]) -> T {
2011-07-27 07:19:39 -05:00
let ln = len[T](v);
2011-06-06 17:48:36 -05:00
assert (ln > 0u);
ret v.(ln - 1u);
2011-06-06 17:48:36 -05:00
}
fn push[@T](v: &mutable array[T], t: &T) { v += [t]; }
fn unshift[@T](v: &mutable array[T], t: &T) {
2011-07-27 07:19:39 -05:00
let rs = alloc[T](len[T](v) + 1u);
2011-06-24 10:55:02 -05:00
rs += [t];
rs += v;
v = rs;
}
fn grow[@T](v: &mutable array[T], n: uint, initval: &T) {
2011-07-27 07:19:39 -05:00
let i: uint = n;
while i > 0u { i -= 1u; v += [initval]; }
}
fn grow_set[@T](v: &mutable vec[mutable T], index: uint, initval: &T,
2011-07-27 07:19:39 -05:00
val: &T) {
let length = vec::len(v);
if index >= length { grow(v, index - length + 1u, initval); }
v.(index) = val;
}
fn grow_init_fn[@T](v: &mutable array[T], n: uint, init_fn: fn() -> T ) {
2011-07-27 07:19:39 -05:00
let i: uint = n;
while i > 0u { i -= 1u; v += [init_fn()]; }
}
fn grow_init_fn_set[@T](v: &mutable array[T], index: uint, init_fn: fn() -> T,
2011-07-27 07:19:39 -05:00
val: &T) {
let length = vec::len(v);
if index >= length { grow_init_fn(v, index - length + 1u, init_fn); }
v.(index) = val;
}
fn map[@T, @U](f: &fn(&T) -> U , v: &vec[T]) -> vec[U] {
2011-07-27 07:19:39 -05:00
let rs: vec[U] = alloc[U](len[T](v));
for ve: T in v { rs += [f(ve)]; }
2011-06-24 10:55:02 -05:00
ret rs;
2011-05-23 20:50:33 -05:00
}
fn filter_map[@T, @U](f: &fn(&T) -> option::t[U] , v: &vec[T]) -> vec[U] {
2011-07-27 07:19:39 -05:00
let rs: vec[U] = [];
for ve: T in v { alt f(ve) { some(elt) { rs += [elt]; } none. { } } }
2011-06-24 10:55:02 -05:00
ret rs;
}
fn map2[@T, @U, @V](f: &operator2[T, U, V], v0: &vec[T], v1: &vec[U])
-> vec[V] {
2011-07-27 07:19:39 -05:00
let v0_len = len[T](v0);
if v0_len != len[U](v1) { fail; }
let u: vec[V] = alloc[V](v0_len);
let i = 0u;
while i < v0_len { u += [f({ v0.(i) }, { v1.(i) })]; i += 1u; }
ret u;
}
fn find[@T](f: fn(&T) -> bool , v: &vec[T]) -> option::t[T] {
2011-07-27 07:19:39 -05:00
for elt: T in v { if f(elt) { ret some[T](elt); } }
ret none[T];
}
fn position[@T](x: &T, v: &array[T]) -> option::t[uint] {
2011-07-27 07:19:39 -05:00
let i: uint = 0u;
while i < len(v) { if x == v.(i) { ret some[uint](i); } i += 1u; }
ret none[uint];
}
2011-07-27 07:19:39 -05:00
fn position_pred[T](f: fn(&T) -> bool , v: &vec[T]) -> option::t[uint] {
let i: uint = 0u;
while i < len(v) { if f(v.(i)) { ret some[uint](i); } i += 1u; }
ret none[uint];
}
2011-07-27 07:19:39 -05:00
fn member[T](x: &T, v: &array[T]) -> bool {
for elt: T in v { if x == elt { ret true; } }
2011-06-09 03:58:31 -05:00
ret false;
}
2011-07-27 07:19:39 -05:00
fn count[T](x: &T, v: &array[T]) -> uint {
let cnt = 0u;
for elt: T in v { if x == elt { cnt += 1u; } }
2011-06-10 09:39:09 -05:00
ret cnt;
}
fn foldl[@T, @U](p: fn(&U, &T) -> U , z: &U, v: &vec[T]) -> U {
2011-07-27 07:19:39 -05:00
let sz = len[T](v);
if sz == 0u {
ret z;
} else {
2011-07-27 07:19:39 -05:00
let rest = slice[T](v, 1u, sz);
ret p(foldl[T, U](p, z, rest), v.(0));
}
}
fn unzip[@T, @U](v: &vec[{_0: T, _1: U}]) -> {_0: vec[T], _1: vec[U]} {
2011-07-27 07:19:39 -05:00
let sz = len(v);
if sz == 0u {
ret {_0: alloc[T](0u), _1: alloc[U](0u)};
} else {
2011-07-27 07:19:39 -05:00
let rest = slice(v, 1u, sz);
let tl = unzip[T, U](rest);
let a = [v.(0)._0];
let b = [v.(0)._1];
ret {_0: a + tl._0, _1: b + tl._1};
}
}
// FIXME make the lengths being equal a constraint
fn zip[@T, @U](v: &vec[T], u: &vec[U]) -> vec[{_0: T, _1: U}] {
2011-07-27 07:19:39 -05:00
let sz = len(v);
assert (sz == len(u));
2011-07-27 07:19:39 -05:00
if sz == 0u {
ret alloc(0u);
} else {
2011-07-27 07:19:39 -05:00
let rest = zip(slice(v, 1u, sz), slice(u, 1u, sz));
vec::push(rest, {_0: v.(0), _1: u.(0)});
ret rest;
}
}
2011-07-27 07:19:39 -05:00
fn or(v: &vec[bool]) -> bool {
let f = orb;
ret vec::foldl[bool, bool](f, false, v);
}
2011-07-27 07:19:39 -05:00
fn any[T](f: &fn(&T) -> bool , v: &vec[T]) -> bool {
for t: T in v { if f(t) { ret true; } }
ret false;
}
2011-07-27 07:19:39 -05:00
fn all[T](f: &fn(&T) -> bool , v: &vec[T]) -> bool {
for t: T in v { if !f(t) { ret false; } }
ret true;
}
fn clone[@T](v: &vec[T]) -> vec[T] { ret slice[T](v, 0u, len[T](v)); }
fn plus_option[@T](v: &mutable vec[T], o: &option::t[T]) {
2011-07-27 07:19:39 -05:00
alt o { none. { } some(x) { v += [x]; } }
}
fn cat_options[@T](v: &vec[option::t[T]]) -> vec[T] {
2011-07-27 07:19:39 -05:00
let rs: vec[T] = [];
for o: option::t[T] in v { alt o { none. { } some(t) { rs += [t]; } } }
2011-06-24 10:55:02 -05:00
ret rs;
}
// TODO: Remove in favor of built-in "freeze" operation when it's implemented.
fn freeze[@T](v: vec[mutable T]) -> vec[T] {
2011-07-27 07:19:39 -05:00
let result: vec[T] = [];
for elem: T in v { result += [elem]; }
ret result;
}
// Swaps two elements in a vector
fn swap[@T](v: &vec[mutable T], a: uint, b: uint) {
2011-07-27 07:19:39 -05:00
let t: T = v.(a);
v.(a) = v.(b);
v.(b) = t;
}
// In place vector reversal
fn reverse[@T](v: &vec[mutable T]) {
2011-07-27 07:19:39 -05:00
let i: uint = 0u;
let ln = len[T](v);
while i < ln / 2u { swap(v, i, ln - i - 1u); i += 1u; }
}
// Functional vector reversal. Returns a reversed copy of v.
fn reversed[@T](v: vec[T]) -> vec[T] {
2011-07-27 07:19:39 -05:00
let rs: vec[T] = [];
let i = len[T](v);
if i == 0u { ret rs; } else { i -= 1u; }
while i != 0u { push[T](rs, v.(i)); i -= 1u; }
2011-06-24 10:55:02 -05:00
push[T](rs, v.(0));
ret rs;
}
/// Truncates the vector to length `new_len`.
/// FIXME: This relies on a typechecker bug (covariance vs. invariance).
fn truncate[@T](v: &mutable vec[mutable? T], new_len: uint) {
v = slice[T](v, 0u, new_len);
}
// Local Variables:
// mode: rust;
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End: