2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Module: vec
|
|
|
|
*/
|
2011-06-16 18:08:26 -05:00
|
|
|
|
2011-09-12 18:13:28 -05:00
|
|
|
import option::{some, none};
|
2011-06-19 20:02:37 -05:00
|
|
|
import uint::next_power_of_two;
|
2011-10-23 09:21:14 -05:00
|
|
|
import ptr::addr_of;
|
2011-06-16 18:08:26 -05:00
|
|
|
|
|
|
|
native "rust-intrinsic" mod rusti {
|
2011-10-17 16:28:44 -05:00
|
|
|
fn vec_len<T>(&&v: [mutable? T]) -> uint;
|
2011-06-16 18:08:26 -05:00
|
|
|
}
|
|
|
|
|
2011-10-17 23:15:50 -05:00
|
|
|
native "c-stack-cdecl" mod rustrt {
|
2011-10-23 09:21:14 -05:00
|
|
|
fn vec_reserve_shared<T>(t: *sys::type_desc,
|
2011-10-17 23:15:50 -05:00
|
|
|
&v: [mutable? T],
|
|
|
|
n: uint);
|
2011-10-23 09:21:14 -05:00
|
|
|
fn vec_from_buf_shared<T>(t: *sys::type_desc,
|
2011-10-17 23:15:50 -05:00
|
|
|
ptr: *T,
|
|
|
|
count: uint) -> [T];
|
2011-06-16 18:08:26 -05:00
|
|
|
}
|
|
|
|
|
2011-10-27 19:03:38 -05:00
|
|
|
/*
|
|
|
|
Type: init_op
|
|
|
|
|
|
|
|
A function used to initialize the elements of a vector.
|
|
|
|
*/
|
|
|
|
type init_op<T> = block(uint) -> T;
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
Predicate: is_empty
|
|
|
|
|
|
|
|
Returns true if a vector contains no elements.
|
|
|
|
*/
|
|
|
|
pure fn is_empty<T>(v: [mutable? T]) -> bool {
|
|
|
|
// FIXME: This would be easier if we could just call len
|
|
|
|
for t: T in v { ret false; }
|
|
|
|
ret true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Predicate: is_not_empty
|
|
|
|
|
|
|
|
Returns true if a vector contains some elements.
|
|
|
|
*/
|
|
|
|
pure fn is_not_empty<T>(v: [mutable? T]) -> bool { ret !is_empty(v); }
|
|
|
|
|
|
|
|
/*
|
|
|
|
Predicate: same_length
|
|
|
|
|
|
|
|
Returns true if two vectors have the same length
|
|
|
|
*/
|
|
|
|
pure fn same_length<T, U>(xs: [T], ys: [U]) -> bool {
|
|
|
|
vec::len(xs) == vec::len(ys)
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: reserve
|
|
|
|
|
|
|
|
Reserves capacity for `n` elements in the given vector.
|
|
|
|
|
|
|
|
If the capacity for `v` is already equal to or greater than the requested
|
|
|
|
capacity, then no action is taken.
|
|
|
|
|
|
|
|
Parameters:
|
|
|
|
|
|
|
|
v - A vector
|
|
|
|
n - The number of elements to reserve space for
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn reserve<T>(&v: [mutable? T], n: uint) {
|
2011-10-23 09:21:14 -05:00
|
|
|
rustrt::vec_reserve_shared(sys::get_type_desc::<T>(), v, n);
|
2011-06-16 18:08:26 -05:00
|
|
|
}
|
|
|
|
|
2011-10-26 13:28:23 -05:00
|
|
|
/*
|
|
|
|
Function: len
|
|
|
|
|
|
|
|
Returns the length of a vector
|
|
|
|
*/
|
2011-09-24 17:10:03 -05:00
|
|
|
pure fn len<T>(v: [mutable? T]) -> uint { unchecked { rusti::vec_len(v) } }
|
2011-06-16 19:06:24 -05:00
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: init_fn
|
|
|
|
|
|
|
|
Creates and initializes an immutable vector.
|
|
|
|
|
|
|
|
Creates an immutable vector of size `n_elts` and initializes the elements
|
|
|
|
to the value returned by the function `op`.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn init_fn<T>(op: init_op<T>, n_elts: uint) -> [T] {
|
2011-08-19 17:16:48 -05:00
|
|
|
let v = [];
|
2011-06-16 19:47:28 -05:00
|
|
|
reserve(v, n_elts);
|
2011-07-27 07:19:39 -05:00
|
|
|
let i: uint = 0u;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < n_elts { v += [op(i)]; i += 1u; }
|
2011-06-16 19:47:28 -05:00
|
|
|
ret v;
|
|
|
|
}
|
|
|
|
|
2011-06-17 21:16:03 -05:00
|
|
|
// TODO: Remove me once we have slots.
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: init_fn
|
|
|
|
|
|
|
|
Creates and initializes a mutable vector.
|
|
|
|
|
|
|
|
Creates a mutable vector of size `n_elts` and initializes the elements to
|
|
|
|
the value returned by the function `op`.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn init_fn_mut<T>(op: init_op<T>, n_elts: uint) -> [mutable T] {
|
2011-08-19 17:16:48 -05:00
|
|
|
let v = [mutable];
|
2011-06-17 21:16:03 -05:00
|
|
|
reserve(v, n_elts);
|
2011-07-27 07:19:39 -05:00
|
|
|
let i: uint = 0u;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < n_elts { v += [mutable op(i)]; i += 1u; }
|
2011-06-17 21:16:03 -05:00
|
|
|
ret v;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: init_elt
|
|
|
|
|
|
|
|
Creates and initializes an immutable vector.
|
|
|
|
|
|
|
|
Creates an immutable vector of size `n_elts` and initializes the elements
|
|
|
|
to the value `t`.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn init_elt<T>(t: T, n_elts: uint) -> [T] {
|
2011-08-19 17:16:48 -05:00
|
|
|
let v = [];
|
2011-06-17 21:16:03 -05:00
|
|
|
reserve(v, n_elts);
|
2011-07-27 07:19:39 -05:00
|
|
|
let i: uint = 0u;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < n_elts { v += [t]; i += 1u; }
|
2011-06-17 21:16:03 -05:00
|
|
|
ret v;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: Remove me once we have slots.
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: init_elt_mut
|
|
|
|
|
|
|
|
Creates and initializes a mutable vector.
|
|
|
|
|
|
|
|
Creates a mutable vector of size `n_elts` and initializes the elements
|
|
|
|
to the value `t`.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn init_elt_mut<T>(t: T, n_elts: uint) -> [mutable T] {
|
2011-08-19 17:16:48 -05:00
|
|
|
let v = [mutable];
|
2011-06-17 21:16:03 -05:00
|
|
|
reserve(v, n_elts);
|
2011-07-27 07:19:39 -05:00
|
|
|
let i: uint = 0u;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < n_elts { v += [mutable t]; i += 1u; }
|
2011-06-17 21:16:03 -05:00
|
|
|
ret v;
|
|
|
|
}
|
|
|
|
|
2011-08-30 18:22:21 -05:00
|
|
|
// FIXME: Possible typestate postcondition:
|
|
|
|
// len(result) == len(v) (needs issue #586)
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: to_mut
|
|
|
|
|
|
|
|
Produces a mutable vector from an immutable vector.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn to_mut<T>(v: [T]) -> [mutable T] {
|
2011-08-19 17:16:48 -05:00
|
|
|
let vres = [mutable];
|
|
|
|
for t: T in v { vres += [mutable t]; }
|
2011-07-16 18:59:17 -05:00
|
|
|
ret vres;
|
|
|
|
}
|
|
|
|
|
2011-08-30 18:22:21 -05:00
|
|
|
// Same comment as from_mut
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: from_mut
|
|
|
|
|
|
|
|
Produces an immutable vector from a mutable vector.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn from_mut<T>(v: [mutable T]) -> [T] {
|
2011-08-19 17:16:48 -05:00
|
|
|
let vres = [];
|
|
|
|
for t: T in v { vres += [t]; }
|
2011-07-16 18:59:17 -05:00
|
|
|
ret vres;
|
|
|
|
}
|
|
|
|
|
2011-06-17 21:16:03 -05:00
|
|
|
// Accessors
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: head
|
|
|
|
|
|
|
|
Returns the first element of a vector
|
|
|
|
|
|
|
|
Predicates:
|
|
|
|
<is_not_empty> (v)
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn head<T>(v: [mutable? T]) : is_not_empty(v) -> T { ret v[0]; }
|
2011-07-14 17:40:43 -05:00
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: tail
|
|
|
|
|
|
|
|
Returns all but the first element of a vector
|
|
|
|
|
|
|
|
Predicates:
|
|
|
|
<is_not_empty> (v)
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn tail<T>(v: [mutable? T]) : is_not_empty(v) -> [T] {
|
2011-07-27 07:48:34 -05:00
|
|
|
ret slice(v, 1u, len(v));
|
|
|
|
}
|
2011-07-14 17:40:43 -05:00
|
|
|
|
2011-10-29 00:42:38 -05:00
|
|
|
// FIXME: This name is sort of confusing next to init_fn, etc
|
|
|
|
// but this is the name haskell uses for this function,
|
|
|
|
// along with head/tail/last.
|
|
|
|
/*
|
|
|
|
Function: init
|
|
|
|
|
|
|
|
Returns all but the last elemnt of a vector
|
|
|
|
|
|
|
|
Preconditions:
|
|
|
|
`v` is not empty
|
|
|
|
*/
|
|
|
|
fn init<T>(v: [mutable? T]) -> [T] {
|
|
|
|
assert len(v) != 0u;
|
|
|
|
slice(v, 0u, len(v) - 1u)
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: last
|
|
|
|
|
2011-10-29 00:42:38 -05:00
|
|
|
Returns the last element of a vector
|
2011-10-24 17:25:41 -05:00
|
|
|
|
|
|
|
Returns:
|
|
|
|
|
|
|
|
An option containing the last element of `v` if `v` is not empty, or
|
|
|
|
none if `v` is empty.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn last<T>(v: [mutable? T]) -> option::t<T> {
|
2011-07-27 07:19:39 -05:00
|
|
|
if len(v) == 0u { ret none; }
|
2011-08-19 17:16:48 -05:00
|
|
|
ret some(v[len(v) - 1u]);
|
2011-06-17 21:16:03 -05:00
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: last_total
|
|
|
|
|
|
|
|
Returns the last element of a non-empty vector `v`
|
|
|
|
|
|
|
|
Predicates:
|
|
|
|
<is_not_empty> (v)
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn last_total<T>(v: [mutable? T]) : is_not_empty(v) -> T {
|
2011-08-30 19:17:42 -05:00
|
|
|
ret v[len(v) - 1u];
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: slice
|
|
|
|
|
|
|
|
Returns a copy of the elements from [`start`..`end`) from `v`.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn slice<T>(v: [mutable? T], start: uint, end: uint) -> [T] {
|
2011-06-17 21:16:03 -05:00
|
|
|
assert (start <= end);
|
|
|
|
assert (end <= len(v));
|
2011-08-19 17:16:48 -05:00
|
|
|
let result = [];
|
2011-06-17 21:16:03 -05:00
|
|
|
reserve(result, end - start);
|
2011-07-27 07:19:39 -05:00
|
|
|
let i = start;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < end { result += [v[i]]; i += 1u; }
|
2011-06-17 21:16:03 -05:00
|
|
|
ret result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: Remove me once we have slots.
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: slice_mut
|
|
|
|
|
|
|
|
Returns a copy of the elements from [`start`..`end`) from `v`.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn slice_mut<T>(v: [mutable? T], start: uint, end: uint) -> [mutable T] {
|
2011-06-17 21:16:03 -05:00
|
|
|
assert (start <= end);
|
|
|
|
assert (end <= len(v));
|
2011-08-19 17:16:48 -05:00
|
|
|
let result = [mutable];
|
2011-06-17 21:16:03 -05:00
|
|
|
reserve(result, end - start);
|
2011-07-27 07:19:39 -05:00
|
|
|
let i = start;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < end { result += [mutable v[i]]; i += 1u; }
|
2011-06-17 21:16:03 -05:00
|
|
|
ret result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Mutators
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: shift
|
|
|
|
|
|
|
|
Removes the first element from a vector and return it
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn shift<T>(&v: [mutable? T]) -> T {
|
2011-08-12 12:56:57 -05:00
|
|
|
let ln = len::<T>(v);
|
2011-08-11 17:50:27 -05:00
|
|
|
assert (ln > 0u);
|
2011-08-19 17:16:48 -05:00
|
|
|
let e = v[0];
|
2011-08-12 12:56:57 -05:00
|
|
|
v = slice::<T>(v, 1u, ln);
|
2011-08-11 17:50:27 -05:00
|
|
|
ret e;
|
|
|
|
}
|
|
|
|
|
2011-07-04 23:20:18 -05:00
|
|
|
// TODO: Write this, unsafely, in a way that's not O(n).
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: pop
|
|
|
|
|
|
|
|
Remove the last element from a vector and return it
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn pop<T>(&v: [mutable? T]) -> T {
|
2011-07-27 07:19:39 -05:00
|
|
|
let ln = len(v);
|
2011-07-04 23:20:18 -05:00
|
|
|
assert (ln > 0u);
|
|
|
|
ln -= 1u;
|
2011-08-19 17:16:48 -05:00
|
|
|
let e = v[ln];
|
2011-07-04 23:20:18 -05:00
|
|
|
v = slice(v, 0u, ln);
|
|
|
|
ret e;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: More.
|
2011-06-17 21:16:03 -05:00
|
|
|
|
|
|
|
|
2011-06-18 18:29:45 -05:00
|
|
|
// Appending
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: grow
|
|
|
|
|
|
|
|
Expands a vector in place, initializing the new elements to a given value
|
|
|
|
|
|
|
|
Parameters:
|
|
|
|
|
|
|
|
v - The vector to grow
|
|
|
|
n - The number of elements to add
|
|
|
|
initval - The value for the new elements
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn grow<T>(&v: [T], n: uint, initval: T) {
|
2011-06-19 20:02:37 -05:00
|
|
|
reserve(v, next_power_of_two(len(v) + n));
|
2011-07-27 07:19:39 -05:00
|
|
|
let i: uint = 0u;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < n { v += [initval]; i += 1u; }
|
2011-06-18 18:29:45 -05:00
|
|
|
}
|
|
|
|
|
2011-06-18 18:41:09 -05:00
|
|
|
// TODO: Remove me once we have slots.
|
2011-10-24 17:25:41 -05:00
|
|
|
// FIXME: Can't grow take a [mutable? T]
|
|
|
|
/*
|
|
|
|
Function: grow_mut
|
|
|
|
|
|
|
|
Expands a vector in place, initializing the new elements to a given value
|
|
|
|
|
|
|
|
Parameters:
|
|
|
|
|
|
|
|
v - The vector to grow
|
|
|
|
n - The number of elements to add
|
|
|
|
initval - The value for the new elements
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn grow_mut<T>(&v: [mutable T], n: uint, initval: T) {
|
2011-06-19 20:02:37 -05:00
|
|
|
reserve(v, next_power_of_two(len(v) + n));
|
2011-07-27 07:19:39 -05:00
|
|
|
let i: uint = 0u;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < n { v += [mutable initval]; i += 1u; }
|
2011-06-18 18:41:09 -05:00
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: grow_fn
|
|
|
|
|
|
|
|
Expands a vector in place, initializing the new elements to the result of a
|
|
|
|
function
|
|
|
|
|
|
|
|
Function `init_fn` is called `n` times with the values [0..`n`)
|
|
|
|
|
|
|
|
Parameters:
|
|
|
|
|
|
|
|
v - The vector to grow
|
|
|
|
n - The number of elements to add
|
|
|
|
init_fn - A function to call to retreive each appended element's value
|
|
|
|
*/
|
2011-10-27 19:06:49 -05:00
|
|
|
fn grow_fn<T>(&v: [T], n: uint, op: init_op<T>) {
|
2011-06-19 20:02:37 -05:00
|
|
|
reserve(v, next_power_of_two(len(v) + n));
|
2011-07-27 07:19:39 -05:00
|
|
|
let i: uint = 0u;
|
2011-10-27 19:06:49 -05:00
|
|
|
while i < n { v += [op(i)]; i += 1u; }
|
2011-06-18 18:29:45 -05:00
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: grow_set
|
|
|
|
|
|
|
|
Sets the value of a vector element at a given index, growing the vector as
|
|
|
|
needed
|
|
|
|
|
|
|
|
Sets the element at position `index` to `val`. If `index` is past the end
|
|
|
|
of the vector, expands the vector by replicating `initval` to fill the
|
|
|
|
intervening space.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn grow_set<T>(&v: [mutable T], index: uint, initval: T, val: T) {
|
2011-07-27 07:19:39 -05:00
|
|
|
if index >= len(v) { grow_mut(v, index - len(v) + 1u, initval); }
|
2011-08-19 17:16:48 -05:00
|
|
|
v[index] = val;
|
2011-06-18 18:41:09 -05:00
|
|
|
}
|
2011-06-18 18:29:45 -05:00
|
|
|
|
2011-07-05 00:48:42 -05:00
|
|
|
|
|
|
|
// Functional utilities
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: map
|
|
|
|
|
|
|
|
Apply a function to each element of a vector and return the results
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn map<T, U>(f: block(T) -> U, v: [mutable? T]) -> [U] {
|
2011-08-19 17:16:48 -05:00
|
|
|
let result = [];
|
2011-07-05 00:48:42 -05:00
|
|
|
reserve(result, len(v));
|
2011-08-15 23:54:52 -05:00
|
|
|
for elem: T in v {
|
2011-07-27 07:19:39 -05:00
|
|
|
let elem2 = elem; // satisfies alias checker
|
2011-08-19 17:16:48 -05:00
|
|
|
result += [f(elem2)];
|
2011-07-05 00:48:42 -05:00
|
|
|
}
|
|
|
|
ret result;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: map2
|
|
|
|
|
|
|
|
Apply a function to each pair of elements and return the results
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn map2<T, U, V>(f: block(T, U) -> V, v0: [T], v1: [U]) -> [V] {
|
2011-08-12 12:56:57 -05:00
|
|
|
let v0_len = len::<T>(v0);
|
|
|
|
if v0_len != len::<U>(v1) { fail; }
|
2011-08-19 17:16:48 -05:00
|
|
|
let u: [V] = [];
|
2011-08-11 23:00:11 -05:00
|
|
|
let i = 0u;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < v0_len { u += [f({ v0[i] }, { v1[i] })]; i += 1u; }
|
2011-08-11 23:00:11 -05:00
|
|
|
ret u;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: filter_map
|
|
|
|
|
|
|
|
Apply a function to each element of a vector and return the results
|
|
|
|
|
|
|
|
If function `f` returns `none` then that element is excluded from
|
|
|
|
the resulting vector.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn filter_map<T, U>(f: block(T) -> option::t<U>, v: [mutable? T]) -> [U] {
|
2011-08-19 17:16:48 -05:00
|
|
|
let result = [];
|
2011-08-15 23:54:52 -05:00
|
|
|
for elem: T in v {
|
2011-07-27 07:19:39 -05:00
|
|
|
let elem2 = elem; // satisfies alias checker
|
|
|
|
alt f(elem2) {
|
|
|
|
none. {/* no-op */ }
|
2011-08-19 17:16:48 -05:00
|
|
|
some(result_elem) { result += [result_elem]; }
|
2011-07-05 19:22:02 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
ret result;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: filter
|
|
|
|
|
|
|
|
Construct a new vector from the elements of a vector for which some predicate
|
|
|
|
holds.
|
|
|
|
|
|
|
|
Apply function `f` to each element of `v` and return a vector containing
|
|
|
|
only those elements for which `f` returned true.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn filter<T>(f: block(T) -> bool, v: [mutable? T]) -> [T] {
|
2011-09-23 21:10:48 -05:00
|
|
|
let result = [];
|
|
|
|
for elem: T in v {
|
|
|
|
let elem2 = elem; // satisfies alias checker
|
|
|
|
if f(elem2) {
|
|
|
|
result += [elem2];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret result;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: foldl
|
|
|
|
|
2011-10-27 22:47:06 -05:00
|
|
|
Reduce a vector from left to right
|
2011-10-24 17:25:41 -05:00
|
|
|
*/
|
2011-10-27 23:34:16 -05:00
|
|
|
fn foldl<T, U>(p: block(T, U) -> T, z: T, v: [mutable? U]) -> T {
|
2011-10-27 22:47:06 -05:00
|
|
|
let accum = z;
|
|
|
|
iter(v) { |elt|
|
|
|
|
accum = p(accum, elt);
|
|
|
|
}
|
|
|
|
ret accum;
|
2011-07-05 20:29:18 -05:00
|
|
|
}
|
|
|
|
|
2011-10-27 23:34:16 -05:00
|
|
|
/*
|
|
|
|
Function: foldr
|
|
|
|
|
|
|
|
Reduce a vector from right to left
|
|
|
|
*/
|
|
|
|
fn foldr<T, U>(p: block(T, U) -> U, z: U, v: [mutable? T]) -> U {
|
|
|
|
let accum = z;
|
|
|
|
riter(v) { |elt|
|
|
|
|
accum = p(elt, accum);
|
|
|
|
}
|
|
|
|
ret accum;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: any
|
|
|
|
|
|
|
|
Return true if a predicate matches any elements
|
|
|
|
|
|
|
|
If the vector contains no elements then false is returned.
|
|
|
|
*/
|
2011-09-12 04:27:30 -05:00
|
|
|
fn any<T>(f: block(T) -> bool, v: [T]) -> bool {
|
2011-08-15 23:54:52 -05:00
|
|
|
for elem: T in v { if f(elem) { ret true; } }
|
2011-07-05 01:52:47 -05:00
|
|
|
ret false;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: all
|
|
|
|
|
|
|
|
Return true if a predicate matches all elements
|
|
|
|
|
|
|
|
If the vector contains no elements then true is returned.
|
|
|
|
*/
|
2011-09-12 04:27:30 -05:00
|
|
|
fn all<T>(f: block(T) -> bool, v: [T]) -> bool {
|
2011-08-15 23:54:52 -05:00
|
|
|
for elem: T in v { if !f(elem) { ret false; } }
|
2011-07-05 01:52:47 -05:00
|
|
|
ret true;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: member
|
|
|
|
|
|
|
|
Return true if a vector contains an element with the given value
|
|
|
|
*/
|
2011-09-12 04:27:30 -05:00
|
|
|
fn member<T>(x: T, v: [T]) -> bool {
|
2011-08-15 23:54:52 -05:00
|
|
|
for elt: T in v { if x == elt { ret true; } }
|
2011-07-08 09:27:55 -05:00
|
|
|
ret false;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: count
|
|
|
|
|
|
|
|
Returns the number of elements that are equal to a given value
|
|
|
|
*/
|
2011-09-12 04:27:30 -05:00
|
|
|
fn count<T>(x: T, v: [mutable? T]) -> uint {
|
2011-07-27 07:19:39 -05:00
|
|
|
let cnt = 0u;
|
2011-08-15 23:54:52 -05:00
|
|
|
for elt: T in v { if x == elt { cnt += 1u; } }
|
2011-07-12 19:00:25 -05:00
|
|
|
ret cnt;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: find
|
|
|
|
|
|
|
|
Search for an element that matches a given predicate
|
|
|
|
|
|
|
|
Apply function `f` to each element of `v`, starting from the first.
|
2011-10-26 13:28:23 -05:00
|
|
|
When function `f` returns true then an option containing the element
|
2011-10-24 17:25:41 -05:00
|
|
|
is returned. If `f` matches no elements then none is returned.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn find<T>(f: block(T) -> bool, v: [T]) -> option::t<T> {
|
2011-08-15 23:54:52 -05:00
|
|
|
for elt: T in v { if f(elt) { ret some(elt); } }
|
2011-08-12 13:47:44 -05:00
|
|
|
ret none;
|
2011-07-08 09:27:55 -05:00
|
|
|
}
|
2011-07-05 00:48:42 -05:00
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: position
|
|
|
|
|
|
|
|
Find the first index containing a matching value
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
|
|
|
|
option::some(uint) - The first index containing a matching value
|
|
|
|
option::none - No elements matched
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn position<T>(x: T, v: [T]) -> option::t<uint> {
|
2011-08-11 23:00:11 -05:00
|
|
|
let i: uint = 0u;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < len(v) { if x == v[i] { ret some::<uint>(i); } i += 1u; }
|
2011-08-12 12:56:57 -05:00
|
|
|
ret none;
|
2011-08-11 23:00:11 -05:00
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: position_pred
|
|
|
|
|
|
|
|
Find the first index for which the value matches some predicate
|
|
|
|
*/
|
2011-10-27 18:27:47 -05:00
|
|
|
fn position_pred<T>(f: block(T) -> bool, v: [T]) -> option::t<uint> {
|
2011-08-11 23:00:11 -05:00
|
|
|
let i: uint = 0u;
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < len(v) { if f(v[i]) { ret some::<uint>(i); } i += 1u; }
|
2011-08-12 12:56:57 -05:00
|
|
|
ret none;
|
2011-08-11 23:00:11 -05:00
|
|
|
}
|
|
|
|
|
2011-08-30 18:22:21 -05:00
|
|
|
// FIXME: if issue #586 gets implemented, could have a postcondition
|
|
|
|
// saying the two result lists have the same length -- or, could
|
|
|
|
// return a nominal record with a constraint saying that, instead of
|
|
|
|
// returning a tuple (contingent on issue #869)
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: unzip
|
|
|
|
|
|
|
|
Convert a vector of pairs into a pair of vectors
|
|
|
|
|
|
|
|
Returns a tuple containing two vectors where the i-th element of the first
|
|
|
|
vector contains the first element of the i-th tuple of the input vector,
|
|
|
|
and the i-th element of the second vector contains the second element
|
|
|
|
of the i-th tuple of the input vector.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn unzip<T, U>(v: [(T, U)]) -> ([T], [U]) {
|
2011-08-19 17:16:48 -05:00
|
|
|
let as = [], bs = [];
|
|
|
|
for (a, b) in v { as += [a]; bs += [b]; }
|
2011-08-15 07:32:58 -05:00
|
|
|
ret (as, bs);
|
2011-07-16 19:35:20 -05:00
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: zip
|
|
|
|
|
|
|
|
Convert two vectors to a vector of pairs
|
|
|
|
|
|
|
|
Returns a vector of tuples, where the i-th tuple contains contains the
|
|
|
|
i-th elements from each of the input vectors.
|
|
|
|
|
|
|
|
Preconditions:
|
|
|
|
|
|
|
|
<same_length> (v, u)
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn zip<T, U>(v: [T], u: [U]) : same_length(v, u) -> [(T, U)] {
|
2011-08-19 17:16:48 -05:00
|
|
|
let zipped = [];
|
2011-08-15 07:32:58 -05:00
|
|
|
let sz = len(v), i = 0u;
|
2011-07-26 07:06:02 -05:00
|
|
|
assert (sz == len(u));
|
2011-08-19 17:16:48 -05:00
|
|
|
while i < sz { zipped += [(v[i], u[i])]; i += 1u; }
|
2011-08-15 07:32:58 -05:00
|
|
|
ret zipped;
|
2011-07-16 19:35:20 -05:00
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: swap
|
|
|
|
|
|
|
|
Swaps two elements in a vector
|
|
|
|
|
|
|
|
Parameters:
|
|
|
|
v - The input vector
|
|
|
|
a - The index of the first element
|
|
|
|
b - The index of the second element
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn swap<T>(v: [mutable T], a: uint, b: uint) {
|
2011-08-19 17:16:48 -05:00
|
|
|
let t: T = v[a];
|
|
|
|
v[a] = v[b];
|
|
|
|
v[b] = t;
|
2011-08-11 23:07:09 -05:00
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: reverse
|
|
|
|
|
|
|
|
Reverse the order of elements in a vector, in place
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
fn reverse<T>(v: [mutable T]) {
|
2011-08-11 23:07:09 -05:00
|
|
|
let i: uint = 0u;
|
2011-08-12 12:56:57 -05:00
|
|
|
let ln = len::<T>(v);
|
2011-08-11 23:07:09 -05:00
|
|
|
while i < ln / 2u { swap(v, i, ln - i - 1u); i += 1u; }
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: reversed
|
|
|
|
|
|
|
|
Returns a vector with the order of elements reversed
|
|
|
|
*/
|
2011-10-27 19:49:13 -05:00
|
|
|
fn reversed<T>(v: [mutable? T]) -> [T] {
|
2011-08-19 17:16:48 -05:00
|
|
|
let rs: [T] = [];
|
2011-08-12 12:56:57 -05:00
|
|
|
let i = len::<T>(v);
|
2011-08-11 23:07:09 -05:00
|
|
|
if i == 0u { ret rs; } else { i -= 1u; }
|
2011-08-19 17:16:48 -05:00
|
|
|
while i != 0u { rs += [v[i]]; i -= 1u; }
|
|
|
|
rs += [v[0]];
|
2011-08-11 23:07:09 -05:00
|
|
|
ret rs;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
// FIXME: Seems like this should take char params. Maybe belongs in char
|
|
|
|
/*
|
|
|
|
Function: enum_chars
|
|
|
|
|
|
|
|
Returns a vector containing a range of chars
|
|
|
|
*/
|
2011-09-02 17:34:58 -05:00
|
|
|
fn enum_chars(start: u8, end: u8) : u8::le(start, end) -> [char] {
|
2011-08-30 18:22:21 -05:00
|
|
|
let i = start;
|
|
|
|
let r = [];
|
2011-09-02 17:34:58 -05:00
|
|
|
while i <= end { r += [i as char]; i += 1u as u8; }
|
2011-08-30 18:22:21 -05:00
|
|
|
ret r;
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
// FIXME: Probably belongs in uint. Compare to uint::range
|
|
|
|
/*
|
|
|
|
Function: enum_uints
|
|
|
|
|
|
|
|
Returns a vector containing a range of uints
|
|
|
|
*/
|
2011-09-02 17:34:58 -05:00
|
|
|
fn enum_uints(start: uint, end: uint) : uint::le(start, end) -> [uint] {
|
2011-08-30 18:22:21 -05:00
|
|
|
let i = start;
|
|
|
|
let r = [];
|
2011-09-02 17:34:58 -05:00
|
|
|
while i <= end { r += [i]; i += 1u; }
|
2011-08-30 18:22:21 -05:00
|
|
|
ret r;
|
|
|
|
}
|
|
|
|
|
2011-10-27 22:29:13 -05:00
|
|
|
/*
|
|
|
|
Function: iter
|
|
|
|
|
|
|
|
Iterates over a vector
|
|
|
|
|
2011-10-27 22:50:10 -05:00
|
|
|
Iterates over vector `v` and, for each element, calls function `f` with the
|
|
|
|
element's value.
|
|
|
|
|
2011-10-27 22:29:13 -05:00
|
|
|
*/
|
2011-10-27 22:50:10 -05:00
|
|
|
fn iter<T>(v: [mutable? T], f: block(T)) {
|
|
|
|
iter2(v) { |_i, v| f(v) }
|
2011-10-27 22:29:13 -05:00
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: iter2
|
|
|
|
|
2011-10-27 22:50:10 -05:00
|
|
|
Iterates over a vector's elements and indexes
|
|
|
|
|
|
|
|
Iterates over vector `v` and, for each element, calls function `f` with the
|
|
|
|
element's value and index.
|
2011-10-24 17:25:41 -05:00
|
|
|
*/
|
2011-10-27 22:50:10 -05:00
|
|
|
fn iter2<T>(v: [mutable? T], f: block(uint, T)) {
|
2011-08-19 18:14:38 -05:00
|
|
|
let i = 0u;
|
2011-10-27 22:50:10 -05:00
|
|
|
for x in v { f(i, x); i += 1u; }
|
2011-08-19 18:14:38 -05:00
|
|
|
}
|
2011-08-11 23:07:09 -05:00
|
|
|
|
2011-10-27 23:09:02 -05:00
|
|
|
/*
|
|
|
|
Function: riter
|
|
|
|
|
|
|
|
Iterates over a vector in reverse
|
|
|
|
|
|
|
|
Iterates over vector `v` and, for each element, calls function `f` with the
|
|
|
|
element's value.
|
|
|
|
|
|
|
|
*/
|
|
|
|
fn riter<T>(v: [mutable? T], f: block(T)) {
|
|
|
|
riter2(v) { |_i, v| f(v) }
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Function: riter2
|
|
|
|
|
|
|
|
Iterates over a vector's elements and indexes in reverse
|
|
|
|
|
|
|
|
Iterates over vector `v` and, for each element, calls function `f` with the
|
|
|
|
element's value and index.
|
|
|
|
*/
|
|
|
|
fn riter2<T>(v: [mutable? T], f: block(uint, T)) {
|
|
|
|
let i = len(v);
|
|
|
|
while 0u < i {
|
|
|
|
i -= 1u;
|
|
|
|
f(i, v[i]);
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: to_ptr
|
|
|
|
|
|
|
|
FIXME: We don't need this wrapper
|
|
|
|
*/
|
|
|
|
unsafe fn to_ptr<T>(v: [T]) -> *T { ret unsafe::to_ptr(v); }
|
|
|
|
|
|
|
|
/*
|
|
|
|
Module: unsafe
|
|
|
|
*/
|
2011-06-16 19:06:24 -05:00
|
|
|
mod unsafe {
|
2011-09-02 17:34:58 -05:00
|
|
|
type vec_repr = {mutable fill: uint, mutable alloc: uint, data: u8};
|
2011-07-10 04:05:52 -05:00
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: from_buf
|
|
|
|
|
|
|
|
Constructs a vector from an unsafe pointer to a buffer
|
|
|
|
|
|
|
|
Parameters:
|
|
|
|
|
|
|
|
ptr - An unsafe pointer to a buffer of `T`
|
|
|
|
elts - The number of elements in the buffer
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
unsafe fn from_buf<T>(ptr: *T, elts: uint) -> [T] {
|
2011-10-23 09:21:14 -05:00
|
|
|
ret rustrt::vec_from_buf_shared(sys::get_type_desc::<T>(),
|
2011-10-17 23:15:50 -05:00
|
|
|
ptr, elts);
|
2011-07-10 04:05:52 -05:00
|
|
|
}
|
2011-07-11 19:26:34 -05:00
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: set_len
|
|
|
|
|
|
|
|
Sets the length of a vector
|
|
|
|
|
|
|
|
This well explicitly set the size of the vector, without actually
|
|
|
|
modifing its buffers, so it is up to the caller to ensure that
|
|
|
|
the vector is actually the specified size.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
unsafe fn set_len<T>(&v: [T], new_len: uint) {
|
2011-09-02 15:44:01 -05:00
|
|
|
let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v));
|
2011-08-25 03:18:02 -05:00
|
|
|
(**repr).fill = new_len * sys::size_of::<T>();
|
2011-07-11 19:26:34 -05:00
|
|
|
}
|
2011-08-25 03:18:02 -05:00
|
|
|
|
2011-10-24 17:25:41 -05:00
|
|
|
/*
|
|
|
|
Function: to_ptr
|
|
|
|
|
|
|
|
Returns an unsafe pointer to the vector's buffer
|
|
|
|
|
|
|
|
The caller must ensure that the vector outlives the pointer this
|
|
|
|
function returns, or else it will end up pointing to garbage.
|
|
|
|
|
|
|
|
Modifying the vector may cause its buffer to be reallocated, which
|
|
|
|
would also make any pointers to it invalid.
|
|
|
|
*/
|
2011-10-25 08:56:55 -05:00
|
|
|
unsafe fn to_ptr<T>(v: [T]) -> *T {
|
2011-09-02 15:44:01 -05:00
|
|
|
let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v));
|
2011-08-25 03:18:02 -05:00
|
|
|
ret ::unsafe::reinterpret_cast(addr_of((**repr).data));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-14 17:32:37 -05:00
|
|
|
// Local Variables:
|
|
|
|
// mode: rust;
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
2011-07-29 20:38:22 -05:00
|
|
|
// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
|
2011-07-14 17:32:37 -05:00
|
|
|
// End:
|