export ptr_eq;
-fn ptr_eq[T](a: &@T, b: &@T) -> bool {
+fn ptr_eq<T>(a: &@T, b: &@T) -> bool {
let a_ptr: uint = unsafe::reinterpret_cast(a);
let b_ptr: uint = unsafe::reinterpret_cast(b);
ret a_ptr == b_ptr;
-}
\ No newline at end of file
+}
fn take_chan(ch : *rust_chan);
fn drop_chan(ch : *rust_chan);
fn chan_send(ch: *rust_chan, v : *void);
- fn chan_id_send[~T](target_task : task_id, target_port : port_id,
+ fn chan_id_send<~T>(target_task : task_id, target_port : port_id,
data : -T);
fn new_port(unit_sz : uint) -> *rust_port;
}
native "rust-intrinsic" mod rusti {
- fn recv[~T](port : *rustrt::rust_port) -> T;
+ fn recv<~T>(port : *rustrt::rust_port) -> T;
}
type port_id = int;
-type _chan[~T] = {
+type _chan<~T> = {
task : task_id,
port : port_id
};
rustrt::del_port(po);
}
-obj _port[~T](raw_port : @port_ptr) {
+obj _port<~T>(raw_port : @port_ptr) {
// FIXME: rename this to chan once chan is not a keyword.
- fn mk_chan() -> _chan[T] {
+ fn mk_chan() -> _chan<T> {
{
task: task::get_task_id(),
port: rustrt::get_port_id(**raw_port)
}
}
-fn mk_port[~T]() -> _port<T> {
+fn mk_port<~T>() -> _port<T> {
_port(@port_ptr(rustrt::new_port(sys::size_of[T]())))
}
-fn send[~T](ch : _chan[T], data : -T) {
+fn send<~T>(ch : _chan<T>, data : -T) {
rustrt::chan_id_send(ch.task, ch.port, data);
}
const const_refcount: uint = 0x7bad_face_u;
native "rust" mod rustrt {
- fn debug_tydesc[T]();
- fn debug_opaque[T](x: &T);
- fn debug_box[T](x: @T);
- fn debug_tag[T](x: &T);
- fn debug_obj[T](x: &T, nmethods: uint, nbytes: uint);
- fn debug_fn[T](x: &T);
- fn debug_ptrcast[T, U](x: @T) -> @U;
+ fn debug_tydesc<T>();
+ fn debug_opaque<T>(x: &T);
+ fn debug_box<T>(x: @T);
+ fn debug_tag<T>(x: &T);
+ fn debug_obj<T>(x: &T, nmethods: uint, nbytes: uint);
+ fn debug_fn<T>(x: &T);
+ fn debug_ptrcast<T, U>(x: @T) -> @U;
fn debug_trap(msg: str);
}
fn debug_tydesc[T]() { rustrt::debug_tydesc[T](); }
-fn debug_opaque[T](x: &T) { rustrt::debug_opaque[T](x); }
+fn debug_opaque<T>(x: &T) { rustrt::debug_opaque[T](x); }
-fn debug_box[T](x: @T) { rustrt::debug_box[T](x); }
+fn debug_box<T>(x: @T) { rustrt::debug_box[T](x); }
-fn debug_tag[T](x: &T) { rustrt::debug_tag[T](x); }
+fn debug_tag<T>(x: &T) { rustrt::debug_tag[T](x); }
/**
* this to at least be 4u, since an implicit captured tydesc pointer sits in
* the front of any obj's data tuple.x
*/
-fn debug_obj[T](x: &T, nmethods: uint, nbytes: uint) {
+fn debug_obj<T>(x: &T, nmethods: uint, nbytes: uint) {
rustrt::debug_obj[T](x, nmethods, nbytes);
}
-fn debug_fn[T](x: &T) { rustrt::debug_fn[T](x); }
+fn debug_fn<T>(x: &T) { rustrt::debug_fn[T](x); }
-fn ptr_cast[T, U](x: @T) -> @U { ret rustrt::debug_ptrcast[T, U](x); }
+fn ptr_cast<T, U>(x: @T) -> @U { ret rustrt::debug_ptrcast[T, U](x); }
fn trap(s: str) { rustrt::debug_trap(s); }
// Local Variables:
/**
* A deque, for fun. Untested as of yet. Likely buggy.
*/
-type t[T] =
+type t<T> =
obj {
fn size() -> uint ;
fn add_front(&T) ;
fn get(int) -> T ;
};
-fn create[@T]() -> t<T> {
- type cell[T] = option::t<T>;
+fn create<@T>() -> t<T> {
+ type cell<T> = option::t<T>;
let initial_capacity: uint = 32u; // 2^5
/**
*/
- fn grow[@T](nelts: uint, lo: uint, elts: &[mutable cell<T>]) ->
+ fn grow<@T>(nelts: uint, lo: uint, elts: &[mutable cell<T>]) ->
[mutable cell<T>] {
assert (nelts == vec::len(elts));
let rv = ~[mutable];
ret rv;
}
- fn get[@T](elts: &[mutable cell<T>], i: uint) -> T {
+ fn get<@T>(elts: &[mutable cell<T>], i: uint) -> T {
ret alt elts.(i) { option::some(t) { t } _ { fail } };
}
- obj deque[@T](mutable nelts: uint,
+ obj deque<@T>(mutable nelts: uint,
mutable lo: uint,
mutable hi: uint,
mutable elts: [mutable cell<T>]) {
import option::some;
import option::none;
-tag t[T, U] { left(T); right(U); }
+tag t<T, U> { left(T); right(U); }
-fn either[T, U, V](f_left: &block(&T) -> V, f_right: &block(&U) -> V,
+fn either<T, U, V>(f_left: &block(&T) -> V, f_right: &block(&U) -> V,
value: &t<T, U>) -> V {
alt value { left(l) { f_left(l) } right(r) { f_right(r) } }
}
-fn lefts[T, U](eithers: &[t<T, U>]) -> [T] {
+fn lefts<T, U>(eithers: &[t<T, U>]) -> [T] {
let result: [T] = ~[];
for elt: t<T, U> in eithers {
alt elt { left(l) { result += ~[l] } _ {/* fallthrough */ } }
ret result;
}
-fn rights[T, U](eithers: &[t<T, U>]) -> [U] {
+fn rights<T, U>(eithers: &[t<T, U>]) -> [U] {
let result: [U] = ~[];
for elt: t<T, U> in eithers {
alt elt { right(r) { result += ~[r] } _ {/* fallthrough */ } }
ret result;
}
-fn partition[T, U](eithers: &[t<T, U>]) -> {lefts: [T], rights: [U]} {
+fn partition<T, U>(eithers: &[t<T, U>]) -> {lefts: [T], rights: [U]} {
let lefts: [T] = ~[];
let rights: [U] = ~[];
for elt: t<T, U> in eithers {
import option::some;
import option::none;
-tag list[T] { cons(T, @list<T>); nil; }
+tag list<T> { cons(T, @list<T>); nil; }
-fn from_vec[@T](v: &[T]) -> list<T> {
+fn from_vec<@T>(v: &[T]) -> list<T> {
let l = nil[T];
// FIXME: This would be faster and more space efficient if it looped over
// a reverse vector iterator. Unfortunately generic iterators seem not to
ret l;
}
-fn foldl[@T, @U](ls_: &list<T>, u: &U, f: &block(&T, &U) -> U ) -> U {
+fn foldl<@T, @U>(ls_: &list<T>, u: &U, f: &block(&T, &U) -> U ) -> U {
let accum: U = u;
let ls = ls_;
while true {
ret accum;
}
-fn find[@T, @U](ls_: &list<T>, f: &block(&T) -> option::t<U>)
+fn find<@T, @U>(ls_: &list<T>, f: &block(&T) -> option::t<U>)
-> option::t<U> {
let ls = ls_;
while true {
ret none;
}
-fn has[@T](ls_: &list<T>, elt: &T) -> bool {
+fn has<@T>(ls_: &list<T>, elt: &T) -> bool {
let ls = ls_;
while true {
alt ls {
ret false;
}
-fn length[@T](ls: &list<T>) -> uint {
- fn count[T](t: &T, u: &uint) -> uint { ret u + 1u; }
+fn length<@T>(ls: &list<T>) -> uint {
+ fn count<T>(t: &T, u: &uint) -> uint { ret u + 1u; }
ret foldl(ls, 0u, count);
}
-fn cdr[@T](ls: &list<T>) -> list<T> {
+fn cdr<@T>(ls: &list<T>) -> list<T> {
alt ls {
cons(_, tl) { ret *tl; }
nil. { fail "list empty" }
}
}
-fn car[@T](ls: &list<T>) -> T {
+fn car<@T>(ls: &list<T>) -> T {
alt ls {
cons(hd, _) { ret hd; }
nil. { fail "list empty" }
}
}
-fn append[@T](l: &list<T>, m: &list<T>) -> list<T> {
+fn append<@T>(l: &list<T>, m: &list<T>) -> list<T> {
alt l {
nil. { ret m; }
cons(x, xs) {
/**
* Hashmap implementation.
*/
-type hashfn[K] = fn(&K) -> uint ;
+type hashfn<K> = fn(&K) -> uint ;
-type eqfn[K] = fn(&K, &K) -> bool ;
+type eqfn<K> = fn(&K, &K) -> bool ;
-type hashmap[K, V] =
+type hashmap<K, V> =
obj {
fn size() -> uint ;
fn insert(&K, &V) -> bool ;
iter items() -> @{key: K, val: V} ;
iter keys() -> K ;
};
-type hashset[K] = hashmap<K, ()>;
+type hashset<K> = hashmap<K, ()>;
-fn set_add[@K](set: hashset<K>, key: &K) -> bool { ret set.insert(key, ()); }
+fn set_add<@K>(set: hashset<K>, key: &K) -> bool { ret set.insert(key, ()); }
-fn mk_hashmap[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
+fn mk_hashmap<@K, @V>(hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
let initial_capacity: uint = 32u; // 2^5
let load_factor: util::rational = {num: 3, den: 4};
- tag bucket[@K, @V] { nil; deleted; some(K, V); }
- fn make_buckets[@K, @V](nbkts: uint) -> [mutable (bucket<K, V>)] {
+ tag bucket<@K, @V> { nil; deleted; some(K, V); }
+ fn make_buckets<@K, @V>(nbkts: uint) -> [mutable (bucket<K, V>)] {
ret vec::init_elt_mut[bucket<K, V>](nil[K, V], nbkts);
}
// Derive two hash functions from the one given by taking the upper
* will fail.
*/
- fn insert_common[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>,
+ fn insert_common<@K, @V>(hasher: &hashfn<K>, eqer: &eqfn<K>,
bkts: &[mutable bucket<K, V>], nbkts: uint,
key: &K, val: &V) -> bool {
let i: uint = 0u;
}
fail; // full table
}
- fn find_common[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>,
+ fn find_common<@K, @V>(hasher: &hashfn<K>, eqer: &eqfn<K>,
bkts: &[mutable bucket<K, V>], nbkts: uint,
key: &K) -> option::t<V> {
let i: uint = 0u;
}
ret option::none;
}
- fn rehash[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>,
+ fn rehash<@K, @V>(hasher: &hashfn<K>, eqer: &eqfn<K>,
oldbkts: &[mutable bucket<K, V>], noldbkts: uint,
newbkts: &[mutable bucket<K, V>], nnewbkts: uint) {
for b: bucket<K, V> in oldbkts {
}
}
}
- obj hashmap[@K, @V](hasher: hashfn<K>,
+ obj hashmap<@K, @V>(hasher: hashfn<K>,
eqer: eqfn<K>,
mutable bkts: [mutable bucket<K, V>],
mutable nbkts: uint,
// Hash map constructors for basic types
-fn new_str_hash[@V]() -> hashmap<str, V> {
+fn new_str_hash<@V>() -> hashmap<str, V> {
ret mk_hashmap(str::hash, str::eq);
}
-fn new_int_hash[@V]() -> hashmap<int, V> {
+fn new_int_hash<@V>() -> hashmap<int, V> {
fn hash_int(x: &int) -> uint { ret x as uint; }
fn eq_int(a: &int, b: &int) -> bool { ret a == b; }
ret mk_hashmap(hash_int, eq_int);
}
-fn new_uint_hash[@V]() -> hashmap<uint, V> {
+fn new_uint_hash<@V>() -> hashmap<uint, V> {
fn hash_uint(x: &uint) -> uint { ret x; }
fn eq_uint(a: &uint, b: &uint) -> bool { ret a == b; }
ret mk_hashmap(hash_uint, eq_uint);
// lib/option::rs
-tag t[@T] { none; some(T); }
+tag t<@T> { none; some(T); }
-fn get[@T](opt: &t<T>) -> T {
+fn get<@T>(opt: &t<T>) -> T {
alt opt {
some(x) { x }
none. { fail "option none" }
}
}
-fn map[@T, @U](f: &block(&T) -> U, opt: &t<T>) -> t<U> {
+fn map<@T, @U>(f: &block(&T) -> U, opt: &t<T>) -> t<U> {
alt opt { some(x) { some(f(x)) } none. { none } }
}
-fn is_none[@T](opt: &t<T>) -> bool {
+fn is_none<@T>(opt: &t<T>) -> bool {
alt opt { none. { true } some(_) { false } }
}
-fn is_some[@T](opt: &t<T>) -> bool { !is_none(opt) }
+fn is_some<@T>(opt: &t<T>) -> bool { !is_none(opt) }
-fn from_maybe[@T](def: &T, opt: &t<T>) -> T {
+fn from_maybe<@T>(def: &T, opt: &t<T>) -> T {
alt opt { some(x) { x } none. { def } }
}
-fn maybe[@T, @U](def: &U, f: &block(&T) -> U, opt: &t<T>) -> U {
+fn maybe<@T, @U>(def: &U, f: &block(&T) -> U, opt: &t<T>) -> U {
alt opt { none. { def } some(t) { f(t) } }
}
// Can be defined in terms of the above when/if we have const bind.
-fn may[@T](f: &block(&T), opt: &t<T>) {
+fn may<@T>(f: &block(&T), opt: &t<T>) {
alt opt { none. {/* nothing */ } some(t) { f(t); } }
}
// Unsafe pointer utility functions.
native "rust-intrinsic" mod rusti {
- fn addr_of[T](val: &T) -> *mutable T;
- fn ptr_offset[T](ptr: *T, count: uint) -> *T;
+ fn addr_of<T>(val: &T) -> *mutable T;
+ fn ptr_offset<T>(ptr: *T, count: uint) -> *T;
}
-fn addr_of[T](val: &T) -> *mutable T { ret rusti::addr_of(val); }
-fn offset[T](ptr: *T, count: uint) -> *T {
+fn addr_of<T>(val: &T) -> *mutable T { ret rusti::addr_of(val); }
+fn offset<T>(ptr: *T, count: uint) -> *T {
ret rusti::ptr_offset(ptr, count);
}
// FIXME: Should not be @; there's a bug somewhere in rustc that requires this
// to be.
-type smallintmap[T] = @{mutable v: [mutable option::t<T>]};
+type smallintmap<T> = @{mutable v: [mutable option::t<T>]};
-fn mk[@T]() -> smallintmap<T> {
+fn mk<@T>() -> smallintmap<T> {
let v: [mutable option::t<T>] = ~[mutable];
ret @{mutable v: v};
}
-fn insert[@T](m: &smallintmap<T>, key: uint, val: &T) {
+fn insert<@T>(m: &smallintmap<T>, key: uint, val: &T) {
vec::grow_set[option::t<T>](m.v, key, none[T], some[T](val));
}
-fn find[@T](m: &smallintmap<T>, key: uint) -> option::t<T> {
+fn find<@T>(m: &smallintmap<T>, key: uint) -> option::t<T> {
if key < vec::len[option::t<T>](m.v) { ret m.v.(key); }
ret none[T];
}
-fn get[@T](m: &smallintmap<T>, key: uint) -> T {
+fn get<@T>(m: &smallintmap<T>, key: uint) -> T {
alt find[T](m, key) {
none[T]. { log_err "smallintmap::get(): key not present"; fail; }
some[T](v) { ret v; }
}
}
-fn contains_key[@T](m: &smallintmap<T>, key: uint) -> bool {
+fn contains_key<@T>(m: &smallintmap<T>, key: uint) -> bool {
ret !option::is_none(find[T](m, key));
}
-fn truncate[@T](m: &smallintmap<T>, len: uint) {
+fn truncate<@T>(m: &smallintmap<T>, len: uint) {
m.v = vec::slice_mut[option::t<T>](m.v, 0u, len);
}
-fn max_key[T](m: &smallintmap<T>) -> uint {
+fn max_key<T>(m: &smallintmap<T>) -> uint {
ret vec::len[option::t<T>](m.v);
}
export quick_sort;
export quick_sort3;
-type lteq[T] = block(&T, &T) -> bool ;
+type lteq<T> = block(&T, &T) -> bool ;
-fn merge_sort[@T](le: <eq<T>, v: &[T]) -> [T] {
- fn merge[@T](le: <eq<T>, a: &[T], b: &[T]) -> [T] {
+fn merge_sort<@T>(le: <eq<T>, v: &[T]) -> [T] {
+ fn merge<@T>(le: <eq<T>, a: &[T], b: &[T]) -> [T] {
let rs: [T] = ~[];
let a_len: uint = len[T](a);
let a_ix: uint = 0u;
ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b));
}
-fn swap[@T](arr: &[mutable T], x: uint, y: uint) {
+fn swap<@T>(arr: &[mutable T], x: uint, y: uint) {
let a = arr.(x);
arr.(x) = arr.(y);
arr.(y) = a;
}
-fn part[@T](compare_func: <eq<T>, arr: &[mutable T], left: uint,
+fn part<@T>(compare_func: <eq<T>, arr: &[mutable T], left: uint,
right: uint, pivot: uint) -> uint {
let pivot_value = arr.(pivot);
swap[T](arr, pivot, right);
ret storage_index;
}
-fn qsort[@T](compare_func: <eq<T>, arr: &[mutable T], left: uint,
+fn qsort<@T>(compare_func: <eq<T>, arr: &[mutable T], left: uint,
right: uint) {
if right > left {
let pivot = (left + right) / 2u;
}
}
-fn quick_sort[@T](compare_func: <eq<T>, arr: &[mutable T]) {
+fn quick_sort<@T>(compare_func: <eq<T>, arr: &[mutable T]) {
if len[T](arr) == 0u { ret; }
qsort[T](compare_func, arr, 0u, len[T](arr) - 1u);
}
// http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf
// According to these slides this is the algorithm of choice for
// 'randomly ordered keys, abstract compare' & 'small number of key values'
-fn qsort3[@T](compare_func_lt: <eq<T>, compare_func_eq: <eq<T>,
+fn qsort3<@T>(compare_func_lt: <eq<T>, compare_func_eq: <eq<T>,
arr: &[mutable T], left: int, right: int) {
if right <= left { ret; }
let v: T = arr.(right);
qsort3[T](compare_func_lt, compare_func_eq, arr, i, right);
}
-fn quick_sort3[@T](compare_func_lt: <eq<T>, compare_func_eq: <eq<T>,
+fn quick_sort3<@T>(compare_func_lt: <eq<T>, compare_func_eq: <eq<T>,
arr: &[mutable T]) {
if len[T](arr) == 0u { ret; }
qsort3[T](compare_func_lt, compare_func_eq, arr, 0,
fn str_from_buf(buf: sbuf, len: uint) -> str;
fn str_push_byte(s: str, byte: uint) -> str;
fn str_slice(s: str, begin: uint, end: uint) -> str;
- fn refcount[T](s: str) -> uint;
+ fn refcount<T>(s: str) -> uint;
}
fn eq(a: &str, b: &str) -> bool {
// available outside this crate. Otherwise it's
// visible-in-crate, but not re-exported.
fn last_os_error() -> str;
- fn size_of[T]() -> uint;
- fn align_of[T]() -> uint;
- fn refcount[T](t: @T) -> uint;
+ fn size_of<T>() -> uint;
+ fn align_of<T>() -> uint;
+ fn refcount<T>(t: @T) -> uint;
fn do_gc();
fn unsupervise();
}
fn migrate_alloc(alloc : *u8, target : task_id);
- fn leak[@T](thing : -T);
+ fn leak<@T>(thing : -T);
}
type task_id = int;
// Unsafe operations.
native "rust-intrinsic" mod rusti {
- fn cast[T, U](src: &T) -> U;
+ fn cast<T, U>(src: &T) -> U;
}
// Casts the value at `src` to U. The two types must have the same length.
-fn reinterpret_cast[T, U](src: &T) -> U { ret rusti::cast(src); }
+fn reinterpret_cast<T, U>(src: &T) -> U { ret rusti::cast(src); }
-fn id[T](x: &T) -> T { ret x; }
+fn id<T>(x: &T) -> T { ret x; }
/* FIXME (issue #141): See test/run-pass/constrained-type.rs. Uncomment
import ptr::addr_of;
native "rust-intrinsic" mod rusti {
- fn ivec_len[T](v: &[T]) -> uint;
+ fn ivec_len<T>(v: &[T]) -> uint;
}
native "rust" mod rustrt {
- fn ivec_reserve_shared[T](v: &mutable [mutable? T], n: uint);
- fn ivec_on_heap[T](v: &[T]) -> uint;
- fn ivec_to_ptr[T](v: &[T]) -> *T;
- fn ivec_copy_from_buf_shared[T](v: &mutable [mutable? T], ptr: *T,
+ fn ivec_reserve_shared<T>(v: &mutable [mutable? T], n: uint);
+ fn ivec_on_heap<T>(v: &[T]) -> uint;
+ fn ivec_to_ptr<T>(v: &[T]) -> *T;
+ fn ivec_copy_from_buf_shared<T>(v: &mutable [mutable? T], ptr: *T,
count: uint);
}
-fn from_vec[@T](v: &vec<mutable? T>) -> [T] {
+fn from_vec<@T>(v: &vec<mutable? T>) -> [T] {
let iv = ~[];
for e in v {
iv += ~[e];
}
/// Reserves space for `n` elements in the given vector.
-fn reserve[@T](v: &mutable [mutable? T], n: uint) {
+fn reserve<@T>(v: &mutable [mutable? T], n: uint) {
rustrt::ivec_reserve_shared(v, n);
}
-fn on_heap[T](v: &[T]) -> bool { ret rustrt::ivec_on_heap(v) != 0u; }
+fn on_heap<T>(v: &[T]) -> bool { ret rustrt::ivec_on_heap(v) != 0u; }
-fn to_ptr[T](v: &[T]) -> *T { ret rustrt::ivec_to_ptr(v); }
+fn to_ptr<T>(v: &[T]) -> *T { ret rustrt::ivec_to_ptr(v); }
-fn len[T](v: &[mutable? T]) -> uint { ret rusti::ivec_len(v); }
+fn len<T>(v: &[mutable? T]) -> uint { ret rusti::ivec_len(v); }
-type init_op[T] = fn(uint) -> T ;
+type init_op<T> = fn(uint) -> T ;
-fn init_fn[@T](op: &init_op<T>, n_elts: uint) -> [T] {
+fn init_fn<@T>(op: &init_op<T>, n_elts: uint) -> [T] {
let v = ~[];
reserve(v, n_elts);
let i: uint = 0u;
}
// TODO: Remove me once we have slots.
-fn init_fn_mut[@T](op: &init_op<T>, n_elts: uint) -> [mutable T] {
+fn init_fn_mut<@T>(op: &init_op<T>, n_elts: uint) -> [mutable T] {
let v = ~[mutable];
reserve(v, n_elts);
let i: uint = 0u;
ret v;
}
-fn init_elt[@T](t: &T, n_elts: uint) -> [T] {
+fn init_elt<@T>(t: &T, n_elts: uint) -> [T] {
let v = ~[];
reserve(v, n_elts);
let i: uint = 0u;
}
// TODO: Remove me once we have slots.
-fn init_elt_mut[@T](t: &T, n_elts: uint) -> [mutable T] {
+fn init_elt_mut<@T>(t: &T, n_elts: uint) -> [mutable T] {
let v = ~[mutable];
reserve(v, n_elts);
let i: uint = 0u;
ret v;
}
-fn to_mut[@T](v: &[T]) -> [mutable T] {
+fn to_mut<@T>(v: &[T]) -> [mutable T] {
let vres = ~[mutable];
for t: T in v { vres += ~[mutable t]; }
ret vres;
}
-fn from_mut[@T](v: &[mutable T]) -> [T] {
+fn from_mut<@T>(v: &[mutable T]) -> [T] {
let vres = ~[];
for t: T in v { vres += ~[t]; }
ret vres;
}
// Predicates
-pred is_empty[T](v: &[mutable? T]) -> bool {
+pred 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;
}
-pred is_not_empty[T](v: &[mutable? T]) -> bool { ret !is_empty(v); }
+pred is_not_empty<T>(v: &[mutable? T]) -> bool { ret !is_empty(v); }
// Accessors
/// Returns the first element of a vector
-fn head[@T](v: &[mutable? T]) : is_not_empty(v) -> T { ret v.(0); }
+fn head<@T>(v: &[mutable? T]) : is_not_empty(v) -> T { ret v.(0); }
/// Returns all but the first element of a vector
-fn tail[@T](v: &[mutable? T]) : is_not_empty(v) -> [mutable? T] {
+fn tail<@T>(v: &[mutable? T]) : is_not_empty(v) -> [mutable? T] {
ret slice(v, 1u, len(v));
}
/// Returns the last element of `v`.
-fn last[@T](v: &[mutable? T]) -> option::t<T> {
+fn last<@T>(v: &[mutable? T]) -> option::t<T> {
if len(v) == 0u { ret none; }
ret some(v.(len(v) - 1u));
}
/// Returns a copy of the elements from [`start`..`end`) from `v`.
-fn slice[@T](v: &[mutable? T], start: uint, end: uint) -> [T] {
+fn slice<@T>(v: &[mutable? T], start: uint, end: uint) -> [T] {
assert (start <= end);
assert (end <= len(v));
let result = ~[];
}
// TODO: Remove me once we have slots.
-fn slice_mut[@T](v: &[mutable? T], start: uint, end: uint) -> [mutable T] {
+fn slice_mut<@T>(v: &[mutable? T], start: uint, end: uint) -> [mutable T] {
assert (start <= end);
assert (end <= len(v));
let result = ~[mutable];
// Mutators
-fn shift[@T](v: &mutable [mutable? T]) -> T {
+fn shift<@T>(v: &mutable [mutable? T]) -> T {
let ln = len[T](v);
assert (ln > 0u);
let e = v.(0);
}
// TODO: Write this, unsafely, in a way that's not O(n).
-fn pop[@T](v: &mutable [mutable? T]) -> T {
+fn pop<@T>(v: &mutable [mutable? T]) -> T {
let ln = len(v);
assert (ln > 0u);
ln -= 1u;
// Appending
/// Expands the given vector in-place by appending `n` copies of `initval`.
-fn grow[@T](v: &mutable [T], n: uint, initval: &T) {
+fn grow<@T>(v: &mutable [T], n: uint, initval: &T) {
reserve(v, next_power_of_two(len(v) + n));
let i: uint = 0u;
while i < n { v += ~[initval]; i += 1u; }
}
// TODO: Remove me once we have slots.
-fn grow_mut[@T](v: &mutable [mutable T], n: uint, initval: &T) {
+fn grow_mut<@T>(v: &mutable [mutable T], n: uint, initval: &T) {
reserve(v, next_power_of_two(len(v) + n));
let i: uint = 0u;
while i < n { v += ~[mutable initval]; i += 1u; }
/// Calls `f` `n` times and appends the results of these calls to the given
/// vector.
-fn grow_fn[@T](v: &mutable [T], n: uint, init_fn: fn(uint) -> T ) {
+fn grow_fn<@T>(v: &mutable [T], n: uint, init_fn: fn(uint) -> T ) {
reserve(v, next_power_of_two(len(v) + n));
let i: uint = 0u;
while i < n { v += ~[init_fn(i)]; i += 1u; }
/// 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.
-fn grow_set[@T](v: &mutable [mutable T], index: uint, initval: &T, val: &T) {
+fn grow_set<@T>(v: &mutable [mutable T], index: uint, initval: &T, val: &T) {
if index >= len(v) { grow_mut(v, index - len(v) + 1u, initval); }
v.(index) = val;
}
// Functional utilities
-fn map[@T, @U](f: &block(&T) -> U , v: &[mutable? T]) -> [U] {
+fn map<@T, @U>(f: &block(&T) -> U , v: &[mutable? T]) -> [U] {
let result = ~[];
reserve(result, len(v));
for elem: T in v {
ret result;
}
-fn map2[@T, @U, @V](f: &block(&T, &U) -> V, v0: &[T], v1: &[U])
+fn map2<@T, @U, @V>(f: &block(&T, &U) -> V, v0: &[T], v1: &[U])
-> [V] {
let v0_len = len[T](v0);
if v0_len != len[U](v1) { fail; }
ret u;
}
-fn filter_map[@T, @U](f: &block(&T) -> option::t<U>,
+fn filter_map<@T, @U>(f: &block(&T) -> option::t<U>,
v: &[mutable? T]) -> [U] {
let result = ~[];
for elem: T in v {
ret result;
}
-fn foldl[@T, @U](p: &block(&U, &T) -> U , z: &U, v: &[mutable? T]) -> U {
+fn foldl<@T, @U>(p: &block(&U, &T) -> U , z: &U, v: &[mutable? T]) -> U {
let sz = len(v);
if sz == 0u { ret z; }
let first = v.(0);
ret p(foldl(p, z, rest), first);
}
-fn any[T](f: &block(&T) -> bool , v: &[T]) -> bool {
+fn any<T>(f: &block(&T) -> bool, v: &[T]) -> bool {
for elem: T in v { if f(elem) { ret true; } }
ret false;
}
-fn all[T](f: &block(&T) -> bool , v: &[T]) -> bool {
+fn all<T>(f: &block(&T) -> bool, v: &[T]) -> bool {
for elem: T in v { if !f(elem) { ret false; } }
ret true;
}
-fn member[T](x: &T, v: &[T]) -> bool {
+fn member<T>(x: &T, v: &[T]) -> bool {
for elt: T in v { if x == elt { ret true; } }
ret false;
}
-fn count[T](x: &T, v: &[mutable? T]) -> uint {
+fn count<T>(x: &T, v: &[mutable? T]) -> uint {
let cnt = 0u;
for elt: T in v { if x == elt { cnt += 1u; } }
ret cnt;
}
-fn find[@T](f: &block(&T) -> bool, v: &[T]) -> option::t<T> {
+fn find<@T>(f: &block(&T) -> bool, v: &[T]) -> option::t<T> {
for elt: T in v { if f(elt) { ret some(elt); } }
ret none;
}
-fn position[@T](x: &T, v: &[T]) -> option::t<uint> {
+fn position<@T>(x: &T, v: &[T]) -> option::t<uint> {
let i: uint = 0u;
while i < len(v) { if x == v.(i) { ret some[uint](i); } i += 1u; }
ret none[uint];
}
-fn position_pred[T](f: fn(&T) -> bool, v: &[T]) -> option::t<uint> {
+fn position_pred<T>(f: fn(&T) -> bool, v: &[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];
}
-fn unzip[@T, @U](v: &[(T, U)]) -> ([T], [U]) {
+fn unzip<@T, @U>(v: &[(T, U)]) -> ([T], [U]) {
let as = ~[], bs = ~[];
for (a, b) in v {
as += ~[a];
}
// FIXME make the lengths being equal a constraint
-fn zip[@T, @U](v: &[T], u: &[U]) -> [(T, U)] {
+fn zip<@T, @U>(v: &[T], u: &[U]) -> [(T, U)] {
let zipped = ~[];
let sz = len(v), i = 0u;
assert (sz == len(u));
}
// Swaps two elements in a vector
-fn swap[@T](v: &[mutable T], a: uint, b: uint) {
+fn swap<@T>(v: &[mutable T], a: uint, b: uint) {
let t: T = v.(a);
v.(a) = v.(b);
v.(b) = t;
}
// In place vector reversal
-fn reverse[@T](v: &[mutable T]) {
+fn reverse<@T>(v: &[mutable T]) {
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: &[T]) -> [T] {
+fn reversed<@T>(v: &[T]) -> [T] {
let rs: [T] = ~[];
let i = len[T](v);
if i == 0u { ret rs; } else { i -= 1u; }
heap_part: *mutable ivec_heap_part};
type ivec_heap_part = {mutable fill: uint};
- fn copy_from_buf[T](v: &mutable [T], ptr: *T, count: uint) {
+ fn copy_from_buf<T>(v: &mutable [T], ptr: *T, count: uint) {
ret rustrt::ivec_copy_from_buf_shared(v, ptr, count);
}
- fn from_buf[T](ptr: *T, bytes: uint) -> [T] {
+ fn from_buf<T>(ptr: *T, bytes: uint) -> [T] {
let v = ~[];
copy_from_buf(v, ptr, bytes);
ret v;
}
- fn set_len[T](v: &mutable [T], new_len: uint) {
+ fn set_len<T>(v: &mutable [T], new_len: uint) {
let new_fill = new_len * sys::size_of[T]();
let stack_part: *mutable ivec_repr =
::unsafe::reinterpret_cast(addr_of(v));