rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 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
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"; log "waiting for bytes";
let data: [u8] = reader.recv(); let data: [u8] = reader.recv();
log "got some bytes"; log "got some bytes";
log vec::len[u8](data); log vec::len::<u8>(data);
if (vec::len[u8](data) == 0u) { if (vec::len::<u8>(data) == 0u) {
log "got empty buffer, bailing"; log "got empty buffer, bailing";
break; break;
} }
@@ -145,7 +145,7 @@ fn request_task(c: _chan<ctx>) {
} }
write(socket,v,status) { write(socket,v,status) {
rustrt::aio_writedata(socket, rustrt::aio_writedata(socket,
vec::to_ptr[u8](v), vec::len[u8](v), vec::to_ptr::<u8>(v), vec::len::<u8>(v),
status); status);
} }
close_server(server,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 { fn create(nbits: uint, init: bool) -> t {
let elt = if init { !0u } else { 0u }; 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}; ret @{storage: storage, nbits: nbits};
} }
@@ -69,7 +69,7 @@ fn assign(v0: &t, v1: t) -> bool {
} }
fn clone(v: t) -> t { 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); let len = vec::len(v.storage);
for each i: uint in uint::range(0u, len) { storage.(i) = v.storage.(i); } for each i: uint in uint::range(0u, len) { storage.(i) = v.storage.(i); }
ret @{storage: storage, nbits: v.nbits}; 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] { fn to_vec(v: &t) -> [uint] {
let sub = bind init_to_vec(v, _); 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 { fn to_str(v: &t) -> str {
@@ -162,7 +162,7 @@ fn to_str(v: &t) -> str {
} }
fn eq_ivec(v0: &t, v1: &[uint]) -> bool { 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 len = v0.nbits;
let i = 0u; let i = 0u;
while i < len { 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> { 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) { 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_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 * 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); 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); } fn trap(s: str) { rustrt::debug_trap(s); }
// Local Variables: // Local Variables:

36
src/lib/deque.rs
View File

@@ -53,24 +53,24 @@ fn create<@T>() -> t<T> {
fn add_front(t: &T) { fn add_front(t: &T) {
let oldlo: uint = lo; let oldlo: uint = lo;
if lo == 0u { if lo == 0u {
lo = vec::len[cell<T>](elts) - 1u; lo = vec::len::<cell<T>>(elts) - 1u;
} else { lo -= 1u; } } else { lo -= 1u; }
if lo == hi { if lo == hi {
elts = grow[T](nelts, oldlo, elts); elts = grow::<T>(nelts, oldlo, elts);
lo = vec::len[cell<T>](elts) - 1u; lo = vec::len::<cell<T>>(elts) - 1u;
hi = nelts; hi = nelts;
} }
elts.(lo) = option::some[T](t); elts.(lo) = option::some::<T>(t);
nelts += 1u; nelts += 1u;
} }
fn add_back(t: &T) { fn add_back(t: &T) {
if lo == hi && nelts != 0u { if lo == hi && nelts != 0u {
elts = grow[T](nelts, lo, elts); elts = grow::<T>(nelts, lo, elts);
lo = 0u; lo = 0u;
hi = nelts; hi = nelts;
} }
elts.(hi) = option::some[T](t); elts.(hi) = option::some::<T>(t);
hi = (hi + 1u) % vec::len[cell<T>](elts); hi = (hi + 1u) % vec::len::<cell<T>>(elts);
nelts += 1u; nelts += 1u;
} }
@@ -79,31 +79,31 @@ fn create<@T>() -> t<T> {
* that we don't keep anyone's refcount up unexpectedly. * that we don't keep anyone's refcount up unexpectedly.
*/ */
fn pop_front() -> T { fn pop_front() -> T {
let t: T = get[T](elts, lo); let t: T = get::<T>(elts, lo);
elts.(lo) = option::none[T]; elts.(lo) = option::none::<T>;
lo = (lo + 1u) % vec::len[cell<T>](elts); lo = (lo + 1u) % vec::len::<cell<T>>(elts);
nelts -= 1u; nelts -= 1u;
ret t; ret t;
} }
fn pop_back() -> T { fn pop_back() -> T {
if hi == 0u { if hi == 0u {
hi = vec::len[cell<T>](elts) - 1u; hi = vec::len::<cell<T>>(elts) - 1u;
} else { hi -= 1u; } } else { hi -= 1u; }
let t: T = get[T](elts, hi); let t: T = get::<T>(elts, hi);
elts.(hi) = option::none[T]; elts.(hi) = option::none::<T>;
nelts -= 1u; nelts -= 1u;
ret t; ret t;
} }
fn peek_front() -> T { ret get[T](elts, lo); } fn peek_front() -> T { ret get::<T>(elts, lo); }
fn peek_back() -> T { ret get[T](elts, hi - 1u); } fn peek_back() -> T { ret get::<T>(elts, hi - 1u); }
fn get(i: int) -> T { fn get(i: int) -> T {
let idx: uint = (lo + (i as uint)) % vec::len[cell<T>](elts); let idx: uint = (lo + (i as uint)) % vec::len::<cell<T>>(elts);
ret get[T](elts, idx); ret get::<T>(elts, idx);
} }
} }
let v: [mutable cell<T>] = let v: [mutable cell<T>] =
vec::init_elt_mut(option::none, initial_capacity); vec::init_elt_mut(option::none, initial_capacity);
ret deque[T](0u, 0u, 0u, v); ret deque::<T>(0u, 0u, 0u, v);
} }
// Local Variables: // Local Variables:
// mode: rust; // 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 { 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 { 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); let elt_size = vint_at(*d.data, elt_tag.next);
pos = elt_size.next + elt_size.val; pos = elt_size.next + elt_size.val;
if elt_tag.val == tg { 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 { 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 { fn be_uint_from_bytes(data: &@[u8], start: uint, size: uint) -> uint {
let sz = size; let sz = size;
@@ -167,7 +167,7 @@ fn start_tag(w: &writer, tag_id: uint) {
} }
fn end_tag(w: &writer) { 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(); let cur_pos = w.writer.tell();
w.writer.seek(last_size_pos as int, io::seek_set); w.writer.seek(last_size_pos as int, io::seek_set);
write_sized_vint(w.writer, cur_pos - last_size_pos - 4u, 4u); 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 // FIXME: This might be useful in str: but needs to be utf8 safe first
fn str_init_elt(c: char, n_elts: uint) -> str { 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); 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> { fn getenv(n: str) -> option::t<str> {
let s = os::libc::getenv(str::buf(n)); let s = os::libc::getenv(str::buf(n));
ret if s as int == 0 { ret if s as int == 0 {
option::none[str] option::none::<str>
} else { option::some[str](str::str_from_cstr(s)) }; } else { option::some::<str>(str::str_from_cstr(s)) };
} }
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]

39
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> { fn find_opt(opts: &[opt], nm: name) -> option::t<uint> {
let i = 0u; let i = 0u;
let l = vec::len[opt](opts); let l = vec::len::<opt>(opts);
while i < l { if opts.(i).name == nm { ret some[uint](i); } i += 1u; } while i < l { if opts.(i).name == nm { ret some::<uint>(i); } i += 1u; }
ret none[uint]; ret none::<uint>;
} }
tag fail_ { tag fail_ {
@@ -107,11 +107,11 @@ fn fail_str(f: fail_) -> str {
tag result { success(match); failure(fail_); } tag result { success(match); failure(fail_); }
fn getopts(args: &[str], opts: &[opt]) -> result { 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 ~[]; } 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 free: [str] = ~[];
let l = vec::len[str](args); let l = vec::len::<str>(args);
let i = 0u; let i = 0u;
while i < l { while i < l {
let cur = args.(i); let cur = args.(i);
@@ -124,7 +124,7 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
break; break;
} else { } else {
let names; let names;
let i_arg = option::none[str]; let i_arg = option::none::<str>;
if cur.(1) == '-' as u8 { if cur.(1) == '-' as u8 {
let tail = str::slice(cur, 2u, curlen); let tail = str::slice(cur, 2u, curlen);
let eq = str::index(tail, '=' as u8); let eq = str::index(tail, '=' as u8);
@@ -133,7 +133,8 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
} else { } else {
names = ~[long(str::slice(tail, 0u, eq as uint))]; names = ~[long(str::slice(tail, 0u, eq as uint))];
i_arg = i_arg =
option::some[str](str::slice(tail, (eq as uint) + 1u, option::some::<str>(str::slice(tail,
(eq as uint) + 1u,
curlen - 2u)); curlen - 2u));
} }
} else { } else {
@@ -155,22 +156,22 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
} }
alt opts.(optid).hasarg { alt opts.(optid).hasarg {
no. { no. {
if !option::is_none[str](i_arg) { if !option::is_none::<str>(i_arg) {
ret failure(unexpected_argument(name_str(nm))); ret failure(unexpected_argument(name_str(nm)));
} }
vals.(optid) += ~[given]; vals.(optid) += ~[given];
} }
maybe. { maybe. {
if !option::is_none[str](i_arg) { if !option::is_none::<str>(i_arg) {
vals.(optid) += ~[val(option::get(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))) { i + 1u == l || is_arg(args.(i + 1u))) {
vals.(optid) += ~[given]; vals.(optid) += ~[given];
} else { i += 1u; vals.(optid) += ~[val(args.(i))]; } } else { i += 1u; vals.(optid) += ~[val(args.(i))]; }
} }
yes. { yes. {
if !option::is_none[str](i_arg) { if !option::is_none::<str>(i_arg) {
vals.(optid) += ~[val(option::get[str](i_arg))]; vals.(optid) += ~[val(option::get::<str>(i_arg))];
} else if (i + 1u == l) { } else if (i + 1u == l) {
ret failure(argument_missing(name_str(nm))); ret failure(argument_missing(name_str(nm)));
} else { i += 1u; vals.(optid) += ~[val(args.(i))]; } } else { i += 1u; vals.(optid) += ~[val(args.(i))]; }
@@ -182,7 +183,7 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
} }
i = 0u; i = 0u;
while i < n_opts { while i < n_opts {
let n = vec::len[optval](vals.(i)); let n = vec::len::<optval>(vals.(i));
let occ = opts.(i).occur; let occ = opts.(i).occur;
if occ == req { if occ == req {
if n == 0u { 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_val(m: &match, nm: str) -> optval { ret opt_vals(m, nm).(0); }
fn opt_present(m: &match, nm: str) -> bool { 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 { 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> { fn opt_maybe_str(m: &match, nm: str) -> option::t<str> {
let vals = opt_vals(m, nm); let vals = opt_vals(m, nm);
if vec::len[optval](vals) == 0u { ret none[str]; } if vec::len::<optval>(vals) == 0u { ret none::<str>; }
ret alt vals.(0) { val(s) { some[str](s) } _ { 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. /// present and an argument was provided.
fn opt_default(m: &match, nm: str, def: str) -> option::t<str> { fn opt_default(m: &match, nm: str, def: str) -> option::t<str> {
let vals = opt_vals(m, nm); let vals = opt_vals(m, nm);
if vec::len[optval](vals) == 0u { ret none[str]; } if vec::len::<optval>(vals) == 0u { ret none::<str>; }
ret alt vals.(0) { val(s) { some[str](s) } _ { some[str](def) } } ret alt vals.(0) { val(s) { some::<str>(s) } _ { some::<str>(def) } }
} }
// Local Variables: // Local Variables:
// mode: rust; // 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>) { obj FILE_buf_reader(f: os::libc::FILE, res: option::t<@FILE_res>) {
fn read(len: uint) -> [u8] { fn read(len: uint) -> [u8] {
let buf = ~[]; let buf = ~[];
vec::reserve[u8](buf, len); vec::reserve::<u8>(buf, len);
let read = os::libc::fread(vec::to_ptr[u8](buf), 1u, len, f); let read = os::libc::fread(vec::to_ptr::<u8>(buf), 1u, len, f);
vec::unsafe::set_len[u8](buf, read); vec::unsafe::set_len::<u8>(buf, read);
ret buf; ret buf;
} }
fn read_byte() -> int { ret os::libc::fgetc(f); } 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) { obj byte_buf_reader(bbuf: byte_buf) {
fn read(len: uint) -> [u8] { 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; let to_read = len;
if rest < to_read { to_read = rest; } 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; bbuf.pos += to_read;
ret range; ret range;
} }
fn read_byte() -> int { 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); let b = bbuf.buf.(bbuf.pos);
bbuf.pos += 1u; bbuf.pos += 1u;
ret b as int; ret b as int;
} }
fn unread_byte(byte: int) { log_err "TODO: unread_byte"; fail; } 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) { fn seek(offset: int, whence: seek_style) {
let pos = bbuf.pos; 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); bbuf.pos = seek_in_buf(offset, pos, len, whence);
} }
fn tell() -> uint { ret bbuf.pos; } 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>) { obj FILE_writer(f: os::libc::FILE, res: option::t<@FILE_res>) {
fn write(v: &[u8]) { fn write(v: &[u8]) {
let len = vec::len[u8](v); let len = vec::len::<u8>(v);
let vbuf = vec::to_ptr[u8](v); let vbuf = vec::to_ptr::<u8>(v);
let nout = os::libc::fwrite(vbuf, len, 1u, f); let nout = os::libc::fwrite(vbuf, len, 1u, f);
if nout < 1u { log_err "error dumping buffer"; } 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>) { obj fd_buf_writer(fd: int, res: option::t<@fd_res>) {
fn write(v: &[u8]) { fn write(v: &[u8]) {
let len = vec::len[u8](v); let len = vec::len::<u8>(v);
let count = 0u; let count = 0u;
let vbuf; let vbuf;
while count < len { 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); let nout = os::libc::write(fd, vbuf, len);
if nout < 0 { if nout < 0 {
log_err "error dumping buffer"; log_err "error dumping buffer";
@@ -403,12 +403,12 @@ obj byte_buf_writer(buf: mutable_byte_buf) {
if buf.pos == vec::len(buf.buf) { if buf.pos == vec::len(buf.buf) {
for b: u8 in v { buf.buf += ~[mutable b]; } for b: u8 in v { buf.buf += ~[mutable b]; }
buf.pos += vec::len[u8](v); buf.pos += vec::len::<u8>(v);
ret; ret;
} }
// FIXME: Optimize: These should be unique pointers. // FIXME: Optimize: These should be unique pointers.
let vlen = vec::len[u8](v); let vlen = vec::len::<u8>(v);
let vpos = 0u; let vpos = 0u;
while vpos < vlen { while vpos < vlen {
let b = v.(vpos); 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; } 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]; let l = nil::<T>;
// FIXME: This would be faster and more space efficient if it looped over // FIXME: This would be faster and more space efficient if it looped over
// a reverse vector iterator. Unfortunately generic iterators seem not to // a reverse vector iterator. Unfortunately generic iterators seem not to
// work yet. // 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; 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}; let load_factor: util::rational = {num: 3, den: 4};
tag bucket<@K, @V> { nil; deleted; some(K, V); } tag bucket<@K, @V> { nil; deleted; some(K, V); }
fn make_buckets<@K, @V>(nbkts: uint) -> [mutable (bucket<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 // Derive two hash functions from the one given by taking the upper
// half and lower half of the uint bits. Our bucket probing // 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); os::libc::closedir(dir);
ret result; ret result;
} }
vec::push[str](result, rustrt::rust_dirent_filename(ent)); vec::push::<str>(result, rustrt::rust_dirent_filename(ent));
} }
os::libc::closedir(dir); os::libc::closedir(dir);
ret result; ret result;

6
src/lib/sha1.rs
View File

@@ -248,13 +248,13 @@ fn mk_sha1() -> sha1 {
} }
} }
let st = 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_low: 0u32,
mutable len_high: 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 msg_block_idx: 0u,
mutable computed: false, 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); let sh = sha1(st);
sh.reset(); sh.reset();
ret sh; 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) { 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> { fn find<@T>(m: &smallintmap<T>, key: uint) -> option::t<T> {
if key < vec::len[option::t<T>](m.v) { ret m.v.(key); } if key < vec::len::<option::t<T>>(m.v) { ret m.v.(key); }
ret none[T]; 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) { alt find::<T>(m, key) {
none[T]. { log_err "smallintmap::get(): key not present"; fail; } none::<T>. { log_err "smallintmap::get(): key not present"; fail; }
some[T](v) { ret v; } 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)); 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); 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); 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_sort<@T>(le: &lteq<T>, v: &[T]) -> [T] {
fn merge<@T>(le: &lteq<T>, a: &[T], b: &[T]) -> [T] { fn merge<@T>(le: &lteq<T>, a: &[T], b: &[T]) -> [T] {
let rs: [T] = ~[]; let rs: [T] = ~[];
let a_len: uint = len[T](a); let a_len: uint = len::<T>(a);
let a_ix: uint = 0u; let a_ix: uint = 0u;
let b_len: uint = len[T](b); let b_len: uint = len::<T>(b);
let b_ix: uint = 0u; let b_ix: uint = 0u;
while a_ix < a_len && b_ix < b_len { while a_ix < a_len && b_ix < b_len {
if le(a.(a_ix), b.(b_ix)) { 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; a_ix += 1u;
} else { rs += ~[b.(b_ix)]; b_ix += 1u; } } else { rs += ~[b.(b_ix)]; b_ix += 1u; }
} }
rs += slice[T](a, a_ix, a_len); rs += slice::<T>(a, a_ix, a_len);
rs += slice[T](b, b_ix, b_len); rs += slice::<T>(b, b_ix, b_len);
ret rs; ret rs;
} }
let v_len: uint = len[T](v); let v_len: uint = len::<T>(v);
if v_len <= 1u { ret v; } if v_len <= 1u { ret v; }
let mid: uint = v_len / 2u; let mid: uint = v_len / 2u;
let a: [T] = slice[T](v, 0u, mid); let a: [T] = slice::<T>(v, 0u, mid);
let b: [T] = slice[T](v, mid, v_len); let b: [T] = slice::<T>(v, mid, v_len);
ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b)); 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) {
@@ -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, fn part<@T>(compare_func: &lteq<T>, arr: &[mutable T], left: uint,
right: uint, pivot: uint) -> uint { right: uint, pivot: uint) -> uint {
let pivot_value = arr.(pivot); let pivot_value = arr.(pivot);
swap[T](arr, pivot, right); swap::<T>(arr, pivot, right);
let storage_index: uint = left; let storage_index: uint = left;
let i: uint = left; let i: uint = left;
while i < right { while i < right {
if compare_func({ arr.(i) }, pivot_value) { if compare_func({ arr.(i) }, pivot_value) {
swap[T](arr, i, storage_index); swap::<T>(arr, i, storage_index);
storage_index += 1u; storage_index += 1u;
} }
i += 1u; i += 1u;
} }
swap[T](arr, storage_index, right); swap::<T>(arr, storage_index, right);
ret storage_index; ret storage_index;
} }
@@ -60,18 +60,18 @@ fn qsort<@T>(compare_func: &lteq<T>, arr: &[mutable T], left: uint,
right: uint) { right: uint) {
if right > left { if right > left {
let pivot = (left + right) / 2u; 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 { if new_pivot != 0u {
// Need to do this check before recursing due to overflow // 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]) { fn quick_sort<@T>(compare_func: &lteq<T>, arr: &[mutable T]) {
if len[T](arr) == 0u { ret; } if len::<T>(arr) == 0u { ret; }
qsort[T](compare_func, arr, 0u, len[T](arr) - 1u); 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; j -= 1;
} }
if i >= j { break; } 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) { if compare_func_eq({ arr.(i) }, v) {
p += 1; 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) }) { if compare_func_eq(v, { arr.(j) }) {
q -= 1; 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; j = i - 1;
i += 1; i += 1;
let k: int = left; let k: int = left;
while k < p { while k < p {
swap[T](arr, k as uint, j as uint); swap::<T>(arr, k as uint, j as uint);
k += 1; k += 1;
j -= 1; j -= 1;
if k == len[T](arr) as int { break; } if k == len::<T>(arr) as int { break; }
} }
k = right - 1; k = right - 1;
while k > q { while k > q {
swap[T](arr, i as uint, k as uint); swap::<T>(arr, i as uint, k as uint);
k -= 1; k -= 1;
i += 1; i += 1;
if k == 0 { break; } if k == 0 { break; }
} }
qsort3[T](compare_func_lt, compare_func_eq, arr, left, j); 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, i, right);
} }
fn quick_sort3<@T>(compare_func_lt: &lteq<T>, compare_func_eq: &lteq<T>, fn quick_sort3<@T>(compare_func_lt: &lteq<T>, compare_func_eq: &lteq<T>,
arr: &[mutable T]) { arr: &[mutable T]) {
if len[T](arr) == 0u { ret; } if len::<T>(arr) == 0u { ret; }
qsort3[T](compare_func_lt, compare_func_eq, arr, 0, qsort3::<T>(compare_func_lt, compare_func_eq, arr, 0,
(len[T](arr) as int) - 1); (len::<T>(arr) as int) - 1);
} }
// Local Variables: // 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 { fn is_utf8(v: &[u8]) -> bool {
let i = 0u; let i = 0u;
let total = vec::len[u8](v); let total = vec::len::<u8>(v);
while i < total { while i < total {
let chsize = utf8_char_width(v.(i)); let chsize = utf8_char_width(v.(i));
if chsize == 0u { ret false; } 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 unshift_char(s: &mutable str, ch: char) { s = from_char(ch) + s; }
fn refcount(s: str) -> uint { 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; } 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 { fn make_set(ufnd: &ufind) -> uint {
let idx = vec::len(ufnd.nodes); let idx = vec::len(ufnd.nodes);
ufnd.nodes += ~[mutable none[uint]]; ufnd.nodes += ~[mutable none::<uint>];
ret idx; ret idx;
} }
@@ -36,17 +36,19 @@ fn union(ufnd: &ufind, m: uint, n: uint) {
let m_root = find(ufnd, m); let m_root = find(ufnd, m);
let n_root = find(ufnd, n); let n_root = find(ufnd, n);
if m_root < n_root { if m_root < n_root {
ufnd.nodes.(n_root) = some[uint](m_root); ufnd.nodes.(n_root) = some::<uint>(m_root);
} else if (m_root > n_root) { ufnd.nodes.(m_root) = some[uint](n_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. // Removes all sets with IDs greater than or equal to the given value.
fn prune(ufnd: &ufind, n: uint) { fn prune(ufnd: &ufind, n: uint) {
// TODO: Use "slice" once we get rid of "mutable?" // TODO: Use "slice" once we get rid of "mutable?"
let len = vec::len[node](ufnd.nodes); let len = vec::len::<node>(ufnd.nodes);
while len != n { vec::pop[node](ufnd.nodes); len -= 1u; } 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 // FIXME change |* uint(4)| below to |* uint(8) / uint(2)| and watch the
// world explode. // 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 tmp: uint = n - 1u;
let shift: uint = 1u; let shift: uint = 1u;
while shift <= halfbits { tmp |= tmp >> shift; shift <<= 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 { fn parse_buf(buf: &[u8], radix: uint) -> uint {
if vec::len[u8](buf) == 0u { log_err "parse_buf(): buf is empty"; fail; } if vec::len::<u8>(buf) == 0u {
let i = vec::len[u8](buf) - 1u; log_err "parse_buf(): buf is empty";
fail;
}
let i = vec::len::<u8>(buf) - 1u;
let power = 1u; let power = 1u;
let n = 0u; let n = 0u;
while true { 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 // Mutators
fn shift<@T>(v: &mutable [mutable? T]) -> T { fn shift<@T>(v: &mutable [mutable? T]) -> T {
let ln = len[T](v); let ln = len::<T>(v);
assert (ln > 0u); assert (ln > 0u);
let e = v.(0); let e = v.(0);
v = slice[T](v, 1u, ln); v = slice::<T>(v, 1u, ln);
ret e; 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]) fn map2<@T, @U, @V>(f: &block(&T, &U) -> V, v0: &[T], v1: &[U])
-> [V] { -> [V] {
let v0_len = len[T](v0); let v0_len = len::<T>(v0);
if v0_len != len[U](v1) { fail; } if v0_len != len::<U>(v1) { fail; }
let u: [V] = ~[]; let u: [V] = ~[];
let i = 0u; let i = 0u;
while i < v0_len { u += ~[f({ v0.(i) }, { v1.(i) })]; i += 1u; } 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> { fn position<@T>(x: &T, v: &[T]) -> option::t<uint> {
let i: uint = 0u; let i: uint = 0u;
while i < len(v) { if x == v.(i) { ret some[uint](i); } i += 1u; } while i < len(v) { if x == v.(i) { ret some::<uint>(i); } i += 1u; }
ret none[uint]; ret none;
} }
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; let i: uint = 0u;
while i < len(v) { if f(v.(i)) { ret some[uint](i); } i += 1u; } while i < len(v) { if f(v.(i)) { ret some::<uint>(i); } i += 1u; }
ret none[uint]; ret none;
} }
fn unzip<@T, @U>(v: &[(T, U)]) -> ([T], [U]) { 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 // In place vector reversal
fn reverse<@T>(v: &[mutable T]) { fn reverse<@T>(v: &[mutable T]) {
let i: uint = 0u; 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; } 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. // 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 rs: [T] = ~[];
let i = len[T](v); let i = len::<T>(v);
if i == 0u { ret rs; } else { i -= 1u; } if i == 0u { ret rs; } else { i -= 1u; }
while i != 0u { rs += ~[v.(i)]; i -= 1u; } while i != 0u { rs += ~[v.(i)]; i -= 1u; }
rs += ~[v.(0)]; rs += ~[v.(0)];
@@ -334,7 +334,7 @@ mod unsafe {
} }
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 new_fill = new_len * sys::size_of::<T>();
let stack_part: *mutable ivec_repr = let stack_part: *mutable ivec_repr =
::unsafe::reinterpret_cast(addr_of(v)); ::unsafe::reinterpret_cast(addr_of(v));
if (*stack_part).fill == 0u { if (*stack_part).fill == 0u {