diff --git a/src/lib/aio.rs b/src/lib/aio.rs
index 03953f40a42..fc10e40a327 100644
--- a/src/lib/aio.rs
+++ b/src/lib/aio.rs
@@ -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) {
diff --git a/src/lib/bitv.rs b/src/lib/bitv.rs
index 444d388059e..74e68fd4b39 100644
--- a/src/lib/bitv.rs
+++ b/src/lib/bitv.rs
@@ -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 {
diff --git a/src/lib/comm.rs b/src/lib/comm.rs
index 2fe0dc2bcaa..03b719cdc73 100644
--- a/src/lib/comm.rs
+++ b/src/lib/comm.rs
@@ -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) {
diff --git a/src/lib/dbg.rs b/src/lib/dbg.rs
index 543f22bffe6..ce353edadfa 100644
--- a/src/lib/dbg.rs
+++ b/src/lib/dbg.rs
@@ -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:
diff --git a/src/lib/deque.rs b/src/lib/deque.rs
index bda06870efe..19d74f14789 100644
--- a/src/lib/deque.rs
+++ b/src/lib/deque.rs
@@ -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;
diff --git a/src/lib/ebml.rs b/src/lib/ebml.rs
index cd7fbf9eb3b..31814b8d098 100644
--- a/src/lib/ebml.rs
+++ b/src/lib/ebml.rs
@@ -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);
diff --git a/src/lib/extfmt.rs b/src/lib/extfmt.rs
index 11239d7ed42..dde2e9ec8a3 100644
--- a/src/lib/extfmt.rs
+++ b/src/lib/extfmt.rs
@@ -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);
     }
diff --git a/src/lib/generic_os.rs b/src/lib/generic_os.rs
index da660e34dc5..acb9a772048 100644
--- a/src/lib/generic_os.rs
+++ b/src/lib/generic_os.rs
@@ -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")]
diff --git a/src/lib/getopts.rs b/src/lib/getopts.rs
index eb56b44b490..681815881a7 100644
--- a/src/lib/getopts.rs
+++ b/src/lib/getopts.rs
@@ -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;
diff --git a/src/lib/io.rs b/src/lib/io.rs
index d10cb2fe33b..0778a64e3f1 100644
--- a/src/lib/io.rs
+++ b/src/lib/io.rs
@@ -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);
diff --git a/src/lib/list.rs b/src/lib/list.rs
index abc0c363d41..7856fc800f2 100644
--- a/src/lib/list.rs
+++ b/src/lib/list.rs
@@ -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;
 }
 
diff --git a/src/lib/map.rs b/src/lib/map.rs
index 31ff01ef8b6..3f92503e589 100644
--- a/src/lib/map.rs
+++ b/src/lib/map.rs
@@ -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
diff --git a/src/lib/posix_fs.rs b/src/lib/posix_fs.rs
index 16dacf287f6..43ade4a7703 100644
--- a/src/lib/posix_fs.rs
+++ b/src/lib/posix_fs.rs
@@ -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;
diff --git a/src/lib/sha1.rs b/src/lib/sha1.rs
index dc487180867..99c0f1276d1 100644
--- a/src/lib/sha1.rs
+++ b/src/lib/sha1.rs
@@ -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;
diff --git a/src/lib/smallintmap.rs b/src/lib/smallintmap.rs
index 6d2c6e715c1..6eca2eccc23 100644
--- a/src/lib/smallintmap.rs
+++ b/src/lib/smallintmap.rs
@@ -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);
 }
 
diff --git a/src/lib/sort.rs b/src/lib/sort.rs
index 4400b21535b..137cf0495ca 100644
--- a/src/lib/sort.rs
+++ b/src/lib/sort.rs
@@ -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:
diff --git a/src/lib/str.rs b/src/lib/str.rs
index b6a6beb0a8d..df9f6817343 100644
--- a/src/lib/str.rs
+++ b/src/lib/str.rs
@@ -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; }
 }
 
diff --git a/src/lib/ufind.rs b/src/lib/ufind.rs
index eb52027d4b8..12e85a98b7c 100644
--- a/src/lib/ufind.rs
+++ b/src/lib/ufind.rs
@@ -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; }
 }
diff --git a/src/lib/uint.rs b/src/lib/uint.rs
index 7925f3ba951..8be0df57fd7 100644
--- a/src/lib/uint.rs
+++ b/src/lib/uint.rs
@@ -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 {
diff --git a/src/lib/vec.rs b/src/lib/vec.rs
index 0a6228945fb..dc0dab58d0c 100644
--- a/src/lib/vec.rs
+++ b/src/lib/vec.rs
@@ -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 {