mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Port the stdlib to the expr foo::<T> syntax.

Browse Source
This commit is contained in:
Erick Tryzelaar 2011-08-12 10:56:57 -07:00 committed by Graydon Hoare
parent 3520499544
commit d9327a61bb
20 changed files with 147 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/lib/aio.rs
View File

@ -78,8 +78,8 @@ fn new_client(client: client, evt: _chan<socket_event>) {
log "waiting for bytes";
let data: [u8] = reader.recv();
log "got some bytes";
log vec::len[u8](data);
if (vec::len[u8](data) == 0u) {
log vec::len::<u8>(data);
if (vec::len::<u8>(data) == 0u) {
log "got empty buffer, bailing";
break;
}
@ -145,7 +145,7 @@ fn request_task(c: _chan<ctx>) {
}
write(socket,v,status) {
rustrt::aio_writedata(socket,
vec::to_ptr[u8](v), vec::len[u8](v),
vec::to_ptr::<u8>(v), vec::len::<u8>(v),
status);
}
close_server(server,status) {

8
src/lib/bitv.rs
View File

@ -32,7 +32,7 @@ fn uint_bits() -> uint { ret 32u + (1u << 32u >> 27u); }
fn create(nbits: uint, init: bool) -> t {
let elt = if init { !0u } else { 0u };
let storage = vec::init_elt_mut[uint](elt, nbits / uint_bits() + 1u);
let storage = vec::init_elt_mut::<uint>(elt, nbits / uint_bits() + 1u);
ret @{storage: storage, nbits: nbits};
}
@ -69,7 +69,7 @@ fn assign(v0: &t, v1: t) -> bool {
}
fn clone(v: t) -> t {
let storage = vec::init_elt_mut[uint](0u, v.nbits / uint_bits() + 1u);
let storage = vec::init_elt_mut::<uint>(0u, v.nbits / uint_bits() + 1u);
let len = vec::len(v.storage);
for each i: uint in uint::range(0u, len) { storage.(i) = v.storage.(i); }
ret @{storage: storage, nbits: v.nbits};
@ -150,7 +150,7 @@ fn init_to_vec(v: t, i: uint) -> uint { ret if get(v, i) { 1u } else { 0u }; }
fn to_vec(v: &t) -> [uint] {
let sub = bind init_to_vec(v, _);
ret vec::init_fn[uint](sub, v.nbits);
ret vec::init_fn::<uint>(sub, v.nbits);
}
fn to_str(v: &t) -> str {
@ -162,7 +162,7 @@ fn to_str(v: &t) -> str {
}
fn eq_ivec(v0: &t, v1: &[uint]) -> bool {
assert (v0.nbits == vec::len[uint](v1));
assert (v0.nbits == vec::len::<uint>(v1));
let len = v0.nbits;
let i = 0u;
while i < len {

2
src/lib/comm.rs
View File

@ -60,7 +60,7 @@ obj _port<~T>(raw_port : @port_ptr) {
}
fn mk_port<~T>() -> _port<T> {
_port(@port_ptr(rustrt::new_port(sys::size_of[T]())))
_port(@port_ptr(rustrt::new_port(sys::size_of::<T>())))
}
fn send<~T>(ch : _chan<T>, data : -T) {

14
src/lib/dbg.rs
View File

@ -22,13 +22,13 @@ native "rust" mod rustrt {
fn debug_trap(msg: str);
}
fn debug_tydesc[T]() { rustrt::debug_tydesc[T](); }
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); }
/**
@ -41,12 +41,12 @@ fn debug_tag<T>(x: &T) { rustrt::debug_tag[T](x); }
* the front of any obj's data tuple.x
*/
fn debug_obj<T>(x: &T, nmethods: uint, nbytes: uint) {
rustrt::debug_obj[T](x, nmethods, nbytes);
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:

36
src/lib/deque.rs
View File

@ -53,24 +53,24 @@ fn create<@T>() -> t<T> {
fn add_front(t: &T) {
let oldlo: uint = lo;
if lo == 0u {
lo = vec::len[cell<T>](elts) - 1u;
lo = vec::len::<cell<T>>(elts) - 1u;
} else { lo -= 1u; }
if lo == hi {
elts = grow[T](nelts, oldlo, elts);
lo = vec::len[cell<T>](elts) - 1u;
elts = grow::<T>(nelts, oldlo, elts);
lo = vec::len::<cell<T>>(elts) - 1u;
hi = nelts;
}
elts.(lo) = option::some[T](t);
elts.(lo) = option::some::<T>(t);
nelts += 1u;
}
fn add_back(t: &T) {
if lo == hi && nelts != 0u {
elts = grow[T](nelts, lo, elts);
elts = grow::<T>(nelts, lo, elts);
lo = 0u;
hi = nelts;
}
elts.(hi) = option::some[T](t);
hi = (hi + 1u) % vec::len[cell<T>](elts);
elts.(hi) = option::some::<T>(t);
hi = (hi + 1u) % vec::len::<cell<T>>(elts);
nelts += 1u;
}
@ -79,31 +79,31 @@ fn create<@T>() -> t<T> {
* that we don't keep anyone's refcount up unexpectedly.
*/
fn pop_front() -> T {
let t: T = get[T](elts, lo);
elts.(lo) = option::none[T];
lo = (lo + 1u) % vec::len[cell<T>](elts);
let t: T = get::<T>(elts, lo);
elts.(lo) = option::none::<T>;
lo = (lo + 1u) % vec::len::<cell<T>>(elts);
nelts -= 1u;
ret t;
}
fn pop_back() -> T {
if hi == 0u {
hi = vec::len[cell<T>](elts) - 1u;
hi = vec::len::<cell<T>>(elts) - 1u;
} else { hi -= 1u; }
let t: T = get[T](elts, hi);
elts.(hi) = option::none[T];
let t: T = get::<T>(elts, hi);
elts.(hi) = option::none::<T>;
nelts -= 1u;
ret t;
}
fn peek_front() -> T { ret get[T](elts, lo); }
fn peek_back() -> T { ret get[T](elts, hi - 1u); }
fn peek_front() -> T { ret get::<T>(elts, lo); }
fn peek_back() -> T { ret get::<T>(elts, hi - 1u); }
fn get(i: int) -> T {
let idx: uint = (lo + (i as uint)) % vec::len[cell<T>](elts);
ret get[T](elts, idx);
let idx: uint = (lo + (i as uint)) % vec::len::<cell<T>>(elts);
ret get::<T>(elts, idx);
}
}
let v: [mutable cell<T>] =
vec::init_elt_mut(option::none, initial_capacity);
ret deque[T](0u, 0u, 0u, v);
ret deque::<T>(0u, 0u, 0u, v);
}
// Local Variables:
// mode: rust;

10
src/lib/ebml.rs
View File

@ -40,7 +40,7 @@ fn vint_at(data: &[u8], start: uint) -> {val: uint, next: uint} {
}
fn new_doc(data: &@[u8]) -> doc {
ret {data: data, start: 0u, end: vec::len[u8](*data)};
ret {data: data, start: 0u, end: vec::len::<u8>(*data)};
}
fn doc_at(data: &@[u8], start: uint) -> doc {
@ -57,10 +57,10 @@ fn maybe_get_doc(d: doc, tg: uint) -> option::t<doc> {
let elt_size = vint_at(*d.data, elt_tag.next);
pos = elt_size.next + elt_size.val;
if elt_tag.val == tg {
ret some[doc]({data: d.data, start: elt_size.next, end: pos});
ret some::<doc>({data: d.data, start: elt_size.next, end: pos});
}
}
ret none[doc];
ret none::<doc>;
}
fn get_doc(d: doc, tg: uint) -> doc {
@ -96,7 +96,7 @@ iter tagged_docs(d: doc, tg: uint) -> doc {
}
}
fn doc_data(d: doc) -> [u8] { ret vec::slice[u8](*d.data, d.start, d.end); }
fn doc_data(d: doc) -> [u8] { ret vec::slice::<u8>(*d.data, d.start, d.end); }
fn be_uint_from_bytes(data: &@[u8], start: uint, size: uint) -> uint {
let sz = size;
@ -167,7 +167,7 @@ fn start_tag(w: &writer, tag_id: uint) {
}
fn end_tag(w: &writer) {
let last_size_pos = vec::pop[uint](w.size_positions);
let last_size_pos = vec::pop::<uint>(w.size_positions);
let cur_pos = w.writer.tell();
w.writer.seek(last_size_pos as int, io::seek_set);
write_sized_vint(w.writer, cur_pos - last_size_pos - 4u, 4u);

2
src/lib/extfmt.rs
View File

@ -372,7 +372,7 @@ mod rt {
// FIXME: This might be useful in str: but needs to be utf8 safe first
fn str_init_elt(c: char, n_elts: uint) -> str {
let svec = vec::init_elt[u8](c as u8, n_elts);
let svec = vec::init_elt::<u8>(c as u8, n_elts);
ret str::unsafe_from_bytes(svec);
}

4
src/lib/generic_os.rs
View File

@ -6,8 +6,8 @@ import str::sbuf;
fn getenv(n: str) -> option::t<str> {
let s = os::libc::getenv(str::buf(n));
ret if s as int == 0 {
option::none[str]
} else { option::some[str](str::str_from_cstr(s)) };
option::none::<str>
} else { option::some::<str>(str::str_from_cstr(s)) };
}
#[cfg(target_os = "linux")]

41
src/lib/getopts.rs
View File

@ -77,9 +77,9 @@ fn name_str(nm: name) -> str {
fn find_opt(opts: &[opt], nm: name) -> option::t<uint> {
let i = 0u;
let l = vec::len[opt](opts);
while i < l { if opts.(i).name == nm { ret some[uint](i); } i += 1u; }
ret none[uint];
let l = vec::len::<opt>(opts);
while i < l { if opts.(i).name == nm { ret some::<uint>(i); } i += 1u; }
ret none::<uint>;
}
tag fail_ {
@ -107,11 +107,11 @@ fn fail_str(f: fail_) -> str {
tag result { success(match); failure(fail_); }
fn getopts(args: &[str], opts: &[opt]) -> result {
let n_opts = vec::len[opt](opts);
let n_opts = vec::len::<opt>(opts);
fn f(x: uint) -> [optval] { ret ~[]; }
let vals = vec::init_fn_mut[[optval]](f, n_opts);
let vals = vec::init_fn_mut::<[optval]>(f, n_opts);
let free: [str] = ~[];
let l = vec::len[str](args);
let l = vec::len::<str>(args);
let i = 0u;
while i < l {
let cur = args.(i);
@ -124,7 +124,7 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
break;
} else {
let names;
let i_arg = option::none[str];
let i_arg = option::none::<str>;
if cur.(1) == '-' as u8 {
let tail = str::slice(cur, 2u, curlen);
let eq = str::index(tail, '=' as u8);
@ -133,8 +133,9 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
} else {
names = ~[long(str::slice(tail, 0u, eq as uint))];
i_arg =
option::some[str](str::slice(tail, (eq as uint) + 1u,
curlen - 2u));
option::some::<str>(str::slice(tail,
(eq as uint) + 1u,
curlen - 2u));
}
} else {
let j = 1u;
@ -155,22 +156,22 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
}
alt opts.(optid).hasarg {
no. {
if !option::is_none[str](i_arg) {
if !option::is_none::<str>(i_arg) {
ret failure(unexpected_argument(name_str(nm)));
}
vals.(optid) += ~[given];
}
maybe. {
if !option::is_none[str](i_arg) {
if !option::is_none::<str>(i_arg) {
vals.(optid) += ~[val(option::get(i_arg))];
} else if (name_pos < vec::len[name](names) ||
} else if (name_pos < vec::len::<name>(names) ||
i + 1u == l || is_arg(args.(i + 1u))) {
vals.(optid) += ~[given];
} else { i += 1u; vals.(optid) += ~[val(args.(i))]; }
}
yes. {
if !option::is_none[str](i_arg) {
vals.(optid) += ~[val(option::get[str](i_arg))];
if !option::is_none::<str>(i_arg) {
vals.(optid) += ~[val(option::get::<str>(i_arg))];
} else if (i + 1u == l) {
ret failure(argument_missing(name_str(nm)));
} else { i += 1u; vals.(optid) += ~[val(args.(i))]; }
@ -182,7 +183,7 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
}
i = 0u;
while i < n_opts {
let n = vec::len[optval](vals.(i));
let n = vec::len::<optval>(vals.(i));
let occ = opts.(i).occur;
if occ == req {
if n == 0u {
@ -209,7 +210,7 @@ fn opt_vals(m: &match, nm: str) -> [optval] {
fn opt_val(m: &match, nm: str) -> optval { ret opt_vals(m, nm).(0); }
fn opt_present(m: &match, nm: str) -> bool {
ret vec::len[optval](opt_vals(m, nm)) > 0u;
ret vec::len::<optval>(opt_vals(m, nm)) > 0u;
}
fn opt_str(m: &match, nm: str) -> str {
@ -226,8 +227,8 @@ fn opt_strs(m: &match, nm: str) -> [str] {
fn opt_maybe_str(m: &match, nm: str) -> option::t<str> {
let vals = opt_vals(m, nm);
if vec::len[optval](vals) == 0u { ret none[str]; }
ret alt vals.(0) { val(s) { some[str](s) } _ { none[str] } };
if vec::len::<optval>(vals) == 0u { ret none::<str>; }
ret alt vals.(0) { val(s) { some::<str>(s) } _ { none::<str> } };
}
@ -236,8 +237,8 @@ fn opt_maybe_str(m: &match, nm: str) -> option::t<str> {
/// present and an argument was provided.
fn opt_default(m: &match, nm: str, def: str) -> option::t<str> {
let vals = opt_vals(m, nm);
if vec::len[optval](vals) == 0u { ret none[str]; }
ret alt vals.(0) { val(s) { some[str](s) } _ { some[str](def) } }
if vec::len::<optval>(vals) == 0u { ret none::<str>; }
ret alt vals.(0) { val(s) { some::<str>(s) } _ { some::<str>(def) } }
}
// Local Variables:
// mode: rust;

28
src/lib/io.rs
View File

@ -62,9 +62,9 @@ resource FILE_res(f: os::libc::FILE) {
obj FILE_buf_reader(f: os::libc::FILE, res: option::t<@FILE_res>) {
fn read(len: uint) -> [u8] {
let buf = ~[];
vec::reserve[u8](buf, len);
let read = os::libc::fread(vec::to_ptr[u8](buf), 1u, len, f);
vec::unsafe::set_len[u8](buf, read);
vec::reserve::<u8>(buf, len);
let read = os::libc::fread(vec::to_ptr::<u8>(buf), 1u, len, f);
vec::unsafe::set_len::<u8>(buf, read);
ret buf;
}
fn read_byte() -> int { ret os::libc::fgetc(f); }
@ -196,24 +196,24 @@ type byte_buf = @{buf: [u8], mutable pos: uint};
obj byte_buf_reader(bbuf: byte_buf) {
fn read(len: uint) -> [u8] {
let rest = vec::len[u8](bbuf.buf) - bbuf.pos;
let rest = vec::len::<u8>(bbuf.buf) - bbuf.pos;
let to_read = len;
if rest < to_read { to_read = rest; }
let range = vec::slice[u8](bbuf.buf, bbuf.pos, bbuf.pos + to_read);
let range = vec::slice::<u8>(bbuf.buf, bbuf.pos, bbuf.pos + to_read);
bbuf.pos += to_read;
ret range;
}
fn read_byte() -> int {
if bbuf.pos == vec::len[u8](bbuf.buf) { ret -1; }
if bbuf.pos == vec::len::<u8>(bbuf.buf) { ret -1; }
let b = bbuf.buf.(bbuf.pos);
bbuf.pos += 1u;
ret b as int;
}
fn unread_byte(byte: int) { log_err "TODO: unread_byte"; fail; }
fn eof() -> bool { ret bbuf.pos == vec::len[u8](bbuf.buf); }
fn eof() -> bool { ret bbuf.pos == vec::len::<u8>(bbuf.buf); }
fn seek(offset: int, whence: seek_style) {
let pos = bbuf.pos;
let len = vec::len[u8](bbuf.buf);
let len = vec::len::<u8>(bbuf.buf);
bbuf.pos = seek_in_buf(offset, pos, len, whence);
}
fn tell() -> uint { ret bbuf.pos; }
@ -245,8 +245,8 @@ type buf_writer =
obj FILE_writer(f: os::libc::FILE, res: option::t<@FILE_res>) {
fn write(v: &[u8]) {
let len = vec::len[u8](v);
let vbuf = vec::to_ptr[u8](v);
let len = vec::len::<u8>(v);
let vbuf = vec::to_ptr::<u8>(v);
let nout = os::libc::fwrite(vbuf, len, 1u, f);
if nout < 1u { log_err "error dumping buffer"; }
}
@ -264,11 +264,11 @@ resource fd_res(fd: int) {
obj fd_buf_writer(fd: int, res: option::t<@fd_res>) {
fn write(v: &[u8]) {
let len = vec::len[u8](v);
let len = vec::len::<u8>(v);
let count = 0u;
let vbuf;
while count < len {
vbuf = ptr::offset(vec::to_ptr[u8](v), count);
vbuf = ptr::offset(vec::to_ptr::<u8>(v), count);
let nout = os::libc::write(fd, vbuf, len);
if nout < 0 {
log_err "error dumping buffer";
@ -403,12 +403,12 @@ obj byte_buf_writer(buf: mutable_byte_buf) {
if buf.pos == vec::len(buf.buf) {
for b: u8 in v { buf.buf += ~[mutable b]; }
buf.pos += vec::len[u8](v);
buf.pos += vec::len::<u8>(v);
ret;
}
// FIXME: Optimize: These should be unique pointers.
let vlen = vec::len[u8](v);
let vlen = vec::len::<u8>(v);
let vpos = 0u;
while vpos < vlen {
let b = v.(vpos);

4
src/lib/list.rs
View File

@ -4,12 +4,12 @@ import option::none;
tag list<T> { cons(T, @list<T>); nil; }
fn from_vec<@T>(v: &[T]) -> list<T> {
let l = nil[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
// work yet.
for item: T in vec::reversed(v) { l = cons[T](item, @l); }
for item: T in vec::reversed(v) { l = cons::<T>(item, @l); }
ret l;
}

2
src/lib/map.rs
View File

@ -27,7 +27,7 @@ fn mk_hashmap<@K, @V>(hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
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>)] {
ret vec::init_elt_mut[bucket<K, V>](nil[K, V], nbkts);
ret vec::init_elt_mut::<bucket<K, V>>(nil::<K, V>, nbkts);
}
// Derive two hash functions from the one given by taking the upper
// half and lower half of the uint bits. Our bucket probing

2
src/lib/posix_fs.rs
View File

@ -24,7 +24,7 @@ fn list_dir(path: str) -> [str] {
os::libc::closedir(dir);
ret result;
}
vec::push[str](result, rustrt::rust_dirent_filename(ent));
vec::push::<str>(result, rustrt::rust_dirent_filename(ent));
}
os::libc::closedir(dir);
ret result;

6
src/lib/sha1.rs
View File

@ -248,13 +248,13 @@ fn mk_sha1() -> sha1 {
}
}
let st =
{h: vec::init_elt_mut[u32](0u32, digest_buf_len),
{h: vec::init_elt_mut::<u32>(0u32, digest_buf_len),
mutable len_low: 0u32,
mutable len_high: 0u32,
msg_block: vec::init_elt_mut[u8](0u8, msg_block_len),
msg_block: vec::init_elt_mut::<u8>(0u8, msg_block_len),
mutable msg_block_idx: 0u,
mutable computed: false,
work_buf: vec::init_elt_mut[u32](0u32, work_buf_len)};
work_buf: vec::init_elt_mut::<u32>(0u32, work_buf_len)};
let sh = sha1(st);
sh.reset();
ret sh;

18
src/lib/smallintmap.rs
View File

@ -15,30 +15,30 @@ fn mk<@T>() -> smallintmap<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));
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> {
if key < vec::len[option::t<T>](m.v) { ret m.v.(key); }
ret none[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 {
alt find[T](m, key) {
none[T]. { log_err "smallintmap::get(): key not present"; fail; }
some[T](v) { ret v; }
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 {
ret !option::is_none(find[T](m, key));
ret !option::is_none(find::<T>(m, key));
}
fn truncate<@T>(m: &smallintmap<T>, len: uint) {
m.v = vec::slice_mut[option::t<T>](m.v, 0u, len);
m.v = vec::slice_mut::<option::t<T>>(m.v, 0u, len);
}
fn max_key<T>(m: &smallintmap<T>) -> uint {
ret vec::len[option::t<T>](m.v);
ret vec::len::<option::t<T>>(m.v);
}

56
src/lib/sort.rs
View File

@ -11,9 +11,9 @@ type lteq<T> = block(&T, &T) -> bool ;
fn merge_sort<@T>(le: &lteq<T>, v: &[T]) -> [T] {
fn merge<@T>(le: &lteq<T>, a: &[T], b: &[T]) -> [T] {
let rs: [T] = ~[];
let a_len: uint = len[T](a);
let a_len: uint = len::<T>(a);
let a_ix: uint = 0u;
let b_len: uint = len[T](b);
let b_len: uint = len::<T>(b);
let b_ix: uint = 0u;
while a_ix < a_len && b_ix < b_len {
if le(a.(a_ix), b.(b_ix)) {
@ -21,16 +21,16 @@ fn merge_sort<@T>(le: &lteq<T>, v: &[T]) -> [T] {
a_ix += 1u;
} else { rs += ~[b.(b_ix)]; b_ix += 1u; }
}
rs += slice[T](a, a_ix, a_len);
rs += slice[T](b, b_ix, b_len);
rs += slice::<T>(a, a_ix, a_len);
rs += slice::<T>(b, b_ix, b_len);
ret rs;
}
let v_len: uint = len[T](v);
let v_len: uint = len::<T>(v);
if v_len <= 1u { ret v; }
let mid: uint = v_len / 2u;
let a: [T] = slice[T](v, 0u, mid);
let b: [T] = slice[T](v, mid, v_len);
ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b));
let a: [T] = slice::<T>(v, 0u, mid);
let b: [T] = slice::<T>(v, mid, v_len);
ret merge::<T>(le, merge_sort::<T>(le, a), merge_sort::<T>(le, b));
}
fn swap<@T>(arr: &[mutable T], x: uint, y: uint) {
@ -42,17 +42,17 @@ fn swap<@T>(arr: &[mutable T], x: uint, y: uint) {
fn part<@T>(compare_func: &lteq<T>, arr: &[mutable T], left: uint,
right: uint, pivot: uint) -> uint {
let pivot_value = arr.(pivot);
swap[T](arr, pivot, right);
swap::<T>(arr, pivot, right);
let storage_index: uint = left;
let i: uint = left;
while i < right {
if compare_func({ arr.(i) }, pivot_value) {
swap[T](arr, i, storage_index);
swap::<T>(arr, i, storage_index);
storage_index += 1u;
}
i += 1u;
}
swap[T](arr, storage_index, right);
swap::<T>(arr, storage_index, right);
ret storage_index;
}
@ -60,18 +60,18 @@ fn qsort<@T>(compare_func: &lteq<T>, arr: &[mutable T], left: uint,
right: uint) {
if right > left {
let pivot = (left + right) / 2u;
let new_pivot = part[T](compare_func, arr, left, right, pivot);
let new_pivot = part::<T>(compare_func, arr, left, right, pivot);
if new_pivot != 0u {
// Need to do this check before recursing due to overflow
qsort[T](compare_func, arr, left, new_pivot - 1u);
qsort::<T>(compare_func, arr, left, new_pivot - 1u);
}
qsort[T](compare_func, arr, new_pivot + 1u, right);
qsort::<T>(compare_func, arr, new_pivot + 1u, right);
}
}
fn quick_sort<@T>(compare_func: &lteq<T>, arr: &[mutable T]) {
if len[T](arr) == 0u { ret; }
qsort[T](compare_func, arr, 0u, len[T](arr) - 1u);
if len::<T>(arr) == 0u { ret; }
qsort::<T>(compare_func, arr, 0u, len::<T>(arr) - 1u);
}
@ -96,42 +96,42 @@ fn qsort3<@T>(compare_func_lt: &lteq<T>, compare_func_eq: &lteq<T>,
j -= 1;
}
if i >= j { break; }
swap[T](arr, i as uint, j as uint);
swap::<T>(arr, i as uint, j as uint);
if compare_func_eq({ arr.(i) }, v) {
p += 1;
swap[T](arr, p as uint, i as uint);
swap::<T>(arr, p as uint, i as uint);
}
if compare_func_eq(v, { arr.(j) }) {
q -= 1;
swap[T](arr, j as uint, q as uint);
swap::<T>(arr, j as uint, q as uint);
}
}
swap[T](arr, i as uint, right as uint);
swap::<T>(arr, i as uint, right as uint);
j = i - 1;
i += 1;
let k: int = left;
while k < p {
swap[T](arr, k as uint, j as uint);
swap::<T>(arr, k as uint, j as uint);
k += 1;
j -= 1;
if k == len[T](arr) as int { break; }
if k == len::<T>(arr) as int { break; }
}
k = right - 1;
while k > q {
swap[T](arr, i as uint, k as uint);
swap::<T>(arr, i as uint, k as uint);
k -= 1;
i += 1;
if k == 0 { break; }
}
qsort3[T](compare_func_lt, compare_func_eq, arr, left, j);
qsort3[T](compare_func_lt, compare_func_eq, arr, i, right);
qsort3::<T>(compare_func_lt, compare_func_eq, arr, left, j);
qsort3::<T>(compare_func_lt, compare_func_eq, arr, i, right);
}
fn quick_sort3<@T>(compare_func_lt: &lteq<T>, compare_func_eq: &lteq<T>,
arr: &[mutable T]) {
if len[T](arr) == 0u { ret; }
qsort3[T](compare_func_lt, compare_func_eq, arr, 0,
(len[T](arr) as int) - 1);
if len::<T>(arr) == 0u { ret; }
qsort3::<T>(compare_func_lt, compare_func_eq, arr, 0,
(len::<T>(arr) as int) - 1);
}
// Local Variables:

4
src/lib/str.rs
View File

@ -132,7 +132,7 @@ const tag_six_b: uint = 252u;
fn is_utf8(v: &[u8]) -> bool {
let i = 0u;
let total = vec::len[u8](v);
let total = vec::len::<u8>(v);
while i < total {
let chsize = utf8_char_width(v.(i));
if chsize == 0u { ret false; }
@ -329,7 +329,7 @@ fn shift_char(s: &mutable str) -> char {
fn unshift_char(s: &mutable str, ch: char) { s = from_char(ch) + s; }
fn refcount(s: str) -> uint {
let r = rustrt::refcount[u8](s);
let r = rustrt::refcount::<u8>(s);
if r == dbg::const_refcount { ret r; } else { ret r - 1u; }
}

14
src/lib/ufind.rs
View File

@ -14,7 +14,7 @@ fn make() -> ufind { ret {mutable nodes: ~[mutable]}; }
fn make_set(ufnd: &ufind) -> uint {
let idx = vec::len(ufnd.nodes);
ufnd.nodes += ~[mutable none[uint]];
ufnd.nodes += ~[mutable none::<uint>];
ret idx;
}
@ -36,17 +36,19 @@ fn union(ufnd: &ufind, m: uint, n: uint) {
let m_root = find(ufnd, m);
let n_root = find(ufnd, n);
if m_root < n_root {
ufnd.nodes.(n_root) = some[uint](m_root);
} else if (m_root > n_root) { ufnd.nodes.(m_root) = some[uint](n_root); }
ufnd.nodes.(n_root) = some::<uint>(m_root);
} else if (m_root > n_root) {
ufnd.nodes.(m_root) = some::<uint>(n_root);
}
}
fn set_count(ufnd: &ufind) -> uint { ret vec::len[node](ufnd.nodes); }
fn set_count(ufnd: &ufind) -> uint { ret vec::len::<node>(ufnd.nodes); }
// Removes all sets with IDs greater than or equal to the given value.
fn prune(ufnd: &ufind, n: uint) {
// TODO: Use "slice" once we get rid of "mutable?"
let len = vec::len[node](ufnd.nodes);
while len != n { vec::pop[node](ufnd.nodes); len -= 1u; }
let len = vec::len::<node>(ufnd.nodes);
while len != n { vec::pop::<node>(ufnd.nodes); len -= 1u; }
}

9
src/lib/uint.rs
View File

@ -35,7 +35,7 @@ fn next_power_of_two(n: uint) -> uint {
// FIXME change |* uint(4)| below to |* uint(8) / uint(2)| and watch the
// world explode.
let halfbits: uint = sys::rustrt::size_of[uint]() * 4u;
let halfbits: uint = sys::rustrt::size_of::<uint>() * 4u;
let tmp: uint = n - 1u;
let shift: uint = 1u;
while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; }
@ -43,8 +43,11 @@ fn next_power_of_two(n: uint) -> uint {
}
fn parse_buf(buf: &[u8], radix: uint) -> uint {
if vec::len[u8](buf) == 0u { log_err "parse_buf(): buf is empty"; fail; }
let i = vec::len[u8](buf) - 1u;
if vec::len::<u8>(buf) == 0u {
log_err "parse_buf(): buf is empty";
fail;
}
let i = vec::len::<u8>(buf) - 1u;
let power = 1u;
let n = 0u;
while true {

22
src/lib/vec.rs
View File

@ -135,10 +135,10 @@ fn slice_mut<@T>(v: &[mutable? T], start: uint, end: uint) -> [mutable T] {
// Mutators
fn shift<@T>(v: &mutable [mutable? T]) -> T {
let ln = len[T](v);
let ln = len::<T>(v);
assert (ln > 0u);
let e = v.(0);
v = slice[T](v, 1u, ln);
v = slice::<T>(v, 1u, ln);
ret e;
}
@ -202,8 +202,8 @@ fn map<@T, @U>(f: &block(&T) -> U , v: &[mutable? T]) -> [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; }
let v0_len = len::<T>(v0);
if v0_len != len::<U>(v1) { fail; }
let u: [V] = ~[];
let i = 0u;
while i < v0_len { u += ~[f({ v0.(i) }, { v1.(i) })]; i += 1u; }
@ -259,14 +259,14 @@ fn find<@T>(f: &block(&T) -> bool, v: &[T]) -> option::t<T> {
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];
while i < len(v) { if x == v.(i) { ret some::<uint>(i); } i += 1u; }
ret none;
}
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];
while i < len(v) { if f(v.(i)) { ret some::<uint>(i); } i += 1u; }
ret none;
}
fn unzip<@T, @U>(v: &[(T, U)]) -> ([T], [U]) {
@ -300,7 +300,7 @@ fn swap<@T>(v: &[mutable T], a: uint, b: uint) {
// In place vector reversal
fn reverse<@T>(v: &[mutable T]) {
let i: uint = 0u;
let ln = len[T](v);
let ln = len::<T>(v);
while i < ln / 2u { swap(v, i, ln - i - 1u); i += 1u; }
}
@ -308,7 +308,7 @@ fn reverse<@T>(v: &[mutable T]) {
// Functional vector reversal. Returns a reversed copy of v.
fn reversed<@T>(v: &[T]) -> [T] {
let rs: [T] = ~[];
let i = len[T](v);
let i = len::<T>(v);
if i == 0u { ret rs; } else { i -= 1u; }
while i != 0u { rs += ~[v.(i)]; i -= 1u; }
rs += ~[v.(0)];
@ -334,7 +334,7 @@ mod unsafe {
}
fn set_len<T>(v: &mutable [T], new_len: uint) {
let new_fill = new_len * sys::size_of[T]();
let new_fill = new_len * sys::size_of::<T>();
let stack_part: *mutable ivec_repr =
::unsafe::reinterpret_cast(addr_of(v));
if (*stack_part).fill == 0u {