diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs
index de8aa4bfa1b7..7ff80d70ce56 100644
--- a/src/comp/back/link.rs
+++ b/src/comp/back/link.rs
@@ -5,7 +5,7 @@ import front::attr;
 import middle::ty;
 import metadata::encoder;
 import middle::trans_common::crate_ctxt;
-import std::istr;
+import std::str;
 import std::fs;
 import std::vec;
 import std::option;
@@ -37,7 +37,7 @@ fn llvm_err(sess: session::session, msg: &istr) {
         sess.fatal(msg);
     } else {
         sess.fatal(
-            msg + ~": " + istr::str_from_cstr(buf));
+            msg + ~": " + str::str_from_cstr(buf));
     }
 }
 
@@ -45,7 +45,7 @@ fn link_intrinsics(sess: session::session, llmod: ModuleRef) {
     let path =
         fs::connect(sess.get_opts().sysroot,
                     ~"lib/intrinsics.bc");
-    let membuf = istr::as_buf(path, { |buf|
+    let membuf = str::as_buf(path, { |buf|
         llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf)
     });
     if membuf as uint == 0u {
@@ -78,11 +78,11 @@ mod write {
     // Decides what to call an intermediate file, given the name of the output
     // and the extension to use.
     fn mk_intermediate_name(output_path: &istr, extension: &istr) -> istr {
-        let dot_pos = istr::index(output_path, '.' as u8);
+        let dot_pos = str::index(output_path, '.' as u8);
         let stem;
         if dot_pos < 0 {
             stem = output_path;
-        } else { stem = istr::substr(output_path, 0u, dot_pos as uint); }
+        } else { stem = str::substr(output_path, 0u, dot_pos as uint); }
         ret stem + ~"." + extension;
     }
     fn run_passes(sess: session::session, llmod: ModuleRef, output: &istr) {
@@ -103,14 +103,14 @@ mod write {
               output_type_bitcode. {
                 if opts.optimize != 0u {
                     let filename = mk_intermediate_name(output, ~"no-opt.bc");
-                    istr::as_buf(filename, { |buf|
+                    str::as_buf(filename, { |buf|
                         llvm::LLVMWriteBitcodeToFile(llmod, buf)
                     });
                 }
               }
               _ {
                 let filename = mk_intermediate_name(output, ~"bc");
-                istr::as_buf(filename, { |buf|
+                str::as_buf(filename, { |buf|
                     llvm::LLVMWriteBitcodeToFile(llmod, buf)
                 });
               }
@@ -185,7 +185,7 @@ mod write {
 
                 let filename = mk_intermediate_name(output, ~"opt.bc");
                 llvm::LLVMRunPassManager(pm.llpm, llmod);
-                istr::as_buf(filename, { |buf|
+                str::as_buf(filename, { |buf|
                     llvm::LLVMWriteBitcodeToFile(llmod, buf)
                 });
                 pm = mk_pass_manager();
@@ -193,8 +193,8 @@ mod write {
 
                 if opts.output_type == output_type_assembly {
                     let _: () =
-                        istr::as_buf(x86::get_target_triple(), { |buf_t|
-                            istr::as_buf(output, { |buf_o|
+                        str::as_buf(x86::get_target_triple(), { |buf_t|
+                            str::as_buf(output, { |buf_o|
                                 llvm::LLVMRustWriteOutputFile(
                                     pm.llpm, llmod,
                                     buf_t,
@@ -210,8 +210,8 @@ mod write {
                 if opts.output_type == output_type_object ||
                        opts.output_type == output_type_exe {
                     let _: () =
-                        istr::as_buf(x86::get_target_triple(), { |buf_t|
-                            istr::as_buf(output, { |buf_o|
+                        str::as_buf(x86::get_target_triple(), { |buf_t|
+                            str::as_buf(output, { |buf_o|
                                 llvm::LLVMRustWriteOutputFile(
                                     pm.llpm, llmod,
                                     buf_t,
@@ -224,8 +224,8 @@ mod write {
                 // If we aren't saving temps then just output the file
                 // type corresponding to the '-c' or '-S' flag used
 
-                let _: () = istr::as_buf(x86::get_target_triple(), { |buf_t|
-                    istr::as_buf(output, { |buf_o|
+                let _: () = str::as_buf(x86::get_target_triple(), { |buf_t|
+                    str::as_buf(output, { |buf_o|
                         llvm::LLVMRustWriteOutputFile(pm.llpm, llmod,
                                                       buf_t,
                                                       buf_o,
@@ -243,7 +243,7 @@ mod write {
         // flag, then output it here
 
         llvm::LLVMRunPassManager(pm.llpm, llmod);
-        istr::as_buf(output, { |buf|
+        str::as_buf(output, { |buf|
             llvm::LLVMWriteBitcodeToFile(llmod, buf)
         });
         llvm::LLVMDisposeModule(llmod);
@@ -340,7 +340,7 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &istr,
     fn crate_meta_extras_hash(sha: sha1, _crate: &ast::crate,
                               metas: &provided_metas) -> istr {
         fn len_and_str(s: &istr) -> istr {
-            ret #ifmt["%u_%s", istr::byte_len(s), s];
+            ret #ifmt["%u_%s", str::byte_len(s), s];
         }
 
         fn len_and_str_lit(l: &ast::lit) -> istr {
@@ -383,12 +383,12 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &istr,
               none. {
                 let name =
                     {
-                        let os = istr::split(
+                        let os = str::split(
                             fs::basename(output),
                             '.' as u8);
                         assert (vec::len(os) >= 2u);
                         vec::pop(os);
-                        istr::connect(os, ~".")
+                        str::connect(os, ~".")
                     };
                 warn_missing(sess, ~"name", name);
                 name
@@ -417,7 +417,7 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &istr,
 }
 
 fn truncated_sha1_result(sha: sha1) -> istr {
-    ret istr::substr(sha.result_str(), 0u, 16u);
+    ret str::substr(sha.result_str(), 0u, 16u);
 }
 
 
@@ -458,7 +458,7 @@ fn mangle(ss: &[istr]) -> istr {
     let n = ~"_ZN"; // Begin name-sequence.
 
     for s: istr in ss {
-        n += #ifmt["%u%s", istr::byte_len(s), s];
+        n += #ifmt["%u%s", str::byte_len(s), s];
     }
     n += ~"E"; // End name-sequence.
 
diff --git a/src/comp/back/upcall.rs b/src/comp/back/upcall.rs
index 4d14145d8f73..13186bcbca4e 100644
--- a/src/comp/back/upcall.rs
+++ b/src/comp/back/upcall.rs
@@ -1,5 +1,5 @@
 
-import std::istr;
+import std::str;
 import middle::trans;
 import trans::decl_cdecl_fn;
 import middle::trans_common::T_f32;
diff --git a/src/comp/back/x86.rs b/src/comp/back/x86.rs
index 6823f8c20309..02b33ff105ca 100644
--- a/src/comp/back/x86.rs
+++ b/src/comp/back/x86.rs
@@ -1,34 +1,34 @@
 
 import lib::llvm::llvm;
 import lib::llvm::llvm::ModuleRef;
-import std::istr;
+import std::str;
 import std::os::target_os;
 
 fn get_module_asm() -> istr { ret ~""; }
 
 fn get_meta_sect_name() -> istr {
-    if istr::eq(target_os(), ~"macos") { ret ~"__DATA,__note.rustc"; }
-    if istr::eq(target_os(), ~"win32") { ret ~".note.rustc"; }
+    if str::eq(target_os(), ~"macos") { ret ~"__DATA,__note.rustc"; }
+    if str::eq(target_os(), ~"win32") { ret ~".note.rustc"; }
     ret ~".note.rustc";
 }
 
 fn get_data_layout() -> istr {
-    if istr::eq(target_os(), ~"macos") {
+    if str::eq(target_os(), ~"macos") {
         ret ~"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16" +
             ~"-i32:32:32-i64:32:64" +
             ~"-f32:32:32-f64:32:64-v64:64:64" +
             ~"-v128:128:128-a0:0:64-f80:128:128" +
             ~"-n8:16:32";
     }
-    if istr::eq(target_os(), ~"win32") {
+    if str::eq(target_os(), ~"win32") {
         ret ~"e-p:32:32-f64:64:64-i64:64:64-f80:32:32-n8:16:32";
     }
     ret ~"e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32";
 }
 
 fn get_target_triple() -> istr {
-    if istr::eq(target_os(), ~"macos") { ret ~"i686-apple-darwin"; }
-    if istr::eq(target_os(), ~"win32") { ret ~"i686-pc-mingw32"; }
+    if str::eq(target_os(), ~"macos") { ret ~"i686-apple-darwin"; }
+    if str::eq(target_os(), ~"win32") { ret ~"i686-pc-mingw32"; }
     ret ~"i686-unknown-linux-gnu";
 }
 //
diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
index 71537effd032..3ae222369dce 100644
--- a/src/comp/driver/rustc.rs
+++ b/src/comp/driver/rustc.rs
@@ -26,7 +26,7 @@ import std::map::mk_hashmap;
 import std::option;
 import std::option::some;
 import std::option::none;
-import std::istr;
+import std::str;
 import std::vec;
 import std::int;
 import std::io;
@@ -107,7 +107,7 @@ fn parse_input_src(sess: session::session, cfg: &ast::crate_cfg,
         if infile != ~"-" {
             io::file_reader(infile)
         } else { io::stdin() }.read_whole_stream();
-    let src = istr::unsafe_from_bytes(srcbytes);
+    let src = str::unsafe_from_bytes(srcbytes);
     let crate =
         parser::parse_crate_from_source_str(
             infile,
@@ -260,7 +260,7 @@ fn version(argv0: &istr) {
     // FIXME: Restore after istr conversion
     //let env_vers = #env["CFG_VERSION"];
     let env_vers = ~"FIXME";
-    if istr::byte_len(env_vers) != 0u { vers = env_vers; }
+    if str::byte_len(env_vers) != 0u { vers = env_vers; }
     io::stdout().write_str(
         #ifmt["%s %s\n",
                              argv0,
@@ -307,40 +307,40 @@ options:
 }
 
 fn get_os(triple: &istr) -> session::os {
-    ret if istr::find(triple, ~"win32") >= 0 ||
-               istr::find(triple, ~"mingw32") >= 0 {
+    ret if str::find(triple, ~"win32") >= 0 ||
+               str::find(triple, ~"mingw32") >= 0 {
             session::os_win32
-        } else if istr::find(triple, ~"darwin") >= 0 {
+        } else if str::find(triple, ~"darwin") >= 0 {
             session::os_macos
-        } else if istr::find(triple, ~"linux") >= 0 {
+        } else if str::find(triple, ~"linux") >= 0 {
             session::os_linux
         } else { log_err ~"Unknown operating system!"; fail };
 }
 
 fn get_arch(triple: &istr) -> session::arch {
-    ret if istr::find(triple, ~"i386") >= 0 ||
-        istr::find(triple, ~"i486") >= 0 ||
-               istr::find(triple, ~"i586") >= 0 ||
-               istr::find(triple, ~"i686") >= 0 ||
-               istr::find(triple, ~"i786") >= 0 {
+    ret if str::find(triple, ~"i386") >= 0 ||
+        str::find(triple, ~"i486") >= 0 ||
+               str::find(triple, ~"i586") >= 0 ||
+               str::find(triple, ~"i686") >= 0 ||
+               str::find(triple, ~"i786") >= 0 {
             session::arch_x86
-        } else if istr::find(triple, ~"x86_64") >= 0 {
+        } else if str::find(triple, ~"x86_64") >= 0 {
             session::arch_x64
-        } else if istr::find(triple, ~"arm") >= 0 ||
-                      istr::find(triple, ~"xscale") >= 0 {
+        } else if str::find(triple, ~"arm") >= 0 ||
+                      str::find(triple, ~"xscale") >= 0 {
             session::arch_arm
         } else { log_err ~"Unknown architecture! " + triple; fail };
 }
 
 fn get_default_sysroot(binary: &istr) -> istr {
     let dirname = fs::dirname(binary);
-    if istr::eq(dirname, binary) { ret ~"."; }
+    if str::eq(dirname, binary) { ret ~"."; }
     ret dirname;
 }
 
 fn build_target_config() -> @session::config {
     let triple: istr =
-        istr::str_from_cstr(llvm::llvm::LLVMRustGetHostTriple());
+        str::str_from_cstr(llvm::llvm::LLVMRustGetHostTriple());
     let target_cfg: @session::config =
         @{os: get_os(triple),
           arch: get_arch(triple),
@@ -442,13 +442,13 @@ fn build_session(sopts: @session::options) -> session::session {
 }
 
 fn parse_pretty(sess: session::session, name: &istr) -> pp_mode {
-    if istr::eq(name, ~"normal") {
+    if str::eq(name, ~"normal") {
         ret ppm_normal;
-    } else if istr::eq(name, ~"expanded") {
+    } else if str::eq(name, ~"expanded") {
         ret ppm_expanded;
-    } else if istr::eq(name, ~"typed") {
+    } else if str::eq(name, ~"typed") {
         ret ppm_typed;
-    } else if istr::eq(name, ~"identified") { ret ppm_identified; }
+    } else if str::eq(name, ~"identified") { ret ppm_identified; }
     sess.fatal(~"argument to `pretty` must be one of `normal`, `typed`, or "
                + ~"`identified`");
 }
@@ -533,10 +533,10 @@ fn main(args: [istr]) {
         // We want to toss everything after the final '.'
         let parts =
             if !input_is_stdin(ifile) {
-                istr::split(ifile, '.' as u8)
+                str::split(ifile, '.' as u8)
             } else { [~"default", ~"rs"] };
         vec::pop(parts);
-        saved_out_filename = istr::connect(parts, ~".");
+        saved_out_filename = str::connect(parts, ~".");
         let suffix =
             alt sopts.output_type {
               link::output_type_none. { ~"none" }
@@ -591,15 +591,15 @@ fn main(args: [istr]) {
             bind fn (config: @session::config, filename: &istr) -> istr {
             if config.os == session::os_macos ||
                 config.os == session::os_linux &&
-                istr::find(filename, ~"lib") == 0 {
-                ret istr::slice(filename, 3u,
-                                istr::byte_len(filename));
+                str::find(filename, ~"lib") == 0 {
+                ret str::slice(filename, 3u,
+                                str::byte_len(filename));
             } else { ret filename; }
         }(config, _);
         fn rmext(filename: &istr) -> istr {
-            let parts = istr::split(filename, '.' as u8);
+            let parts = str::split(filename, '.' as u8);
             vec::pop(parts);
-            ret istr::connect(parts, ~".");
+            ret str::connect(parts, ~".");
         }
         ret alt config.os {
               session::os_macos. { rmext(rmlib(filename)) }
@@ -610,7 +610,7 @@ fn main(args: [istr]) {
 
     let cstore = sess.get_cstore();
     for cratepath: istr in cstore::get_used_crate_files(cstore) {
-        if istr::ends_with(cratepath, ~".rlib") {
+        if str::ends_with(cratepath, ~".rlib") {
             gcc_args += [cratepath];
             cont;
         }
@@ -641,7 +641,7 @@ fn main(args: [istr]) {
             #ifmt["linking with gcc failed with code %d", err_code]);
         sess.note(
             #ifmt["gcc arguments: %s",
-                       istr::connect(gcc_args, ~" ")]);
+                       str::connect(gcc_args, ~" ")]);
         sess.abort_if_errors();
     }
     // Clean up on Darwin
diff --git a/src/comp/driver/session.rs b/src/comp/driver/session.rs
index cf5841b12276..7f40921088dc 100644
--- a/src/comp/driver/session.rs
+++ b/src/comp/driver/session.rs
@@ -9,7 +9,7 @@ import std::map;
 import std::option;
 import std::option::some;
 import std::option::none;
-import std::istr;
+import std::str;
 import syntax::parse::parser::parse_sess;
 
 tag os { os_win32; os_macos; os_linux; }
diff --git a/src/comp/front/attr.rs b/src/comp/front/attr.rs
index 47e557a35e50..4ad38e2274e2 100644
--- a/src/comp/front/attr.rs
+++ b/src/comp/front/attr.rs
@@ -1,7 +1,7 @@
 // Functions dealing with attributes and meta_items
 
 import std::vec;
-import std::istr;
+import std::str;
 import std::map;
 import std::option;
 import syntax::ast;
diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs
index 1f9a1f869f38..f2eced866346 100644
--- a/src/comp/front/test.rs
+++ b/src/comp/front/test.rs
@@ -2,7 +2,7 @@
 
 import std::option;
 import std::vec;
-import std::istr;
+import std::str;
 import syntax::ast;
 import syntax::ast_util;
 import syntax::ast_util::*;
diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs
index 2b185c1abbbc..d59f68938151 100644
--- a/src/comp/lib/llvm.rs
+++ b/src/comp/lib/llvm.rs
@@ -1,6 +1,6 @@
 import std::vec;
-import std::istr;
-import std::istr::sbuf;
+import std::str;
+import std::str::sbuf;
 
 import llvm::ModuleRef;
 import llvm::ContextRef;
@@ -1070,7 +1070,7 @@ resource target_data_res(TD: TargetDataRef) {
 type target_data = {lltd: TargetDataRef, dtor: @target_data_res};
 
 fn mk_target_data(string_rep: &istr) -> target_data {
-    let lltd = istr::as_buf(string_rep, { |buf|
+    let lltd = str::as_buf(string_rep, { |buf|
         llvm::LLVMCreateTargetData(buf)
     });
     ret {lltd: lltd, dtor: @target_data_res(lltd)};
diff --git a/src/comp/metadata/common.rs b/src/comp/metadata/common.rs
index 02f434c5c501..05c0de1bb2bb 100644
--- a/src/comp/metadata/common.rs
+++ b/src/comp/metadata/common.rs
@@ -1,6 +1,6 @@
 // EBML tag definitions and utils shared by the encoder and decoder
 
-import std::istr;
+import std::str;
 
 const tag_paths: uint = 0x01u;
 
@@ -69,7 +69,7 @@ fn hash_node_id(node_id: &int) -> uint { ret 177573u ^ (node_id as uint); }
 
 fn hash_path(s: &istr) -> uint {
     let h = 5381u;
-    for ch: u8 in istr::bytes(s) { h = (h << 5u) + h ^ (ch as uint); }
+    for ch: u8 in str::bytes(s) { h = (h << 5u) + h ^ (ch as uint); }
     ret h;
 }
 
diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs
index 64b198b861a8..81978664a07f 100644
--- a/src/comp/metadata/creader.rs
+++ b/src/comp/metadata/creader.rs
@@ -14,7 +14,7 @@ import syntax::codemap::span;
 import back::x86;
 import util::common;
 import std::vec;
-import std::istr;
+import std::str;
 import std::fs;
 import std::io;
 import std::option;
@@ -173,7 +173,7 @@ fn find_library_crate_aux(nn: &{prefix: istr, suffix: istr},
         for path: istr in fs::list_dir(library_search_path) {
             log #ifmt["searching %s", path];
             let f: istr = fs::basename(path);
-            if !(istr::starts_with(f, prefix) && istr::ends_with(f, suffix))
+            if !(str::starts_with(f, prefix) && str::ends_with(f, suffix))
                {
                 log #ifmt["skipping %s, doesn't look like %s*%s",
                          path,
@@ -200,7 +200,7 @@ fn find_library_crate_aux(nn: &{prefix: istr, suffix: istr},
 }
 
 fn get_metadata_section(filename: &istr) -> option::t<@[u8]> {
-    let mb = istr::as_buf(filename, { |buf|
+    let mb = str::as_buf(filename, { |buf|
         llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf)
     });
     if mb as int == 0 { ret option::none::<@[u8]>; }
@@ -208,8 +208,8 @@ fn get_metadata_section(filename: &istr) -> option::t<@[u8]> {
     let si = mk_section_iter(of.llof);
     while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False {
         let name_buf = llvm::LLVMGetSectionName(si.llsi);
-        let name = istr::str_from_cstr(name_buf);
-        if istr::eq(name, x86::get_meta_sect_name()) {
+        let name = str::str_from_cstr(name_buf);
+        if str::eq(name, x86::get_meta_sect_name()) {
             let cbuf = llvm::LLVMGetSectionContents(si.llsi);
             let csz = llvm::LLVMGetSectionSize(si.llsi);
             let cvbuf: *u8 = std::unsafe::reinterpret_cast(cbuf);
diff --git a/src/comp/metadata/cstore.rs b/src/comp/metadata/cstore.rs
index b286e155f7ab..c5f161394bd8 100644
--- a/src/comp/metadata/cstore.rs
+++ b/src/comp/metadata/cstore.rs
@@ -3,7 +3,7 @@
 
 import std::vec;
 import std::map;
-import std::istr;
+import std::str;
 import syntax::ast;
 
 export cstore;
@@ -106,7 +106,7 @@ fn get_used_libraries(cstore: &cstore) -> [istr] {
 }
 
 fn add_used_link_args(cstore: &cstore, args: &istr) {
-    p(cstore).used_link_args += istr::split(args, ' ' as u8);
+    p(cstore).used_link_args += str::split(args, ' ' as u8);
 }
 
 fn get_used_link_args(cstore: &cstore) -> [istr] {
diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs
index e6a44618cf9a..c3365f4f57c8 100644
--- a/src/comp/metadata/decoder.rs
+++ b/src/comp/metadata/decoder.rs
@@ -3,7 +3,7 @@
 import std::ebml;
 import std::vec;
 import std::option;
-import std::istr;
+import std::str;
 import std::io;
 import std::map::hashmap;
 import syntax::ast;
@@ -85,7 +85,7 @@ fn item_family(item: &ebml::doc) -> u8 {
 
 fn item_symbol(item: &ebml::doc) -> istr {
     let sym = ebml::get_doc(item, tag_items_data_item_symbol);
-    ret istr::unsafe_from_bytes(ebml::doc_data(sym));
+    ret str::unsafe_from_bytes(ebml::doc_data(sym));
 }
 
 fn variant_tag_id(d: &ebml::doc) -> ast::def_id {
@@ -98,7 +98,7 @@ fn item_type(item: &ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
     fn parse_external_def_id(this_cnum: ast::crate_num,
                              extres: &external_resolver, s: &istr) ->
        ast::def_id {
-        let buf = istr::bytes(s);
+        let buf = str::bytes(s);
         let external_def_id = parse_def_id(buf);
 
 
@@ -150,9 +150,9 @@ fn tag_variant_ids(item: &ebml::doc, this_cnum: ast::crate_num) ->
 // definition the path refers to.
 fn resolve_path(path: &[ast::ident], data: @[u8]) -> [ast::def_id] {
     fn eq_item(data: &[u8], s: &istr) -> bool {
-        ret istr::eq(istr::unsafe_from_bytes(data), s);
+        ret str::eq(str::unsafe_from_bytes(data), s);
     }
-    let s = istr::connect(path, ~"::");
+    let s = str::connect(path, ~"::");
     let md = ebml::new_doc(data);
     let paths = ebml::get_doc(md, tag_paths);
     let eqer = bind eq_item(_, s);
@@ -272,7 +272,7 @@ fn read_path(d: &ebml::doc) -> {path: istr, pos: uint} {
     let desc = ebml::doc_data(d);
     let pos = ebml::be_uint_from_bytes(@desc, 0u, 4u);
     let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc));
-    let path = istr::unsafe_from_bytes(pathbytes);
+    let path = str::unsafe_from_bytes(pathbytes);
     ret {path: path, pos: pos};
 }
 
@@ -301,15 +301,15 @@ fn get_meta_items(md: &ebml::doc) -> [@ast::meta_item] {
     for each meta_item_doc: ebml::doc in
              ebml::tagged_docs(md, tag_meta_item_word) {
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = istr::unsafe_from_bytes(ebml::doc_data(nd));
+        let n = str::unsafe_from_bytes(ebml::doc_data(nd));
         items += [attr::mk_word_item(n)];
     }
     for each meta_item_doc: ebml::doc in
              ebml::tagged_docs(md, tag_meta_item_name_value) {
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let vd = ebml::get_doc(meta_item_doc, tag_meta_item_value);
-        let n = istr::unsafe_from_bytes(ebml::doc_data(nd));
-        let v = istr::unsafe_from_bytes(ebml::doc_data(vd));
+        let n = str::unsafe_from_bytes(ebml::doc_data(nd));
+        let v = str::unsafe_from_bytes(ebml::doc_data(vd));
         // FIXME (#611): Should be able to decode meta_name_value variants,
         // but currently they can't be encoded
         items += [attr::mk_name_value_item_str(n, v)];
@@ -317,7 +317,7 @@ fn get_meta_items(md: &ebml::doc) -> [@ast::meta_item] {
     for each meta_item_doc: ebml::doc in
              ebml::tagged_docs(md, tag_meta_item_list) {
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = istr::unsafe_from_bytes(ebml::doc_data(nd));
+        let n = str::unsafe_from_bytes(ebml::doc_data(nd));
         let subitems = get_meta_items(meta_item_doc);
         items += [attr::mk_list_item(n, subitems)];
     }
@@ -377,7 +377,7 @@ fn get_crate_deps(data: @[u8]) -> [crate_dep] {
     let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
     let crate_num = 1;
     for each depdoc: ebml::doc in ebml::tagged_docs(depsdoc, tag_crate_dep) {
-        let depname = istr::unsafe_from_bytes(ebml::doc_data(depdoc));
+        let depname = str::unsafe_from_bytes(ebml::doc_data(depdoc));
         deps += [{cnum: crate_num, ident: depname}];
         crate_num += 1;
     }
diff --git a/src/comp/metadata/encoder.rs b/src/comp/metadata/encoder.rs
index e4e8ff1bbe92..384088c59e6e 100644
--- a/src/comp/metadata/encoder.rs
+++ b/src/comp/metadata/encoder.rs
@@ -1,7 +1,7 @@
 // Metadata encoding
 
 import std::vec;
-import std::istr;
+import std::str;
 import std::uint;
 import std::io;
 import std::option;
@@ -28,13 +28,13 @@ type encode_ctxt = {ccx: @crate_ctxt, type_abbrevs: abbrev_map};
 // Path table encoding
 fn encode_name(ebml_w: &ebml::writer, name: &istr) {
     ebml::start_tag(ebml_w, tag_paths_data_name);
-    ebml_w.writer.write(istr::bytes(name));
+    ebml_w.writer.write(str::bytes(name));
     ebml::end_tag(ebml_w);
 }
 
 fn encode_def_id(ebml_w: &ebml::writer, id: &def_id) {
     ebml::start_tag(ebml_w, tag_def_id);
-    ebml_w.writer.write(istr::bytes(def_to_str(id)));
+    ebml_w.writer.write(str::bytes(def_to_str(id)));
     ebml::end_tag(ebml_w);
 }
 
@@ -55,7 +55,7 @@ fn add_to_index(ebml_w: &ebml::writer, path: &[istr],
                 index: &mutable [entry<istr>], name: &istr) {
     let full_path = path + [name];
     index +=
-        [{val: istr::connect(full_path, ~"::"), pos: ebml_w.writer.tell()}];
+        [{val: str::connect(full_path, ~"::"), pos: ebml_w.writer.tell()}];
 }
 
 fn encode_native_module_item_paths(ebml_w: &ebml::writer, nmod: &native_mod,
@@ -197,7 +197,7 @@ fn encode_type_param_kinds(ebml_w: &ebml::writer, tps: &[ty_param]) {
 
 fn encode_variant_id(ebml_w: &ebml::writer, vid: &def_id) {
     ebml::start_tag(ebml_w, tag_items_data_item_variant);
-    ebml_w.writer.write(istr::bytes(def_to_str(vid)));
+    ebml_w.writer.write(str::bytes(def_to_str(vid)));
     ebml::end_tag(ebml_w);
 }
 
@@ -214,20 +214,20 @@ fn encode_type(ecx: &@encode_ctxt, ebml_w: &ebml::writer, typ: ty::t) {
 
 fn encode_symbol(ecx: &@encode_ctxt, ebml_w: &ebml::writer, id: node_id) {
     ebml::start_tag(ebml_w, tag_items_data_item_symbol);
-    ebml_w.writer.write(istr::bytes(ecx.ccx.item_symbols.get(id)));
+    ebml_w.writer.write(str::bytes(ecx.ccx.item_symbols.get(id)));
     ebml::end_tag(ebml_w);
 }
 
 fn encode_discriminant(ecx: &@encode_ctxt, ebml_w: &ebml::writer,
                        id: node_id) {
     ebml::start_tag(ebml_w, tag_items_data_item_symbol);
-    ebml_w.writer.write(istr::bytes(ecx.ccx.discrim_symbols.get(id)));
+    ebml_w.writer.write(str::bytes(ecx.ccx.discrim_symbols.get(id)));
     ebml::end_tag(ebml_w);
 }
 
 fn encode_tag_id(ebml_w: &ebml::writer, id: &def_id) {
     ebml::start_tag(ebml_w, tag_items_data_item_tag_id);
-    ebml_w.writer.write(istr::bytes(def_to_str(id)));
+    ebml_w.writer.write(str::bytes(def_to_str(id)));
     ebml::end_tag(ebml_w);
 }
 
@@ -454,7 +454,7 @@ fn encode_meta_item(ebml_w: &ebml::writer, mi: &meta_item) {
       meta_word(name) {
         ebml::start_tag(ebml_w, tag_meta_item_word);
         ebml::start_tag(ebml_w, tag_meta_item_name);
-        ebml_w.writer.write(istr::bytes(name));
+        ebml_w.writer.write(str::bytes(name));
         ebml::end_tag(ebml_w);
         ebml::end_tag(ebml_w);
       }
@@ -463,10 +463,10 @@ fn encode_meta_item(ebml_w: &ebml::writer, mi: &meta_item) {
           lit_str(value, _) {
             ebml::start_tag(ebml_w, tag_meta_item_name_value);
             ebml::start_tag(ebml_w, tag_meta_item_name);
-            ebml_w.writer.write(istr::bytes(name));
+            ebml_w.writer.write(str::bytes(name));
             ebml::end_tag(ebml_w);
             ebml::start_tag(ebml_w, tag_meta_item_value);
-            ebml_w.writer.write(istr::bytes(value));
+            ebml_w.writer.write(str::bytes(value));
             ebml::end_tag(ebml_w);
             ebml::end_tag(ebml_w);
           }
@@ -476,7 +476,7 @@ fn encode_meta_item(ebml_w: &ebml::writer, mi: &meta_item) {
       meta_list(name, items) {
         ebml::start_tag(ebml_w, tag_meta_item_list);
         ebml::start_tag(ebml_w, tag_meta_item_name);
-        ebml_w.writer.write(istr::bytes(name));
+        ebml_w.writer.write(str::bytes(name));
         ebml::end_tag(ebml_w);
         for inner_item: @meta_item in items {
             encode_meta_item(ebml_w, *inner_item);
@@ -588,7 +588,7 @@ fn encode_crate_deps(ebml_w: &ebml::writer, cstore: &cstore::cstore) {
     ebml::start_tag(ebml_w, tag_crate_deps);
     for cname: istr in get_ordered_names(cstore) {
         ebml::start_tag(ebml_w, tag_crate_dep);
-        ebml_w.writer.write(istr::bytes(cname));
+        ebml_w.writer.write(str::bytes(cname));
         ebml::end_tag(ebml_w);
     }
     ebml::end_tag(ebml_w);
diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs
index 9f5a0dca4d67..23ba2fa01a69 100644
--- a/src/comp/metadata/tydecode.rs
+++ b/src/comp/metadata/tydecode.rs
@@ -1,7 +1,7 @@
 // Type decoding
 
 import std::vec;
-import std::istr;
+import std::str;
 import std::uint;
 import std::option;
 import std::option::none;
@@ -44,7 +44,7 @@ fn parse_ident_(st: @pstate, _sd: str_def, is_last: fn(char) -> bool) ->
    ast::ident {
     let rslt = ~"";
     while !is_last(peek(st) as char) {
-        rslt += istr::unsafe_from_byte(next(st));
+        rslt += str::unsafe_from_byte(next(st));
     }
     ret rslt;
 }
@@ -227,7 +227,7 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
         while peek(st) as char != ']' {
             let name = ~"";
             while peek(st) as char != '=' {
-                name += istr::unsafe_from_byte(next(st));
+                name += str::unsafe_from_byte(next(st));
             }
             st.pos = st.pos + 1u;
             fields += [{ident: name, mt: parse_mt(st, sd)}];
@@ -280,7 +280,7 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
             }
             let name = ~"";
             while peek(st) as char != '[' {
-                name += istr::unsafe_from_byte(next(st));
+                name += str::unsafe_from_byte(next(st));
             }
             let func = parse_ty_fn(st, sd);
             methods +=
@@ -345,7 +345,7 @@ fn parse_mt(st: @pstate, sd: str_def) -> ty::mt {
 fn parse_def(st: @pstate, sd: str_def) -> ast::def_id {
     let def = ~"";
     while peek(st) as char != '|' {
-        def += istr::unsafe_from_byte(next(st));
+        def += str::unsafe_from_byte(next(st));
     }
     st.pos = st.pos + 1u;
     ret sd(def);
diff --git a/src/comp/metadata/tyencode.rs b/src/comp/metadata/tyencode.rs
index fe010f589bf4..c76cd75a2852 100644
--- a/src/comp/metadata/tyencode.rs
+++ b/src/comp/metadata/tyencode.rs
@@ -1,6 +1,6 @@
 // Type encoding
 
-import std::istr;
+import std::str;
 import std::io;
 import std::map::hashmap;
 import std::option::some;
diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs
index 5d42131e3af6..aaa973992944 100644
--- a/src/comp/middle/alias.rs
+++ b/src/comp/middle/alias.rs
@@ -10,7 +10,7 @@ import syntax::codemap::span;
 import syntax::visit;
 import visit::vt;
 import std::vec;
-import std::istr;
+import std::str;
 import std::option;
 import std::option::some;
 import std::option::none;
diff --git a/src/comp/middle/freevars.rs b/src/comp/middle/freevars.rs
index 622f4bb52828..706e814a01c1 100644
--- a/src/comp/middle/freevars.rs
+++ b/src/comp/middle/freevars.rs
@@ -5,7 +5,7 @@ import std::map;
 import std::map::*;
 import std::option;
 import std::int;
-import std::istr;
+import std::str;
 import std::option::*;
 import syntax::ast;
 import syntax::ast_util;
diff --git a/src/comp/middle/gc.rs b/src/comp/middle/gc.rs
index 3932e9c07358..d98580579702 100644
--- a/src/comp/middle/gc.rs
+++ b/src/comp/middle/gc.rs
@@ -10,7 +10,7 @@ import middle::ty;
 import std::option::none;
 import std::option::some;
 import std::ptr;
-import std::istr;
+import std::str;
 import std::unsafe;
 import std::vec;
 
@@ -22,7 +22,7 @@ type ctxt = @{mutable next_tydesc_num: uint};
 fn mk_ctxt() -> ctxt { ret @{mutable next_tydesc_num: 0u}; }
 
 fn add_global(ccx: &@crate_ctxt, llval: ValueRef, name: &istr) -> ValueRef {
-    let llglobal = istr::as_buf(name, { |buf|
+    let llglobal = str::as_buf(name, { |buf|
         lll::LLVMAddGlobal(ccx.llmod, val_ty(llval), buf)
     });
     lll::LLVMSetInitializer(llglobal, llval);
diff --git a/src/comp/middle/kind.rs b/src/comp/middle/kind.rs
index 9a9807cf4890..71b211109621 100644
--- a/src/comp/middle/kind.rs
+++ b/src/comp/middle/kind.rs
@@ -77,7 +77,7 @@ import syntax::visit;
 
 import std::vec;
 import std::option;
-import std::istr;
+import std::str;
 
 import ast::kind;
 import ast::kind_unique;
diff --git a/src/comp/middle/mut.rs b/src/comp/middle/mut.rs
index b2420252efa8..bf54a5d01d6f 100644
--- a/src/comp/middle/mut.rs
+++ b/src/comp/middle/mut.rs
@@ -1,4 +1,4 @@
-import std::{vec, istr, option};
+import std::{vec, str, option};
 import option::{some, none};
 import syntax::ast::*;
 import syntax::visit;
@@ -54,7 +54,7 @@ fn expr_root(tcx: &ty::ctxt, ex: @expr, autoderef: bool)
             alt ty::struct(tcx, auto_unbox.t) {
               ty::ty_rec(fields) {
                 for fld: ty::field in fields {
-                    if istr::eq(ident, fld.ident) {
+                    if str::eq(ident, fld.ident) {
                         mut = fld.mt.mut != imm;
                         break;
                     }
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index e712abaa751e..117c10b0db75 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -32,7 +32,7 @@ import std::option;
 import std::option::is_none;
 import std::option::some;
 import std::option::none;
-import std::istr;
+import std::str;
 import syntax::print::pprust::*;
 
 export resolve_crate;
@@ -79,7 +79,7 @@ type ext_hash = hashmap<{did: def_id, ident: istr, ns: namespace}, def>;
 fn new_ext_hash() -> ext_hash {
     type key = {did: def_id, ident: istr, ns: namespace};
     fn hash(v: &key) -> uint {
-        ret istr::hash(v.ident) + util::common::hash_def(v.did) +
+        ret str::hash(v.ident) + util::common::hash_def(v.did) +
                 alt v.ns {
                   ns_value. { 1u }
                   ns_type. { 2u }
@@ -88,7 +88,7 @@ fn new_ext_hash() -> ext_hash {
     }
     fn eq(v1: &key, v2: &key) -> bool {
         ret util::common::def_eq(v1.did, v2.did) &&
-                istr::eq(v1.ident, v2.ident) && v1.ns == v2.ns;
+                str::eq(v1.ident, v2.ident) && v1.ns == v2.ns;
     }
     ret std::map::mk_hashmap::<key, def>(hash, eq);
 }
@@ -430,7 +430,7 @@ fn follow_import(e: &env, sc: &scopes, path: &[ident], sp: &span) ->
           ast::def_mod(_) | ast::def_native_mod(_) { ret dcur; }
           _ {
             e.sess.span_err(sp,
-                            istr::connect(path, ~"::") +
+                            str::connect(path, ~"::") +
                                 ~" does not name a module.");
             ret none;
           }
@@ -463,7 +463,7 @@ fn resolve_import(e: &env, defid: ast::def_id, name: &ast::ident,
     let end_id = ids[n_idents - 1u];
     // Ignore the current scope if this import would shadow itself.
     let sc =
-        if istr::eq(name, ids[0]) { std::list::cdr(sc_in) } else { sc_in };
+        if str::eq(name, ids[0]) { std::list::cdr(sc_in) } else { sc_in };
     if n_idents == 1u {
         register(e, defid, sp, end_id, sc_in,
                  lookup_in_scope(e, sc, sp, end_id, ns_value),
@@ -560,7 +560,7 @@ fn unresolved_err(e: &env, sc: &scopes, sp: &span,
     }
     let err_scope = find_fn_or_mod_scope(sc);
     for rs: {ident: istr, sc: scope} in e.reported {
-        if istr::eq(rs.ident, name)
+        if str::eq(rs.ident, name)
             && err_scope == rs.sc { ret; }
     }
     e.reported += [{ident: name, sc: err_scope}];
@@ -759,7 +759,7 @@ fn lookup_in_ty_params(name: &ident, ty_params: &[ast::ty_param]) ->
    option::t<def> {
     let i = 0u;
     for tp: ast::ty_param in ty_params {
-        if istr::eq(tp.ident, name) { ret some(ast::def_ty_arg(i, tp.kind)); }
+        if str::eq(tp.ident, name) { ret some(ast::def_ty_arg(i, tp.kind)); }
         i += 1u;
     }
     ret none::<def>;
@@ -769,7 +769,7 @@ fn lookup_in_pat(name: &ident, pat: &@ast::pat) -> option::t<def_id> {
     let found = none;
     for each bound in ast_util::pat_bindings(pat) {
         let p_name = alt bound.node { ast::pat_bind(n) { n } };
-        if istr::eq(p_name, name) { found = some(local_def(bound.id)); }
+        if str::eq(p_name, name) { found = some(local_def(bound.id)); }
     }
     ret found;
 }
@@ -780,7 +780,7 @@ fn lookup_in_fn(name: &ident, decl: &ast::fn_decl,
     alt ns {
       ns_value. {
         for a: ast::arg in decl.inputs {
-            if istr::eq(a.ident, name) {
+            if str::eq(a.ident, name) {
                 ret some(ast::def_arg(local_def(a.id), a.mode));
             }
         }
@@ -796,7 +796,7 @@ fn lookup_in_obj(name: &ident, ob: &ast::_obj, ty_params: &[ast::ty_param],
     alt ns {
       ns_value. {
         for f: ast::obj_field in ob.fields {
-            if istr::eq(f.ident, name) {
+            if str::eq(f.ident, name) {
                 ret some(ast::def_obj_field(local_def(f.id), f.mut));
             }
         }
@@ -835,12 +835,12 @@ fn lookup_in_block(name: &ident, b: &ast::blk_, pos: uint, loc_pos: uint,
                 alt it.node {
                   ast::item_tag(variants, _) {
                     if ns == ns_type {
-                        if istr::eq(it.ident, name) {
+                        if str::eq(it.ident, name) {
                             ret some(ast::def_ty(local_def(it.id)));
                         }
                     } else if ns == ns_value {
                         for v: ast::variant in variants {
-                            if istr::eq(v.node.name, name) {
+                            if str::eq(v.node.name, name) {
                                 let i = v.node.id;
                                 ret some(ast::def_variant(local_def(it.id),
                                                           local_def(i)));
@@ -849,7 +849,7 @@ fn lookup_in_block(name: &ident, b: &ast::blk_, pos: uint, loc_pos: uint,
                     }
                   }
                   _ {
-                    if istr::eq(it.ident, name) {
+                    if str::eq(it.ident, name) {
                         let found = found_def_item(it, ns);
                         if !is_none(found) { ret found; }
                     }
@@ -1332,7 +1332,7 @@ fn check_arm(e: &@env, a: &ast::arm, x: &(), v: &vt<()>) {
                             ~"inconsistent number of bindings");
         } else {
             for name: ident in ch.seen {
-                if is_none(vec::find(bind istr::eq(name, _), seen0)) {
+                if is_none(vec::find(bind str::eq(name, _), seen0)) {
                     // Fight the alias checker
                     let name_ = name;
                     e.sess.span_err(a.pats[i].span,
@@ -1428,7 +1428,7 @@ fn checker(e: &env, kind: &istr) -> checker {
 
 fn check_name(ch: &checker, sp: &span, name: &ident) {
     for s: ident in ch.seen {
-        if istr::eq(s, name) {
+        if str::eq(s, name) {
             ch.sess.span_fatal(sp, ~"duplicate " + ch.kind
                                + ~" name: " + name);
         }
diff --git a/src/comp/middle/shape.rs b/src/comp/middle/shape.rs
index 0a000fd6f68d..181eaa0251a9 100644
--- a/src/comp/middle/shape.rs
+++ b/src/comp/middle/shape.rs
@@ -30,7 +30,7 @@ import std::vec;
 import std::map::hashmap;
 import std::option::none;
 import std::option::some;
-import std::istr;
+import std::str;
 
 import ty_ctxt = middle::ty::ctxt;
 
@@ -86,7 +86,7 @@ fn eq_res_info(a: &res_info, b: &res_info) -> bool {
 
 fn mk_global(ccx: &@crate_ctxt, name: &istr, llval: ValueRef,
              internal: bool) -> ValueRef {
-    let llglobal = istr::as_buf(name, { |buf|
+    let llglobal = str::as_buf(name, { |buf|
         lib::llvm::llvm::LLVMAddGlobal(ccx.llmod, val_ty(llval), buf)
     });
     lib::llvm::llvm::LLVMSetInitializer(llglobal, llval);
@@ -248,7 +248,7 @@ fn s_float(_tcx: &ty_ctxt) -> u8 {
 
 fn mk_ctxt(llmod: ModuleRef) -> ctxt {
     let llshapetablesty = trans_common::T_named_struct(~"shapes");
-    let llshapetables = istr::as_buf(~"shapes", { |buf|
+    let llshapetables = str::as_buf(~"shapes", { |buf|
         lib::llvm::llvm::LLVMAddGlobal(llmod, llshapetablesty, buf)
     });
 
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index 7bd39752be17..8aafae528206 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -13,7 +13,7 @@
 //     but many TypeRefs correspond to one ty::t; for instance, tup(int, int,
 //     int) and rec(x=int, y=int, z=int) will have the same TypeRef.
 import std::int;
-import std::istr;
+import std::str;
 import std::uint;
 import std::map;
 import std::map::hashmap;
@@ -301,7 +301,7 @@ fn sanitize(s: &istr) -> istr {
                            c != ' ' as u8 && c != '\t' as u8 && c != ';' as u8
                        {
                         let v = [c];
-                        result += istr::unsafe_from_bytes(v);
+                        result += str::unsafe_from_bytes(v);
                     }
                 }
             }
@@ -322,7 +322,7 @@ fn log_fn_time(ccx: &@crate_ctxt, name: &istr, start: &time::timeval,
 
 fn decl_fn(llmod: ModuleRef, name: &istr, cc: uint, llty: TypeRef) ->
    ValueRef {
-    let llfn: ValueRef = istr::as_buf(name, { |buf|
+    let llfn: ValueRef = str::as_buf(name, { |buf|
         llvm::LLVMAddFunction(llmod, buf, llty)
     });
     llvm::LLVMSetFunctionCallConv(llfn, cc);
@@ -336,7 +336,7 @@ fn decl_cdecl_fn(llmod: ModuleRef, name: &istr, llty: TypeRef) -> ValueRef {
 fn decl_fastcall_fn(llmod: ModuleRef, name: &istr,
                     llty: TypeRef) -> ValueRef {
     let llfn = decl_fn(llmod, name, lib::llvm::LLVMFastCallConv, llty);
-    let _: () = istr::as_buf(~"rust", { |buf|
+    let _: () = str::as_buf(~"rust", { |buf|
         llvm::LLVMSetGC(llfn, buf)
     });
     ret llfn;
@@ -350,7 +350,7 @@ fn decl_internal_fastcall_fn(llmod: ModuleRef, name: &istr, llty: TypeRef) ->
     let llfn = decl_fn(llmod, name, lib::llvm::LLVMFastCallConv, llty);
     llvm::LLVMSetLinkage(llfn,
                          lib::llvm::LLVMInternalLinkage as llvm::Linkage);
-    let _: () = istr::as_buf(~"rust", { |buf|
+    let _: () = str::as_buf(~"rust", { |buf|
         llvm::LLVMSetGC(llfn, buf)
     });
     ret llfn;
@@ -375,7 +375,7 @@ fn get_extern_const(externs: &hashmap<istr, ValueRef>, llmod: ModuleRef,
     if externs.contains_key(name) {
         ret externs.get(name);
     }
-    let c = istr::as_buf(name, { |buf|
+    let c = str::as_buf(name, { |buf|
         llvm::LLVMAddGlobal(llmod, ty, buf)
     });
     externs.insert(name, c);
@@ -1137,7 +1137,7 @@ fn declare_tydesc(cx: &@local_ctxt, sp: &span, t: ty::t, ty_params: &[uint])
         name = mangle_internal_name_by_type_only(cx.ccx, t, ~"tydesc");
         name = sanitize(name);
     } else { name = mangle_internal_name_by_seq(cx.ccx, ~"tydesc"); }
-    let gvar = istr::as_buf(name, { |buf|
+    let gvar = str::as_buf(name, { |buf|
         llvm::LLVMAddGlobal(ccx.llmod, ccx.tydesc_type, buf)
     });
     let info =
@@ -1501,7 +1501,7 @@ fn decr_refcnt_maybe_free(cx: &@block_ctxt, box_ptr_alias: ValueRef,
 // Structural comparison: a rather involved form of glue.
 fn maybe_name_value(cx: &@crate_ctxt, v: ValueRef, s: &istr) {
     if cx.sess.get_opts().save_temps {
-        let _: () = istr::as_buf(s, { |buf|
+        let _: () = str::as_buf(s, { |buf|
             llvm::LLVMSetValueName(v, buf)
         });
     }
@@ -3050,7 +3050,7 @@ fn lookup_discriminant(lcx: &@local_ctxt, vid: &ast::def_id) -> ValueRef {
         // It's an external discriminant that we haven't seen yet.
         assert (vid.crate != ast::local_crate);
         let sym = csearch::get_symbol(lcx.ccx.sess.get_cstore(), vid);
-        let gvar = istr::as_buf(sym, { |buf|
+        let gvar = str::as_buf(sym, { |buf|
             llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(), buf)
         });
         llvm::LLVMSetLinkage(gvar,
@@ -3998,7 +3998,7 @@ fn trans_rec(cx: &@block_ctxt, fields: &[ast::field],
         bcx = dst_res.bcx;
         let expr_provided = false;
         for f: ast::field in fields {
-            if istr::eq(f.node.ident, tf.ident) {
+            if str::eq(f.node.ident, tf.ident) {
                 expr_provided = true;
                 let lv = trans_lval(bcx, f.node.expr);
                 bcx = move_val_if_temp(lv.res.bcx, INIT, dst_res.val,
@@ -4288,7 +4288,7 @@ fn load_if_immediate(cx: &@block_ctxt, v: ValueRef, t: ty::t) -> ValueRef {
 
 fn trans_log(lvl: int, cx: &@block_ctxt, e: &@ast::expr) -> result {
     let lcx = cx.fcx.lcx;
-    let modname = istr::connect(lcx.module_path, ~"::");
+    let modname = str::connect(lcx.module_path, ~"::");
     let global;
     if lcx.ccx.module_data.contains_key(modname) {
         global = lcx.ccx.module_data.get(modname);
@@ -4298,7 +4298,7 @@ fn trans_log(lvl: int, cx: &@block_ctxt, e: &@ast::expr) -> result {
                 lcx.ccx,
                 lcx.module_path,
                 ~"loglevel");
-        global = istr::as_buf(s, { |buf|
+        global = str::as_buf(s, { |buf|
             llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(), buf)
         });
         llvm::LLVMSetGlobalConstant(global, False);
@@ -4677,7 +4677,7 @@ fn new_block_ctxt(cx: &@fn_ctxt, parent: &block_parent, kind: block_kind,
            cx.lcx.ccx.sess.get_opts().debuginfo {
         s = cx.lcx.ccx.names.next(name);
     }
-    let llbb: BasicBlockRef = istr::as_buf(s, { |buf|
+    let llbb: BasicBlockRef = str::as_buf(s, { |buf|
         llvm::LLVMAppendBasicBlock(cx.llfn, buf)
     });
     ret @{llbb: llbb,
@@ -4836,7 +4836,7 @@ fn alloc_local(cx: &@block_ctxt, local: &@ast::local) -> result {
     alt local.node.pat.node {
       ast::pat_bind(ident) {
         if bcx_ccx(cx).sess.get_opts().debuginfo {
-            let _: () = istr::as_buf(ident, { |buf|
+            let _: () = str::as_buf(ident, { |buf|
                 llvm::LLVMSetValueName(r.val, buf)
             });
         }
@@ -4922,19 +4922,19 @@ fn mk_standard_basic_blocks(llfn: ValueRef) ->
     dt: BasicBlockRef,
     da: BasicBlockRef,
     rt: BasicBlockRef} {
-    ret {sa: istr::as_buf(~"statuc_allocas", { |buf|
+    ret {sa: str::as_buf(~"statuc_allocas", { |buf|
              llvm::LLVMAppendBasicBlock(llfn, buf)
                                              }),
-         ca: istr::as_buf(~"copy_args", { |buf|
+         ca: str::as_buf(~"copy_args", { |buf|
              llvm::LLVMAppendBasicBlock(llfn, buf)
                                         }),
-         dt: istr::as_buf(~"derived_tydescs", { |buf|
+         dt: str::as_buf(~"derived_tydescs", { |buf|
              llvm::LLVMAppendBasicBlock(llfn, buf)
                                               }),
-         da: istr::as_buf(~"dynamic_allocas", { |buf|
+         da: str::as_buf(~"dynamic_allocas", { |buf|
              llvm::LLVMAppendBasicBlock(llfn, buf)
                                               }),
-         rt: istr::as_buf(~"return", { |buf|
+         rt: str::as_buf(~"return", { |buf|
              llvm::LLVMAppendBasicBlock(llfn, buf)
                                      })};
 }
@@ -5254,7 +5254,7 @@ fn trans_fn(cx: @local_ctxt, sp: &span, f: &ast::_fn, llfndecl: ValueRef,
     let start = time::get_time();
     trans_fn_inner(cx, sp, f, llfndecl, ty_self, ty_params, id);
     let end = time::get_time();
-    log_fn_time(cx.ccx, istr::connect(cx.path, ~"::"),
+    log_fn_time(cx.ccx, str::connect(cx.path, ~"::"),
                 start, end);
 }
 
@@ -5546,7 +5546,7 @@ fn create_main_wrapper(ccx: &@crate_ctxt, sp: &span, main_llfn: ValueRef,
 
     // FIXME: This is a transitional way to let the runtime know
     // it needs to feed us istrs
-    let lltakesistr = istr::as_buf(~"_rust_main_takes_istr", { |buf|
+    let lltakesistr = str::as_buf(~"_rust_main_takes_istr", { |buf|
         llvm::LLVMAddGlobal(ccx.llmod, T_int(), buf)
     });
     llvm::LLVMSetInitializer(lltakesistr, C_uint(main_takes_istr as uint));
@@ -5597,7 +5597,7 @@ fn create_main_wrapper(ccx: &@crate_ctxt, sp: &span, main_llfn: ValueRef,
 // space for the function's environment.
 fn create_fn_pair(cx: &@crate_ctxt, ps: &istr, llfnty: TypeRef,
                   llfn: ValueRef, external: bool) -> ValueRef {
-    let gvar = istr::as_buf(ps, { |buf|
+    let gvar = str::as_buf(ps, { |buf|
         llvm::LLVMAddGlobal(cx.llmod, T_fn_pair(*cx, llfnty), buf)
     });
     let pair = C_struct([llfn, C_null(T_opaque_closure_ptr(*cx))]);
@@ -5874,7 +5874,7 @@ fn collect_item_1(ccx: @crate_ctxt, i: &@ast::item, pt: &[istr],
         let s =
             mangle_exported_name(ccx, pt + [i.ident],
                                  node_id_type(ccx, i.id));
-        let g = istr::as_buf(s, { |buf|
+        let g = str::as_buf(s, { |buf|
             llvm::LLVMAddGlobal(ccx.llmod, type_of(ccx, i.span, typ), buf)
         });
         ccx.item_symbols.insert(i.id, s);
@@ -5966,7 +5966,7 @@ fn trans_constant(ccx: @crate_ctxt, it: &@ast::item, pt: &[istr],
                               ~"discrim"];
             let s = mangle_exported_name(ccx, p,
                                          ty::mk_int(ccx.tcx));
-            let discrim_gvar = istr::as_buf(s, { |buf|
+            let discrim_gvar = str::as_buf(s, { |buf|
                 llvm::LLVMAddGlobal(ccx.llmod, T_int(), buf)
             });
             if n_variants != 1u {
@@ -6074,19 +6074,19 @@ fn make_common_glue(sess: &session::session, output: &istr) {
     let task_type = T_task();
     let taskptr_type = T_ptr(task_type);
 
-    let llmod = istr::as_buf(~"rust_out", { |buf|
+    let llmod = str::as_buf(~"rust_out", { |buf|
         llvm::LLVMModuleCreateWithNameInContext(buf,
                                                 llvm::LLVMGetGlobalContext())
     });
-    let _: () = istr::as_buf(x86::get_data_layout(), { |buf|
+    let _: () = str::as_buf(x86::get_data_layout(), { |buf|
         llvm::LLVMSetDataLayout(llmod, buf)
     });
-    let _: () = istr::as_buf(x86::get_target_triple(), { |buf|
+    let _: () = str::as_buf(x86::get_target_triple(), { |buf|
         llvm::LLVMSetTarget(llmod, buf)
     });
     mk_target_data(x86::get_data_layout());
     declare_intrinsics(llmod);
-    let _: () = istr::as_buf(x86::get_module_asm(), { |buf|
+    let _: () = str::as_buf(x86::get_module_asm(), { |buf|
         llvm::LLVMSetModuleInlineAsm(llmod, buf)
     });
     make_glues(llmod, taskptr_type);
@@ -6096,7 +6096,7 @@ fn make_common_glue(sess: &session::session, output: &istr) {
 fn create_module_map(ccx: &@crate_ctxt) -> ValueRef {
     let elttype = T_struct([T_int(), T_int()]);
     let maptype = T_array(elttype, ccx.module_data.size() + 1u);
-    let map = istr::as_buf(~"_rust_mod_map", { |buf|
+    let map = str::as_buf(~"_rust_mod_map", { |buf|
         llvm::LLVMAddGlobal(ccx.llmod, maptype, buf)
     });
     llvm::LLVMSetLinkage(map,
@@ -6122,7 +6122,7 @@ fn create_crate_map(ccx: &@crate_ctxt) -> ValueRef {
     while cstore::have_crate_data(cstore, i) {
         let nm = ~"_rust_crate_map_" +
             cstore::get_crate_data(cstore, i).name;
-        let cr = istr::as_buf(nm, { |buf|
+        let cr = str::as_buf(nm, { |buf|
             llvm::LLVMAddGlobal(ccx.llmod, T_int(), buf)
         });
         subcrates += [p2i(cr)];
@@ -6136,7 +6136,7 @@ fn create_crate_map(ccx: &@crate_ctxt) -> ValueRef {
     let sym_name = ~"_rust_crate_map_" + mapname;
     let arrtype = T_array(T_int(), std::vec::len::<ValueRef>(subcrates));
     let maptype = T_struct([T_int(), arrtype]);
-    let map = istr::as_buf(sym_name, { |buf|
+    let map = str::as_buf(sym_name, { |buf|
         llvm::LLVMAddGlobal(ccx.llmod, maptype, buf)
     });
     llvm::LLVMSetLinkage(map,
@@ -6152,11 +6152,11 @@ fn write_metadata(cx: &@crate_ctxt, crate: &@ast::crate) {
     let llmeta = C_postr(
         metadata::encoder::encode_metadata(cx, crate));
     let llconst = trans_common::C_struct([llmeta]);
-    let llglobal = istr::as_buf(~"rust_metadata", { |buf|
+    let llglobal = str::as_buf(~"rust_metadata", { |buf|
         llvm::LLVMAddGlobal(cx.llmod, val_ty(llconst), buf)
     });
     llvm::LLVMSetInitializer(llglobal, llconst);
-    let _: () = istr::as_buf(x86::get_meta_sect_name(), { |buf|
+    let _: () = str::as_buf(x86::get_meta_sect_name(), { |buf|
         llvm::LLVMSetSection(llglobal, buf)
     });
     llvm::LLVMSetLinkage(llglobal,
@@ -6164,7 +6164,7 @@ fn write_metadata(cx: &@crate_ctxt, crate: &@ast::crate) {
 
     let t_ptr_i8 = T_ptr(T_i8());
     llglobal = llvm::LLVMConstBitCast(llglobal, t_ptr_i8);
-    let llvm_used = istr::as_buf(~"llvm.used", { |buf|
+    let llvm_used = str::as_buf(~"llvm.used", { |buf|
         llvm::LLVMAddGlobal(cx.llmod, T_array(t_ptr_i8, 1u), buf)
     });
     llvm::LLVMSetLinkage(llvm_used,
@@ -6181,14 +6181,14 @@ fn write_abi_version(ccx: &@crate_ctxt) {
 fn trans_crate(sess: &session::session, crate: &@ast::crate, tcx: &ty::ctxt,
                output: &istr, amap: &ast_map::map, mut_map: mut::mut_map)
     -> ModuleRef {
-    let llmod = istr::as_buf(~"rust_out", { |buf|
+    let llmod = str::as_buf(~"rust_out", { |buf|
         llvm::LLVMModuleCreateWithNameInContext(buf,
                                                 llvm::LLVMGetGlobalContext())
     });
-    let _: () = istr::as_buf(x86::get_data_layout(), { |buf|
+    let _: () = str::as_buf(x86::get_data_layout(), { |buf|
         llvm::LLVMSetDataLayout(llmod, buf)
     });
-    let _: () = istr::as_buf(x86::get_target_triple(), { |buf|
+    let _: () = str::as_buf(x86::get_target_triple(), { |buf|
         llvm::LLVMSetTarget(llmod, buf)
     });
     let td = mk_target_data(x86::get_data_layout());
diff --git a/src/comp/middle/trans_alt.rs b/src/comp/middle/trans_alt.rs
index 73a49a04c5fc..a4cdb44f5741 100644
--- a/src/comp/middle/trans_alt.rs
+++ b/src/comp/middle/trans_alt.rs
@@ -1,4 +1,4 @@
-import std::istr;
+import std::str;
 import std::vec;
 import std::option;
 import option::some;
@@ -59,7 +59,7 @@ fn variant_opt(ccx: &@crate_ctxt, pat_id: ast::node_id) -> opt {
 type bind_map = [{ident: ast::ident, val: ValueRef}];
 fn assoc(key: &istr, list: &bind_map) -> option::t<ValueRef> {
     for elt: {ident: ast::ident, val: ValueRef} in list {
-        if istr::eq(elt.ident, key) { ret some(elt.val); }
+        if str::eq(elt.ident, key) { ret some(elt.val); }
     }
     ret none;
 }
@@ -145,7 +145,7 @@ fn enter_rec(m: &match, col: uint, fields: &[ast::ident], val: ValueRef) ->
             for fname: ast::ident in fields {
                 let pat = dummy;
                 for fpat: ast::field_pat in fpats {
-                    if istr::eq(fpat.ident, fname) { pat = fpat.pat; break; }
+                    if str::eq(fpat.ident, fname) { pat = fpat.pat; break; }
                 }
                 pats += [pat];
             }
@@ -233,7 +233,7 @@ fn collect_record_fields(m: &match, col: uint) -> [ast::ident] {
         alt br.pats[col].node {
           ast::pat_rec(fs, _) {
             for f: ast::field_pat in fs {
-                if !vec::any(bind istr::eq(f.ident, _), fields) {
+                if !vec::any(bind str::eq(f.ident, _), fields) {
                     fields += [f.ident];
                 }
             }
diff --git a/src/comp/middle/trans_build.rs b/src/comp/middle/trans_build.rs
index 9cad896c9492..1355bbff0aad 100644
--- a/src/comp/middle/trans_build.rs
+++ b/src/comp/middle/trans_build.rs
@@ -1,5 +1,5 @@
-import std::{vec, istr};
-import std::istr::sbuf;
+import std::{vec, str};
+import std::str::sbuf;
 import lib::llvm::llvm;
 import llvm::{ValueRef, TypeRef, BasicBlockRef, BuilderRef,
               Opcode, ModuleRef};
@@ -61,7 +61,7 @@ fn Invoke(cx: &@block_ctxt, Fn: ValueRef, Args: &[ValueRef],
           Then: BasicBlockRef, Catch: BasicBlockRef) -> ValueRef {
     assert (!cx.terminated);;
     cx.terminated = true;
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildInvoke(B(cx), Fn, vec::to_ptr(Args),
                               vec::len(Args), Then, Catch, buf)
     });
@@ -75,212 +75,212 @@ fn Unreachable(cx: &@block_ctxt) -> ValueRef {
 
 /* Arithmetic */
 fn Add(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildAdd(B(cx), LHS, RHS, buf)
     });
 }
 
 fn NSWAdd(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildNSWAdd(B(cx), LHS, RHS, buf)
     });
 }
 
 fn NUWAdd(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildNUWAdd(B(cx), LHS, RHS, buf)
     });
 }
 
 fn FAdd(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFAdd(B(cx), LHS, RHS, buf)
     });
 }
 
 fn Sub(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildSub(B(cx), LHS, RHS, buf)
     });
 }
 
 fn NSWSub(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildNSWSub(B(cx), LHS, RHS, buf)
     });
 }
 
 fn NUWSub(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildNUWSub(B(cx), LHS, RHS, buf)
     });
 }
 
 fn FSub(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFSub(B(cx), LHS, RHS, buf)
     });
 }
 
 fn Mul(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildMul(B(cx), LHS, RHS, buf)
     });
 }
 
 fn NSWMul(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildNSWMul(B(cx), LHS, RHS, buf)
     });
 }
 
 fn NUWMul(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildNUWMul(B(cx), LHS, RHS, buf)
     });
 }
 
 fn FMul(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFMul(B(cx), LHS, RHS, buf)
     });
 }
 
 fn UDiv(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildUDiv(B(cx), LHS, RHS, buf)
     });
 }
 
 fn SDiv(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildSDiv(B(cx), LHS, RHS, buf)
     });
 }
 
 fn ExactSDiv(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildExactSDiv(B(cx), LHS, RHS, buf)
     });
 }
 
 fn FDiv(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFDiv(B(cx), LHS, RHS, buf)
     });
 }
 
 fn URem(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildURem(B(cx), LHS, RHS, buf)
     });
 }
 
 fn SRem(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildSRem(B(cx), LHS, RHS, buf)
     });
 }
 
 fn FRem(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFRem(B(cx), LHS, RHS, buf)
     });
 }
 
 fn Shl(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildShl(B(cx), LHS, RHS, buf)
     });
 }
 
 fn LShr(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildLShr(B(cx), LHS, RHS, buf)
     });
 }
 
 fn AShr(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildAShr(B(cx), LHS, RHS, buf)
     });
 }
 
 fn And(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildAnd(B(cx), LHS, RHS, buf)
     });
 }
 
 fn Or(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildOr(B(cx), LHS, RHS, buf)
     });
 }
 
 fn Xor(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildXor(B(cx), LHS, RHS, buf)
     });
 }
 
 fn BinOp(cx: &@block_ctxt, Op: Opcode, LHS: ValueRef,
          RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildBinOp(B(cx), Op, LHS, RHS, buf)
     });
 }
 
 fn Neg(cx: &@block_ctxt, V: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildNeg(B(cx), V, buf)
     });
 }
 
 fn NSWNeg(cx: &@block_ctxt, V: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildNSWNeg(B(cx), V, buf)
     });
 }
 
 fn NUWNeg(cx: &@block_ctxt, V: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildNUWNeg(B(cx), V, buf)
     });
 }
 fn FNeg(cx: &@block_ctxt, V: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFNeg(B(cx), V, buf)
     });
 }
 
 fn Not(cx: &@block_ctxt, V: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildNot(B(cx), V, buf)
     });
 }
 
 /* Memory */
 fn Malloc(cx: &@block_ctxt, Ty: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildMalloc(B(cx), Ty, buf)
     });
 }
 
 fn ArrayMalloc(cx: &@block_ctxt, Ty: TypeRef, Val: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildArrayMalloc(B(cx), Ty, Val, buf)
     });
 }
 
 fn Alloca(cx: &@block_ctxt, Ty: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildAlloca(B(cx), Ty, buf)
     });
 }
 
 fn ArrayAlloca(cx: &@block_ctxt, Ty: TypeRef, Val: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildArrayAlloca(B(cx), Ty, Val, buf)
     });
 }
@@ -290,7 +290,7 @@ fn Free(cx: &@block_ctxt, PointerVal: ValueRef) -> ValueRef {
 }
 
 fn Load(cx: &@block_ctxt, PointerVal: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildLoad(B(cx), PointerVal, buf)
     });
 }
@@ -301,7 +301,7 @@ fn Store(cx: &@block_ctxt, Val: ValueRef, Ptr: ValueRef) -> ValueRef {
 
 fn GEP(cx: &@block_ctxt, Pointer: ValueRef,
        Indices: &[ValueRef]) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildGEP(B(cx), Pointer, vec::to_ptr(Indices),
                            vec::len(Indices), buf)
     });
@@ -309,122 +309,122 @@ fn GEP(cx: &@block_ctxt, Pointer: ValueRef,
 
 fn InBoundsGEP(cx: &@block_ctxt, Pointer: ValueRef,
                Indices: &[ValueRef]) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildInBoundsGEP(B(cx), Pointer, vec::to_ptr(Indices),
                                    vec::len(Indices), buf)
     });
 }
 
 fn StructGEP(cx: &@block_ctxt, Pointer: ValueRef, Idx: uint) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildStructGEP(B(cx), Pointer, Idx, buf)
     });
 }
 
 fn GlobalString(cx: &@block_ctxt, _Str: sbuf) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildGlobalString(B(cx), _Str, buf)
     });
 }
 
 fn GlobalStringPtr(cx: &@block_ctxt, _Str: sbuf) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildGlobalStringPtr(B(cx), _Str, buf)
     });
 }
 
 /* Casts */
 fn Trunc(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildTrunc(B(cx), Val, DestTy, buf)
     });
 }
 
 fn ZExt(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildZExt(B(cx), Val, DestTy, buf)
     });
 }
 
 fn SExt(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildSExt(B(cx), Val, DestTy, buf)
     });
 }
 
 fn FPToUI(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFPToUI(B(cx), Val, DestTy, buf)
     });
 }
 
 fn FPToSI(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFPToSI(B(cx), Val, DestTy, buf)
     });
 }
 
 fn UIToFP(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildUIToFP(B(cx), Val, DestTy, buf)
     });
 }
 
 fn SIToFP(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildSIToFP(B(cx), Val, DestTy, buf)
     });
 }
 
 fn FPTrunc(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFPTrunc(B(cx), Val, DestTy, buf)
     });
 }
 
 fn FPExt(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFPExt(B(cx), Val, DestTy, buf)
     });
 }
 
 fn PtrToInt(cx: &@block_ctxt, Val: ValueRef,
             DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildPtrToInt(B(cx), Val, DestTy, buf)
     });
 }
 
 fn IntToPtr(cx: &@block_ctxt, Val: ValueRef,
             DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildIntToPtr(B(cx), Val, DestTy, buf)
     });
 }
 
 fn BitCast(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildBitCast(B(cx), Val, DestTy, buf)
     });
 }
 
 fn ZExtOrBitCast(cx: &@block_ctxt, Val: ValueRef,
                  DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildZExtOrBitCast(B(cx), Val, DestTy, buf)
     });
 }
 
 fn SExtOrBitCast(cx: &@block_ctxt, Val: ValueRef,
                  DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildSExtOrBitCast(B(cx), Val, DestTy, buf)
     });
 }
 
 fn TruncOrBitCast(cx: &@block_ctxt, Val: ValueRef,
                   DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildTruncOrBitCast(B(cx), Val, DestTy, buf)
     });
 }
@@ -432,25 +432,25 @@ fn TruncOrBitCast(cx: &@block_ctxt, Val: ValueRef,
 fn Cast(cx: &@block_ctxt, Op: Opcode, Val: ValueRef,
         DestTy: TypeRef, _Name: sbuf) ->
     ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildCast(B(cx), Op, Val, DestTy, buf)
     });
 }
 
 fn PointerCast(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildPointerCast(B(cx), Val, DestTy, buf)
     });
 }
 
 fn IntCast(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildIntCast(B(cx), Val, DestTy, buf)
     });
 }
 
 fn FPCast(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFPCast(B(cx), Val, DestTy, buf)
     });
 }
@@ -459,14 +459,14 @@ fn FPCast(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
 /* Comparisons */
 fn ICmp(cx: &@block_ctxt, Op: uint, LHS: ValueRef,
         RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildICmp(B(cx), Op, LHS, RHS, buf)
     });
 }
 
 fn FCmp(cx: &@block_ctxt, Op: uint, LHS: ValueRef,
         RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildFCmp(B(cx), Op, LHS, RHS, buf)
     });
 }
@@ -475,7 +475,7 @@ fn FCmp(cx: &@block_ctxt, Op: uint, LHS: ValueRef,
 /* Miscellaneous instructions */
 fn Phi(cx: &@block_ctxt, Ty: TypeRef, vals: &[ValueRef],
        bbs: &[BasicBlockRef]) -> ValueRef {
-    let phi = istr::as_buf(~"", { |buf|
+    let phi = str::as_buf(~"", { |buf|
         llvm::LLVMBuildPhi(B(cx), Ty, buf)
     });
     assert (vec::len::<ValueRef>(vals) == vec::len::<BasicBlockRef>(bbs));
@@ -491,14 +491,14 @@ fn AddIncomingToPhi(phi: ValueRef, vals: &[ValueRef], bbs: &[BasicBlockRef]) {
 }
 
 fn Call(cx: &@block_ctxt, Fn: ValueRef, Args: &[ValueRef]) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildCall(B(cx), Fn, vec::to_ptr(Args),
                             vec::len(Args), buf)
     });
 }
 
 fn FastCall(cx: &@block_ctxt, Fn: ValueRef, Args: &[ValueRef]) -> ValueRef {
-    let v = istr::as_buf(~"", { |buf|
+    let v = str::as_buf(~"", { |buf|
         llvm::LLVMBuildCall(B(cx), Fn, vec::to_ptr(Args), vec::len(Args), buf)
     });
     llvm::LLVMSetInstructionCallConv(v, lib::llvm::LLVMFastCallConv);
@@ -507,7 +507,7 @@ fn FastCall(cx: &@block_ctxt, Fn: ValueRef, Args: &[ValueRef]) -> ValueRef {
 
 fn CallWithConv(cx: &@block_ctxt, Fn: ValueRef, Args: &[ValueRef],
                 Conv: uint) -> ValueRef {
-    let v = istr::as_buf(~"", { |buf|
+    let v = str::as_buf(~"", { |buf|
         llvm::LLVMBuildCall(B(cx), Fn, vec::to_ptr(Args), vec::len(Args), buf)
     });
     llvm::LLVMSetInstructionCallConv(v, Conv);
@@ -516,20 +516,20 @@ fn CallWithConv(cx: &@block_ctxt, Fn: ValueRef, Args: &[ValueRef],
 
 fn Select(cx: &@block_ctxt, If: ValueRef, Then: ValueRef,
           Else: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildSelect(B(cx), If, Then, Else, buf)
     });
 }
 
 fn VAArg(cx: &@block_ctxt, list: ValueRef, Ty: TypeRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildVAArg(B(cx), list, Ty, buf)
     });
 }
 
 fn ExtractElement(cx: &@block_ctxt, VecVal: ValueRef,
                   Index: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildExtractElement(B(cx), VecVal, Index, buf)
     });
 }
@@ -537,45 +537,45 @@ fn ExtractElement(cx: &@block_ctxt, VecVal: ValueRef,
 fn InsertElement(cx: &@block_ctxt, VecVal: ValueRef, EltVal: ValueRef,
                  Index: ValueRef) ->
     ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildInsertElement(B(cx), VecVal, EltVal, Index, buf)
     });
 }
 
 fn ShuffleVector(cx: &@block_ctxt, V1: ValueRef, V2: ValueRef,
                  Mask: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildShuffleVector(B(cx), V1, V2, Mask, buf)
     });
 }
 
 fn ExtractValue(cx: &@block_ctxt, AggVal: ValueRef, Index: uint) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildExtractValue(B(cx), AggVal, Index, buf)
     });
 }
 
 fn InsertValue(cx: &@block_ctxt, AggVal: ValueRef,
                EltVal: ValueRef, Index: uint) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildInsertValue(B(cx), AggVal, EltVal, Index, buf)
     });
 }
 
 fn IsNull(cx: &@block_ctxt, Val: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildIsNull(B(cx), Val, buf)
     });
 }
 
 fn IsNotNull(cx: &@block_ctxt, Val: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildIsNotNull(B(cx), Val, buf)
     });
 }
 
 fn PtrDiff(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildPtrDiff(B(cx), LHS, RHS, buf)
     });
 }
@@ -585,12 +585,12 @@ fn Trap(cx: &@block_ctxt) -> ValueRef {
     let BB: BasicBlockRef = llvm::LLVMGetInsertBlock(b);
     let FN: ValueRef = llvm::LLVMGetBasicBlockParent(BB);
     let M: ModuleRef = llvm::LLVMGetGlobalParent(FN);
-    let T: ValueRef = istr::as_buf(~"llvm.trap", { |buf|
+    let T: ValueRef = str::as_buf(~"llvm.trap", { |buf|
         llvm::LLVMGetNamedFunction(M, buf)
     });
     assert (T as int != 0);
     let Args: [ValueRef] = [];
-    ret istr::as_buf(~"", { |buf|
+    ret str::as_buf(~"", { |buf|
         llvm::LLVMBuildCall(b, T, vec::to_ptr(Args), vec::len(Args), buf)
     });
 }
diff --git a/src/comp/middle/trans_common.rs b/src/comp/middle/trans_common.rs
index 9cee76c1db61..5a7bb4faf072 100644
--- a/src/comp/middle/trans_common.rs
+++ b/src/comp/middle/trans_common.rs
@@ -6,7 +6,7 @@
 import std::int;
 import std::vec;
 import std::vec::to_ptr;
-import std::istr;
+import std::str;
 import std::uint;
 import std::map;
 import std::map::hashmap;
@@ -547,7 +547,7 @@ fn T_struct(elts: &[TypeRef]) -> TypeRef {
 
 fn T_named_struct(name: &istr) -> TypeRef {
     let c = llvm::LLVMGetGlobalContext();
-    ret istr::as_buf(name, { |buf|
+    ret str::as_buf(name, { |buf|
         llvm::LLVMStructCreateNamed(c, buf)
     });
 }
@@ -767,13 +767,13 @@ fn C_integral(t: TypeRef, u: uint, sign_extend: Bool) -> ValueRef {
 }
 
 fn C_float(s: &istr) -> ValueRef {
-    ret istr::as_buf(s, { |buf|
+    ret str::as_buf(s, { |buf|
         llvm::LLVMConstRealOfString(T_float(), buf)
     });
 }
 
 fn C_floating(s: &istr, t: TypeRef) -> ValueRef {
-    ret istr::as_buf(s, { |buf|
+    ret str::as_buf(s, { |buf|
         llvm::LLVMConstRealOfString(t, buf)
     });
 }
@@ -800,10 +800,10 @@ fn C_u8(i: uint) -> ValueRef { ret C_integral(T_i8(), i, False); }
 // This is a 'c-like' raw string, which differs from
 // our boxed-and-length-annotated strings.
 fn C_cstr(cx: &@crate_ctxt, s: &istr) -> ValueRef {
-    let sc = istr::as_buf(s, { |buf|
-        llvm::LLVMConstString(buf, istr::byte_len(s), False)
+    let sc = str::as_buf(s, { |buf|
+        llvm::LLVMConstString(buf, str::byte_len(s), False)
     });
-    let g = istr::as_buf(cx.names.next(~"str"), { |buf|
+    let g = str::as_buf(cx.names.next(~"str"), { |buf|
         llvm::LLVMAddGlobal(cx.llmod, val_ty(sc), buf)
     });
     llvm::LLVMSetInitializer(g, sc);
@@ -816,17 +816,17 @@ fn C_cstr(cx: &@crate_ctxt, s: &istr) -> ValueRef {
 // A rust boxed-and-length-annotated string.
 fn C_str(cx: &@crate_ctxt, s: &istr) -> ValueRef {
     let len =
-        istr::byte_len(s); // 'alloc'
+        str::byte_len(s); // 'alloc'
                           // 'fill'
                           // 'pad'
 
-    let cstr = istr::as_buf(s, { |buf|
+    let cstr = str::as_buf(s, { |buf|
         llvm::LLVMConstString(buf, len, False)
     });
     let box =
         C_struct([C_int(abi::const_refcount as int), C_int(len + 1u as int),
                   C_int(len + 1u as int), C_int(0), cstr]);
-    let g = istr::as_buf(cx.names.next(~"str"), { |buf|
+    let g = str::as_buf(cx.names.next(~"str"), { |buf|
         llvm::LLVMAddGlobal(cx.llmod, val_ty(box), buf)
     });
     llvm::LLVMSetInitializer(g, box);
@@ -837,8 +837,8 @@ fn C_str(cx: &@crate_ctxt, s: &istr) -> ValueRef {
 
 // Returns a Plain Old LLVM String:
 fn C_postr(s: &istr) -> ValueRef {
-    ret istr::as_buf(s, { |buf|
-        llvm::LLVMConstString(buf, istr::byte_len(s), False)
+    ret str::as_buf(s, { |buf|
+        llvm::LLVMConstString(buf, str::byte_len(s), False)
     });
 }
 
@@ -871,7 +871,7 @@ fn C_bytes(bytes: &[u8]) -> ValueRef {
 
 fn C_shape(ccx: &@crate_ctxt, bytes: &[u8]) -> ValueRef {
     let llshape = C_bytes(bytes);
-    let llglobal = istr::as_buf(ccx.names.next(~"shape"), { |buf|
+    let llglobal = str::as_buf(ccx.names.next(~"shape"), { |buf|
         llvm::LLVMAddGlobal(ccx.llmod, val_ty(llshape), buf)
     });
     llvm::LLVMSetInitializer(llglobal, llshape);
diff --git a/src/comp/middle/trans_ivec.rs b/src/comp/middle/trans_ivec.rs
index 9b269d042c09..8beb796fd47a 100644
--- a/src/comp/middle/trans_ivec.rs
+++ b/src/comp/middle/trans_ivec.rs
@@ -114,7 +114,7 @@ fn trans_ivec(bcx: &@block_ctxt, args: &[@ast::expr],
     ret rslt(bcx, vptr);
 }
 fn trans_istr(bcx: &@block_ctxt, s: istr) -> result {
-    let veclen = std::istr::byte_len(s) + 1u; // +1 for \0
+    let veclen = std::str::byte_len(s) + 1u; // +1 for \0
     let {bcx, val: sptr, _} =
         alloc(bcx, ty::mk_istr(bcx_tcx(bcx)), veclen);
 
diff --git a/src/comp/middle/trans_objects.rs b/src/comp/middle/trans_objects.rs
index 49da4aba9a03..6c70e8aab9fe 100644
--- a/src/comp/middle/trans_objects.rs
+++ b/src/comp/middle/trans_objects.rs
@@ -1,6 +1,6 @@
 // Translation of object-related things to LLVM IR.
 
-import std::istr;
+import std::str;
 import std::option;
 import std::vec;
 import option::none;
@@ -396,7 +396,7 @@ tag vtbl_mthd {
 
 // Alphabetize ast::methods by ident.  A helper for create_vtbl.
 fn ast_mthd_lteq(a: &@ast::method, b: &@ast::method) -> bool {
-    ret istr::lteq(a.node.ident, b.node.ident);
+    ret str::lteq(a.node.ident, b.node.ident);
 }
 
 // Alphabetize vtbl_mthds by ident.  A helper for create_vtbl.
@@ -404,14 +404,14 @@ fn vtbl_mthd_lteq(a: &vtbl_mthd, b: &vtbl_mthd) -> bool {
     alt a {
       normal_mthd(ma) {
         alt b {
-          normal_mthd(mb) { ret istr::lteq(ma.node.ident, mb.node.ident); }
-          fwding_mthd(mb) { ret istr::lteq(ma.node.ident, mb.ident); }
+          normal_mthd(mb) { ret str::lteq(ma.node.ident, mb.node.ident); }
+          fwding_mthd(mb) { ret str::lteq(ma.node.ident, mb.ident); }
         }
       }
       fwding_mthd(ma) {
         alt b {
-          normal_mthd(mb) { ret istr::lteq(ma.ident, mb.node.ident); }
-          fwding_mthd(mb) { ret istr::lteq(ma.ident, mb.ident); }
+          normal_mthd(mb) { ret str::lteq(ma.ident, mb.node.ident); }
+          fwding_mthd(mb) { ret str::lteq(ma.ident, mb.ident); }
         }
       }
     }
@@ -430,7 +430,7 @@ fn filtering_fn(cx: @local_ctxt, m: &vtbl_mthd, addtl_meths: [@ast::method])
     alt m {
       fwding_mthd(fm) {
         for am: @ast::method in addtl_meths {
-            if istr::eq(am.node.ident, fm.ident) { ret none; }
+            if str::eq(am.node.ident, fm.ident) { ret none; }
         }
         ret some(fwding_mthd(fm));
       }
@@ -570,7 +570,7 @@ fn finish_vtbl(cx: @local_ctxt, llmethods: [ValueRef], name: &istr) ->
     let vtbl = C_struct(llmethods);
     let vtbl_name = mangle_internal_name_by_path(
         cx.ccx, cx.path + [name]);
-    let gvar = istr::as_buf(vtbl_name, { |buf|
+    let gvar = str::as_buf(vtbl_name, { |buf|
         llvm::LLVMAddGlobal(cx.ccx.llmod, val_ty(vtbl), buf)
     });
     llvm::LLVMSetInitializer(gvar, vtbl);
diff --git a/src/comp/middle/tstate/annotate.rs b/src/comp/middle/tstate/annotate.rs
index 7a5039e44cec..0be3d1776ba5 100644
--- a/src/comp/middle/tstate/annotate.rs
+++ b/src/comp/middle/tstate/annotate.rs
@@ -4,7 +4,7 @@ import std::option::some;
 import std::option::none;
 import std::int;
 import std::uint;
-import std::istr;
+import std::str;
 import syntax::ast::*;
 import syntax::ast_util::pat_binding_ids;
 import syntax::visit;
diff --git a/src/comp/middle/tstate/auxiliary.rs b/src/comp/middle/tstate/auxiliary.rs
index bdc94f803cf5..62c883eb9f8f 100644
--- a/src/comp/middle/tstate/auxiliary.rs
+++ b/src/comp/middle/tstate/auxiliary.rs
@@ -1,6 +1,6 @@
 import std::vec;
 import std::int::str;
-import std::istr;
+import std::str;
 import std::option;
 import std::option::*;
 import std::int;
diff --git a/src/comp/middle/tstate/ck.rs b/src/comp/middle/tstate/ck.rs
index 8817a16cdd43..cef36843ea69 100644
--- a/src/comp/middle/tstate/ck.rs
+++ b/src/comp/middle/tstate/ck.rs
@@ -37,7 +37,7 @@ import std::option;
 import std::option::t;
 import std::option::some;
 import std::option::none;
-import std::istr;
+import std::str;
 import aux::*;
 import syntax::print::pprust::ty_to_str;
 import util::common::log_stmt_err;
diff --git a/src/comp/middle/tstate/collect_locals.rs b/src/comp/middle/tstate/collect_locals.rs
index dbdb3b15c16c..4c6ce536d7df 100644
--- a/src/comp/middle/tstate/collect_locals.rs
+++ b/src/comp/middle/tstate/collect_locals.rs
@@ -1,4 +1,4 @@
-import std::istr;
+import std::str;
 import std::uint;
 import std::int;
 import std::vec;
diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs
index 189b52491434..a7f385161252 100644
--- a/src/comp/middle/tstate/pre_post_conditions.rs
+++ b/src/comp/middle/tstate/pre_post_conditions.rs
@@ -1,6 +1,6 @@
 
 import std::vec;
-import std::istr;
+import std::str;
 import std::option;
 import std::option::none;
 import std::option::some;
diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs
index fc65961d6928..e6b35121ec29 100644
--- a/src/comp/middle/tstate/states.rs
+++ b/src/comp/middle/tstate/states.rs
@@ -1,7 +1,7 @@
 import syntax::print::pprust::path_to_str;
 import util::ppaux::ty_to_str;
 import std::vec;
-import std::istr;
+import std::str;
 import std::option;
 import std::option::get;
 import std::option::is_none;
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 5a09bfa9b6f1..56ccb1b0dc5c 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -1,6 +1,6 @@
 import std::int;
 import std::vec;
-import std::istr;
+import std::str;
 import std::uint;
 import std::box;
 import std::ufind;
@@ -1420,7 +1420,7 @@ fn hash_type_structure(st: &sty) -> uint {
       ty_native_fn(_, args, rty) { ret hash_fn(28u, args, rty); }
       ty_obj(methods) {
         let h = 29u;
-        for m: method in methods { h += h << 5u + istr::hash(m.ident); }
+        for m: method in methods { h += h << 5u + str::hash(m.ident); }
         ret h;
       }
       ty_var(v) { ret hash_uint(30u, v as uint); }
@@ -1447,7 +1447,7 @@ fn hash_type_info(st: &sty, cname_opt: &option::t<istr>) -> uint {
     let h = hash_type_structure(st);
     alt cname_opt {
       none. {/* no-op */ }
-      some(s) { h += h << 5u + istr::hash(s); }
+      some(s) { h += h << 5u + str::hash(s); }
     }
     ret h;
 }
@@ -1511,7 +1511,7 @@ fn eq_raw_ty(a: &@raw_t, b: &@raw_t) -> bool {
       none. { alt b.cname { none. {/* ok */ } _ { ret false; } } }
       some(s_a) {
         alt b.cname {
-          some(s_b) { if !istr::eq(s_a, s_b) { ret false; } }
+          some(s_b) { if !str::eq(s_a, s_b) { ret false; } }
           _ { ret false; }
         }
       }
@@ -1708,7 +1708,7 @@ fn stmt_node_id(s: &@ast::stmt) -> ast::node_id {
 fn field_idx(sess: &session::session, sp: &span, id: &ast::ident,
              fields: &[field]) -> uint {
     let i: uint = 0u;
-    for f: field in fields { if istr::eq(f.ident, id) { ret i; } i += 1u; }
+    for f: field in fields { if str::eq(f.ident, id) { ret i; } i += 1u; }
     sess.span_fatal(sp, ~"unknown field '" +
                     id + ~"' of record");
 }
@@ -1716,13 +1716,13 @@ fn field_idx(sess: &session::session, sp: &span, id: &ast::ident,
 fn method_idx(sess: &session::session, sp: &span, id: &ast::ident,
               meths: &[method]) -> uint {
     let i: uint = 0u;
-    for m: method in meths { if istr::eq(m.ident, id) { ret i; } i += 1u; }
+    for m: method in meths { if str::eq(m.ident, id) { ret i; } i += 1u; }
     sess.span_fatal(sp, ~"unknown method '" + id + ~"' of obj");
 }
 
 fn sort_methods(meths: &[method]) -> [method] {
     fn method_lteq(a: &method, b: &method) -> bool {
-        ret istr::lteq(a.ident, b.ident);
+        ret str::lteq(a.ident, b.ident);
     }
     ret std::sort::merge_sort::<method>(bind method_lteq(_, _), meths);
 }
@@ -2039,7 +2039,7 @@ mod unify {
         while i < expected_len {
             let e_meth = expected_meths[i];
             let a_meth = actual_meths[i];
-            if !istr::eq(e_meth.ident, a_meth.ident) {
+            if !str::eq(e_meth.ident, a_meth.ident) {
                 ret ures_err(terr_obj_meths(e_meth.ident, a_meth.ident));
             }
             let r =
@@ -2316,7 +2316,7 @@ mod unify {
                       none. { ret ures_err(terr_record_mutability); }
                       some(m) { mut = m; }
                     }
-                    if !istr::eq(expected_field.ident, actual_field.ident) {
+                    if !str::eq(expected_field.ident, actual_field.ident) {
                         let err =
                             terr_record_fields(expected_field.ident,
                                                actual_field.ident);
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index 23153a23e291..15e6301511c3 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -36,7 +36,7 @@ import middle::ty::unify::fix_ok;
 import middle::ty::unify::fix_err;
 import std::int;
 import std::vec;
-import std::istr;
+import std::str;
 import std::uint;
 import std::map;
 import std::map::hashmap;
@@ -1443,7 +1443,7 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast_util::pat_id_map, pat: &@ast::pat,
                      ex_f_count, f_count]);
         }
         fn matches(name: &istr, f: &ty::field) -> bool {
-            ret istr::eq(name, f.ident);
+            ret str::eq(name, f.ident);
         }
         for f: ast::field_pat in fields {
             alt vec::find(bind matches(f.ident, _), ex_fields) {
@@ -2233,7 +2233,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
             for f: spanned<ty::field> in fields_t {
                 let found = false;
                 for bf: ty::field in base_fields {
-                    if istr::eq(f.node.ident, bf.ident) {
+                    if str::eq(f.node.ident, bf.ident) {
                         demand::simple(fcx, f.span, bf.mt.ty, f.node.mt.ty);
                         found = true;
                     }
@@ -2397,7 +2397,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
                option::t<ty::method> {
 
                 for om: @ast::method in outer_obj_methods {
-                    if istr::eq(om.node.ident, m.ident) {
+                    if str::eq(om.node.ident, m.ident) {
                         // We'd better be overriding with one of the same
                         // type.  Check to make sure.
                         let new_type = ty_of_method(ccx, om);
diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs
index 5481229a7624..d82a2302be59 100644
--- a/src/comp/syntax/ast_util.rs
+++ b/src/comp/syntax/ast_util.rs
@@ -1,4 +1,4 @@
-import std::istr;
+import std::str;
 import std::option;
 import codemap::span;
 import ast::*;
@@ -16,7 +16,7 @@ fn dummy_sp() -> span { ret mk_sp(0u, 0u); }
 fn path_name(p: &path) -> istr { path_name_i(p.node.idents) }
 
 fn path_name_i(idents: &[ident]) -> istr {
-    istr::connect(idents, ~"::")
+    str::connect(idents, ~"::")
 }
 
 fn local_def(id: node_id) -> def_id { ret {crate: local_crate, node: id}; }
@@ -157,7 +157,7 @@ fn is_exported(i: ident, m: _mod) -> bool {
     for vi: @view_item in m.view_items {
         alt vi.node {
           view_item_export(ids, _) {
-            for id in ids { if istr::eq(i, id) { ret true; } }
+            for id in ids { if str::eq(i, id) { ret true; } }
             count += 1u;
           }
           _ {/* fall through */ }
diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs
index 14dc3e46448a..c56ccc219219 100644
--- a/src/comp/syntax/codemap.rs
+++ b/src/comp/syntax/codemap.rs
@@ -1,6 +1,6 @@
 import std::vec;
 import std::uint;
-import std::istr;
+import std::str;
 import std::term;
 import std::io;
 import std::option;
@@ -148,13 +148,13 @@ fn maybe_highlight_lines(sp: &option::t<span>, cm: &codemap,
             io::stdout().write_str(
                 #ifmt[~"%s:%u ", fm.name, line + 1u]);
             let s = get_line(fm, line as int, file);
-            if !istr::ends_with(s, ~"\n") { s += ~"\n"; }
+            if !str::ends_with(s, ~"\n") { s += ~"\n"; }
             io::stdout().write_str(s);
         }
         if elided {
             let last_line = display_lines[vec::len(display_lines) - 1u];
             let s = #ifmt[~"%s:%u ", fm.name, last_line + 1u];
-            let indent = istr::char_len(s);
+            let indent = str::char_len(s);
             let out = ~"";
             while indent > 0u { out += ~" "; indent -= 1u; }
             out += ~"...\n";
@@ -172,16 +172,16 @@ fn maybe_highlight_lines(sp: &option::t<span>, cm: &codemap,
             while num > 0u { num /= 10u; digits += 1u; }
 
             // indent past |name:## | and the 0-offset column location
-            let left = istr::char_len(fm.name) + digits + lo.col + 3u;
+            let left = str::char_len(fm.name) + digits + lo.col + 3u;
             let s = ~"";
-            while left > 0u { istr::push_char(s, ' '); left -= 1u; }
+            while left > 0u { str::push_char(s, ' '); left -= 1u; }
 
             s += ~"^";
             let hi = lookup_char_pos(cm, option::get(sp).hi);
             if hi.col != lo.col {
                 // the ^ already takes up one space
                 let width = hi.col - lo.col - 1u;
-                while width > 0u { istr::push_char(s, '~'); width -= 1u; }
+                while width > 0u { str::push_char(s, '~'); width -= 1u; }
             }
             io::stdout().write_str(s + ~"\n");
         }
@@ -221,12 +221,12 @@ fn get_line(fm: filemap, line: int, file: &istr) -> istr {
         // If we're not done parsing the file, we're at the limit of what's
         // parsed. If we just slice the rest of the string, we'll print out
         // the remainder of the file, which is undesirable.
-        end = istr::byte_len(file);
-        let rest = istr::slice(file, begin, end);
-        let newline = istr::index(rest, '\n' as u8);
+        end = str::byte_len(file);
+        let rest = str::slice(file, begin, end);
+        let newline = str::index(rest, '\n' as u8);
         if newline != -1 { end = begin + (newline as uint); }
     }
-    ret istr::slice(file, begin, end);
+    ret str::slice(file, begin, end);
 }
 
 fn get_filemap(cm: codemap, filename: istr) -> filemap {
diff --git a/src/comp/syntax/ext/base.rs b/src/comp/syntax/ext/base.rs
index 051c667e38fb..84d9061c6148 100644
--- a/src/comp/syntax/ext/base.rs
+++ b/src/comp/syntax/ext/base.rs
@@ -1,4 +1,4 @@
-import std::istr;
+import std::str;
 import std::vec;
 import std::option;
 import std::map::hashmap;
diff --git a/src/comp/syntax/ext/env.rs b/src/comp/syntax/ext/env.rs
index c10f835ff293..ed493137369c 100644
--- a/src/comp/syntax/ext/env.rs
+++ b/src/comp/syntax/ext/env.rs
@@ -5,7 +5,7 @@
  * interface.
  */
 import std::vec;
-import std::istr;
+import std::str;
 import std::option;
 import std::generic_os;
 import base::*;
diff --git a/src/comp/syntax/ext/expand.rs b/src/comp/syntax/ext/expand.rs
index ce787c2bc6ed..ad58a617f45f 100644
--- a/src/comp/syntax/ext/expand.rs
+++ b/src/comp/syntax/ext/expand.rs
@@ -5,7 +5,7 @@ import std::option::some;
 
 import std::map::hashmap;
 import std::vec;
-import std::istr;
+import std::str;
 
 import syntax::ast::crate;
 import syntax::ast::expr_;
diff --git a/src/comp/syntax/ext/ident_to_str.rs b/src/comp/syntax/ext/ident_to_str.rs
index d2c73bfb16fd..d989151831ec 100644
--- a/src/comp/syntax/ext/ident_to_str.rs
+++ b/src/comp/syntax/ext/ident_to_str.rs
@@ -1,5 +1,5 @@
 import std::vec;
-import std::istr;
+import std::str;
 import std::option;
 import base::*;
 import syntax::ast;
diff --git a/src/comp/syntax/ext/ifmt.rs b/src/comp/syntax/ext/ifmt.rs
index b48d73d0fc5f..3b90ebeed13b 100644
--- a/src/comp/syntax/ext/ifmt.rs
+++ b/src/comp/syntax/ext/ifmt.rs
@@ -6,7 +6,7 @@
  * compiler syntax extension plugin interface.
  */
 import std::vec;
-import std::istr;
+import std::str;
 import std::option;
 import std::option::none;
 import std::option::some;
@@ -103,7 +103,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
     }
     fn make_path_vec(cx: &ext_ctxt, ident: &ast::ident) -> [ast::ident] {
         fn compiling_std(cx: &ext_ctxt) -> bool {
-            ret istr::find(cx.crate_file_name(), ~"std.rc") >= 0;
+            ret str::find(cx.crate_file_name(), ~"std.rc") >= 0;
         }
         if compiling_std(cx) {
             ret [~"extifmt", ~"rt", ident];
diff --git a/src/comp/syntax/ext/log_syntax.rs b/src/comp/syntax/ext/log_syntax.rs
index 5acad14fbb26..a8fa657c20cb 100644
--- a/src/comp/syntax/ext/log_syntax.rs
+++ b/src/comp/syntax/ext/log_syntax.rs
@@ -1,7 +1,7 @@
 import std::option;
 import base::*;
 import syntax::ast;
-import std::istr;
+import std::str;
 
 fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
                      _body: &option::t<istr>) -> @ast::expr {
diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs
index 2ab61e122444..2df629d3f8ce 100644
--- a/src/comp/syntax/ext/simplext.rs
+++ b/src/comp/syntax/ext/simplext.rs
@@ -2,7 +2,7 @@ use std;
 
 import codemap::span;
 import std::vec;
-import std::istr;
+import std::str;
 import std::option;
 import std::map::hashmap;
 import std::map::new_str_hash;
diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs
index 6318c4c769bb..ee7c5a3d3383 100644
--- a/src/comp/syntax/parse/eval.rs
+++ b/src/comp/syntax/parse/eval.rs
@@ -1,5 +1,5 @@
 
-import std::istr;
+import std::str;
 import std::option;
 import std::option::some;
 import std::option::none;
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index 37eddf59abe7..57720422306d 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -2,7 +2,7 @@
 import std::io;
 import std::int;
 import std::vec;
-import std::istr;
+import std::str;
 import std::map;
 import std::map::hashmap;
 import std::option;
@@ -44,19 +44,19 @@ fn new_reader(cm: &codemap::codemap, src: &istr, filemap: codemap::filemap,
         fn get_str_from(start: uint) -> istr {
             // I'm pretty skeptical about this subtraction. What if there's a
             // multi-byte character before the mark?
-            ret istr::slice(src, start - 1u, pos - 1u);
+            ret str::slice(src, start - 1u, pos - 1u);
         }
         fn get_chpos() -> uint { ret chpos; }
         fn get_byte_pos() -> uint { ret pos; }
         fn curr() -> char { ret ch; }
         fn next() -> char {
             if pos < len {
-                ret istr::char_at(src, pos);
+                ret str::char_at(src, pos);
             } else { ret -1 as char; }
         }
         fn init() {
             if pos < len {
-                let next = istr::char_range_at(src, pos);
+                let next = str::char_range_at(src, pos);
                 pos = next.next;
                 ch = next.ch;
             }
@@ -69,7 +69,7 @@ fn new_reader(cm: &codemap::codemap, src: &istr, filemap: codemap::filemap,
                     codemap::next_line(fm, chpos, pos + fm.start_pos.byte);
                     col = 0u;
                 }
-                let next = istr::char_range_at(src, pos);
+                let next = str::char_range_at(src, pos);
                 pos = next.next;
                 ch = next.ch;
             } else { ch = -1 as char; }
@@ -85,7 +85,7 @@ fn new_reader(cm: &codemap::codemap, src: &istr, filemap: codemap::filemap,
     }
     let strs: [istr] = [];
     let rd =
-        reader(cm, src, istr::byte_len(src), 0u, 0u, -1 as char,
+        reader(cm, src, str::byte_len(src), 0u, 0u, -1 as char,
                filemap.start_pos.ch, strs, filemap, itr);
     rd.init();
     ret rd;
@@ -178,15 +178,15 @@ fn scan_exponent(rdr: &reader) -> option::t<istr> {
     let c = rdr.curr();
     let rslt = ~"";
     if c == 'e' || c == 'E' {
-        rslt += istr::unsafe_from_bytes([c as u8]);
+        rslt += str::unsafe_from_bytes([c as u8]);
         rdr.bump();
         c = rdr.curr();
         if c == '-' || c == '+' {
-            rslt += istr::unsafe_from_bytes([c as u8]);
+            rslt += str::unsafe_from_bytes([c as u8]);
             rdr.bump();
         }
         let exponent = scan_dec_digits(rdr);
-        if istr::byte_len(exponent) > 0u {
+        if str::byte_len(exponent) > 0u {
             ret some(rslt + exponent);
         } else { rdr.err(~"scan_exponent: bad fp literal"); fail; }
     } else { ret none::<istr>; }
@@ -196,7 +196,7 @@ fn scan_dec_digits(rdr: &reader) -> istr {
     let c = rdr.curr();
     let rslt: istr = ~"";
     while is_dec_digit(c) || c == '_' {
-        if c != '_' { rslt += istr::unsafe_from_bytes([c as u8]); }
+        if c != '_' { rslt += str::unsafe_from_bytes([c as u8]); }
         rdr.bump();
         c = rdr.curr();
     }
@@ -348,11 +348,11 @@ fn next_token_inner(rdr: &reader) -> token::token {
     let c = rdr.curr();
     if is_alpha(c) || c == '_' {
         while is_alnum(c) || c == '_' {
-            istr::push_char(accum_str, c);
+            str::push_char(accum_str, c);
             rdr.bump();
             c = rdr.curr();
         }
-        if istr::eq(accum_str, ~"_") { ret token::UNDERSCORE; }
+        if str::eq(accum_str, ~"_") { ret token::UNDERSCORE; }
         let is_mod_name = c == ':' && rdr.next() == ':';
         ret token::IDENT(interner::intern::<istr>(
             *rdr.get_interner(),
@@ -493,20 +493,20 @@ fn next_token_inner(rdr: &reader) -> token::token {
                 let escaped = rdr.curr();
                 rdr.bump();
                 alt escaped {
-                  'n' { istr::push_byte(accum_str, '\n' as u8); }
-                  'r' { istr::push_byte(accum_str, '\r' as u8); }
-                  't' { istr::push_byte(accum_str, '\t' as u8); }
-                  '\\' { istr::push_byte(accum_str, '\\' as u8); }
-                  '"' { istr::push_byte(accum_str, '"' as u8); }
+                  'n' { str::push_byte(accum_str, '\n' as u8); }
+                  'r' { str::push_byte(accum_str, '\r' as u8); }
+                  't' { str::push_byte(accum_str, '\t' as u8); }
+                  '\\' { str::push_byte(accum_str, '\\' as u8); }
+                  '"' { str::push_byte(accum_str, '"' as u8); }
                   '\n' { consume_whitespace(rdr); }
                   'x' {
-                    istr::push_char(accum_str, scan_numeric_escape(rdr, 2u));
+                    str::push_char(accum_str, scan_numeric_escape(rdr, 2u));
                   }
                   'u' {
-                    istr::push_char(accum_str, scan_numeric_escape(rdr, 4u));
+                    str::push_char(accum_str, scan_numeric_escape(rdr, 4u));
                   }
                   'U' {
-                    istr::push_char(accum_str, scan_numeric_escape(rdr, 8u));
+                    str::push_char(accum_str, scan_numeric_escape(rdr, 8u));
                   }
                   c2 {
                     rdr.err(
@@ -516,7 +516,7 @@ fn next_token_inner(rdr: &reader) -> token::token {
                   }
                 }
               }
-              _ { istr::push_char(accum_str, ch); }
+              _ { str::push_char(accum_str, ch); }
             }
         }
         rdr.bump();
@@ -569,7 +569,7 @@ type cmnt = {style: cmnt_style, lines: [istr], pos: uint};
 fn read_to_eol(rdr: &reader) -> istr {
     let val = ~"";
     while rdr.curr() != '\n' && !rdr.is_eof() {
-        istr::push_char(val, rdr.curr());
+        str::push_char(val, rdr.curr());
         rdr.bump();
     }
     if rdr.curr() == '\n' { rdr.bump(); }
@@ -634,8 +634,8 @@ fn trim_whitespace_prefix_and_push_line(lines: &mutable [istr], s: &istr,
                                         col: uint) {
     let s1;
     if all_whitespace(s, 0u, col) {
-        if col < istr::byte_len(s) {
-            s1 = istr::slice(s, col, istr::byte_len(s));
+        if col < str::byte_len(s) {
+            s1 = str::slice(s, col, str::byte_len(s));
         } else { s1 = ~""; }
     } else { s1 = s; }
     log ~"pushing line: " + s1;
@@ -659,7 +659,7 @@ fn read_block_comment(rdr: &reader, code_to_the_left: bool) -> cmnt {
             curr_line = ~"";
             rdr.bump();
         } else {
-            istr::push_char(curr_line, rdr.curr());
+            str::push_char(curr_line, rdr.curr());
             if rdr.curr() == '/' && rdr.next() == '*' {
                 rdr.bump();
                 rdr.bump();
@@ -675,7 +675,7 @@ fn read_block_comment(rdr: &reader, code_to_the_left: bool) -> cmnt {
             }
         }
     }
-    if istr::byte_len(curr_line) != 0u {
+    if str::byte_len(curr_line) != 0u {
         trim_whitespace_prefix_and_push_line(lines, curr_line, col);
     }
     let style = if code_to_the_left { trailing } else { isolated };
@@ -722,8 +722,8 @@ type lit = {lit: istr, pos: uint};
 fn gather_comments_and_literals(cm: &codemap::codemap, path: &istr,
                                 srdr: io::reader) ->
    {cmnts: [cmnt], lits: [lit]} {
-    let src = istr::unsafe_from_bytes(srdr.read_whole_stream());
-    let itr = @interner::mk::<istr>(istr::hash, istr::eq);
+    let src = str::unsafe_from_bytes(srdr.read_whole_stream());
+    let itr = @interner::mk::<istr>(str::hash, str::eq);
     let rdr = new_reader(cm, src,
                          codemap::new_filemap(
                              path, 0u, 0u), itr);
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index e22ebeb78d3b..763172c81fa5 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -1,7 +1,7 @@
 
 import std::io;
 import std::vec;
-import std::istr;
+import std::str;
 import std::option;
 import std::option::some;
 import std::option::none;
@@ -66,7 +66,7 @@ fn new_parser_from_file(sess: parse_sess, cfg: &ast::crate_cfg, path: &istr,
     let filemap = codemap::new_filemap(
         path, chpos, byte_pos);
     sess.cm.files += [filemap];
-    let itr = @interner::mk(istr::hash, istr::eq);
+    let itr = @interner::mk(str::hash, str::eq);
     let rdr = lexer::new_reader(sess.cm, src, filemap, itr);
     ret new_parser(sess, cfg, rdr, ftype);
 }
@@ -247,7 +247,7 @@ fn eat(p: &parser, tok: &token::token) -> bool {
 
 fn is_word(p: &parser, word: &istr) -> bool {
     ret alt p.peek() {
-          token::IDENT(sid, false) { istr::eq(word, p.get_str(sid)) }
+          token::IDENT(sid, false) { str::eq(word, p.get_str(sid)) }
           _ { false }
         };
 }
@@ -255,7 +255,7 @@ fn is_word(p: &parser, word: &istr) -> bool {
 fn eat_word(p: &parser, word: &istr) -> bool {
     alt p.peek() {
       token::IDENT(sid, false) {
-        if istr::eq(word, p.get_str(sid)) {
+        if str::eq(word, p.get_str(sid)) {
             p.bump();
             ret true;
         } else { ret false; }
@@ -2036,14 +2036,14 @@ fn parse_item_native_mod(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
     let abi = ast::native_abi_cdecl;
     if !is_word(p, ~"mod") {
         let t = parse_str(p);
-        if istr::eq(t, ~"cdecl") {
-        } else if istr::eq(t, ~"rust") {
+        if str::eq(t, ~"cdecl") {
+        } else if str::eq(t, ~"rust") {
             abi = ast::native_abi_rust;
-        } else if istr::eq(t, ~"llvm") {
+        } else if str::eq(t, ~"llvm") {
             abi = ast::native_abi_llvm;
-        } else if istr::eq(t, ~"rust-intrinsic") {
+        } else if str::eq(t, ~"rust-intrinsic") {
             abi = ast::native_abi_rust_intrinsic;
-        } else if istr::eq(t, ~"x86stdcall") {
+        } else if str::eq(t, ~"x86stdcall") {
             abi = ast::native_abi_x86stdcall;
         } else { p.fatal(~"unsupported abi: " + t); }
     }
@@ -2419,8 +2419,8 @@ fn is_view_item(p: &parser) -> bool {
     alt p.peek() {
       token::IDENT(sid, false) {
         let st = p.get_str(sid);
-        ret istr::eq(st, ~"use") || istr::eq(st, ~"import") ||
-                istr::eq(st, ~"export");
+        ret str::eq(st, ~"use") || str::eq(st, ~"import") ||
+                str::eq(st, ~"export");
       }
       _ { ret false; }
     }
@@ -2450,7 +2450,7 @@ fn parse_crate_from_source_str(name: &istr, source: &istr,
     let ftype = SOURCE_FILE;
     let filemap = codemap::new_filemap(name, 0u, 0u);
     sess.cm.files += [filemap];
-    let itr = @interner::mk(istr::hash, istr::eq);
+    let itr = @interner::mk(str::hash, str::eq);
     let rdr = lexer::new_reader(sess.cm, source,
                                 filemap, itr);
     let p = new_parser(sess, cfg, rdr, ftype);
@@ -2588,9 +2588,9 @@ fn parse_crate_from_crate_file(input: &istr, cfg: &ast::crate_cfg,
 
 fn parse_crate_from_file(input: &istr, cfg: &ast::crate_cfg,
                          sess: &parse_sess) -> @ast::crate {
-    if istr::ends_with(input, ~".rc") {
+    if str::ends_with(input, ~".rc") {
         parse_crate_from_crate_file(input, cfg, sess)
-    } else if istr::ends_with(input, ~".rs") {
+    } else if str::ends_with(input, ~".rs") {
         parse_crate_from_source_file(input, cfg, sess)
     } else {
         codemap::emit_error(none, ~"unknown input file type: "
diff --git a/src/comp/syntax/parse/token.rs b/src/comp/syntax/parse/token.rs
index 6ae2affdb043..24d2a3b9a6f7 100644
--- a/src/comp/syntax/parse/token.rs
+++ b/src/comp/syntax/parse/token.rs
@@ -5,7 +5,7 @@ import std::map::new_str_hash;
 import util::interner;
 import std::int;
 import std::uint;
-import std::istr;
+import std::str;
 
 type str_num = uint;
 
@@ -166,8 +166,8 @@ fn to_str(r: lexer::reader, t: token) -> istr {
       LIT_CHAR(c) {
         // FIXME: escape.
         let tmp = ~"'";
-        istr::push_char(tmp, c);
-        istr::push_byte(tmp, '\'' as u8);
+        str::push_char(tmp, c);
+        str::push_byte(tmp, '\'' as u8);
         ret tmp;
       }
       LIT_BOOL(b) { if b { ret ~"true"; } else { ret ~"false"; } }
diff --git a/src/comp/syntax/print/pp.rs b/src/comp/syntax/print/pp.rs
index ae94fb959b57..39e5b59eb613 100644
--- a/src/comp/syntax/print/pp.rs
+++ b/src/comp/syntax/print/pp.rs
@@ -1,7 +1,7 @@
 
 import std::io;
 import std::vec;
-import std::istr;
+import std::str;
 
 /*
  * This pretty-printer is a direct reimplementation of Philip Karlton's
@@ -496,7 +496,7 @@ fn end(p: printer) { p.pretty_print(END); }
 fn eof(p: printer) { p.pretty_print(EOF); }
 
 fn word(p: printer, wrd: &istr) {
-    p.pretty_print(STRING(wrd, istr::char_len(wrd) as int));
+    p.pretty_print(STRING(wrd, str::char_len(wrd) as int));
 }
 
 fn huge_word(p: printer, wrd: &istr) {
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index f1382341eb94..a78006417a45 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -2,7 +2,7 @@
 import std::vec;
 import std::int;
 import std::io;
-import std::istr;
+import std::str;
 import std::uint;
 import std::option;
 import parse::lexer;
@@ -156,7 +156,7 @@ fn head(s: &ps, w: &istr) {
     // outer-box is consistent
     cbox(s, indent_unit);
     // head-box is inconsistent
-    ibox(s, istr::char_len(w) + 1u);
+    ibox(s, str::char_len(w) + 1u);
     // keyword that starts the head
     word_nbsp(s, w);
 }
@@ -432,7 +432,7 @@ fn print_item(s: &ps, item: &@ast::item) {
         }
         word_nbsp(s, ~"mod");
         word_nbsp(s, item.ident);
-        if !istr::eq(nmod.native_name, item.ident) {
+        if !str::eq(nmod.native_name, item.ident) {
             word_space(s, ~"=");
             print_string(s, nmod.native_name);
             nbsp(s);
@@ -458,7 +458,7 @@ fn print_item(s: &ps, item: &@ast::item) {
       ast::item_tag(variants, params) {
         let newtype =
             vec::len(variants) == 1u &&
-                istr::eq(item.ident, variants[0].node.name) &&
+                str::eq(item.ident, variants[0].node.name) &&
                 vec::len(variants[0].node.args) == 1u;
         if newtype {
             ibox(s, indent_unit);
@@ -1318,7 +1318,7 @@ fn print_view_item(s: &ps, item: &@ast::view_item) {
       }
       ast::view_item_import(id, ids, _) {
         head(s, ~"import");
-        if !istr::eq(id, ids[vec::len(ids) - 1u]) {
+        if !str::eq(id, ids[vec::len(ids) - 1u]) {
             word_space(s, id);
             word_space(s, ~"=");
         }
@@ -1510,7 +1510,7 @@ fn print_literal(s: &ps, lit: &@ast::lit) {
       }
       ast::lit_char(ch) {
         word(s.s,
-             ~"'" + escape_str(istr::unsafe_from_bytes([ch as u8]), '\'') +
+             ~"'" + escape_str(str::unsafe_from_bytes([ch as u8]), '\'') +
                  ~"'");
       }
       ast::lit_int(val) { word(s.s, int::str(val)); }
@@ -1572,7 +1572,7 @@ fn print_comment(s: &ps, cmnt: lexer::cmnt) {
         for line: istr in cmnt.lines {
             // Don't print empty lines because they will end up as trailing
             // whitespace
-            if istr::is_not_empty(line) {
+            if str::is_not_empty(line) {
                 word(s.s, line);
             }
             hardbreak(s.s);
@@ -1586,7 +1586,7 @@ fn print_comment(s: &ps, cmnt: lexer::cmnt) {
         } else {
             ibox(s, 0u);
             for line: istr in cmnt.lines {
-                if istr::is_not_empty(line) {
+                if str::is_not_empty(line) {
                     word(s.s, line);
                 }
                 hardbreak(s.s);
@@ -1615,7 +1615,7 @@ fn print_string(s: &ps, st: &istr) {
 
 fn escape_str(st: &istr, to_escape: char) -> istr {
     let out: istr = ~"";
-    let len = istr::byte_len(st);
+    let len = str::byte_len(st);
     let i = 0u;
     while i < len {
         alt st[i] as char {
@@ -1627,7 +1627,7 @@ fn escape_str(st: &istr, to_escape: char) -> istr {
             if cur == to_escape { out += ~"\\"; }
             // FIXME some (or all?) non-ascii things should be escaped
 
-            istr::push_char(out, cur);
+            str::push_char(out, cur);
           }
         }
         i += 1u;
diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs
index da0fba4a96a8..89d52834b99c 100644
--- a/src/comp/util/common.rs
+++ b/src/comp/util/common.rs
@@ -1,4 +1,4 @@
-import std::istr;
+import std::str;
 import std::map;
 import std::map::hashmap;
 import std::uint;
@@ -154,7 +154,7 @@ fn call_kind_str(c: call_kind) -> istr {
 }
 
 fn is_main_name(path: &[ast::ident]) -> bool {
-    istr::eq(option::get(std::vec::last(path)), ~"main")
+    str::eq(option::get(std::vec::last(path)), ~"main")
 }
 
 // FIXME mode this to std::float when editing the stdlib no longer
diff --git a/src/comp/util/ppaux.rs b/src/comp/util/ppaux.rs
index 5e7e7e3fd782..8fec8e547272 100644
--- a/src/comp/util/ppaux.rs
+++ b/src/comp/util/ppaux.rs
@@ -1,5 +1,5 @@
 import std::vec;
-import std::istr;
+import std::str;
 import std::int;
 import std::option;
 import std::option::none;
@@ -44,7 +44,7 @@ fn fn_ident_to_string(id: ast::node_id, i: &ast::fn_ident) -> istr {
 fn get_id_ident(cx: &ctxt, id: ast::def_id) -> istr {
     if id.crate != ast::local_crate {
         alt cx.ext_map.find(id) {
-          some(j) { istr::connect(j, ~"::") }
+          some(j) { str::connect(j, ~"::") }
           _ { fail (~"get_id_ident: can't find item in ext_map, id.crate = "
                     + int::str(id.crate)) }
         }
@@ -76,7 +76,7 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> istr {
         s += ~"(";
         let strs = [];
         for a: arg in inputs { strs += [fn_input_to_str(cx, a)]; }
-        s += istr::connect(strs, ~", ");
+        s += str::connect(strs, ~", ");
         s += ~")";
         if struct(cx, output) != ty_nil {
             alt cf {
@@ -128,19 +128,19 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> istr {
           ty_rec(elems) {
             let strs: [istr] = [];
             for fld: field in elems { strs += [field_to_str(cx, fld)]; }
-            ~"{" + istr::connect(strs, ~",") + ~"}"
+            ~"{" + str::connect(strs, ~",") + ~"}"
           }
           ty_tup(elems) {
             let strs = [];
             for elem in elems { strs += [ty_to_str(cx, elem)]; }
-            ~"(" + istr::connect(strs, ~",") + ~")"
+            ~"(" + str::connect(strs, ~",") + ~")"
           }
           ty_tag(id, tps) {
             let s = get_id_ident(cx, id);
             if vec::len::<t>(tps) > 0u {
                 let strs: [istr] = [];
                 for typ: t in tps { strs += [ty_to_str(cx, typ)]; }
-                s += ~"[" + istr::connect(strs, ~",") + ~"]";
+                s += ~"[" + str::connect(strs, ~",") + ~"]";
             }
             s
           }
@@ -154,12 +154,12 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> istr {
           ty_obj(meths) {
             let strs = [];
             for m: method in meths { strs += [method_to_str(cx, m)]; }
-            ~"obj {\n\t" + istr::connect(strs, ~"\n\t") + ~"\n}"
+            ~"obj {\n\t" + str::connect(strs, ~"\n\t") + ~"\n}"
           }
           ty_res(id, _, _) { get_id_ident(cx, id) }
           ty_var(v) { ~"<T" + int::str(v) + ~">" }
           ty_param(id, _) {
-            ~"'" + istr::unsafe_from_bytes([('a' as u8) + (id as u8)])
+            ~"'" + str::unsafe_from_bytes([('a' as u8) + (id as u8)])
           }
           _ { ty_to_short_str(cx, typ) }
         }
@@ -167,7 +167,7 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> istr {
 
 fn ty_to_short_str(cx: &ctxt, typ: t) -> istr {
     let s = encoder::encoded_ty(cx, typ);
-    if istr::byte_len(s) >= 32u { s = istr::substr(s, 0u, 32u); }
+    if str::byte_len(s) >= 32u { s = str::substr(s, 0u, 32u); }
     ret s;
 }
 
diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs
index 8a30e0caba1b..4de76a12abbb 100644
--- a/src/fuzzer/fuzzer.rs
+++ b/src/fuzzer/fuzzer.rs
@@ -9,7 +9,7 @@ import std::getopts::opt_str;
 import std::io;
 import std::io::stdout;
 import std::vec;
-import std::istr;
+import std::str;
 import std::uint;
 import std::option;
 
@@ -28,20 +28,20 @@ fn write_file(filename: &istr, content: &istr) {
 
 fn file_contains(filename: &istr, needle: &istr) -> bool {
     let contents = io::read_whole_file_str(filename);
-    ret istr::find(contents, needle) != -1;
+    ret str::find(contents, needle) != -1;
 }
 
 fn contains(haystack: &istr, needle: &istr) -> bool {
-    istr::find(haystack, needle) != -1
+    str::find(haystack, needle) != -1
 }
 
 fn find_rust_files(files: &mutable [istr], path: &istr) {
-    if istr::ends_with(path, ~".rs") {
+    if str::ends_with(path, ~".rs") {
         if file_contains(path, ~"xfail-test") {
             //log_err "Skipping " + path + " because it is marked as xfail-test";
         } else { files += [path]; }
     } else if fs::file_is_dir(path)
-        && istr::find(path, ~"compile-fail") == -1 {
+        && str::find(path, ~"compile-fail") == -1 {
         for p in fs::list_dir(path) {
             find_rust_files(files, p);
         }
diff --git a/src/lib/aio.rs b/src/lib/aio.rs
index e1c8625352bc..cdb0e3fb90d3 100644
--- a/src/lib/aio.rs
+++ b/src/lib/aio.rs
@@ -47,8 +47,8 @@ type ctx = chan<request>;
 fn ip_to_sbuf(ip: net::ip_addr) -> *u8 {
     // FIXME: This is broken. We're creating a vector, getting a pointer
     // to its buffer, then dropping the vector. On top of that, the vector
-    // created by istr::bytes is not null-terminated.
-    vec::to_ptr(istr::bytes(net::format_addr(ip)))
+    // created by str::bytes is not null-terminated.
+    vec::to_ptr(str::bytes(net::format_addr(ip)))
 }
 
 fn connect_task(ip: net::ip_addr, portnum: int, evt: chan<socket_event>) {
diff --git a/src/lib/extifmt.rs b/src/lib/extifmt.rs
index ea602891868a..7f363b661da3 100644
--- a/src/lib/extifmt.rs
+++ b/src/lib/extifmt.rs
@@ -72,10 +72,10 @@ mod ct {
 
     fn parse_fmt_string(s: &istr, error: error_fn) -> [piece] {
         let pieces: [piece] = [];
-        let lim = istr::byte_len(s);
+        let lim = str::byte_len(s);
         let buf = ~"";
         fn flush_buf(buf: &istr, pieces: &mutable [piece]) -> istr {
-            if istr::byte_len(buf) > 0u {
+            if str::byte_len(buf) > 0u {
                 let piece = piece_string(buf);
                 pieces += [piece];
             }
@@ -83,14 +83,14 @@ mod ct {
         }
         let i = 0u;
         while i < lim {
-            let curr = istr::substr(s, i, 1u);
-            if istr::eq(curr, ~"%") {
+            let curr = str::substr(s, i, 1u);
+            if str::eq(curr, ~"%") {
                 i += 1u;
                 if i >= lim {
                     error(~"unterminated conversion at end of string");
                 }
-                let curr2 = istr::substr(s, i, 1u);
-                if istr::eq(curr2, ~"%") {
+                let curr2 = str::substr(s, i, 1u);
+                if str::eq(curr2, ~"%") {
                     i += 1u;
                 } else {
                     buf = flush_buf(buf, pieces);
@@ -217,27 +217,27 @@ mod ct {
     fn parse_type(s: &istr, i: uint, lim: uint, error: error_fn) ->
        {ty: ty, next: uint} {
         if i >= lim { error(~"missing type in conversion"); }
-        let tstr = istr::substr(s, i, 1u);
+        let tstr = str::substr(s, i, 1u);
         // TODO: Do we really want two signed types here?
         // How important is it to be printf compatible?
         let t =
-            if istr::eq(tstr, ~"b") {
+            if str::eq(tstr, ~"b") {
                 ty_bool
-            } else if istr::eq(tstr, ~"s") {
+            } else if str::eq(tstr, ~"s") {
                 ty_str
-            } else if istr::eq(tstr, ~"c") {
+            } else if str::eq(tstr, ~"c") {
                 ty_char
-            } else if istr::eq(tstr, ~"d") || istr::eq(tstr, ~"i") {
+            } else if str::eq(tstr, ~"d") || str::eq(tstr, ~"i") {
                 ty_int(signed)
-            } else if istr::eq(tstr, ~"u") {
+            } else if str::eq(tstr, ~"u") {
                 ty_int(unsigned)
-            } else if istr::eq(tstr, ~"x") {
+            } else if str::eq(tstr, ~"x") {
                 ty_hex(case_lower)
-            } else if istr::eq(tstr, ~"X") {
+            } else if str::eq(tstr, ~"X") {
                 ty_hex(case_upper)
-            } else if istr::eq(tstr, ~"t") {
+            } else if str::eq(tstr, ~"t") {
                 ty_bits
-            } else if istr::eq(tstr, ~"o") {
+            } else if str::eq(tstr, ~"o") {
                 ty_octal
             } else { error(~"unknown type in conversion: " + tstr) };
         ret {ty: t, next: i + 1u};
@@ -289,7 +289,7 @@ mod rt {
             alt cv.ty {
               ty_default. { uint_to_str_prec(u, 10u, prec) }
               ty_hex_lower. { uint_to_str_prec(u, 16u, prec) }
-              ty_hex_upper. { istr::to_upper(uint_to_str_prec(u, 16u, prec)) }
+              ty_hex_upper. { str::to_upper(uint_to_str_prec(u, 16u, prec)) }
               ty_bits. { uint_to_str_prec(u, 2u, prec) }
               ty_octal. { uint_to_str_prec(u, 8u, prec) }
             };
@@ -303,7 +303,7 @@ mod rt {
         ret conv_str(cv, s);
     }
     fn conv_char(cv: &conv, c: char) -> istr {
-        ret pad(cv, istr::from_char(c), pad_nozero);
+        ret pad(cv, str::from_char(c), pad_nozero);
     }
     fn conv_str(cv: &conv, s: &istr) -> istr {
         // For strings, precision is the maximum characters
@@ -314,8 +314,8 @@ mod rt {
             alt cv.precision {
               count_implied. { s }
               count_is(max) {
-                if max as uint < istr::char_len(s) {
-                    istr::substr(s, 0u, max as uint)
+                if max as uint < str::char_len(s) {
+                    str::substr(s, 0u, max as uint)
                 } else { s }
               }
             };
@@ -338,7 +338,7 @@ mod rt {
                 ~""
             } else {
                 let s = uint::to_str(num, radix);
-                let len = istr::char_len(s);
+                let len = str::char_len(s);
                 if len < prec {
                     let diff = prec - len;
                     let pad = str_init_elt('0', diff);
@@ -357,7 +357,7 @@ mod rt {
     fn str_init_elt(c: char, n_elts: uint) -> istr {
         let svec = vec::init_elt::<u8>(c as u8, n_elts);
 
-        ret istr::unsafe_from_bytes(svec);
+        ret str::unsafe_from_bytes(svec);
     }
     tag pad_mode { pad_signed; pad_unsigned; pad_nozero; }
     fn pad(cv: &conv, s: &istr, mode: pad_mode) -> istr {
@@ -370,7 +370,7 @@ mod rt {
             uwidth = width as uint;
           }
         }
-        let strlen = istr::char_len(s);
+        let strlen = str::char_len(s);
         if uwidth <= strlen { ret s; }
         let padchar = ' ';
         let diff = uwidth - strlen;
@@ -403,12 +403,12 @@ mod rt {
         // zeros. It may make sense to convert zero padding to a precision
         // instead.
 
-        if signed && zero_padding && istr::byte_len(s) > 0u {
+        if signed && zero_padding && str::byte_len(s) > 0u {
             let head = s[0];
             if head == '+' as u8 || head == '-' as u8 || head == ' ' as u8 {
-                let headstr = istr::unsafe_from_bytes([head]);
-                let bytelen = istr::byte_len(s);
-                let numpart = istr::substr(s, 1u, bytelen - 1u);
+                let headstr = str::unsafe_from_bytes([head]);
+                let bytelen = str::byte_len(s);
+                let numpart = str::substr(s, 1u, bytelen - 1u);
                 ret headstr + padstr + numpart;
             }
         }
diff --git a/src/lib/fs.rs b/src/lib/fs.rs
index 297c27cb2a85..745c30c80b31 100644
--- a/src/lib/fs.rs
+++ b/src/lib/fs.rs
@@ -3,37 +3,37 @@ import os::getcwd;
 import os_fs;
 
 native "rust" mod rustrt {
-    fn rust_file_is_dir(path: istr::sbuf) -> int;
+    fn rust_file_is_dir(path: str::sbuf) -> int;
 }
 
-fn path_sep() -> istr { ret istr::from_char(os_fs::path_sep); }
+fn path_sep() -> istr { ret str::from_char(os_fs::path_sep); }
 
 type path = istr;
 
 fn dirname(p: &path) -> path {
-    let i: int = istr::rindex(p, os_fs::path_sep as u8);
+    let i: int = str::rindex(p, os_fs::path_sep as u8);
     if i == -1 {
-        i = istr::rindex(p, os_fs::alt_path_sep as u8);
+        i = str::rindex(p, os_fs::alt_path_sep as u8);
         if i == -1 { ret ~"."; }
     }
-    ret istr::substr(p, 0u, i as uint);
+    ret str::substr(p, 0u, i as uint);
 }
 
 fn basename(p: &path) -> path {
-    let i: int = istr::rindex(p, os_fs::path_sep as u8);
+    let i: int = str::rindex(p, os_fs::path_sep as u8);
     if i == -1 {
-        i = istr::rindex(p, os_fs::alt_path_sep as u8);
+        i = str::rindex(p, os_fs::alt_path_sep as u8);
         if i == -1 { ret p; }
     }
-    let len = istr::byte_len(p);
+    let len = str::byte_len(p);
     if i + 1 as uint >= len { ret p; }
-    ret istr::slice(p, i + 1 as uint, len);
+    ret str::slice(p, i + 1 as uint, len);
 }
 
 
 // FIXME: Need some typestate to avoid bounds check when len(pre) == 0
 fn connect(pre: &path, post: &path) -> path {
-    let len = istr::byte_len(pre);
+    let len = str::byte_len(pre);
     ret if pre[len - 1u] == os_fs::path_sep as u8 {
 
             // Trailing '/'?
@@ -42,19 +42,19 @@ fn connect(pre: &path, post: &path) -> path {
 }
 
 fn file_is_dir(p: &path) -> bool {
-    ret istr::as_buf(p, { |buf|
+    ret str::as_buf(p, { |buf|
         rustrt::rust_file_is_dir(buf) != 0
     });
 }
 
 fn list_dir(p: &path) -> [istr] {
     let p = p;
-    let pl = istr::byte_len(p);
+    let pl = str::byte_len(p);
     if pl == 0u || p[pl - 1u] as char != os_fs::path_sep { p += path_sep(); }
     let full_paths: [istr] = [];
     for filename: istr in os_fs::list_dir(p) {
-        if !istr::eq(filename, ~".") {
-            if !istr::eq(filename, ~"..") { full_paths += [p + filename]; }
+        if !str::eq(filename, ~".") {
+            if !str::eq(filename, ~"..") { full_paths += [p + filename]; }
         }
     }
     ret full_paths;
diff --git a/src/lib/generic_os.rs b/src/lib/generic_os.rs
index 32df07b9c768..169548d106a3 100644
--- a/src/lib/generic_os.rs
+++ b/src/lib/generic_os.rs
@@ -1,17 +1,17 @@
-import istr::sbuf;
+import str::sbuf;
 
 
 #[cfg(target_os = "linux")]
 #[cfg(target_os = "macos")]
 fn getenv(n: &istr) -> option::t<istr> {
-    let s = istr::as_buf(n, { |buf|
+    let s = str::as_buf(n, { |buf|
         os::libc::getenv(buf)
     });
     ret if unsafe::reinterpret_cast(s) == 0 {
         option::none::<istr>
     } else {
         let s = unsafe::reinterpret_cast(s);
-        option::some::<istr>(istr::str_from_cstr(s))
+        option::some::<istr>(str::str_from_cstr(s))
     };
 }
 
@@ -19,9 +19,9 @@ fn getenv(n: &istr) -> option::t<istr> {
 #[cfg(target_os = "macos")]
 fn setenv(n: &istr, v: &istr) {
     // FIXME (868)
-    let _: () = istr::as_buf(n, { |nbuf|
+    let _: () = str::as_buf(n, { |nbuf|
         // FIXME (868)
-        let _: () = istr::as_buf(v, { |vbuf|
+        let _: () = str::as_buf(v, { |vbuf|
             os::libc::setenv(nbuf, vbuf, 1);
         });
     });
@@ -33,7 +33,7 @@ fn getenv(n: &istr) -> option::t<istr> {
     while true {
         let v: [u8] = [];
         vec::reserve(v, nsize);
-        let res = istr::as_buf(n, { |nbuf|
+        let res = str::as_buf(n, { |nbuf|
             let vbuf = vec::to_ptr(v);
             os::kernel32::GetEnvironmentVariableA(nbuf, vbuf, nsize)
         });
@@ -41,7 +41,7 @@ fn getenv(n: &istr) -> option::t<istr> {
             ret option::none;
         } else if res < nsize {
             vec::unsafe::set_len(v, res);
-            ret option::some(istr::unsafe_from_bytes(v));
+            ret option::some(str::unsafe_from_bytes(v));
         } else { nsize = res; }
     }
     fail;
@@ -50,8 +50,8 @@ fn getenv(n: &istr) -> option::t<istr> {
 #[cfg(target_os = "win32")]
 fn setenv(n: &istr, v: &istr) {
     // FIXME (868)
-    let _: () = istr::as_buf(n, { |nbuf|
-        let _: () = istr::as_buf(v, { |vbuf|
+    let _: () = str::as_buf(n, { |nbuf|
+        let _: () = str::as_buf(v, { |vbuf|
             os::kernel32::SetEnvironmentVariableA(nbuf, vbuf);
         });
     });
diff --git a/src/lib/getopts.rs b/src/lib/getopts.rs
index c38b93ee8b03..3df282206510 100644
--- a/src/lib/getopts.rs
+++ b/src/lib/getopts.rs
@@ -38,8 +38,8 @@ tag occur { req; optional; multi; }
 type opt = {name: name, hasarg: hasarg, occur: occur};
 
 fn mkname(nm: &istr) -> name {
-    ret if istr::char_len(nm) == 1u {
-            short(istr::char_at(nm, 0u))
+    ret if str::char_len(nm) == 1u {
+            short(str::char_at(nm, 0u))
         } else { long(nm) };
 }
 
@@ -68,11 +68,11 @@ tag optval { val(istr); given; }
 type match = {opts: [opt], vals: [mutable [optval]], free: [istr]};
 
 fn is_arg(arg: &istr) -> bool {
-    ret istr::byte_len(arg) > 1u && arg[0] == '-' as u8;
+    ret str::byte_len(arg) > 1u && arg[0] == '-' as u8;
 }
 
 fn name_str(nm: &name) -> istr {
-    ret alt nm { short(ch) { istr::from_char(ch) } long(s) { s } };
+    ret alt nm { short(ch) { str::from_char(ch) } long(s) { s } };
 }
 
 fn find_opt(opts: &[opt], nm: &name) -> option::t<uint> {
@@ -117,10 +117,10 @@ fn getopts(args: &[istr], opts: &[opt]) -> result {
     let i = 0u;
     while i < l {
         let cur = args[i];
-        let curlen = istr::byte_len(cur);
+        let curlen = str::byte_len(cur);
         if !is_arg(cur) {
             free += [cur];
-        } else if istr::eq(cur, ~"--") {
+        } else if str::eq(cur, ~"--") {
             let j = i + 1u;
             while j < l { free += [args[j]]; j += 1u; }
             break;
@@ -128,14 +128,14 @@ fn getopts(args: &[istr], opts: &[opt]) -> result {
             let names;
             let i_arg = option::none::<istr>;
             if cur[1] == '-' as u8 {
-                let tail = istr::slice(cur, 2u, curlen);
-                let eq = istr::index(tail, '=' as u8);
+                let tail = str::slice(cur, 2u, curlen);
+                let eq = str::index(tail, '=' as u8);
                 if eq == -1 {
                     names = [long(tail)];
                 } else {
-                    names = [long(istr::slice(tail, 0u, eq as uint))];
+                    names = [long(str::slice(tail, 0u, eq as uint))];
                     i_arg =
-                        option::some::<istr>(istr::slice(tail,
+                        option::some::<istr>(str::slice(tail,
                                                         (eq as uint) + 1u,
                                                         curlen - 2u));
                 }
@@ -143,7 +143,7 @@ fn getopts(args: &[istr], opts: &[opt]) -> result {
                 let j = 1u;
                 names = [];
                 while j < curlen {
-                    let range = istr::char_range_at(cur, j);
+                    let range = str::char_range_at(cur, j);
                     names += [short(range.ch)];
                     j = range.next;
                 }
diff --git a/src/lib/io.rs b/src/lib/io.rs
index 50cb1c668c3c..57ebb806f52e 100644
--- a/src/lib/io.rs
+++ b/src/lib/io.rs
@@ -88,7 +88,7 @@ obj new_reader(rdr: buf_reader) {
 
         }
         let b0 = c0 as u8;
-        let w = istr::utf8_char_width(b0);
+        let w = str::utf8_char_width(b0);
         assert (w > 0u);
         if w == 1u { ret b0 as char; }
         let val = 0u;
@@ -117,7 +117,7 @@ obj new_reader(rdr: buf_reader) {
                 go_on = false;
             } else { buf += [ch as u8]; }
         }
-        ret istr::unsafe_from_bytes(buf);
+        ret str::unsafe_from_bytes(buf);
     }
     fn read_c_str() -> istr {
         let buf: [u8] = [];
@@ -126,7 +126,7 @@ obj new_reader(rdr: buf_reader) {
             let ch = rdr.read_byte();
             if ch < 1 { go_on = false; } else { buf += [ch as u8]; }
         }
-        ret istr::unsafe_from_bytes(buf);
+        ret str::unsafe_from_bytes(buf);
     }
 
     // FIXME deal with eof?
@@ -175,8 +175,8 @@ fn stdin() -> reader {
 }
 
 fn file_reader(path: &istr) -> reader {
-    let f = istr::as_buf(path, { |pathbuf|
-        istr::as_buf(~"r", { |modebuf|
+    let f = str::as_buf(path, { |pathbuf|
+        str::as_buf(~"r", { |modebuf|
             os::libc::fopen(pathbuf, modebuf)
         })
     });
@@ -220,7 +220,7 @@ fn new_byte_buf_reader(buf: &[u8]) -> buf_reader {
 }
 
 fn string_reader(s: &istr) -> reader {
-    ret new_reader(new_byte_buf_reader(istr::bytes(s)));
+    ret new_reader(new_byte_buf_reader(str::bytes(s)));
 }
 
 
@@ -290,7 +290,7 @@ fn file_buf_writer(path: &istr, flags: &[fileflag]) -> buf_writer {
           none. { }
         }
     }
-    let fd = istr::as_buf(path, { |pathbuf|
+    let fd = str::as_buf(path, { |pathbuf|
         os::libc::open(pathbuf, fflags,
                        os::libc_constants::S_IRUSR() |
                            os::libc_constants::S_IWUSR())
@@ -334,19 +334,19 @@ fn uint_to_be_bytes(n: uint, size: uint) -> [u8] {
 
 obj new_writer(out: buf_writer) {
     fn get_buf_writer() -> buf_writer { ret out; }
-    fn write_str(s: &istr) { out.write(istr::bytes(s)); }
+    fn write_str(s: &istr) { out.write(str::bytes(s)); }
     fn write_line(s: &istr) {
-        out.write(istr::bytes(s));
-        out.write(istr::bytes(~"\n"));
+        out.write(str::bytes(s));
+        out.write(str::bytes(~"\n"));
     }
     fn write_char(ch: char) {
         // FIXME needlessly consy
 
-        out.write(istr::bytes(istr::from_char(ch)));
+        out.write(str::bytes(str::from_char(ch)));
     }
-    fn write_int(n: int) { out.write(istr::bytes(
+    fn write_int(n: int) { out.write(str::bytes(
         int::to_str(n, 10u))); }
-    fn write_uint(n: uint) { out.write(istr::bytes(
+    fn write_uint(n: uint) { out.write(str::bytes(
         uint::to_str(n, 10u))); }
     fn write_bytes(bytes: &[u8]) { out.write(bytes); }
     fn write_le_uint(n: uint, size: uint) {
@@ -367,8 +367,8 @@ fn file_writer(path: &istr, flags: &[fileflag]) -> writer {
 
 // FIXME: fileflags
 fn buffered_file_buf_writer(path: &istr) -> buf_writer {
-    let f = istr::as_buf(path, { |pathbuf|
-        istr::as_buf(~"w", { |modebuf|
+    let f = str::as_buf(path, { |pathbuf|
+        str::as_buf(~"w", { |modebuf|
             os::libc::fopen(pathbuf, modebuf)
         })
     });
@@ -427,7 +427,7 @@ fn string_writer() -> str_writer {
     let buf: mutable_byte_buf = @{mutable buf: b, mutable pos: 0u};
     obj str_writer_wrap(wr: writer, buf: mutable_byte_buf) {
         fn get_writer() -> writer { ret wr; }
-        fn get_str() -> istr { ret istr::unsafe_from_bytes(buf.buf); }
+        fn get_str() -> istr { ret str::unsafe_from_bytes(buf.buf); }
     }
     ret str_writer_wrap(new_writer(byte_buf_writer(buf)), buf);
 }
@@ -448,7 +448,7 @@ fn seek_in_buf(offset: int, pos: uint, len: uint, whence: seek_style) ->
 }
 
 fn read_whole_file_str(file: &istr) -> istr {
-    istr::unsafe_from_bytes(read_whole_file(file))
+    str::unsafe_from_bytes(read_whole_file(file))
 }
 
 fn read_whole_file(file: &istr) -> [u8] {
diff --git a/src/lib/linux_os.rs b/src/lib/linux_os.rs
index be8b99bac80f..0081aa182659 100644
--- a/src/lib/linux_os.rs
+++ b/src/lib/linux_os.rs
@@ -7,11 +7,11 @@ native "cdecl" mod libc = "" {
     fn write(fd: int, buf: *u8, count: uint) -> int;
     fn fread(buf: *u8, size: uint, n: uint, f: libc::FILE) -> uint;
     fn fwrite(buf: *u8, size: uint, n: uint, f: libc::FILE) -> uint;
-    fn open(s: istr::sbuf, flags: int, mode: uint) -> int;
+    fn open(s: str::sbuf, flags: int, mode: uint) -> int;
     fn close(fd: int) -> int;
     type FILE;
-    fn fopen(path: istr::sbuf, mode: istr::sbuf) -> FILE;
-    fn fdopen(fd: int, mode: istr::sbuf) -> FILE;
+    fn fopen(path: str::sbuf, mode: str::sbuf) -> FILE;
+    fn fdopen(fd: int, mode: str::sbuf) -> FILE;
     fn fclose(f: FILE);
     fn fgetc(f: FILE) -> int;
     fn ungetc(c: int, f: FILE);
@@ -19,13 +19,13 @@ native "cdecl" mod libc = "" {
     fn fseek(f: FILE, offset: int, whence: int) -> int;
     fn ftell(f: FILE) -> int;
     type dir;
-    fn opendir(d: istr::sbuf) -> dir;
+    fn opendir(d: str::sbuf) -> dir;
     fn closedir(d: dir) -> int;
     type dirent;
     fn readdir(d: dir) -> dirent;
-    fn getenv(n: istr::sbuf) -> istr::sbuf;
-    fn setenv(n: istr::sbuf, v: istr::sbuf, overwrite: int) -> int;
-    fn unsetenv(n: istr::sbuf) -> int;
+    fn getenv(n: str::sbuf) -> str::sbuf;
+    fn setenv(n: str::sbuf, v: str::sbuf, overwrite: int) -> int;
+    fn unsetenv(n: str::sbuf) -> int;
     fn pipe(buf: *mutable int) -> int;
     fn waitpid(pid: int, status: &mutable int, options: int) -> int;
 }
@@ -63,7 +63,7 @@ fn pipe() -> {in: int, out: int} {
 }
 
 fn fd_FILE(fd: int) -> libc::FILE {
-    ret istr::as_buf(~"r", { |modebuf|
+    ret str::as_buf(~"r", { |modebuf|
         libc::fdopen(fd, modebuf)
     });
 }
diff --git a/src/lib/macos_os.rs b/src/lib/macos_os.rs
index ce9a2089bf7d..2c244048113e 100644
--- a/src/lib/macos_os.rs
+++ b/src/lib/macos_os.rs
@@ -4,11 +4,11 @@ native "cdecl" mod libc = "" {
     fn write(fd: int, buf: *u8, count: uint) -> int;
     fn fread(buf: *u8, size: uint, n: uint, f: libc::FILE) -> uint;
     fn fwrite(buf: *u8, size: uint, n: uint, f: libc::FILE) -> uint;
-    fn open(s: istr::sbuf, flags: int, mode: uint) -> int;
+    fn open(s: str::sbuf, flags: int, mode: uint) -> int;
     fn close(fd: int) -> int;
     type FILE;
-    fn fopen(path: istr::sbuf, mode: istr::sbuf) -> FILE;
-    fn fdopen(fd: int, mode: istr::sbuf) -> FILE;
+    fn fopen(path: str::sbuf, mode: str::sbuf) -> FILE;
+    fn fdopen(fd: int, mode: str::sbuf) -> FILE;
     fn fclose(f: FILE);
     fn fgetc(f: FILE) -> int;
     fn ungetc(c: int, f: FILE);
@@ -16,13 +16,13 @@ native "cdecl" mod libc = "" {
     fn fseek(f: FILE, offset: int, whence: int) -> int;
     fn ftell(f: FILE) -> int;
     type dir;
-    fn opendir(d: istr::sbuf) -> dir;
+    fn opendir(d: str::sbuf) -> dir;
     fn closedir(d: dir) -> int;
     type dirent;
     fn readdir(d: dir) -> dirent;
-    fn getenv(n: istr::sbuf) -> istr::sbuf;
-    fn setenv(n: istr::sbuf, v: istr::sbuf, overwrite: int) -> int;
-    fn unsetenv(n: istr::sbuf) -> int;
+    fn getenv(n: str::sbuf) -> str::sbuf;
+    fn setenv(n: str::sbuf, v: str::sbuf, overwrite: int) -> int;
+    fn unsetenv(n: str::sbuf) -> int;
     fn pipe(buf: *mutable int) -> int;
     fn waitpid(pid: int, status: &mutable int, options: int) -> int;
 }
@@ -60,7 +60,7 @@ fn pipe() -> {in: int, out: int} {
 }
 
 fn fd_FILE(fd: int) -> libc::FILE {
-    ret istr::as_buf(~"r", { |modebuf|
+    ret str::as_buf(~"r", { |modebuf|
         libc::fdopen(fd, modebuf)
     });
 }
diff --git a/src/lib/map.rs b/src/lib/map.rs
index 7a46e28e67de..a608e7b877be 100644
--- a/src/lib/map.rs
+++ b/src/lib/map.rs
@@ -195,7 +195,7 @@ fn mk_hashmap<@K, @V>(hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
 // Hash map constructors for basic types
 
 fn new_str_hash<@V>() -> hashmap<istr, V> {
-    ret mk_hashmap(istr::hash, istr::eq);
+    ret mk_hashmap(str::hash, str::eq);
 }
 
 fn new_int_hash<@V>() -> hashmap<int, V> {
diff --git a/src/lib/net.rs b/src/lib/net.rs
index 4dac4eee04c7..e7d8d13df2bc 100644
--- a/src/lib/net.rs
+++ b/src/lib/net.rs
@@ -15,7 +15,7 @@ fn format_addr(ip: ip_addr) -> istr {
 fn parse_addr(ip: &istr) -> ip_addr {
     let parts = vec::map(
         { |&s| uint::from_str(s) },
-        istr::split(ip, ~"."[0]));
+        str::split(ip, ~"."[0]));
     if vec::len(parts) != 4u { fail "Too many dots in IP address"; }
     for i in parts { if i > 255u { fail "Invalid IP Address part."; } }
     ipv4(parts[0] as u8, parts[1] as u8, parts[2] as u8, parts[3] as u8)
diff --git a/src/lib/posix_fs.rs b/src/lib/posix_fs.rs
index 1a346ed661a8..2aebc49619bf 100644
--- a/src/lib/posix_fs.rs
+++ b/src/lib/posix_fs.rs
@@ -31,7 +31,7 @@ fn list_dir(path: &istr) -> [istr] {
 
 }
 
-fn path_is_absolute(p: &istr) -> bool { ret istr::char_at(p, 0u) == '/'; }
+fn path_is_absolute(p: &istr) -> bool { ret str::char_at(p, 0u) == '/'; }
 
 const path_sep: char = '/';
 
diff --git a/src/lib/run_program.rs b/src/lib/run_program.rs
index 4fc546b07b16..3558da2388a4 100644
--- a/src/lib/run_program.rs
+++ b/src/lib/run_program.rs
@@ -1,5 +1,5 @@
 
-import istr::sbuf;
+import str::sbuf;
 
 export program;
 export run_program;
@@ -13,9 +13,9 @@ native "rust" mod rustrt {
 }
 
 fn arg_vec(prog: &istr, args: &[@istr]) -> [sbuf] {
-    let argptrs = istr::as_buf(prog, { |buf| [buf] });
+    let argptrs = str::as_buf(prog, { |buf| [buf] });
     for arg in args {
-        argptrs += istr::as_buf(*arg, { |buf| [buf] });
+        argptrs += str::as_buf(*arg, { |buf| [buf] });
     }
     argptrs += [unsafe::reinterpret_cast(0)];
     ret argptrs;
@@ -106,7 +106,7 @@ fn read_all(rd: &io::reader) -> istr {
     let buf = ~"";
     while !rd.eof() {
         let bytes = rd.read_bytes(4096u);
-        buf += istr::unsafe_from_bytes(bytes);
+        buf += str::unsafe_from_bytes(bytes);
     }
     ret buf;
 }
diff --git a/src/lib/sha1.rs b/src/lib/sha1.rs
index c2d63af9a18f..b1c1a2ac2298 100644
--- a/src/lib/sha1.rs
+++ b/src/lib/sha1.rs
@@ -215,7 +215,7 @@ fn mk_sha1() -> sha1 {
             st.computed = false;
         }
         fn input(msg: &[u8]) { add_input(st, msg); }
-        fn input_str(msg: &istr) { add_input(st, istr::bytes(msg)); }
+        fn input_str(msg: &istr) { add_input(st, str::bytes(msg)); }
         fn result() -> [u8] { ret mk_result(st); }
         fn result_str() -> istr {
             let r = mk_result(st);
diff --git a/src/lib/std.rc b/src/lib/std.rc
index 21b09312860a..3f3832f05b46 100644
--- a/src/lib/std.rc
+++ b/src/lib/std.rc
@@ -15,7 +15,7 @@ mod uint;
 mod u8;
 mod u64;
 mod vec;
-mod istr;
+mod str;
 
 // General io and system-services modules.
 
diff --git a/src/lib/istr.rs b/src/lib/str.rs
similarity index 100%
rename from src/lib/istr.rs
rename to src/lib/str.rs
diff --git a/src/lib/term.rs b/src/lib/term.rs
index cd5b1122a596..f5189c49a432 100644
--- a/src/lib/term.rs
+++ b/src/lib/term.rs
@@ -52,7 +52,7 @@ fn color_supported() -> bool {
     ret alt generic_os::getenv(~"TERM") {
           option::some(env) {
             for term: istr in supported_terms {
-                if istr::eq(term, env) { ret true; }
+                if str::eq(term, env) { ret true; }
             }
             false
           }
diff --git a/src/lib/test.rs b/src/lib/test.rs
index 85b2accdb9e7..77936e2b572a 100644
--- a/src/lib/test.rs
+++ b/src/lib/test.rs
@@ -265,7 +265,7 @@ fn filter_tests(opts: &test_opts, tests: &[test_desc]) -> [test_desc] {
             let filter =
                 bind fn (test: &test_desc, filter_str: &istr) ->
                         option::t<test_desc> {
-                         if istr::find(test.name, filter_str) >= 0 {
+                         if str::find(test.name, filter_str) >= 0 {
                              ret option::some(test);
                          } else { ret option::none; }
                      }(_, filter_str);
@@ -296,7 +296,7 @@ fn filter_tests(opts: &test_opts, tests: &[test_desc]) -> [test_desc] {
     filtered =
         {
             fn lteq(t1: &test_desc, t2: &test_desc) -> bool {
-                istr::lteq(t1.name, t2.name)
+                str::lteq(t1.name, t2.name)
             }
             sort::merge_sort(lteq, filtered)
         };
diff --git a/src/lib/uint.rs b/src/lib/uint.rs
index 7fb0c5d179c2..e7f85074ef2f 100644
--- a/src/lib/uint.rs
+++ b/src/lib/uint.rs
@@ -56,7 +56,7 @@ fn parse_buf(buf: &[u8], radix: uint) -> uint {
     fail;
 }
 
-fn from_str(s: &istr) -> uint { parse_buf(istr::bytes(s), 10u) }
+fn from_str(s: &istr) -> uint { parse_buf(str::bytes(s), 10u) }
 
 fn to_str(num: uint, radix: uint) -> istr {
     let n = num;
@@ -85,12 +85,12 @@ fn to_str(num: uint, radix: uint) -> istr {
     if n == 0u { ret ~"0"; }
     let s: istr = ~"";
     while n != 0u {
-        s += istr::unsafe_from_byte(digit(n % radix) as u8);
+        s += str::unsafe_from_byte(digit(n % radix) as u8);
         n /= radix;
     }
     let s1: istr = ~"";
-    let len: uint = istr::byte_len(s);
-    while len != 0u { len -= 1u; s1 += istr::unsafe_from_byte(s[len]); }
+    let len: uint = str::byte_len(s);
+    while len != 0u { len -= 1u; s1 += str::unsafe_from_byte(s[len]); }
     ret s1;
 }
 fn str(i: uint) -> istr { ret to_str(i, 10u); }
diff --git a/src/lib/win32_fs.rs b/src/lib/win32_fs.rs
index 228773ef6dbc..3633a014ca43 100644
--- a/src/lib/win32_fs.rs
+++ b/src/lib/win32_fs.rs
@@ -11,8 +11,8 @@ fn list_dir(path: &istr) -> [istr] {
 }
 
 fn path_is_absolute(p: &istr) -> bool {
-    ret istr::char_at(p, 0u) == '/' ||
-            istr::char_at(p, 1u) == ':' && istr::char_at(p, 2u) == '\\';
+    ret str::char_at(p, 0u) == '/' ||
+            str::char_at(p, 1u) == ':' && str::char_at(p, 2u) == '\\';
 }
 
 /* FIXME: win32 path handling actually accepts '/' or '\' and has subtly
diff --git a/src/lib/win32_os.rs b/src/lib/win32_os.rs
index 99ec04f6ff77..9dccbcc679db 100644
--- a/src/lib/win32_os.rs
+++ b/src/lib/win32_os.rs
@@ -4,11 +4,11 @@ native "cdecl" mod libc = "" {
     fn write(fd: int, buf: *u8, count: uint) -> int;
     fn fread(buf: *u8, size: uint, n: uint, f: libc::FILE) -> uint;
     fn fwrite(buf: *u8, size: uint, n: uint, f: libc::FILE) -> uint;
-    fn open(s: istr::sbuf, flags: int, mode: uint) -> int = "_open";
+    fn open(s: str::sbuf, flags: int, mode: uint) -> int = "_open";
     fn close(fd: int) -> int = "_close";
     type FILE;
-    fn fopen(path: istr::sbuf, mode: istr::sbuf) -> FILE;
-    fn _fdopen(fd: int, mode: istr::sbuf) -> FILE;
+    fn fopen(path: str::sbuf, mode: str::sbuf) -> FILE;
+    fn _fdopen(fd: int, mode: str::sbuf) -> FILE;
     fn fclose(f: FILE);
     fn fgetc(f: FILE) -> int;
     fn ungetc(c: int, f: FILE);
@@ -40,9 +40,9 @@ mod libc_constants {
 }
 
 native "x86stdcall" mod kernel32 {
-    fn GetEnvironmentVariableA(n: istr::sbuf, v: istr::sbuf,
+    fn GetEnvironmentVariableA(n: str::sbuf, v: str::sbuf,
                                nsize: uint) -> uint;
-    fn SetEnvironmentVariableA(n: istr::sbuf, v: istr::sbuf) -> int;
+    fn SetEnvironmentVariableA(n: str::sbuf, v: str::sbuf) -> int;
 }
 
 fn exec_suffix() -> istr { ret ~".exe"; }
@@ -69,7 +69,7 @@ fn pipe() -> {in: int, out: int} {
 }
 
 fn fd_FILE(fd: int) -> libc::FILE {
-    ret istr::as_buf(~"r", { |modebuf|
+    ret str::as_buf(~"r", { |modebuf|
         libc::_fdopen(fd, modebuf)
     });
 }
diff --git a/src/test/bench/99bob-iter.rs b/src/test/bench/99bob-iter.rs
index 3268d21078f3..fea1420f8bb7 100644
--- a/src/test/bench/99bob-iter.rs
+++ b/src/test/bench/99bob-iter.rs
@@ -6,7 +6,7 @@
  */
 use std;
 import std::int;
-import std::istr;
+import std::str;
 
 fn b1() -> istr { ret ~"# of beer on the wall, # of beer."; }
 
@@ -31,8 +31,8 @@ fn sub(t: &istr, n: int) -> istr {
       1 { ns = ~"1 bottle"; }
       _ { ns = int::to_str(n, 10u) + ~" bottles"; }
     }
-    while i < istr::byte_len(t) {
-        if t[i] == '#' as u8 { b += ns; } else { istr::push_byte(b, t[i]); }
+    while i < str::byte_len(t) {
+        if t[i] == '#' as u8 { b += ns; } else { str::push_byte(b, t[i]); }
         i += 1u;
     }
     ret b;
diff --git a/src/test/bench/99bob-pattern.rs b/src/test/bench/99bob-pattern.rs
index dae406b09825..a13015fb4f77 100644
--- a/src/test/bench/99bob-pattern.rs
+++ b/src/test/bench/99bob-pattern.rs
@@ -6,7 +6,7 @@
  */
 use std;
 import std::int;
-import std::istr;
+import std::str;
 
 tag bottle { none; dual; single; multiple(int); }
 
diff --git a/src/test/bench/99bob-simple.rs b/src/test/bench/99bob-simple.rs
index 3b3b1e8278c8..30518c63e2dd 100644
--- a/src/test/bench/99bob-simple.rs
+++ b/src/test/bench/99bob-simple.rs
@@ -6,7 +6,7 @@
  */
 use std;
 import std::int;
-import std::istr;
+import std::str;
 
 fn b1() -> istr { ret ~"# of beer on the wall, # of beer."; }
 
@@ -31,8 +31,8 @@ fn sub(t: &istr, n: int) -> istr {
       1 { ns = ~"1 bottle"; }
       _ { ns = int::to_str(n, 10u) + ~" bottles"; }
     }
-    while i < istr::byte_len(t) {
-        if t[i] == '#' as u8 { b += ns; } else { istr::push_byte(b, t[i]); }
+    while i < str::byte_len(t) {
+        if t[i] == '#' as u8 { b += ns; } else { str::push_byte(b, t[i]); }
         i += 1u;
     }
     ret b;
diff --git a/src/test/bench/99bob-tail.rs b/src/test/bench/99bob-tail.rs
index 80c8fdd0cdaa..9ab8973cbcef 100644
--- a/src/test/bench/99bob-tail.rs
+++ b/src/test/bench/99bob-tail.rs
@@ -4,7 +4,7 @@
  */
 use std;
 import std::int;
-import std::istr;
+import std::str;
 
 fn main() {
     fn multiple(n: int) {
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 404633449b46..cd29838b378a 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -9,7 +9,7 @@ use std;
 import std::vec;
 import std::uint;
 import std::int;
-import std::istr;
+import std::str;
 
 fn LINE_LENGTH() -> uint { ret 60u; }
 
@@ -49,21 +49,21 @@ fn make_random_fasta(id: &istr, desc: &istr,
     let rng = myrandom(std::rand::mk_rng().next());
     let op: istr = ~"";
     for each i: uint in uint::range(0u, n as uint) {
-        istr::push_byte(op, select_random(rng.next(100u32), genelist) as u8);
-        if istr::byte_len(op) >= LINE_LENGTH() { log op; op = ~""; }
+        str::push_byte(op, select_random(rng.next(100u32), genelist) as u8);
+        if str::byte_len(op) >= LINE_LENGTH() { log op; op = ~""; }
     }
-    if istr::byte_len(op) > 0u { log op; }
+    if str::byte_len(op) > 0u { log op; }
 }
 
 fn make_repeat_fasta(id: &istr, desc: &istr, s: &istr, n: int) {
     log ~">" + id + ~" " + desc;
     let op: istr = ~"";
-    let sl: uint = istr::byte_len(s);
+    let sl: uint = str::byte_len(s);
     for each i: uint in uint::range(0u, n as uint) {
-        istr::push_byte(op, s[i % sl]);
-        if istr::byte_len(op) >= LINE_LENGTH() { log op; op = ~""; }
+        str::push_byte(op, s[i % sl]);
+        if str::byte_len(op) >= LINE_LENGTH() { log op; op = ~""; }
     }
-    if istr::byte_len(op) > 0u { log op; }
+    if str::byte_len(op) > 0u { log op; }
 }
 
 fn acid(ch: char, prob: u32) -> aminoacids { ret {ch: ch, prob: prob}; }
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 9cdc2d21b8e3..b9fba948561b 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -14,7 +14,7 @@ use std;
 import std::vec;
 import std::uint;
 import std::time;
-import std::istr;
+import std::str;
 import std::int::range;
 import std::io;
 import std::getopts;
@@ -91,7 +91,7 @@ fn main(argv: [istr]) {
         if opts.stress {
             stress(2);
         } else {
-            let max = uint::parse_buf(istr::bytes(argv[1]), 10u) as int;
+            let max = uint::parse_buf(str::bytes(argv[1]), 10u) as int;
 
             let num_trials = 10;
 
diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs
index dc186811153b..941f01830311 100644
--- a/src/test/bench/task-perf-spawnalot.rs
+++ b/src/test/bench/task-perf-spawnalot.rs
@@ -2,7 +2,7 @@ use std;
 import std::vec;
 import std::task;
 import std::uint;
-import std::istr;
+import std::str;
 
 fn f(n: uint) {
     let i = 0u;
@@ -17,7 +17,7 @@ fn main(args: [istr]) {
     let n =
         if vec::len(args) < 2u {
             10u
-        } else { uint::parse_buf(istr::bytes(args[1]), 10u) };
+        } else { uint::parse_buf(str::bytes(args[1]), 10u) };
     let i = 0u;
     while i < n { task::spawn(bind f(n)); i += 1u; }
 }
diff --git a/src/test/bench/task-perf-vector-party.rs b/src/test/bench/task-perf-vector-party.rs
index 8450405e01cd..fd650df660b5 100644
--- a/src/test/bench/task-perf-vector-party.rs
+++ b/src/test/bench/task-perf-vector-party.rs
@@ -6,7 +6,7 @@
 use std;
 import std::vec;
 import std::uint;
-import std::istr;
+import std::str;
 import std::task;
 
 fn f(n: uint) {
@@ -20,7 +20,7 @@ fn main(args: [istr]) {
     let n = if vec::len(args) < 2u {
         100u
     } else {
-        uint::parse_buf(istr::bytes(args[1]), 10u)
+        uint::parse_buf(str::bytes(args[1]), 10u)
     };
     for each i in uint::range(0u, 100u) {
         task::spawn(bind f(n));
diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index 6374cf8ab985..5d01e725ed3b 100644
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -13,7 +13,7 @@ use std;
 import option = std::option::t;
 import std::option::some;
 import std::option::none;
-import std::istr;
+import std::str;
 import std::treemap;
 import std::vec;
 import std::io;
@@ -30,11 +30,11 @@ import std::comm::recv;
 import std::comm::send;
 
 fn map(filename: &[u8], emit: &map_reduce::putter<[u8], int>) {
-    let f = io::file_reader(istr::unsafe_from_bytes(filename));
+    let f = io::file_reader(str::unsafe_from_bytes(filename));
 
     while true {
         alt read_word(f) {
-          some(w) { emit(istr::bytes(w), 1); }
+          some(w) { emit(str::bytes(w), 1); }
           none. { break; }
         }
     }
@@ -212,7 +212,7 @@ fn main(argv: [istr]) {
 
     let iargs = [];
     for a in vec::slice(argv, 1u, vec::len(argv)) {
-        iargs += [istr::bytes(a)];
+        iargs += [str::bytes(a)];
     }
 
     // We can get by with 8k stacks, and we'll probably exhaust our
@@ -239,7 +239,7 @@ fn read_word(r: io::reader) -> option<istr> {
 
 
         if is_word_char(c) {
-            w += istr::from_char(c);
+            w += str::from_char(c);
         } else { if w != ~"" { ret some(w); } }
     }
     ret none;
diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs
index 726a5f22fdd6..e947d6bd1d94 100644
--- a/src/test/bench/task-perf-word-count.rs
+++ b/src/test/bench/task-perf-word-count.rs
@@ -13,7 +13,7 @@ use std;
 import option = std::option::t;
 import std::option::some;
 import std::option::none;
-import std::istr;
+import std::str;
 import std::map;
 import std::vec;
 import std::io;
@@ -227,7 +227,7 @@ fn read_word(r: io::reader) -> option<istr> {
 
 
         if is_word_char(c) {
-            w += istr::from_char(c);
+            w += str::from_char(c);
         } else { if w != ~"" { ret some(w); } }
     }
     ret none;
diff --git a/src/test/compile-fail/fn-constraint.rs b/src/test/compile-fail/fn-constraint.rs
index f66a80aa98e1..dec1df5d4586 100644
--- a/src/test/compile-fail/fn-constraint.rs
+++ b/src/test/compile-fail/fn-constraint.rs
@@ -1,6 +1,6 @@
 // error-pattern:precondition constraint (for example, uint::le(a, b)
 use std;
-import std::istr::*;
+import std::str::*;
 
 fn main() {
     let a: uint = 4u;
diff --git a/src/test/compile-fail/no-constraint-prop.rs b/src/test/compile-fail/no-constraint-prop.rs
index d9f1a44828de..c01b20042fa3 100644
--- a/src/test/compile-fail/no-constraint-prop.rs
+++ b/src/test/compile-fail/no-constraint-prop.rs
@@ -1,6 +1,6 @@
 // error-pattern:Unsatisfied precondition constraint (for example, le(b, d
 use std;
-import std::istr::*;
+import std::str::*;
 import std::uint::*;
 
 fn main() {
diff --git a/src/test/compiletest/compiletest.rs b/src/test/compiletest/compiletest.rs
index a7d0d1205494..704482749844 100644
--- a/src/test/compiletest/compiletest.rs
+++ b/src/test/compiletest/compiletest.rs
@@ -2,7 +2,7 @@ import std::option;
 import std::getopts;
 import std::test;
 import std::fs;
-import std::istr;
+import std::str;
 import std::vec;
 import std::task;
 
@@ -164,11 +164,11 @@ fn is_test(config: &config, testfile: &istr) -> bool {
     let valid = false;
 
     for ext in valid_extensions {
-        if istr::ends_with(name, ext) { valid = true }
+        if str::ends_with(name, ext) { valid = true }
     }
 
     for pre in invalid_prefixes {
-        if istr::starts_with(name, pre) { valid = false }
+        if str::starts_with(name, pre) { valid = false }
     }
 
     ret valid;
@@ -210,7 +210,7 @@ fn make_test_closure(testfile: &istr, configchan: chan<[u8]>) ->
 }
 
 fn send_config(testfile: istr, configchan: chan<[u8]>) {
-    send(configchan, istr::bytes(testfile));
+    send(configchan, str::bytes(testfile));
 }
 
 /*
diff --git a/src/test/compiletest/header.rs b/src/test/compiletest/header.rs
index 1ba29dddbdaa..5a4a0ea095bf 100644
--- a/src/test/compiletest/header.rs
+++ b/src/test/compiletest/header.rs
@@ -1,5 +1,5 @@
 import std::option;
-import std::istr;
+import std::str;
 import std::io;
 import std::fs;
 
@@ -74,8 +74,8 @@ iter iter_header(testfile: &istr) -> istr {
         // Assume that any directives will be found before the first
         // module or function. This doesn't seem to be an optimization
         // with a warm page cache. Maybe with a cold one.
-        if istr::starts_with(ln, ~"fn")
-            || istr::starts_with(ln, ~"mod") {
+        if str::starts_with(ln, ~"fn")
+            || str::starts_with(ln, ~"mod") {
             break;
         } else { put ln; }
     }
@@ -103,17 +103,17 @@ fn parse_pp_exact(line: &istr, testfile: &istr) -> option::t<istr> {
 }
 
 fn parse_name_directive(line: &istr, directive: &istr) -> bool {
-    istr::find(line, directive) >= 0
+    str::find(line, directive) >= 0
 }
 
 fn parse_name_value_directive(line: &istr,
                               directive: &istr) -> option::t<istr> {
     let keycolon = directive + ~":";
-    if istr::find(line, keycolon) >= 0 {
-        let colon = istr::find(line, keycolon) as uint;
+    if str::find(line, keycolon) >= 0 {
+        let colon = str::find(line, keycolon) as uint;
         let value =
-            istr::slice(line, colon + istr::byte_len(keycolon),
-                       istr::byte_len(line));
+            str::slice(line, colon + str::byte_len(keycolon),
+                       str::byte_len(line));
         log #ifmt("%s: %s", directive,
                   value);
         option::some(value)
diff --git a/src/test/compiletest/procsrv.rs b/src/test/compiletest/procsrv.rs
index a31dff23dcbc..eb6d46767114 100644
--- a/src/test/compiletest/procsrv.rs
+++ b/src/test/compiletest/procsrv.rs
@@ -12,7 +12,7 @@ import std::vec;
 import std::os;
 import std::run;
 import std::io;
-import std::istr;
+import std::str;
 import std::comm::chan;
 import std::comm::port;
 import std::comm::send;
@@ -58,7 +58,7 @@ fn run(handle: &handle, lib_path: &istr, prog: &istr, args: &[istr],
     let p = port();
     let ch = chan(p);
     send(handle.chan,
-         exec(istr::bytes(lib_path), istr::bytes(prog), clone_vecstr(args),
+         exec(str::bytes(lib_path), str::bytes(prog), clone_vecstr(args),
               ch));
     let resp = recv(p);
 
@@ -85,7 +85,7 @@ fn readclose(fd: int) -> istr {
     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;
@@ -114,8 +114,8 @@ fn worker(p: port<request>) {
                 // the alt discriminant are wrong.
                 alt recv(p) {
                   exec(lib_path, prog, args, respchan) {
-                    {lib_path: istr::unsafe_from_bytes(lib_path),
-                     prog: istr::unsafe_from_bytes(prog),
+                    {lib_path: str::unsafe_from_bytes(lib_path),
+                     prog: str::unsafe_from_bytes(prog),
                      args: clone_vecu8str(args),
                      respchan: respchan}
                   }
@@ -174,14 +174,14 @@ fn export_lib_path(path: &istr) {
 
 fn clone_vecstr(v: &[istr]) -> [[u8]] {
     let r = [];
-    for t: istr in vec::slice(v, 0u, vec::len(v)) { r += [istr::bytes(t)]; }
+    for t: istr in vec::slice(v, 0u, vec::len(v)) { r += [str::bytes(t)]; }
     ret r;
 }
 
 fn clone_vecu8str(v: &[[u8]]) -> [istr] {
     let r = [];
     for t in vec::slice(v, 0u, vec::len(v)) {
-        r += [istr::unsafe_from_bytes(t)];
+        r += [str::unsafe_from_bytes(t)];
     }
     ret r;
 }
diff --git a/src/test/compiletest/runtest.rs b/src/test/compiletest/runtest.rs
index 0ffe3c0697df..e8e519196804 100644
--- a/src/test/compiletest/runtest.rs
+++ b/src/test/compiletest/runtest.rs
@@ -1,5 +1,5 @@
 import std::io;
-import std::istr;
+import std::str;
 import std::option;
 import std::fs;
 import std::os;
@@ -19,7 +19,7 @@ import util::logv;
 export run;
 
 fn run(cx: &cx, _testfile: -[u8]) {
-    let testfile = istr::unsafe_from_bytes(_testfile);
+    let testfile = str::unsafe_from_bytes(_testfile);
     if cx.config.verbose {
         // We're going to be dumping a lot of info. Start on a new line.
         io::stdout().write_str(~"\n\n");
@@ -116,9 +116,9 @@ fn run_pretty_test(cx: &cx, props: &test_props, testfile: &istr) {
     if option::is_some(props.pp_exact) {
         // Now we have to care about line endings
         let cr = ~"\r";
-        check (istr::is_not_empty(cr));
-        actual = istr::replace(actual, cr, ~"");
-        expected = istr::replace(expected, cr, ~"");
+        check (str::is_not_empty(cr));
+        actual = str::replace(actual, cr, ~"");
+        expected = str::replace(expected, cr, ~"");
     }
 
     compare_source(expected, actual);
@@ -188,8 +188,8 @@ fn check_error_patterns(props: &test_props, testfile: &istr,
 
     let next_err_idx = 0u;
     let next_err_pat = props.error_patterns[next_err_idx];
-    for line: istr in istr::split(procres.stdout, '\n' as u8) {
-        if istr::find(line, next_err_pat) > 0 {
+    for line: istr in str::split(procres.stdout, '\n' as u8) {
+        if str::find(line, next_err_pat) > 0 {
             log #ifmt["found error pattern %s",
                       next_err_pat];
             next_err_idx += 1u;
@@ -289,7 +289,7 @@ fn split_maybe_args(argstr: &option::t<istr>) -> [istr] {
     }
 
     alt argstr {
-      option::some(s) { rm_whitespace(istr::split(s, ' ' as u8)) }
+      option::some(s) { rm_whitespace(str::split(s, ' ' as u8)) }
       option::none. { [] }
     }
 }
@@ -315,7 +315,7 @@ fn make_cmdline(libpath: &istr, prog: &istr, args: &[istr]) -> istr {
     #ifmt["%s %s %s",
           lib_path_cmd_prefix(libpath),
           prog,
-          istr::connect(args, ~" ")]
+          str::connect(args, ~" ")]
 }
 
 // Build the LD_LIBRARY_PATH variable as it would be seen on the command line
@@ -357,10 +357,10 @@ fn output_base_name(config: &config, testfile: &istr) -> istr {
     let base = config.build_base;
     let filename =
         {
-            let parts = istr::split(fs::basename(testfile),
+            let parts = str::split(fs::basename(testfile),
                                     '.' as u8);
             parts = vec::slice(parts, 0u, vec::len(parts) - 1u);
-            istr::connect(parts, ~".")
+            str::connect(parts, ~".")
         };
     #ifmt["%s%s.%s", base, filename,
                         config.stage_id]
diff --git a/src/test/compiletest/util.rs b/src/test/compiletest/util.rs
index 6c845b8ff5fa..88320d29dc16 100644
--- a/src/test/compiletest/util.rs
+++ b/src/test/compiletest/util.rs
@@ -1,7 +1,7 @@
 import std::option;
 import std::generic_os::getenv;
 import std::io;
-import std::istr;
+import std::str;
 
 import common::config;
 
diff --git a/src/test/run-fail/fn-constraint.rs b/src/test/run-fail/fn-constraint.rs
index d1d9e1feed9c..f55772d2def0 100644
--- a/src/test/run-fail/fn-constraint.rs
+++ b/src/test/run-fail/fn-constraint.rs
@@ -1,6 +1,6 @@
 // error-pattern:Predicate le(a, b) failed
 use std;
-import std::istr::*;
+import std::str::*;
 import std::uint::le;
 
 fn main() {
diff --git a/src/test/run-pass/constraint-prop-expr-move.rs b/src/test/run-pass/constraint-prop-expr-move.rs
index e598c269a8f3..a8f4f9768722 100644
--- a/src/test/run-pass/constraint-prop-expr-move.rs
+++ b/src/test/run-pass/constraint-prop-expr-move.rs
@@ -1,5 +1,5 @@
 use std;
-import std::istr::*;
+import std::str::*;
 import std::uint::*;
 
 fn main() {
diff --git a/src/test/run-pass/constraint-prop-move.rs b/src/test/run-pass/constraint-prop-move.rs
index 16f38f176838..b691fb75dbdd 100644
--- a/src/test/run-pass/constraint-prop-move.rs
+++ b/src/test/run-pass/constraint-prop-move.rs
@@ -1,5 +1,5 @@
 use std;
-import std::istr::*;
+import std::str::*;
 import std::uint::*;
 
 fn main() {
diff --git a/src/test/run-pass/constraint-prop-swap.rs b/src/test/run-pass/constraint-prop-swap.rs
index 9cc037490960..5814f095f664 100644
--- a/src/test/run-pass/constraint-prop-swap.rs
+++ b/src/test/run-pass/constraint-prop-swap.rs
@@ -1,5 +1,5 @@
 use std;
-import std::istr::*;
+import std::str::*;
 import std::uint::*;
 
 fn main() {
diff --git a/src/test/run-pass/constraint-prop.rs b/src/test/run-pass/constraint-prop.rs
index ca3c67cf0483..c0a5903f69cd 100644
--- a/src/test/run-pass/constraint-prop.rs
+++ b/src/test/run-pass/constraint-prop.rs
@@ -1,5 +1,5 @@
 use std;
-import std::istr::*;
+import std::str::*;
 import std::uint::*;
 
 fn main() {
diff --git a/src/test/run-pass/fn-constraint.rs b/src/test/run-pass/fn-constraint.rs
index e9b8b1ac1011..5e2dac48eabe 100644
--- a/src/test/run-pass/fn-constraint.rs
+++ b/src/test/run-pass/fn-constraint.rs
@@ -1,5 +1,5 @@
 use std;
-import std::istr::*;
+import std::str::*;
 import std::uint::*;
 
 fn main() {
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index e7e881e5440f..81c827bfb22e 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -9,7 +9,7 @@ use std;
 import option = std::option::t;
 import std::option::some;
 import std::option::none;
-import std::istr;
+import std::str;
 import std::vec;
 import std::map;
 import std::task;
@@ -50,7 +50,7 @@ mod map_reduce {
               none. {
                 let p = port();
                 log_err "sending find_reducer";
-                send(ctrl, find_reducer(istr::bytes(key), chan(p)));
+                send(ctrl, find_reducer(str::bytes(key), chan(p)));
                 log_err "receiving";
                 c = recv(p);
                 log_err c;
@@ -82,7 +82,7 @@ mod map_reduce {
               mapper_done. { num_mappers -= 1; }
               find_reducer(k, cc) {
                 let c;
-                alt reducers.find(istr::unsafe_from_bytes(k)) {
+                alt reducers.find(str::unsafe_from_bytes(k)) {
                   some(_c) { c = _c; }
                   none. { c = 0; }
                 }
diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs
index a53c88aa829e..33ac76300a7a 100644
--- a/src/test/run-pass/spawn-types.rs
+++ b/src/test/run-pass/spawn-types.rs
@@ -6,13 +6,13 @@
 
 use std;
 
-import std::istr;
+import std::str;
 import std::comm;
 import std::task;
 
 type ctx = comm::chan<int>;
 
-fn iotask(cx: ctx, ip: -istr) { assert (istr::eq(ip, ~"localhost")); }
+fn iotask(cx: ctx, ip: -istr) { assert (str::eq(ip, ~"localhost")); }
 
 fn main() {
     let p = comm::port::<int>();
diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs
index 565197e9fe38..5677f562a2f5 100644
--- a/src/test/run-pass/str-append.rs
+++ b/src/test/run-pass/str-append.rs
@@ -2,7 +2,7 @@
 
 // -*- rust -*-
 use std;
-import std::istr;
+import std::str;
 
 fn test1() {
     let s: istr = ~"hello";
@@ -19,8 +19,8 @@ fn test2() {
     let b: istr = ~"ABC" + ff + ~"ABC";
     log a;
     log b;
-    assert (istr::eq(a, ~"abcABCabc"));
-    assert (istr::eq(b, ~"ABCabcABC"));
+    assert (str::eq(a, ~"abcABCabc"));
+    assert (str::eq(b, ~"ABCabcABC"));
 }
 
 fn main() { test1(); test2(); }
diff --git a/src/test/run-pass/str-multiline.rs b/src/test/run-pass/str-multiline.rs
index 1710c8679102..3df1a7d926f8 100644
--- a/src/test/run-pass/str-multiline.rs
+++ b/src/test/run-pass/str-multiline.rs
@@ -2,7 +2,7 @@
 
 // -*- rust -*-
 use std;
-import std::istr;
+import std::str;
 
 fn main() {
     let a: istr = ~"this \
@@ -12,6 +12,6 @@ is a test";
                is \
                another \
                test";
-    assert (istr::eq(a, ~"this is a test"));
-    assert (istr::eq(b, ~"this is another test"));
+    assert (str::eq(a, ~"this is a test"));
+    assert (str::eq(b, ~"this is another test"));
 }
diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs
index e4cdcbd2e64b..29bef1379bbf 100644
--- a/src/test/run-pass/string-self-append.rs
+++ b/src/test/run-pass/string-self-append.rs
@@ -1,5 +1,5 @@
 use std;
-import std::istr;
+import std::str;
 
 fn main() {
     // Make sure we properly handle repeated self-appends.
@@ -7,8 +7,8 @@ fn main() {
     let i = 20;
     let expected_len = 1u;
     while i > 0 {
-        log_err istr::byte_len(a);
-        assert (istr::byte_len(a) == expected_len);
+        log_err str::byte_len(a);
+        assert (str::byte_len(a) == expected_len);
         a += a;
         i -= 1;
         expected_len *= 2u;
diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs
index 9e103adcf606..3ac83d281737 100644
--- a/src/test/run-pass/syntax-extension-fmt.rs
+++ b/src/test/run-pass/syntax-extension-fmt.rs
@@ -1,10 +1,10 @@
 use std;
-import std::istr;
+import std::str;
 
 fn test(actual: &istr, expected: &istr) {
     log actual;
     log expected;
-    assert (istr::eq(actual, expected));
+    assert (str::eq(actual, expected));
 }
 
 fn main() {
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index 737bde7c5f3c..4b292d1ba867 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -1,31 +1,31 @@
 use std;
-import std::istr;
+import std::str;
 import std::vec;
 
 fn main() {
     // Chars of 1, 2, 3, and 4 bytes
     let chs: [char] = ['e', 'é', '€', 0x10000 as char];
-    let s: istr = istr::from_chars(chs);
+    let s: istr = str::from_chars(chs);
 
-    assert (istr::byte_len(s) == 10u);
-    assert (istr::char_len(s) == 4u);
-    assert (vec::len::<char>(istr::to_chars(s)) == 4u);
-    assert (istr::eq(istr::from_chars(istr::to_chars(s)), s));
-    assert (istr::char_at(s, 0u) == 'e');
-    assert (istr::char_at(s, 1u) == 'é');
+    assert (str::byte_len(s) == 10u);
+    assert (str::char_len(s) == 4u);
+    assert (vec::len::<char>(str::to_chars(s)) == 4u);
+    assert (str::eq(str::from_chars(str::to_chars(s)), s));
+    assert (str::char_at(s, 0u) == 'e');
+    assert (str::char_at(s, 1u) == 'é');
 
-    assert (istr::is_utf8(istr::bytes(s)));
-    assert (!istr::is_utf8([0x80_u8]));
-    assert (!istr::is_utf8([0xc0_u8]));
-    assert (!istr::is_utf8([0xc0_u8, 0x10_u8]));
+    assert (str::is_utf8(str::bytes(s)));
+    assert (!str::is_utf8([0x80_u8]));
+    assert (!str::is_utf8([0xc0_u8]));
+    assert (!str::is_utf8([0xc0_u8, 0x10_u8]));
 
     let stack = ~"a×c€";
-    assert (istr::pop_char(stack) == '€');
-    assert (istr::pop_char(stack) == 'c');
-    istr::push_char(stack, 'u');
-    assert (istr::eq(stack, ~"a×u"));
-    assert (istr::shift_char(stack) == 'a');
-    assert (istr::shift_char(stack) == '×');
-    istr::unshift_char(stack, 'ß');
-    assert (istr::eq(stack, ~"ßu"));
+    assert (str::pop_char(stack) == '€');
+    assert (str::pop_char(stack) == 'c');
+    str::push_char(stack, 'u');
+    assert (str::eq(stack, ~"a×u"));
+    assert (str::shift_char(stack) == 'a');
+    assert (str::shift_char(stack) == '×');
+    str::unshift_char(stack, 'ß');
+    assert (str::eq(stack, ~"ßu"));
 }
diff --git a/src/test/stdtest/int.rs b/src/test/stdtest/int.rs
index 185c9db4a2e5..bc13e248d0bd 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 679466cbece0..a66b3bab4641 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 67bd91281654..585bae03cc95 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 d3e88b13738f..5c62ed3eb0e4 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 950409b72620..a66b898ddfa3 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 c622728544f5..a559b61d3f2c 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 d32930893e95..cb4b93130291 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 217b01ed4627..9a2ef1e8e683 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");