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

13 files changed, 68 insertions, 68 deletions

diff --git a/src/test/stdtest/bitv.rs b/src/test/stdtest/bitv.rs
index d95a0cf414a..9ad241bb3f1 100644
--- a/src/test/stdtest/bitv.rs
+++ b/src/test/stdtest/bitv.rs
@@ -8,8 +8,8 @@ fn test_0_elements() {
     let act;
     let exp;
     act = bitv::create(0u, false);
-    exp = vec::init_elt[uint](0u, 0u);
-    // FIXME: why can't I write vec[uint]()?
+    exp = vec::init_elt::<uint>(0u, 0u);
+    // FIXME: why can't I write vec::<uint>()?
 
     assert (bitv::eq_ivec(act, exp));
 }
diff --git a/src/test/stdtest/box.rs b/src/test/stdtest/box.rs
index 6212ec63965..c28cb520be8 100644
--- a/src/test/stdtest/box.rs
+++ b/src/test/stdtest/box.rs
@@ -6,8 +6,8 @@ import std::box;
 fn test() {
     let x = @3;
     let y = @3;
-    assert (box::ptr_eq[int](x, x));
-    assert (box::ptr_eq[int](y, y));
-    assert (!box::ptr_eq[int](x, y));
-    assert (!box::ptr_eq[int](y, x));
-}
\ No newline at end of file
+    assert (box::ptr_eq::<int>(x, x));
+    assert (box::ptr_eq::<int>(y, y));
+    assert (!box::ptr_eq::<int>(x, y));
+    assert (!box::ptr_eq::<int>(y, x));
+}
diff --git a/src/test/stdtest/comm.rs b/src/test/stdtest/comm.rs
index 5f83542001d..e0e310e5ee2 100644
--- a/src/test/stdtest/comm.rs
+++ b/src/test/stdtest/comm.rs
@@ -3,13 +3,13 @@ import std::comm;
 
 #[test]
 fn create_port_and_chan() {
-    let p = comm::mk_port<int>();
+    let p = comm::mk_port::<int>();
     let c = p.mk_chan();
 }
 
 #[test]
 fn send_recv() {
-    let p = comm::mk_port<int>();
+    let p = comm::mk_port::<int>();
     let c = p.mk_chan();
 
     comm::send(c, 42);
diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs
index 0c53895bd37..d751bd5c45d 100644
--- a/src/test/stdtest/deque.rs
+++ b/src/test/stdtest/deque.rs
@@ -6,7 +6,7 @@ import std::deque;
 
 #[test]
 fn test_simple() {
-    let d: deque::t<int> = deque::create[int]();
+    let d: deque::t<int> = deque::create::<int>();
     assert (d.size() == 0u);
     d.add_front(17);
     d.add_front(42);
@@ -50,7 +50,7 @@ fn test_simple() {
 }
 
 fn test_boxes(a: @int, b: @int, c: @int, d: @int) {
-    let deq: deque::t<@int> = deque::create[@int]();
+    let deq: deque::t<@int> = deque::create::<@int>();
     assert (deq.size() == 0u);
     deq.add_front(a);
     deq.add_front(b);
@@ -82,7 +82,7 @@ fn test_boxes(a: @int, b: @int, c: @int, d: @int) {
 type eqfn<T> = fn(&T, &T) -> bool ;
 
 fn test_parameterized<@T>(e: eqfn<T>, a: &T, b: &T, c: &T, d: &T) {
-    let deq: deque::t<T> = deque::create[T]();
+    let deq: deque::t<T> = deque::create::<T>();
     assert (deq.size() == 0u);
     deq.add_front(a);
     deq.add_front(b);
@@ -140,18 +140,18 @@ fn test() {
     }
     fn taggypareq<@T>(a: &taggypar<T>, b: &taggypar<T>) -> bool {
         alt a {
-          onepar[T](a1) {
-            alt b { onepar[T](b1) { ret a1 == b1; } _ { ret false; } }
+          onepar::<T>(a1) {
+            alt b { onepar::<T>(b1) { ret a1 == b1; } _ { ret false; } }
           }
-          twopar[T](a1, a2) {
+          twopar::<T>(a1, a2) {
             alt b {
-              twopar[T](b1, b2) { ret a1 == b1 && a2 == b2; }
+              twopar::<T>(b1, b2) { ret a1 == b1 && a2 == b2; }
               _ { ret false; }
             }
           }
-          threepar[T](a1, a2, a3) {
+          threepar::<T>(a1, a2, a3) {
             alt b {
-              threepar[T](b1, b2, b3) {
+              threepar::<T>(b1, b2, b3) {
                 ret a1 == b1 && a2 == b2 && a3 == b3;
               }
               _ { ret false; }
@@ -167,24 +167,24 @@ fn test() {
     log "*** end test boxes";
     log "test parameterized: int";
     let eq1: eqfn<int> = inteq;
-    test_parameterized[int](eq1, 5, 72, 64, 175);
+    test_parameterized::<int>(eq1, 5, 72, 64, 175);
     log "*** test parameterized: @int";
     let eq2: eqfn<@int> = intboxeq;
-    test_parameterized[@int](eq2, @5, @72, @64, @175);
+    test_parameterized::<@int>(eq2, @5, @72, @64, @175);
     log "*** end test parameterized @int";
     log "test parameterized: taggy";
     let eq3: eqfn<taggy> = taggyeq;
-    test_parameterized[taggy](eq3, one(1), two(1, 2), three(1, 2, 3),
+    test_parameterized::<taggy>(eq3, one(1), two(1, 2), three(1, 2, 3),
                               two(17, 42));
 
     log "*** test parameterized: taggypar<int>";
-    let eq4: eqfn<taggypar<int>> = taggypareq[int];
-    test_parameterized[taggypar<int>](eq4,
-                                      onepar[int](1),
-                                      twopar[int](1, 2),
-                                      threepar[int](1, 2, 3),
-                                      twopar[int](17, 42));
-    log "*** end test parameterized: taggypar[int]";
+    let eq4: eqfn<taggypar<int>> = taggypareq::<int>;
+    test_parameterized::<taggypar<int>>(eq4,
+                                      onepar::<int>(1),
+                                      twopar::<int>(1, 2),
+                                      threepar::<int>(1, 2, 3),
+                                      twopar::<int>(17, 42));
+    log "*** end test parameterized: taggypar::<int>";
 
     log "*** test parameterized: reccy";
     let reccy1: reccy = {x: 1, y: 2, t: one(1)};
@@ -192,7 +192,7 @@ fn test() {
     let reccy3: reccy = {x: 1, y: 777, t: three(1, 2, 3)};
     let reccy4: reccy = {x: 19, y: 252, t: two(17, 42)};
     let eq5: eqfn<reccy> = reccyeq;
-    test_parameterized[reccy](eq5, reccy1, reccy2, reccy3, reccy4);
+    test_parameterized::<reccy>(eq5, reccy1, reccy2, reccy3, reccy4);
     log "*** end test parameterized: reccy";
     log "*** done";
 }
diff --git a/src/test/stdtest/list.rs b/src/test/stdtest/list.rs
index 383a6ce49fe..4a44508efc4 100644
--- a/src/test/stdtest/list.rs
+++ b/src/test/stdtest/list.rs
@@ -26,7 +26,7 @@ fn test_foldl() {
 fn test_find_success() {
     let l = from_vec(~[0, 1, 2]);
     fn match(i: &int) -> option::t<int> {
-        ret if i == 2 { option::some(i) } else { option::none[int] };
+        ret if i == 2 { option::some(i) } else { option::none::<int> };
     }
     let rs = list::find(l, match);
     assert (rs == option::some(2));
@@ -35,15 +35,15 @@ fn test_find_success() {
 #[test]
 fn test_find_fail() {
     let l = from_vec(~[0, 1, 2]);
-    fn match(i: &int) -> option::t<int> { ret option::none[int]; }
+    fn match(i: &int) -> option::t<int> { ret option::none::<int>; }
     let rs = list::find(l, match);
-    assert (rs == option::none[int]);
+    assert (rs == option::none::<int>);
 }
 
 #[test]
 fn test_has() {
     let l = from_vec(~[5, 8, 6]);
-    let empty = list::nil[int];
+    let empty = list::nil::<int>;
     assert (list::has(l, 5));
     assert (!list::has(l, 7));
     assert (list::has(l, 8));
diff --git a/src/test/stdtest/map.rs b/src/test/stdtest/map.rs
index ffda00c4947..2da579cf472 100644
--- a/src/test/stdtest/map.rs
+++ b/src/test/stdtest/map.rs
@@ -23,7 +23,7 @@ fn test_simple() {
     let eqer_str: map::eqfn<str> = str::eq;
     log "uint -> uint";
     let hm_uu: map::hashmap<uint, uint> =
-        map::mk_hashmap[uint, uint](hasher_uint, eqer_uint);
+        map::mk_hashmap::<uint, uint>(hasher_uint, eqer_uint);
     assert (hm_uu.insert(10u, 12u));
     assert (hm_uu.insert(11u, 13u));
     assert (hm_uu.insert(12u, 14u));
@@ -39,7 +39,7 @@ fn test_simple() {
     let twelve: str = "twelve";
     log "str -> uint";
     let hm_su: map::hashmap<str, uint> =
-        map::mk_hashmap[str, uint](hasher_str, eqer_str);
+        map::mk_hashmap::<str, uint>(hasher_str, eqer_str);
     assert (hm_su.insert("ten", 12u));
     assert (hm_su.insert(eleven, 13u));
     assert (hm_su.insert("twelve", 14u));
@@ -53,7 +53,7 @@ fn test_simple() {
     assert (hm_su.get("twelve") == 12u);
     log "uint -> str";
     let hm_us: map::hashmap<uint, str> =
-        map::mk_hashmap[uint, str](hasher_uint, eqer_uint);
+        map::mk_hashmap::<uint, str>(hasher_uint, eqer_uint);
     assert (hm_us.insert(10u, "twelve"));
     assert (hm_us.insert(11u, "thirteen"));
     assert (hm_us.insert(12u, "fourteen"));
@@ -66,7 +66,7 @@ fn test_simple() {
     assert (str::eq(hm_us.get(12u), "twelve"));
     log "str -> str";
     let hm_ss: map::hashmap<str, str> =
-        map::mk_hashmap[str, str](hasher_str, eqer_str);
+        map::mk_hashmap::<str, str>(hasher_str, eqer_str);
     assert (hm_ss.insert(ten, "twelve"));
     assert (hm_ss.insert(eleven, "thirteen"));
     assert (hm_ss.insert(twelve, "fourteen"));
@@ -99,7 +99,7 @@ fn test_growth() {
     let hasher_uint: map::hashfn<uint> = hash_uint;
     let eqer_uint: map::eqfn<uint> = eq_uint;
     let hm_uu: map::hashmap<uint, uint> =
-        map::mk_hashmap[uint, uint](hasher_uint, eqer_uint);
+        map::mk_hashmap::<uint, uint>(hasher_uint, eqer_uint);
     let i: uint = 0u;
     while i < num_to_insert {
         assert (hm_uu.insert(i, i * i));
@@ -130,7 +130,7 @@ fn test_growth() {
     let hasher_str: map::hashfn<str> = str::hash;
     let eqer_str: map::eqfn<str> = str::eq;
     let hm_ss: map::hashmap<str, str> =
-        map::mk_hashmap[str, str](hasher_str, eqer_str);
+        map::mk_hashmap::<str, str>(hasher_str, eqer_str);
     i = 0u;
     while i < num_to_insert {
         assert (hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u)));
@@ -181,7 +181,7 @@ fn test_removal() {
     let hasher: map::hashfn<uint> = hash;
     let eqer: map::eqfn<uint> = eq;
     let hm: map::hashmap<uint, uint> =
-        map::mk_hashmap[uint, uint](hasher, eqer);
+        map::mk_hashmap::<uint, uint>(hasher, eqer);
     let i: uint = 0u;
     while i < num_to_insert {
         assert (hm.insert(i, i * i));
@@ -200,10 +200,10 @@ fn test_removal() {
 
         let v: util.option<uint> = hm.remove(i);
         alt (v) {
-          case (util.some[uint](u)) {
+          case (util.some::<uint>(u)) {
             assert (u == (i * i));
           }
-          case (util.none[uint]()) { fail; }
+          case (util.none::<uint>()) { fail; }
         }
 
          * but we util.option is a tag type so util.some and util.none are
@@ -268,7 +268,7 @@ fn test_removal() {
 #[test]
 fn test_contains_key() {
     let key = "k";
-    let map = map::mk_hashmap[str, str](str::hash, str::eq);
+    let map = map::mk_hashmap::<str, str>(str::hash, str::eq);
     assert (!map.contains_key(key));
     map.insert(key, "val");
     assert (map.contains_key(key));
@@ -277,7 +277,7 @@ fn test_contains_key() {
 #[test]
 fn test_find() {
     let key = "k";
-    let map = map::mk_hashmap[str, str](str::hash, str::eq);
+    let map = map::mk_hashmap::<str, str>(str::hash, str::eq);
     assert (std::option::is_none(map.find(key)));
     map.insert(key, "val");
     assert (std::option::get(map.find(key)) == "val");
diff --git a/src/test/stdtest/option.rs b/src/test/stdtest/option.rs
index 6426c96ffb6..ef383832604 100644
--- a/src/test/stdtest/option.rs
+++ b/src/test/stdtest/option.rs
@@ -2,4 +2,4 @@
 use std;
 
 #[test]
-fn test() { let x = std::option::some[int](10); }
\ No newline at end of file
+fn test() { let x = std::option::some::<int>(10); }
diff --git a/src/test/stdtest/qsort.rs b/src/test/stdtest/qsort.rs
index 0abf551a28f..4e557b533a4 100644
--- a/src/test/stdtest/qsort.rs
+++ b/src/test/stdtest/qsort.rs
@@ -6,10 +6,10 @@ import std::vec;
 import std::int;
 
 fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
-    let len = std::vec::len[int](v1);
+    let len = std::vec::len::<int>(v1);
     fn ltequal(a: &int, b: &int) -> bool { ret a <= b; }
     let f = ltequal;
-    std::sort::quick_sort[int](f, v1);
+    std::sort::quick_sort::<int>(f, v1);
     let i = 0u;
     while i < len { log v2.(i); assert (v2.(i) == v1.(i)); i += 1u; }
 }
diff --git a/src/test/stdtest/qsort3.rs b/src/test/stdtest/qsort3.rs
index 707e17967cd..21f43218806 100644
--- a/src/test/stdtest/qsort3.rs
+++ b/src/test/stdtest/qsort3.rs
@@ -2,12 +2,12 @@
 use std;
 
 fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
-    let len = std::vec::len[int](v1);
+    let len = std::vec::len::<int>(v1);
     fn lt(a: &int, b: &int) -> bool { ret a < b; }
     fn equal(a: &int, b: &int) -> bool { ret a == b; }
     let f1 = lt;
     let f2 = equal;
-    std::sort::quick_sort3[int](f1, f2, v1);
+    std::sort::quick_sort3::<int>(f1, f2, v1);
     let i = 0u;
     while i < len { log v2.(i); assert (v2.(i) == v1.(i)); i += 1u; }
 }
diff --git a/src/test/stdtest/sha1.rs b/src/test/stdtest/sha1.rs
index ef581d18c69..74729fa52ae 100644
--- a/src/test/stdtest/sha1.rs
+++ b/src/test/stdtest/sha1.rs
@@ -61,8 +61,8 @@ fn test() {
                 0x10u8, 0x0du8, 0xb4u8, 0xb3u8]}];
     let tests = fips_180_1_tests + wikipedia_tests;
     fn check_vec_eq(v0: &[u8], v1: &[u8]) {
-        assert (vec::len[u8](v0) == vec::len[u8](v1));
-        let len = vec::len[u8](v0);
+        assert (vec::len::<u8>(v0) == vec::len::<u8>(v1));
+        let len = vec::len::<u8>(v0);
         let i = 0u;
         while i < len {
             let a = v0.(i);
diff --git a/src/test/stdtest/sort.rs b/src/test/stdtest/sort.rs
index f4f7d5ea75e..be15881e65a 100644
--- a/src/test/stdtest/sort.rs
+++ b/src/test/stdtest/sort.rs
@@ -2,10 +2,10 @@
 use std;
 
 fn check_sort(v1: &[int], v2: &[int]) {
-    let len = std::vec::len[int](v1);
+    let len = std::vec::len::<int>(v1);
     fn lteq(a: &int, b: &int) -> bool { ret a <= b; }
     let f = lteq;
-    let v3 = std::sort::merge_sort[int](f, v1);
+    let v3 = std::sort::merge_sort::<int>(f, v1);
     let i = 0u;
     while i < len { log v3.(i); assert (v3.(i) == v2.(i)); i += 1u; }
 }
diff --git a/src/test/stdtest/vec.rs b/src/test/stdtest/vec.rs
index dab250ce142..75b3998e28c 100644
--- a/src/test/stdtest/vec.rs
+++ b/src/test/stdtest/vec.rs
@@ -90,14 +90,14 @@ fn test_init_elt() {
 
 #[test]
 fn test_is_empty() {
-    assert (vec::is_empty[int](~[]));
+    assert (vec::is_empty::<int>(~[]));
     assert (!vec::is_empty(~[0]));
 }
 
 #[test]
 fn test_is_not_empty() {
     assert (vec::is_not_empty(~[0]));
-    assert (!vec::is_not_empty[int](~[]));
+    assert (!vec::is_not_empty::<int>(~[]));
 }
 
 #[test]
@@ -242,7 +242,7 @@ fn test_map2() {
     let f = times;
     let v0 = ~[1, 2, 3, 4, 5];
     let v1 = ~[5, 4, 3, 2, 1];
-    let u = vec::map2[int, int, int](f, v0, v1);
+    let u = vec::map2::<int, int, int>(f, v0, v1);
     let i = 0;
     while i < 5 { assert (v0.(i) * v1.(i) == u.(i)); i += 1; }
 }
@@ -266,8 +266,8 @@ fn test_filter_map() {
 
     fn halve(i: &int) -> option::t<int> {
         if i % 2 == 0 {
-            ret option::some[int](i / 2);
-        } else { ret option::none[int]; }
+            ret option::some::<int>(i / 2);
+        } else { ret option::none::<int>; }
     }
     fn halve_for_sure(i: &int) -> int { ret i / 2; }
     let all_even: [int] = ~[0, 2, 8, 6];
@@ -328,10 +328,10 @@ fn test_zip_unzip() {
 #[test]
 fn test_position() {
     let v1: [int] = ~[1, 2, 3, 3, 2, 5];
-    assert (position(1, v1) == option::some[uint](0u));
-    assert (position(2, v1) == option::some[uint](1u));
-    assert (position(5, v1) == option::some[uint](5u));
-    assert (position(4, v1) == option::none[uint]);
+    assert (position(1, v1) == option::some::<uint>(0u));
+    assert (position(2, v1) == option::some::<uint>(1u));
+    assert (position(5, v1) == option::some::<uint>(5u));
+    assert (position(4, v1) == option::none::<uint>);
 }
 
 #[test]
@@ -339,8 +339,8 @@ fn test_position_pred() {
     fn less_than_three(i: &int) -> bool { ret i < 3; }
     fn is_eighteen(i: &int) -> bool { ret i == 18; }
     let v1: [int] = ~[5, 4, 3, 2, 1];
-    assert (position_pred(less_than_three, v1) == option::some[uint](3u));
-    assert (position_pred(is_eighteen, v1) == option::none[uint]);
+    assert (position_pred(less_than_three, v1) == option::some::<uint>(3u));
+    assert (position_pred(is_eighteen, v1) == option::none::<uint>);
 }
 
 #[test]
@@ -351,16 +351,16 @@ fn reverse_and_reversed() {
     vec::reverse(v);
     assert (v.(0) == 20);
     assert (v.(1) == 10);
-    let v2 = vec::reversed[int](~[10, 20]);
+    let v2 = vec::reversed::<int>(~[10, 20]);
     assert (v2.(0) == 20);
     assert (v2.(1) == 10);
     v.(0) = 30;
     assert (v2.(0) == 20);
     // Make sure they work with 0-length vectors too.
 
-    let v4 = vec::reversed[int](~[]);
+    let v4 = vec::reversed::<int>(~[]);
     let v3: [mutable int] = ~[mutable];
-    vec::reverse[int](v3);
+    vec::reverse::<int>(v3);
 }
 
 // Local Variables:
diff --git a/src/test/stdtest/vec_str_conversions.rs b/src/test/stdtest/vec_str_conversions.rs
index e2b11cbfb28..cc52ec80e95 100644
--- a/src/test/stdtest/vec_str_conversions.rs
+++ b/src/test/stdtest/vec_str_conversions.rs
@@ -13,7 +13,7 @@ fn test_simple() {
     let s2: str = str::unsafe_from_bytes(v);
     let i: uint = 0u;
     let n1: uint = str::byte_len(s1);
-    let n2: uint = vec::len[u8](v);
+    let n2: uint = vec::len::<u8>(v);
     assert (n1 == n2);
     while i < n1 {
         let a: u8 = s1.(i);