Rename std::istr to std::str. Issue #855

8 files changed, 131 insertions, 131 deletions

diff --git a/src/test/stdtest/int.rs b/src/test/stdtest/int.rs
index 185c9db4a2e..bc13e248d0b 100644
--- a/src/test/stdtest/int.rs
+++ b/src/test/stdtest/int.rs
@@ -1,7 +1,7 @@
 
 use std;
 import std::int;
-import std::istr::eq;
+import std::str::eq;
 
 #[test]
 fn test_to_str() {
diff --git a/src/test/stdtest/io.rs b/src/test/stdtest/io.rs
index 679466cbece..a66b3bab464 100644
--- a/src/test/stdtest/io.rs
+++ b/src/test/stdtest/io.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
 use std;
 import std::io;
-import std::istr;
+import std::str;
 
 #[cfg(target_os = "linux")]
 #[cfg(target_os = "win32")]
@@ -19,7 +19,7 @@ fn test_simple() {
     let inp: io::reader = io::file_reader(tmpfile);
     let frood2: istr = inp.read_c_str();
     log frood2;
-    assert (istr::eq(frood, frood2));
+    assert (str::eq(frood, frood2));
 }
 
 // FIXME (726)
diff --git a/src/test/stdtest/map.rs b/src/test/stdtest/map.rs
index 67bd9128165..585bae03cc9 100644
--- a/src/test/stdtest/map.rs
+++ b/src/test/stdtest/map.rs
@@ -3,7 +3,7 @@
 // -*- rust -*-
 use std;
 import std::map;
-import std::istr;
+import std::str;
 import std::uint;
 import std::util;
 import std::option;
@@ -14,8 +14,8 @@ fn test_simple() {
     fn eq_uint(x: &uint, y: &uint) -> bool { ret x == y; }
     let hasher_uint: map::hashfn<uint> = util::id;
     let eqer_uint: map::eqfn<uint> = eq_uint;
-    let hasher_str: map::hashfn<istr> = istr::hash;
-    let eqer_str: map::eqfn<istr> = istr::eq;
+    let hasher_str: map::hashfn<istr> = str::hash;
+    let eqer_str: map::eqfn<istr> = str::eq;
     log "uint -> uint";
     let hm_uu: map::hashmap<uint, uint> =
         map::mk_hashmap::<uint, uint>(hasher_uint, eqer_uint);
@@ -52,26 +52,26 @@ fn test_simple() {
     assert (hm_us.insert(10u, ~"twelve"));
     assert (hm_us.insert(11u, ~"thirteen"));
     assert (hm_us.insert(12u, ~"fourteen"));
-    assert (istr::eq(hm_us.get(11u), ~"thirteen"));
-    assert (istr::eq(hm_us.get(12u), ~"fourteen"));
-    assert (istr::eq(hm_us.get(10u), ~"twelve"));
+    assert (str::eq(hm_us.get(11u), ~"thirteen"));
+    assert (str::eq(hm_us.get(12u), ~"fourteen"));
+    assert (str::eq(hm_us.get(10u), ~"twelve"));
     assert (!hm_us.insert(12u, ~"fourteen"));
-    assert (istr::eq(hm_us.get(12u), ~"fourteen"));
+    assert (str::eq(hm_us.get(12u), ~"fourteen"));
     assert (!hm_us.insert(12u, ~"twelve"));
-    assert (istr::eq(hm_us.get(12u), ~"twelve"));
+    assert (str::eq(hm_us.get(12u), ~"twelve"));
     log "str -> str";
     let hm_ss: map::hashmap<istr, istr> =
         map::mk_hashmap::<istr, istr>(hasher_str, eqer_str);
     assert (hm_ss.insert(ten, ~"twelve"));
     assert (hm_ss.insert(eleven, ~"thirteen"));
     assert (hm_ss.insert(twelve, ~"fourteen"));
-    assert (istr::eq(hm_ss.get(~"eleven"), ~"thirteen"));
-    assert (istr::eq(hm_ss.get(~"twelve"), ~"fourteen"));
-    assert (istr::eq(hm_ss.get(~"ten"), ~"twelve"));
+    assert (str::eq(hm_ss.get(~"eleven"), ~"thirteen"));
+    assert (str::eq(hm_ss.get(~"twelve"), ~"fourteen"));
+    assert (str::eq(hm_ss.get(~"ten"), ~"twelve"));
     assert (!hm_ss.insert(~"twelve", ~"fourteen"));
-    assert (istr::eq(hm_ss.get(~"twelve"), ~"fourteen"));
+    assert (str::eq(hm_ss.get(~"twelve"), ~"fourteen"));
     assert (!hm_ss.insert(~"twelve", ~"twelve"));
-    assert (istr::eq(hm_ss.get(~"twelve"), ~"twelve"));
+    assert (str::eq(hm_ss.get(~"twelve"), ~"twelve"));
     log "*** finished test_simple";
 }
 
@@ -116,8 +116,8 @@ fn test_growth() {
         i += 1u;
     }
     log "str -> str";
-    let hasher_str: map::hashfn<istr> = istr::hash;
-    let eqer_str: map::eqfn<istr> = istr::eq;
+    let hasher_str: map::hashfn<istr> = str::hash;
+    let eqer_str: map::eqfn<istr> = str::eq;
     let hm_ss: map::hashmap<istr, istr> =
         map::mk_hashmap::<istr, istr>(hasher_str, eqer_str);
     i = 0u;
@@ -133,13 +133,13 @@ fn test_growth() {
     while i < num_to_insert {
         log ~"get(\"" + uint::to_str(i, 2u) + ~"\") = \"" +
                 hm_ss.get(uint::to_str(i, 2u)) + ~"\"";
-        assert (istr::eq(hm_ss.get(uint::to_str(i, 2u)),
+        assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
                         uint::to_str(i * i, 2u)));
         i += 1u;
     }
     assert (hm_ss.insert(uint::to_str(num_to_insert, 2u),
                          uint::to_str(17u, 2u)));
-    assert (istr::eq(hm_ss.get(
+    assert (str::eq(hm_ss.get(
         uint::to_str(num_to_insert, 2u)),
                     uint::to_str(17u, 2u)));
     log "-----";
@@ -148,7 +148,7 @@ fn test_growth() {
     while i < num_to_insert {
         log ~"get(\"" + uint::to_str(i, 2u) + ~"\") = \"" +
                 hm_ss.get(uint::to_str(i, 2u)) + ~"\"";
-        assert (istr::eq(hm_ss.get(uint::to_str(i, 2u)),
+        assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
                         uint::to_str(i * i, 2u)));
         i += 1u;
     }
@@ -249,7 +249,7 @@ fn test_removal() {
 #[test]
 fn test_contains_key() {
     let key = ~"k";
-    let map = map::mk_hashmap::<istr, istr>(istr::hash, istr::eq);
+    let map = map::mk_hashmap::<istr, istr>(str::hash, str::eq);
     assert (!map.contains_key(key));
     map.insert(key, ~"val");
     assert (map.contains_key(key));
@@ -258,7 +258,7 @@ fn test_contains_key() {
 #[test]
 fn test_find() {
     let key = ~"k";
-    let map = map::mk_hashmap::<istr, istr>(istr::hash, istr::eq);
+    let map = map::mk_hashmap::<istr, istr>(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/run.rs b/src/test/stdtest/run.rs
index d3e88b13738..5c62ed3eb0e 100644
--- a/src/test/stdtest/run.rs
+++ b/src/test/stdtest/run.rs
@@ -3,7 +3,7 @@ import std::run;
 import std::os;
 import std::io;
 import std::option;
-import std::istr;
+import std::str;
 import std::vec;
 
 // Regression test for memory leaks
@@ -60,7 +60,7 @@ fn test_pipes() {
         let buf = ~"";
         while !reader.eof() {
             let bytes = reader.read_bytes(4096u);
-            buf += istr::unsafe_from_bytes(bytes);
+            buf += str::unsafe_from_bytes(bytes);
         }
         os::libc::fclose(file);
         ret buf;
diff --git a/src/test/stdtest/sha1.rs b/src/test/stdtest/sha1.rs
index 950409b7262..a66b898ddfa 100644
--- a/src/test/stdtest/sha1.rs
+++ b/src/test/stdtest/sha1.rs
@@ -5,7 +5,7 @@
 use std;
 import std::sha1;
 import std::vec;
-import std::istr;
+import std::str;
 
 #[test]
 fn test() {
@@ -74,11 +74,11 @@ fn test() {
 
     // Test that it works when accepting the message in pieces
     for t: test in tests {
-        let len = istr::byte_len(t.input);
+        let len = str::byte_len(t.input);
         let left = len;
         while left > 0u {
             let take = (left + 1u) / 2u;
-            sh.input_str(istr::substr(t.input, len - left, take));
+            sh.input_str(str::substr(t.input, len - left, take));
             left = left - take;
         }
         let out = sh.result();
diff --git a/src/test/stdtest/str.rs b/src/test/stdtest/str.rs
index c622728544f..a559b61d3f2 100644
--- a/src/test/stdtest/str.rs
+++ b/src/test/stdtest/str.rs
@@ -1,40 +1,40 @@
-import std::istr;
+import std::str;
 import std::vec;
 
 #[test]
 fn test_eq() {
-    assert istr::eq(~"", ~"");
-    assert istr::eq(~"foo", ~"foo");
-    assert !istr::eq(~"foo", ~"bar");
+    assert str::eq(~"", ~"");
+    assert str::eq(~"foo", ~"foo");
+    assert !str::eq(~"foo", ~"bar");
 }
 
 #[test]
 fn test_lteq() {
-    assert istr::lteq(~"", ~"");
-    assert istr::lteq(~"", ~"foo");
-    assert istr::lteq(~"foo", ~"foo");
-    assert !istr::eq(~"foo", ~"bar");
+    assert str::lteq(~"", ~"");
+    assert str::lteq(~"", ~"foo");
+    assert str::lteq(~"foo", ~"foo");
+    assert !str::eq(~"foo", ~"bar");
 }
 
 #[test]
 fn test_bytes_len() {
-    assert (istr::byte_len(~"") == 0u);
-    assert (istr::byte_len(~"hello world") == 11u);
-    assert (istr::byte_len(~"\x63") == 1u);
-    assert (istr::byte_len(~"\xa2") == 2u);
-    assert (istr::byte_len(~"\u03c0") == 2u);
-    assert (istr::byte_len(~"\u2620") == 3u);
-    assert (istr::byte_len(~"\U0001d11e") == 4u);
+    assert (str::byte_len(~"") == 0u);
+    assert (str::byte_len(~"hello world") == 11u);
+    assert (str::byte_len(~"\x63") == 1u);
+    assert (str::byte_len(~"\xa2") == 2u);
+    assert (str::byte_len(~"\u03c0") == 2u);
+    assert (str::byte_len(~"\u2620") == 3u);
+    assert (str::byte_len(~"\U0001d11e") == 4u);
 }
 
 #[test]
 fn test_index_and_rindex() {
-    assert (istr::index(~"hello", 'e' as u8) == 1);
-    assert (istr::index(~"hello", 'o' as u8) == 4);
-    assert (istr::index(~"hello", 'z' as u8) == -1);
-    assert (istr::rindex(~"hello", 'l' as u8) == 3);
-    assert (istr::rindex(~"hello", 'h' as u8) == 0);
-    assert (istr::rindex(~"hello", 'z' as u8) == -1);
+    assert (str::index(~"hello", 'e' as u8) == 1);
+    assert (str::index(~"hello", 'o' as u8) == 4);
+    assert (str::index(~"hello", 'z' as u8) == -1);
+    assert (str::rindex(~"hello", 'l' as u8) == 3);
+    assert (str::rindex(~"hello", 'h' as u8) == 0);
+    assert (str::rindex(~"hello", 'z' as u8) == -1);
 }
 
 #[test]
@@ -42,11 +42,11 @@ fn test_split() {
     fn t(s: &istr, c: char, i: int, k: &istr) {
         log ~"splitting: " + s;
         log i;
-        let v = istr::split(s, c as u8);
+        let v = str::split(s, c as u8);
         log ~"split to: ";
         for z: istr in v { log z; }
         log ~"comparing: " + v[i] + ~" vs. " + k;
-        assert (istr::eq(v[i], k));
+        assert (str::eq(v[i], k));
     }
     t(~"abc.hello.there", '.', 0, ~"abc");
     t(~"abc.hello.there", '.', 1, ~"hello");
@@ -60,7 +60,7 @@ fn test_split() {
 #[test]
 fn test_find() {
     fn t(haystack: &istr, needle: &istr, i: int) {
-        let j: int = istr::find(haystack, needle);
+        let j: int = str::find(haystack, needle);
         log ~"searched for " + needle;
         log j;
         assert (i == j);
@@ -75,8 +75,8 @@ fn test_find() {
 #[test]
 fn test_substr() {
     fn t(a: &istr, b: &istr, start: int) {
-        assert (istr::eq(istr::substr(a, start as uint,
-                                      istr::byte_len(b)), b));
+        assert (str::eq(str::substr(a, start as uint,
+                                      str::byte_len(b)), b));
     }
     t(~"hello", ~"llo", 2);
     t(~"hello", ~"el", 1);
@@ -85,7 +85,7 @@ fn test_substr() {
 
 #[test]
 fn test_concat() {
-    fn t(v: &[istr], s: &istr) { assert (istr::eq(istr::concat(v), s)); }
+    fn t(v: &[istr], s: &istr) { assert (str::eq(str::concat(v), s)); }
     t([~"you", ~"know", ~"I'm", ~"no", ~"good"], ~"youknowI'mnogood");
     let v: [istr] = [];
     t(v, ~"");
@@ -95,7 +95,7 @@ fn test_concat() {
 #[test]
 fn test_connect() {
     fn t(v: &[istr], sep: &istr, s: &istr) {
-        assert (istr::eq(istr::connect(v, sep), s));
+        assert (str::eq(str::connect(v, sep), s));
     }
     t([~"you", ~"know", ~"I'm", ~"no", ~"good"], ~" ",
       ~"you know I'm no good");
@@ -112,15 +112,15 @@ fn test_to_upper() {
     let unicode = ~"\u65e5\u672c";
     let input = ~"abcDEF" + unicode + ~"xyz:.;";
     let expected = ~"ABCDEF" + unicode + ~"XYZ:.;";
-    let actual = istr::to_upper(input);
-    assert (istr::eq(expected, actual));
+    let actual = str::to_upper(input);
+    assert (str::eq(expected, actual));
 }
 
 #[test]
 fn test_slice() {
-    assert (istr::eq(~"ab", istr::slice(~"abc", 0u, 2u)));
-    assert (istr::eq(~"bc", istr::slice(~"abc", 1u, 3u)));
-    assert (istr::eq(~"", istr::slice(~"abc", 1u, 1u)));
+    assert (str::eq(~"ab", str::slice(~"abc", 0u, 2u)));
+    assert (str::eq(~"bc", str::slice(~"abc", 1u, 3u)));
+    assert (str::eq(~"", str::slice(~"abc", 1u, 1u)));
     fn a_million_letter_a() -> istr {
         let i = 0;
         let rs = ~"";
@@ -133,112 +133,112 @@ fn test_slice() {
         while i < 100000 { rs += ~"aaaaa"; i += 1; }
         ret rs;
     }
-    assert (istr::eq(half_a_million_letter_a(),
-                    istr::slice(a_million_letter_a(), 0u, 500000u)));
+    assert (str::eq(half_a_million_letter_a(),
+                    str::slice(a_million_letter_a(), 0u, 500000u)));
 }
 
 #[test]
 fn test_starts_with() {
-    assert (istr::starts_with(~"", ~""));
-    assert (istr::starts_with(~"abc", ~""));
-    assert (istr::starts_with(~"abc", ~"a"));
-    assert (!istr::starts_with(~"a", ~"abc"));
-    assert (!istr::starts_with(~"", ~"abc"));
+    assert (str::starts_with(~"", ~""));
+    assert (str::starts_with(~"abc", ~""));
+    assert (str::starts_with(~"abc", ~"a"));
+    assert (!str::starts_with(~"a", ~"abc"));
+    assert (!str::starts_with(~"", ~"abc"));
 }
 
 #[test]
 fn test_ends_with() {
-    assert (istr::ends_with(~"", ~""));
-    assert (istr::ends_with(~"abc", ~""));
-    assert (istr::ends_with(~"abc", ~"c"));
-    assert (!istr::ends_with(~"a", ~"abc"));
-    assert (!istr::ends_with(~"", ~"abc"));
+    assert (str::ends_with(~"", ~""));
+    assert (str::ends_with(~"abc", ~""));
+    assert (str::ends_with(~"abc", ~"c"));
+    assert (!str::ends_with(~"a", ~"abc"));
+    assert (!str::ends_with(~"", ~"abc"));
 }
 
 #[test]
 fn test_is_empty() {
-    assert (istr::is_empty(~""));
-    assert (!istr::is_empty(~"a"));
+    assert (str::is_empty(~""));
+    assert (!str::is_empty(~"a"));
 }
 
 #[test]
 fn test_is_not_empty() {
-    assert (istr::is_not_empty(~"a"));
-    assert (!istr::is_not_empty(~""));
+    assert (str::is_not_empty(~"a"));
+    assert (!str::is_not_empty(~""));
 }
 
 #[test]
 fn test_replace() {
     let a = ~"a";
-    check (istr::is_not_empty(a));
-    assert (istr::replace(~"", a, ~"b") == ~"");
-    assert (istr::replace(~"a", a, ~"b") == ~"b");
-    assert (istr::replace(~"ab", a, ~"b") == ~"bb");
+    check (str::is_not_empty(a));
+    assert (str::replace(~"", a, ~"b") == ~"");
+    assert (str::replace(~"a", a, ~"b") == ~"b");
+    assert (str::replace(~"ab", a, ~"b") == ~"bb");
     let test = ~"test";
-    check (istr::is_not_empty(test));
-    assert (istr::replace(~" test test ", test, ~"toast")
+    check (str::is_not_empty(test));
+    assert (str::replace(~" test test ", test, ~"toast")
             == ~" toast toast ");
-    assert (istr::replace(~" test test ", test, ~"") == ~"   ");
+    assert (str::replace(~" test test ", test, ~"") == ~"   ");
 }
 
 #[test]
 fn test_char_slice() {
-    assert (istr::eq(~"ab", istr::char_slice(~"abc", 0u, 2u)));
-    assert (istr::eq(~"bc", istr::char_slice(~"abc", 1u, 3u)));
-    assert (istr::eq(~"", istr::char_slice(~"abc", 1u, 1u)));
-    assert (istr::eq(~"\u65e5", istr::char_slice(~"\u65e5\u672c", 0u, 1u)));
+    assert (str::eq(~"ab", str::char_slice(~"abc", 0u, 2u)));
+    assert (str::eq(~"bc", str::char_slice(~"abc", 1u, 3u)));
+    assert (str::eq(~"", str::char_slice(~"abc", 1u, 1u)));
+    assert (str::eq(~"\u65e5", str::char_slice(~"\u65e5\u672c", 0u, 1u)));
 }
 
 #[test]
 fn trim_left() {
-    assert (istr::trim_left(~"") == ~"");
-    assert (istr::trim_left(~"a") == ~"a");
-    assert (istr::trim_left(~"    ") == ~"");
-    assert (istr::trim_left(~"     blah") == ~"blah");
-    assert (istr::trim_left(~"   \u3000  wut") == ~"wut");
-    assert (istr::trim_left(~"hey ") == ~"hey ");
+    assert (str::trim_left(~"") == ~"");
+    assert (str::trim_left(~"a") == ~"a");
+    assert (str::trim_left(~"    ") == ~"");
+    assert (str::trim_left(~"     blah") == ~"blah");
+    assert (str::trim_left(~"   \u3000  wut") == ~"wut");
+    assert (str::trim_left(~"hey ") == ~"hey ");
 }
 
 #[test]
 fn trim_right() {
-    assert (istr::trim_right(~"") == ~"");
-    assert (istr::trim_right(~"a") == ~"a");
-    assert (istr::trim_right(~"    ") == ~"");
-    assert (istr::trim_right(~"blah     ") == ~"blah");
-    assert (istr::trim_right(~"wut   \u3000  ") == ~"wut");
-    assert (istr::trim_right(~" hey") == ~" hey");
+    assert (str::trim_right(~"") == ~"");
+    assert (str::trim_right(~"a") == ~"a");
+    assert (str::trim_right(~"    ") == ~"");
+    assert (str::trim_right(~"blah     ") == ~"blah");
+    assert (str::trim_right(~"wut   \u3000  ") == ~"wut");
+    assert (str::trim_right(~" hey") == ~" hey");
 }
 
 #[test]
 fn trim() {
-    assert (istr::trim(~"") == ~"");
-    assert (istr::trim(~"a") == ~"a");
-    assert (istr::trim(~"    ") == ~"");
-    assert (istr::trim(~"    blah     ") == ~"blah");
-    assert (istr::trim(~"\nwut   \u3000  ") == ~"wut");
-    assert (istr::trim(~" hey dude ") == ~"hey dude");
+    assert (str::trim(~"") == ~"");
+    assert (str::trim(~"a") == ~"a");
+    assert (str::trim(~"    ") == ~"");
+    assert (str::trim(~"    blah     ") == ~"blah");
+    assert (str::trim(~"\nwut   \u3000  ") == ~"wut");
+    assert (str::trim(~" hey dude ") == ~"hey dude");
 }
 
 #[test]
 fn is_whitespace() {
-    assert (istr::is_whitespace(~""));
-    assert (istr::is_whitespace(~" "));
-    assert (istr::is_whitespace(~"\u2009")); // Thin space
-    assert (istr::is_whitespace(~"  \n\t   "));
-    assert (!istr::is_whitespace(~"   _   "));
+    assert (str::is_whitespace(~""));
+    assert (str::is_whitespace(~" "));
+    assert (str::is_whitespace(~"\u2009")); // Thin space
+    assert (str::is_whitespace(~"  \n\t   "));
+    assert (!str::is_whitespace(~"   _   "));
 }
 
 #[test]
 fn is_ascii() {
-    assert istr::is_ascii(~"");
-    assert istr::is_ascii(~"a");
-    assert !istr::is_ascii(~"\u2009");
+    assert str::is_ascii(~"");
+    assert str::is_ascii(~"a");
+    assert !str::is_ascii(~"\u2009");
 }
 
 #[test]
 fn shift_byte() {
     let s = ~"ABC";
-    let b = istr::shift_byte(s);
+    let b = str::shift_byte(s);
     assert s == ~"BC";
     assert b == 65u8;
 }
@@ -246,7 +246,7 @@ fn shift_byte() {
 #[test]
 fn pop_byte() {
     let s = ~"ABC";
-    let b = istr::pop_byte(s);
+    let b = str::pop_byte(s);
     assert s == ~"AB";
     assert b == 67u8;
 }
@@ -254,7 +254,7 @@ fn pop_byte() {
 #[test]
 fn unsafe_from_bytes() {
     let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8];
-    let b = istr::unsafe_from_bytes(a);
+    let b = str::unsafe_from_bytes(a);
     assert b == ~"AAAAAAA";
 }
 
@@ -262,14 +262,14 @@ fn unsafe_from_bytes() {
 fn str_from_cstr() {
     let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
     let b = vec::to_ptr(a);
-    let c = istr::str_from_cstr(b);
+    let c = str::str_from_cstr(b);
     assert c == ~"AAAAAAA";
 }
 
 #[test]
 fn as_buf() {
     let a = ~"Abcdefg";
-    let b = istr::as_buf(a, { |buf|
+    let b = str::as_buf(a, { |buf|
         assert *buf == 65u8;
         100
     });
@@ -279,7 +279,7 @@ fn as_buf() {
 #[test]
 fn as_buf_small() {
     let a = ~"A";
-    let b = istr::as_buf(a, { |buf|
+    let b = str::as_buf(a, { |buf|
         assert *buf == 65u8;
         100
     });
@@ -289,19 +289,19 @@ fn as_buf_small() {
 #[test]
 fn as_buf2() {
     let s = ~"hello";
-    let sb = istr::as_buf(s, { |b| b });
-    let s_cstr = istr::str_from_cstr(sb);
-    assert (istr::eq(s_cstr, s));
+    let sb = str::as_buf(s, { |b| b });
+    let s_cstr = str::str_from_cstr(sb);
+    assert (str::eq(s_cstr, s));
 }
 
 #[test]
 fn vec_str_conversions() {
     let s1: istr = ~"All mimsy were the borogoves";
 
-    let v: [u8] = istr::bytes(s1);
-    let s2: istr = istr::unsafe_from_bytes(v);
+    let v: [u8] = str::bytes(s1);
+    let s2: istr = str::unsafe_from_bytes(v);
     let i: uint = 0u;
-    let n1: uint = istr::byte_len(s1);
+    let n1: uint = str::byte_len(s1);
     let n2: uint = vec::len::<u8>(v);
     assert (n1 == n2);
     while i < n1 {
diff --git a/src/test/stdtest/test.rs b/src/test/stdtest/test.rs
index d32930893e9..cb4b9313029 100644
--- a/src/test/stdtest/test.rs
+++ b/src/test/stdtest/test.rs
@@ -1,5 +1,5 @@
 import std::test;
-import std::istr;
+import std::str;
 import std::option;
 import std::either;
 import std::vec;
@@ -29,7 +29,7 @@ fn first_free_arg_should_be_a_filter() {
     let args = [~"progname", ~"filter"];
     check (vec::is_not_empty(args));
     let opts = alt test::parse_opts(args) { either::left(o) { o } };
-    assert (istr::eq(~"filter", option::get(opts.filter)));
+    assert (str::eq(~"filter", option::get(opts.filter)));
 }
 
 #[test]
diff --git a/src/test/stdtest/treemap.rs b/src/test/stdtest/treemap.rs
index 217b01ed462..9a2ef1e8e68 100644
--- a/src/test/stdtest/treemap.rs
+++ b/src/test/stdtest/treemap.rs
@@ -2,7 +2,7 @@ use std;
 import std::treemap::*;
 import std::option::some;
 import std::option::none;
-import std::istr;
+import std::str;
 
 #[test]
 fn init_treemap() {
@@ -63,8 +63,8 @@ fn traverse_in_order() {
 fn u8_map() {
     let m = init();
 
-    let k1 = istr::bytes(~"foo");
-    let k2 = istr::bytes(~"bar");
+    let k1 = str::bytes(~"foo");
+    let k2 = str::bytes(~"bar");
 
     insert(m, k1, ~"foo");
     insert(m, k2, ~"bar");