diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs
index abe1b053f9ad..5bb5912630f4 100644
--- a/src/comp/front/test.rs
+++ b/src/comp/front/test.rs
@@ -173,7 +173,7 @@ fn nospan<T>(t: &T) -> ast::spanned<T> {
 }
 
 fn mk_tests(cx: &test_ctxt) -> @ast::item {
-    let ret_ty = mk_test_desc_ivec_ty(cx);
+    let ret_ty = mk_test_desc_vec_ty(cx);
 
     let decl: ast::fn_decl =
         {inputs: ~[],
@@ -213,7 +213,7 @@ fn empty_fn_ty() -> ast::ty {
 }
 
 // The ast::ty of [std::test::test_desc]
-fn mk_test_desc_ivec_ty(cx: &test_ctxt) -> @ast::ty {
+fn mk_test_desc_vec_ty(cx: &test_ctxt) -> @ast::ty {
     let test_desc_ty_path: ast::path =
         nospan({global: false,
                 idents: ~["std", "test", "test_desc"],
@@ -222,9 +222,9 @@ fn mk_test_desc_ivec_ty(cx: &test_ctxt) -> @ast::ty {
     let test_desc_ty: ast::ty =
         nospan(ast::ty_path(test_desc_ty_path, cx.next_node_id()));
 
-    let ivec_mt: ast::mt = {ty: @test_desc_ty, mut: ast::imm};
+    let vec_mt: ast::mt = {ty: @test_desc_ty, mut: ast::imm};
 
-    ret @nospan(ast::ty_vec(ivec_mt));
+    ret @nospan(ast::ty_vec(vec_mt));
 }
 
 fn mk_test_desc_vec(cx: &test_ctxt) -> @ast::expr {
diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs
index 108ba079928f..a9a85e1190bc 100644
--- a/src/comp/metadata/tydecode.rs
+++ b/src/comp/metadata/tydecode.rs
@@ -217,7 +217,7 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
       '@' { ret ty::mk_box(st.tcx, parse_mt(st, sd)); }
       '~' { ret ty::mk_uniq(st.tcx, parse_ty(st, sd)); }
       '*' { ret ty::mk_ptr(st.tcx, parse_mt(st, sd)); }
-      'I' { ret ty::mk_ivec(st.tcx, parse_mt(st, sd)); }
+      'I' { ret ty::mk_vec(st.tcx, parse_mt(st, sd)); }
       'R' {
         assert (next(st) as char == '[');
         let fields: [ty::field] = ~[];
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index e8da7cf6d636..122d666cc2fc 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -6329,7 +6329,7 @@ fn create_main_wrapper(ccx: &@crate_ctxt, sp: &span,
                    takes_ivec: bool) -> ValueRef {
         let ivecarg_ty: ty::arg = {
             mode: ty::mo_val,
-            ty: ty::mk_ivec(ccx.tcx, {
+            ty: ty::mk_vec(ccx.tcx, {
                 ty: ty::mk_str(ccx.tcx),
                 mut: ast::imm
             })
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index c00b29be1702..8352d5f9e28a 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -72,7 +72,7 @@ export mk_mut_ptr;
 export mk_imm_vec;
 export mk_int;
 export mk_istr;
-export mk_ivec;
+export mk_vec;
 export mk_mach;
 export mk_native;
 export mk_native_fn;
@@ -563,7 +563,7 @@ fn mk_mut_ptr(cx: &ctxt, ty: &t) -> t {
     ret mk_ptr(cx, {ty: ty, mut: ast::mut});
 }
 
-fn mk_ivec(cx: &ctxt, tm: &mt) -> t { ret gen_ty(cx, ty_vec(tm)); }
+fn mk_vec(cx: &ctxt, tm: &mt) -> t { ret gen_ty(cx, ty_vec(tm)); }
 
 fn mk_rec(cx: &ctxt, fs: &[field]) -> t { ret gen_ty(cx, ty_rec(fs)); }
 
@@ -709,7 +709,7 @@ fn fold_ty(cx: &ctxt, fld: fold_mode, ty_0: t) -> t {
         ty = mk_ptr(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
       }
       ty_vec(tm) {
-        ty = mk_ivec(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
+        ty = mk_vec(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
       }
       ty_tag(tid, subtys) {
         let new_subtys: [t] = ~[];
@@ -2487,7 +2487,7 @@ mod unify {
                 alt result {
                   ures_ok(result_sub) {
                     let mt = {ty: result_sub, mut: mut};
-                    ret ures_ok(mk_ivec(cx.tcx, mt));
+                    ret ures_ok(mk_vec(cx.tcx, mt));
                   }
                   _ { ret result; }
                 }
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index fd1856bf20eb..7d6ba76e7ebd 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -325,7 +325,7 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
         typ = ty::mk_box(tcx, ast_mt_to_mt(tcx, getter, mt));
       }
       ast::ty_vec(mt) {
-        typ = ty::mk_ivec(tcx, ast_mt_to_mt(tcx, getter, mt));
+        typ = ty::mk_vec(tcx, ast_mt_to_mt(tcx, getter, mt));
       }
       ast::ty_ptr(mt) {
         typ = ty::mk_ptr(tcx, ast_mt_to_mt(tcx, getter, mt));
@@ -2182,7 +2182,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
         for e: @ast::expr in args {
             bot |= check_expr_with(fcx, e, t);
         }
-        let typ = ty::mk_ivec(tcx, {ty: t, mut: mut});
+        let typ = ty::mk_vec(tcx, {ty: t, mut: mut});
         write::ty_only_fixup(fcx, id, typ);
       }
       ast::expr_tup(elts) {
diff --git a/src/fuzzer/ast_match.rs b/src/fuzzer/ast_match.rs
index dbbce0ee8a17..ebd3bf339bbd 100644
--- a/src/fuzzer/ast_match.rs
+++ b/src/fuzzer/ast_match.rs
@@ -1,7 +1,7 @@
 use std;
 import std::vec;
 
-fn ivec_equal<T>(v: &[T], u: &[T], element_equality_test: fn(&T, &T) -> bool )
+fn vec_equal<T>(v: &[T], u: &[T], element_equality_test: fn(&T, &T) -> bool )
    -> bool {
     let Lv = vec::len(v);
     if Lv != vec::len(u) { ret false; }
@@ -18,10 +18,10 @@ fn builtin_equal<T>(a: &T, b: &T) -> bool { ret a == b; }
 fn main() {
     assert (builtin_equal(5, 5));
     assert (!builtin_equal(5, 4));
-    assert (!ivec_equal(~[5, 5], ~[5], builtin_equal));
-    assert (!ivec_equal(~[5, 5], ~[5, 4], builtin_equal));
-    assert (!ivec_equal(~[5, 5], ~[4, 5], builtin_equal));
-    assert (ivec_equal(~[5, 5], ~[5, 5], builtin_equal));
+    assert (!vec_equal(~[5, 5], ~[5], builtin_equal));
+    assert (!vec_equal(~[5, 5], ~[5, 4], builtin_equal));
+    assert (!vec_equal(~[5, 5], ~[4, 5], builtin_equal));
+    assert (vec_equal(~[5, 5], ~[5, 5], builtin_equal));
 
     log_err "Pass";
 }
diff --git a/src/fuzzer/ivec_fuzz.rs b/src/fuzzer/ivec_fuzz.rs
index f6681bf70bd7..2d6c51c42258 100644
--- a/src/fuzzer/ivec_fuzz.rs
+++ b/src/fuzzer/ivec_fuzz.rs
@@ -21,9 +21,9 @@ https://github.com/graydon/rust/issues/640
 */
 
 use std;
-import std::ivec;
-import std::ivec::slice;
-import std::ivec::len;
+import std::vec;
+import std::vec::slice;
+import std::vec::len;
 import std::int;
 
 //fn vec_reverse(&<T> v) -> [T] { ... }
diff --git a/src/lib/bitv.rs b/src/lib/bitv.rs
index 3e31dc4b34a6..c42ef07bfb2d 100644
--- a/src/lib/bitv.rs
+++ b/src/lib/bitv.rs
@@ -16,8 +16,7 @@ export is_true;
 export is_false;
 export to_vec;
 export to_str;
-export eq_ivec;
-
+export eq_vec;
 
 // FIXME: With recursive object types, we could implement binary methods like
 //        union, intersection, and difference. At that point, we could write
@@ -161,7 +160,7 @@ fn to_str(v: &t) -> str {
     ret rs;
 }
 
-fn eq_ivec(v0: &t, v1: &[uint]) -> bool {
+fn eq_vec(v0: &t, v1: &[uint]) -> bool {
     assert (v0.nbits == vec::len::<uint>(v1));
     let len = v0.nbits;
     let i = 0u;
diff --git a/src/lib/test.rs b/src/lib/test.rs
index d5986bf01076..b725507502b0 100644
--- a/src/lib/test.rs
+++ b/src/lib/test.rs
@@ -10,7 +10,6 @@ export test_name;
 export test_fn;
 export test_desc;
 export test_main;
-export test_main_ivec;
 export test_result;
 export test_opts;
 export tr_ok;
diff --git a/src/test/compiletest/procsrv.rs b/src/test/compiletest/procsrv.rs
index 68df59be5216..d434562cf3cb 100644
--- a/src/test/compiletest/procsrv.rs
+++ b/src/test/compiletest/procsrv.rs
@@ -64,7 +64,7 @@ fn run(handle: &handle, lib_path: &str,
     let ch = chan(p);
     send(handle.chan, exec(str::bytes(lib_path),
                            str::bytes(prog),
-                           clone_ivecstr(args),
+                           clone_vecstr(args),
                            ch));
     let resp = recv(p);
 
@@ -123,7 +123,7 @@ fn worker(p: port<request>) {
                 {
                     lib_path: str::unsafe_from_bytes(lib_path),
                     prog: str::unsafe_from_bytes(prog),
-                    args: clone_ivecu8str(args),
+                    args: clone_vecu8str(args),
                     respchan: respchan
                 }
               }
@@ -178,7 +178,7 @@ fn append_lib_path(path: &str) { export_lib_path(util::make_new_path(path)); }
 
 fn export_lib_path(path: &str) { setenv(util::lib_path_env_var(), path); }
 
-fn clone_ivecstr(v: &[str]) -> [[u8]] {
+fn clone_vecstr(v: &[str]) -> [[u8]] {
     let r = ~[];
     for t: str in vec::slice(v, 0u, vec::len(v)) {
         r += ~[str::bytes(t)];
@@ -186,7 +186,7 @@ fn clone_ivecstr(v: &[str]) -> [[u8]] {
     ret r;
 }
 
-fn clone_ivecu8str(v: &[[u8]]) -> [str] {
+fn clone_vecu8str(v: &[[u8]]) -> [str] {
     let r = ~[];
     for t in vec::slice(v, 0u, vec::len(v)) {
         r += ~[str::unsafe_from_bytes(t)];
diff --git a/src/test/stdtest/bitv.rs b/src/test/stdtest/bitv.rs
index 9ad241bb3f12..7666063239dd 100644
--- a/src/test/stdtest/bitv.rs
+++ b/src/test/stdtest/bitv.rs
@@ -11,16 +11,16 @@ fn test_0_elements() {
     exp = vec::init_elt::<uint>(0u, 0u);
     // FIXME: why can't I write vec::<uint>()?
 
-    assert (bitv::eq_ivec(act, exp));
+    assert (bitv::eq_vec(act, exp));
 }
 
 #[test]
 fn test_1_element() {
     let act;
     act = bitv::create(1u, false);
-    assert (bitv::eq_ivec(act, ~[0u]));
+    assert (bitv::eq_vec(act, ~[0u]));
     act = bitv::create(1u, true);
-    assert (bitv::eq_ivec(act, ~[1u]));
+    assert (bitv::eq_vec(act, ~[1u]));
 }
 
 #[test]
@@ -29,11 +29,11 @@ fn test_10_elements() {
     // all 0
 
     act = bitv::create(10u, false);
-    assert (bitv::eq_ivec(act, ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
+    assert (bitv::eq_vec(act, ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
     // all 1
 
     act = bitv::create(10u, true);
-    assert (bitv::eq_ivec(act, ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]));
+    assert (bitv::eq_vec(act, ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]));
     // mixed
 
     act = bitv::create(10u, false);
@@ -42,7 +42,7 @@ fn test_10_elements() {
     bitv::set(act, 2u, true);
     bitv::set(act, 3u, true);
     bitv::set(act, 4u, true);
-    assert (bitv::eq_ivec(act, ~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u]));
+    assert (bitv::eq_vec(act, ~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u]));
     // mixed
 
     act = bitv::create(10u, false);
@@ -51,7 +51,7 @@ fn test_10_elements() {
     bitv::set(act, 7u, true);
     bitv::set(act, 8u, true);
     bitv::set(act, 9u, true);
-    assert (bitv::eq_ivec(act, ~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u]));
+    assert (bitv::eq_vec(act, ~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u]));
     // mixed
 
     act = bitv::create(10u, false);
@@ -59,7 +59,7 @@ fn test_10_elements() {
     bitv::set(act, 3u, true);
     bitv::set(act, 6u, true);
     bitv::set(act, 9u, true);
-    assert (bitv::eq_ivec(act, ~[1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u]));
+    assert (bitv::eq_vec(act, ~[1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u]));
 }
 
 #[test]
@@ -68,14 +68,14 @@ fn test_31_elements() {
     // all 0
 
     act = bitv::create(31u, false);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u]));
     // all 1
 
     act = bitv::create(31u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                            1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                            1u, 1u, 1u, 1u, 1u]));
@@ -90,7 +90,7 @@ fn test_31_elements() {
     bitv::set(act, 5u, true);
     bitv::set(act, 6u, true);
     bitv::set(act, 7u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u]));
@@ -105,7 +105,7 @@ fn test_31_elements() {
     bitv::set(act, 21u, true);
     bitv::set(act, 22u, true);
     bitv::set(act, 23u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u]));
@@ -119,7 +119,7 @@ fn test_31_elements() {
     bitv::set(act, 28u, true);
     bitv::set(act, 29u, true);
     bitv::set(act, 30u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
                            1u, 1u, 1u, 1u, 1u]));
@@ -129,7 +129,7 @@ fn test_31_elements() {
     bitv::set(act, 3u, true);
     bitv::set(act, 17u, true);
     bitv::set(act, 30u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 1u]));
@@ -141,14 +141,14 @@ fn test_32_elements() {
     // all 0
 
     act = bitv::create(32u, false);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u]));
     // all 1
 
     act = bitv::create(32u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                            1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                            1u, 1u, 1u, 1u, 1u, 1u]));
@@ -163,7 +163,7 @@ fn test_32_elements() {
     bitv::set(act, 5u, true);
     bitv::set(act, 6u, true);
     bitv::set(act, 7u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u]));
@@ -178,7 +178,7 @@ fn test_32_elements() {
     bitv::set(act, 21u, true);
     bitv::set(act, 22u, true);
     bitv::set(act, 23u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u]));
@@ -193,7 +193,7 @@ fn test_32_elements() {
     bitv::set(act, 29u, true);
     bitv::set(act, 30u, true);
     bitv::set(act, 31u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
                            1u, 1u, 1u, 1u, 1u, 1u]));
@@ -204,7 +204,7 @@ fn test_32_elements() {
     bitv::set(act, 17u, true);
     bitv::set(act, 30u, true);
     bitv::set(act, 31u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 1u, 1u]));
@@ -216,14 +216,14 @@ fn test_33_elements() {
     // all 0
 
     act = bitv::create(33u, false);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u]));
     // all 1
 
     act = bitv::create(33u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                            1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                            1u, 1u, 1u, 1u, 1u, 1u, 1u]));
@@ -238,7 +238,7 @@ fn test_33_elements() {
     bitv::set(act, 5u, true);
     bitv::set(act, 6u, true);
     bitv::set(act, 7u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u]));
@@ -253,7 +253,7 @@ fn test_33_elements() {
     bitv::set(act, 21u, true);
     bitv::set(act, 22u, true);
     bitv::set(act, 23u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u]));
@@ -268,7 +268,7 @@ fn test_33_elements() {
     bitv::set(act, 29u, true);
     bitv::set(act, 30u, true);
     bitv::set(act, 31u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
                            1u, 1u, 1u, 1u, 1u, 1u, 0u]));
@@ -280,7 +280,7 @@ fn test_33_elements() {
     bitv::set(act, 30u, true);
     bitv::set(act, 31u, true);
     bitv::set(act, 32u, true);
-    assert (bitv::eq_ivec(act,
+    assert (bitv::eq_vec(act,
                          ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                            0u, 0u, 0u, 0u, 1u, 1u, 1u]));