auto merge of #7468 : cmr/rust/great_renaming, r=pcwalton

56 files changed, 420 insertions, 514 deletions

diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs
index 13d159d8fed..be9ab863942 100644
--- a/src/libextra/arc.rs
+++ b/src/libextra/arc.rs
@@ -39,15 +39,14 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 use sync;
 use sync::{Mutex, mutex_with_condvars, RWlock, rwlock_with_condvars};
 
-use core::cast;
-use core::unstable::sync::UnsafeAtomicRcBox;
-use core::task;
-use core::borrow;
+use std::cast;
+use std::unstable::sync::UnsafeAtomicRcBox;
+use std::task;
+use std::borrow;
 
 /// As sync::condvar, a mechanism for unlock-and-descheduling and signaling.
 pub struct Condvar<'self> {
@@ -514,14 +513,13 @@ impl<'self, T:Freeze + Send> RWReadMode<'self, T> {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use arc::*;
 
-    use core::cell::Cell;
-    use core::comm;
-    use core::task;
-    use core::uint;
+    use std::cell::Cell;
+    use std::comm;
+    use std::task;
+    use std::uint;
 
     #[test]
     fn manually_share_arc() {
diff --git a/src/libextra/arena.rs b/src/libextra/arena.rs
index 2c6e7a30448..f378384c564 100644
--- a/src/libextra/arena.rs
+++ b/src/libextra/arena.rs
@@ -34,22 +34,21 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 use list::{MutList, MutCons, MutNil};
 
-use core::at_vec;
-use core::cast::{transmute, transmute_mut, transmute_mut_region};
-use core::cast;
-use core::ptr;
-use core::sys;
-use core::uint;
-use core::vec;
-use core::unstable::intrinsics;
-use core::unstable::intrinsics::{TyDesc};
+use std::at_vec;
+use std::cast::{transmute, transmute_mut, transmute_mut_region};
+use std::cast;
+use std::ptr;
+use std::sys;
+use std::uint;
+use std::vec;
+use std::unstable::intrinsics;
+use std::unstable::intrinsics::{TyDesc};
 
 #[cfg(not(stage0))]
-use core::unstable::intrinsics::{get_tydesc};
+use std::unstable::intrinsics::{get_tydesc};
 
 #[cfg(stage0)]
 unsafe fn get_tydesc<T>() -> *TyDesc {
diff --git a/src/libextra/base64.rs b/src/libextra/base64.rs
index 392e7ff29a2..a53a22ee831 100644
--- a/src/libextra/base64.rs
+++ b/src/libextra/base64.rs
@@ -10,9 +10,8 @@
 
 //! Base64 binary-to-text encoding
 
-use core::prelude::*;
 
-use core::vec;
+use std::vec;
 
 /// A trait for converting a value to base64 encoding.
 pub trait ToBase64 {
@@ -199,7 +198,7 @@ impl<'self> FromBase64 for &'self str {
      * Convert any base64 encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.
      *
-     * You can use the `from_bytes` function in `core::str`
+     * You can use the `from_bytes` function in `std::str`
      * to turn a `[u8]` into a string with characters corresponding to those values.
      *
      * # Example
@@ -210,7 +209,7 @@ impl<'self> FromBase64 for &'self str {
      * extern mod extra;
      * use extra::base64::ToBase64;
      * use extra::base64::FromBase64;
-     * use core::str;
+     * use std::str;
      *
      * fn main () {
      *     let hello_str = "Hello, World".to_base64();
diff --git a/src/libextra/bitv.rs b/src/libextra/bitv.rs
index 92ee3fb43c6..30541f83238 100644
--- a/src/libextra/bitv.rs
+++ b/src/libextra/bitv.rs
@@ -10,12 +10,11 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::cmp;
-use core::ops;
-use core::uint;
-use core::vec;
+use std::cmp;
+use std::ops;
+use std::uint;
+use std::vec;
 
 struct SmallBitv {
     /// only the lowest nbits of this value are used. the rest is undefined.
@@ -863,15 +862,15 @@ impl BitvSet {
 
 #[cfg(test)]
 mod tests {
-    use std::test::BenchHarness;
+    use extra::test::BenchHarness;
 
     use bitv::*;
     use bitv;
 
-    use core::uint;
-    use core::vec;
-    use core::rand;
-    use core::rand::Rng;
+    use std::uint;
+    use std::vec;
+    use std::rand;
+    use std::rand::Rng;
 
     static bench_bits : uint = 1 << 14;
 
diff --git a/src/libextra/c_vec.rs b/src/libextra/c_vec.rs
index 79ef5bf2b7e..c6e7b5b0aa7 100644
--- a/src/libextra/c_vec.rs
+++ b/src/libextra/c_vec.rs
@@ -36,10 +36,9 @@
  * still held if needed.
  */
 
-use core::prelude::*;
 
-use core::option;
-use core::ptr;
+use std::option;
+use std::ptr;
 
 /**
  * The type representing a foreign chunk of memory
@@ -150,8 +149,8 @@ mod tests {
 
     use c_vec::*;
 
-    use core::libc::*;
-    use core::libc;
+    use std::libc::*;
+    use std::libc;
 
     fn malloc(n: size_t) -> CVec<u8> {
         unsafe {
diff --git a/src/libextra/comm.rs b/src/libextra/comm.rs
index 2cb2128db5f..44581efc6f0 100644
--- a/src/libextra/comm.rs
+++ b/src/libextra/comm.rs
@@ -16,12 +16,11 @@ Higher level communication abstractions.
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::comm::{GenericChan, GenericSmartChan, GenericPort};
-use core::comm::{Chan, Port, Selectable, Peekable};
-use core::comm;
-use core::pipes;
+use std::comm::{GenericChan, GenericSmartChan, GenericPort};
+use std::comm::{Chan, Port, Selectable, Peekable};
+use std::comm;
+use std::pipes;
 
 /// An extension of `pipes::stream` that allows both sending and receiving.
 pub struct DuplexStream<T, U> {
diff --git a/src/libextra/crypto/digest.rs b/src/libextra/crypto/digest.rs
index c4fb03a7a7d..26e8b80d8e3 100644
--- a/src/libextra/crypto/digest.rs
+++ b/src/libextra/crypto/digest.rs
@@ -8,10 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::uint;
-use core::vec;
+use std::uint;
+use std::vec;
 
 /**
  * The Digest trait specifies an interface common to digest functions, such as SHA-1 and the SHA-2
diff --git a/src/libextra/crypto/sha1.rs b/src/libextra/crypto/sha1.rs
index 5a67e08c190..238e4a4d238 100644
--- a/src/libextra/crypto/sha1.rs
+++ b/src/libextra/crypto/sha1.rs
@@ -22,7 +22,6 @@
  * the `reset` method.
  */
 
-use core::prelude::*;
 
 use digest::Digest;
 
@@ -241,7 +240,7 @@ impl Digest for Sha1 {
 
 #[cfg(test)]
 mod tests {
-    use core::vec;
+    use std::vec;
 
     use digest::{Digest, DigestUtil};
     use sha1::Sha1;
diff --git a/src/libextra/crypto/sha2.rs b/src/libextra/crypto/sha2.rs
index e9c6ac72212..4b120c7b118 100644
--- a/src/libextra/crypto/sha2.rs
+++ b/src/libextra/crypto/sha2.rs
@@ -8,9 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::uint;
+use std::uint;
 
 use digest::Digest;
 
diff --git a/src/libextra/dbg.rs b/src/libextra/dbg.rs
index 43c4aecdd27..1f424b23430 100644
--- a/src/libextra/dbg.rs
+++ b/src/libextra/dbg.rs
@@ -12,17 +12,17 @@
 
 #[allow(missing_doc)];
 
-use core::cast::transmute;
+use std::cast::transmute;
 #[cfg(stage0)]
 use intrinsic::{get_tydesc};
 #[cfg(not(stage0))]
-use core::unstable::intrinsics::{get_tydesc};
+use std::unstable::intrinsics::{get_tydesc};
 
 pub mod rustrt {
     #[cfg(stage0)]
     use intrinsic::{TyDesc};
     #[cfg(not(stage0))]
-    use core::unstable::intrinsics::{TyDesc};
+    use std::unstable::intrinsics::{TyDesc};
 
     #[abi = "cdecl"]
     pub extern {
diff --git a/src/libextra/deque.rs b/src/libextra/deque.rs
index cf7b188cb1d..f834860a4f7 100644
--- a/src/libextra/deque.rs
+++ b/src/libextra/deque.rs
@@ -9,12 +9,11 @@
 // except according to those terms.
 
 //! A double-ended queue implemented as a circular buffer
-use core::prelude::*;
 
-use core::uint;
-use core::util::replace;
-use core::vec;
-use core::cast::transmute;
+use std::uint;
+use std::util::replace;
+use std::vec;
+use std::cast::transmute;
 
 static initial_capacity: uint = 32u; // 2^5
 
@@ -254,9 +253,9 @@ fn get<'r, T>(elts: &'r [Option<T>], i: uint) -> &'r T {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use core::cmp::Eq;
-    use core::kinds::Copy;
-    use core;
+    use std::cmp::Eq;
+    use std::kinds::Copy;
+    use std::int;
 
     #[test]
     fn test_simple() {
@@ -463,12 +462,12 @@ mod tests {
     #[test]
     fn test_iter() {
         let mut d = Deque::new();
-        for core::int::range(0,5) |i| {
+        for int::range(0,5) |i| {
             d.add_back(i);
         }
         assert_eq!(d.iter().collect::<~[&int]>(), ~[&0,&1,&2,&3,&4]);
 
-        for core::int::range(6,9) |i| {
+        for int::range(6,9) |i| {
             d.add_front(i);
         }
         assert_eq!(d.iter().collect::<~[&int]>(), ~[&8,&7,&6,&0,&1,&2,&3,&4]);
@@ -477,12 +476,12 @@ mod tests {
     #[test]
     fn test_rev_iter() {
         let mut d = Deque::new();
-        for core::int::range(0,5) |i| {
+        for int::range(0,5) |i| {
             d.add_back(i);
         }
         assert_eq!(d.rev_iter().collect::<~[&int]>(), ~[&4,&3,&2,&1,&0]);
 
-        for core::int::range(6,9) |i| {
+        for int::range(6,9) |i| {
             d.add_front(i);
         }
         assert_eq!(d.rev_iter().collect::<~[&int]>(), ~[&4,&3,&2,&1,&0,&6,&7,&8]);
diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs
index ee86340e47b..e7dcb0fd7ce 100644
--- a/src/libextra/dlist.rs
+++ b/src/libextra/dlist.rs
@@ -18,9 +18,8 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
 
 */
 
-use core::prelude::*;
 
-use core::managed;
+use std::managed;
 
 pub type DListLink<T> = Option<@mut DListNode<T>>;
 
@@ -522,7 +521,6 @@ impl<T:Copy> DList<T> {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use super::*;
 
diff --git a/src/libextra/ebml.rs b/src/libextra/ebml.rs
index 4634a7db05e..c79b012cfc5 100644
--- a/src/libextra/ebml.rs
+++ b/src/libextra/ebml.rs
@@ -10,9 +10,8 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::str;
+use std::str;
 
 // Simple Extensible Binary Markup Language (ebml) reader and writer on a
 // cursor model. See the specification here:
@@ -94,18 +93,18 @@ pub mod reader {
 
     use serialize;
 
-    use core::cast::transmute;
-    use core::int;
-    use core::io;
-    use core::option::{None, Option, Some};
+    use std::cast::transmute;
+    use std::int;
+    use std::io;
+    use std::option::{None, Option, Some};
 
     #[cfg(target_arch = "x86")]
     #[cfg(target_arch = "x86_64")]
-    use core::ptr::offset;
+    use std::ptr::offset;
 
     #[cfg(target_arch = "x86")]
     #[cfg(target_arch = "x86_64")]
-    use core::unstable::intrinsics::bswap32;
+    use std::unstable::intrinsics::bswap32;
 
     // ebml reading
 
@@ -378,7 +377,7 @@ pub mod reader {
         fn read_u8 (&mut self) -> u8  { doc_as_u8 (self.next_doc(EsU8 )) }
         fn read_uint(&mut self) -> uint {
             let v = doc_as_u64(self.next_doc(EsUint));
-            if v > (::core::uint::max_value as u64) {
+            if v > (::std::uint::max_value as u64) {
                 fail!("uint %? too large for this architecture", v);
             }
             v as uint
@@ -611,8 +610,8 @@ pub mod reader {
 pub mod writer {
     use super::*;
 
-    use core::cast;
-    use core::io;
+    use std::cast;
+    use std::io;
 
     // ebml writing
     pub struct Encoder {
@@ -957,8 +956,8 @@ mod tests {
     use serialize::Encodable;
     use serialize;
 
-    use core::io;
-    use core::option::{None, Option, Some};
+    use std::io;
+    use std::option::{None, Option, Some};
 
     #[test]
     fn test_option_int() {
diff --git a/src/libextra/extra.rs b/src/libextra/extra.rs
index 11aebdf467f..dae1487092b 100644
--- a/src/libextra/extra.rs
+++ b/src/libextra/extra.rs
@@ -32,13 +32,9 @@ Rust extras are part of the standard Rust distribution.
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
 
-#[no_std];
+use std::str::{StrSlice, OwnedStr};
 
-extern mod core(name = "std", vers = "0.7-pre");
-
-use core::str::{StrSlice, OwnedStr};
-
-pub use core::os;
+pub use std::os;
 
 pub mod uv_ll;
 
@@ -135,21 +131,16 @@ pub mod serialize;
 // 'extra' so that macro-expanded references to extra::serialize and such
 // can be resolved within libextra.
 #[doc(hidden)]
-pub mod std {
+pub mod extra {
     pub use serialize;
     pub use test;
 
     // For bootstrapping.
-    pub use core::clone;
-    pub use core::condition;
-    pub use core::cmp;
-    pub use core::sys;
-    pub use core::unstable;
-    pub use core::str;
-    pub use core::os;
-}
-#[doc(hidden)]
-pub mod extra {
-    pub use serialize;
-    pub use test;
+    pub use std::clone;
+    pub use std::condition;
+    pub use std::cmp;
+    pub use std::sys;
+    pub use std::unstable;
+    pub use std::str;
+    pub use std::os;
 }
diff --git a/src/libextra/fileinput.rs b/src/libextra/fileinput.rs
index 7a1e925a15d..5367da2fa8d 100644
--- a/src/libextra/fileinput.rs
+++ b/src/libextra/fileinput.rs
@@ -57,14 +57,14 @@ For more complicated uses (e.g. if one needs to pause iteration and
 resume it later), a `FileInput` instance can be constructed via the
 `from_vec`, `from_vec_raw` and `from_args` functions.
 
-Once created, the `each_line` (from the `core::io::ReaderUtil` trait)
+Once created, the `each_line` (from the `std::io::ReaderUtil` trait)
 and `each_line_state` methods allow one to iterate on the lines; the
 latter provides more information about the position within the
 iteration to the caller.
 
 It is possible (and safe) to skip lines and files using the
 `read_line` and `next_file` methods. Also, `FileInput` implements
-`core::io::Reader`, and the state will be updated correctly while
+`std::io::Reader`, and the state will be updated correctly while
 using any of those methods.
 
 E.g. the following program reads until an empty line, pauses for user
@@ -96,12 +96,11 @@ total line count).
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::io::ReaderUtil;
-use core::io;
-use core::os;
-use core::vec;
+use std::io::ReaderUtil;
+use std::io;
+use std::os;
+use std::vec;
 
 /**
 A summary of the internal state of a `FileInput` object. `line_num`
@@ -410,13 +409,12 @@ pub fn input_vec_state(files: ~[Option<Path>],
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use super::{FileInput, pathify, input_vec, input_vec_state};
 
-    use core::io;
-    use core::uint;
-    use core::vec;
+    use std::io;
+    use std::uint;
+    use std::vec;
 
     fn make_file(path : &Path, contents: &[~str]) {
         let file = io::file_writer(path, [io::Create, io::Truncate]).get();
diff --git a/src/libextra/flate.rs b/src/libextra/flate.rs
index fe8f4bee75e..92f9f834f52 100644
--- a/src/libextra/flate.rs
+++ b/src/libextra/flate.rs
@@ -16,12 +16,12 @@ Simple compression
 
 #[allow(missing_doc)];
 
-use core::libc::{c_void, size_t, c_int};
-use core::libc;
-use core::vec;
+use std::libc::{c_void, size_t, c_int};
+use std::libc;
+use std::vec;
 
 pub mod rustrt {
-    use core::libc::{c_int, c_void, size_t};
+    use std::libc::{c_int, c_void, size_t};
 
     #[link_name = "rustrt"]
     pub extern {
@@ -83,9 +83,8 @@ pub fn inflate_bytes(bytes: &[u8]) -> ~[u8] {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use core::rand;
-    use core::rand::RngUtil;
-    use core::prelude::*;
+    use std::rand;
+    use std::rand::RngUtil;
 
     #[test]
     #[allow(non_implicitly_copyable_typarams)]
diff --git a/src/libextra/flatpipes.rs b/src/libextra/flatpipes.rs
index d5e43e85a14..e8bdc951ca4 100644
--- a/src/libextra/flatpipes.rs
+++ b/src/libextra/flatpipes.rs
@@ -49,14 +49,13 @@ block the scheduler thread, so will their pipes.
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 // The basic send/recv interface FlatChan and PortChan will implement
-use core::io;
-use core::comm::GenericChan;
-use core::comm::GenericPort;
-use core::sys::size_of;
-use core::vec;
+use std::io;
+use std::comm::GenericChan;
+use std::comm::GenericPort;
+use std::sys::size_of;
+use std::vec;
 
 /**
 A FlatPort, consisting of a `BytePort` that receives byte vectors,
@@ -95,9 +94,9 @@ pub mod serial {
     use flatpipes::bytepipes::{PipeBytePort, PipeByteChan};
     use flatpipes::{FlatPort, FlatChan};
 
-    use core::io::{Reader, Writer};
-    use core::comm::{Port, Chan};
-    use core::comm;
+    use std::io::{Reader, Writer};
+    use std::comm::{Port, Chan};
+    use std::comm;
 
     pub type ReaderPort<T, R> = FlatPort<
         T, DeserializingUnflattener<DefaultDecoder, T>,
@@ -172,16 +171,15 @@ POD are not equivelant.
 
 */
 pub mod pod {
-    use core::prelude::*;
 
     use flatpipes::flatteners::{PodUnflattener, PodFlattener};
     use flatpipes::bytepipes::{ReaderBytePort, WriterByteChan};
     use flatpipes::bytepipes::{PipeBytePort, PipeByteChan};
     use flatpipes::{FlatPort, FlatChan};
 
-    use core::io::{Reader, Writer};
-    use core::comm::{Port, Chan};
-    use core::comm;
+    use std::io::{Reader, Writer};
+    use std::comm::{Port, Chan};
+    use std::comm;
 
     pub type ReaderPort<T, R> =
         FlatPort<T, PodUnflattener<T>, ReaderBytePort<R>>;
@@ -337,7 +335,6 @@ impl<T,F:Flattener<T>,C:ByteChan> FlatChan<T, F, C> {
 
 
 pub mod flatteners {
-    use core::prelude::*;
 
     use ebml;
     use flatpipes::{Flattener, Unflattener};
@@ -345,12 +342,12 @@ pub mod flatteners {
     use json;
     use serialize::{Encoder, Decoder, Encodable, Decodable};
 
-    use core::cast;
-    use core::io::{Writer, Reader, ReaderUtil};
-    use core::io;
-    use core::ptr;
-    use core::sys::size_of;
-    use core::vec;
+    use std::cast;
+    use std::io::{Writer, Reader, ReaderUtil};
+    use std::io;
+    use std::ptr;
+    use std::sys::size_of;
+    use std::vec;
 
     // FIXME #4074: Copy + Send != POD
     pub struct PodUnflattener<T> {
@@ -509,13 +506,12 @@ pub mod flatteners {
 }
 
 pub mod bytepipes {
-    use core::prelude::*;
 
     use flatpipes::{ByteChan, BytePort};
 
-    use core::comm::{Port, Chan};
-    use core::comm;
-    use core::io::{Writer, Reader, ReaderUtil};
+    use std::comm::{Port, Chan};
+    use std::comm;
+    use std::io::{Writer, Reader, ReaderUtil};
 
     pub struct ReaderBytePort<R> {
         reader: R
@@ -583,12 +579,12 @@ pub mod bytepipes {
     impl BytePort for PipeBytePort {
         fn try_recv(&self, count: uint) -> Option<~[u8]> {
             if self.buf.len() >= count {
-                let mut bytes = ::core::util::replace(&mut *self.buf, ~[]);
+                let mut bytes = ::std::util::replace(&mut *self.buf, ~[]);
                 *self.buf = bytes.slice(count, bytes.len()).to_owned();
                 bytes.truncate(count);
                 return Some(bytes);
             } else if !self.buf.is_empty() {
-                let mut bytes = ::core::util::replace(&mut *self.buf, ~[]);
+                let mut bytes = ::std::util::replace(&mut *self.buf, ~[]);
                 assert!(count > bytes.len());
                 match self.try_recv(count - bytes.len()) {
                     Some(rest) => {
@@ -637,7 +633,6 @@ pub mod bytepipes {
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use flatpipes::{Flattener, Unflattener};
     use flatpipes::bytepipes::*;
@@ -647,11 +642,11 @@ mod test {
     use flatpipes::{BytePort, FlatChan, FlatPort};
     use net::tcp::TcpSocketBuf;
 
-    use core::comm;
-    use core::int;
-    use core::io::BytesWriter;
-    use core::result;
-    use core::task;
+    use std::comm;
+    use std::int;
+    use std::io::BytesWriter;
+    use std::result;
+    use std::task;
 
     #[test]
     #[ignore(reason = "ebml failure")]
@@ -772,7 +767,7 @@ mod test {
         writer_chan: WriterChanFactory<F>,
         port: uint) {
 
-        use core::cell::Cell;
+        use std::cell::Cell;
         use net::ip;
         use net::tcp;
         use uv;
@@ -871,17 +866,16 @@ mod test {
     // Tests that the different backends behave the same when the
     // binary streaming protocol is broken
     mod broken_protocol {
-        use core::prelude::*;
 
         use flatpipes::{BytePort, FlatPort};
         use flatpipes::flatteners::PodUnflattener;
         use flatpipes::pod;
         use io_util::BufReader;
 
-        use core::comm;
-        use core::io;
-        use core::sys;
-        use core::task;
+        use std::comm;
+        use std::io;
+        use std::sys;
+        use std::task;
 
         type PortLoader<P> =
             ~fn(~[u8]) -> FlatPort<int, PodUnflattener<int>, P>;
diff --git a/src/libextra/fun_treemap.rs b/src/libextra/fun_treemap.rs
index 5906e809c98..4461a4dba5f 100644
--- a/src/libextra/fun_treemap.rs
+++ b/src/libextra/fun_treemap.rs
@@ -19,10 +19,9 @@
  * of features.
  */
 
-use core::prelude::*;
 
-use core::cmp::{Eq, Ord};
-use core::option::{Some, None};
+use std::cmp::{Eq, Ord};
+use std::option::{Some, None};
 
 pub type Treemap<K, V> = @TreeNode<K, V>;
 
diff --git a/src/libextra/future.rs b/src/libextra/future.rs
index 00f4cc3989b..3ef71e1731b 100644
--- a/src/libextra/future.rs
+++ b/src/libextra/future.rs
@@ -25,13 +25,12 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::cast;
-use core::cell::Cell;
-use core::comm::{PortOne, oneshot, send_one, recv_one};
-use core::task;
-use core::util::replace;
+use std::cast;
+use std::cell::Cell;
+use std::comm::{PortOne, oneshot, send_one, recv_one};
+use std::task;
+use std::util::replace;
 
 #[doc = "The future type"]
 pub struct Future<A> {
@@ -151,9 +150,9 @@ pub fn spawn<A:Send>(blk: ~fn() -> A) -> Future<A> {
 mod test {
     use future::*;
 
-    use core::cell::Cell;
-    use core::comm::{oneshot, send_one};
-    use core::task;
+    use std::cell::Cell;
+    use std::comm::{oneshot, send_one};
+    use std::task;
 
     #[test]
     fn test_from_value() {
diff --git a/src/libextra/getopts.rs b/src/libextra/getopts.rs
index fa064e6330e..21fe676ef79 100644
--- a/src/libextra/getopts.rs
+++ b/src/libextra/getopts.rs
@@ -81,14 +81,13 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::cmp::Eq;
-use core::result::{Err, Ok};
-use core::result;
-use core::option::{Some, None};
-use core::str;
-use core::vec;
+use std::cmp::Eq;
+use std::result::{Err, Ok};
+use std::result;
+use std::option::{Some, None};
+use std::str;
+use std::vec;
 
 #[deriving(Eq)]
 pub enum Name {
@@ -466,8 +465,8 @@ pub mod groups {
     use getopts::{HasArg, Long, Maybe, Multi, No, Occur, Opt, Optional, Req};
     use getopts::{Short, Yes};
 
-    use core::str;
-    use core::vec;
+    use std::str;
+    use std::vec;
 
     /** one group of options, e.g., both -h and --help, along with
      * their shared description and properties
@@ -681,8 +680,8 @@ mod tests {
     use getopts::groups::OptGroup;
     use getopts::*;
 
-    use core::result::{Err, Ok};
-    use core::result;
+    use std::result::{Err, Ok};
+    use std::result;
 
     fn check_fail_type(f: Fail_, ft: FailType) {
         match f {
diff --git a/src/libextra/io_util.rs b/src/libextra/io_util.rs
index 11dea1c3a70..afefca8ae65 100644
--- a/src/libextra/io_util.rs
+++ b/src/libextra/io_util.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::io::{Reader, BytesReader};
-use core::io;
-use core::cast;
+use std::io::{Reader, BytesReader};
+use std::io;
+use std::cast;
 
 /// An implementation of the io::Reader interface which reads a buffer of bytes
 pub struct BufReader {
@@ -31,7 +31,7 @@ impl BufReader {
 
     fn as_bytes_reader<A>(&self, f: &fn(&BytesReader) -> A) -> A {
         // XXX FIXME(#5723)
-        let bytes = ::core::util::id::<&[u8]>(self.buf);
+        let bytes = ::std::util::id::<&[u8]>(self.buf);
         let bytes: &'static [u8] = unsafe { cast::transmute(bytes) };
         // Recreating the BytesReader state every call since
         // I can't get the borrowing to work correctly
diff --git a/src/libextra/json.rs b/src/libextra/json.rs
index a71be18174a..210921aa3d7 100644
--- a/src/libextra/json.rs
+++ b/src/libextra/json.rs
@@ -16,16 +16,15 @@
 
 //! json serialization
 
-use core::prelude::*;
 
-use core::char;
-use core::float;
-use core::hashmap::HashMap;
-use core::io::{WriterUtil, ReaderUtil};
-use core::io;
-use core::str;
-use core::to_str;
-use core::vec;
+use std::char;
+use std::float;
+use std::hashmap::HashMap;
+use std::io::{WriterUtil, ReaderUtil};
+use std::io;
+use std::str;
+use std::to_str;
+use std::vec;
 
 use serialize::Encodable;
 use serialize;
@@ -1356,15 +1355,14 @@ impl to_str::ToStr for Error {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use super::*;
 
-    use core::hashmap::HashMap;
-    use core::io;
-    use core::result;
+    use std::hashmap::HashMap;
+    use std::io;
+    use std::result;
 
-    use std::serialize::Decodable;
+    use extra::serialize::Decodable;
 
     #[deriving(Eq, Encodable, Decodable)]
     enum Animal {
diff --git a/src/libextra/list.rs b/src/libextra/list.rs
index 34c35e0d7fd..86b01cf157d 100644
--- a/src/libextra/list.rs
+++ b/src/libextra/list.rs
@@ -10,7 +10,6 @@
 
 //! A standard, garbage-collected linked list.
 
-use core::prelude::*;
 
 
 #[deriving(Eq)]
@@ -181,7 +180,7 @@ mod tests {
     use list::*;
     use list;
 
-    use core::option;
+    use std::option;
 
     #[test]
     fn test_is_empty() {
diff --git a/src/libextra/md4.rs b/src/libextra/md4.rs
index 3be7394b46d..6b08fea580f 100644
--- a/src/libextra/md4.rs
+++ b/src/libextra/md4.rs
@@ -8,10 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::uint;
-use core::vec;
+use std::uint;
+use std::vec;
 
 struct Quad {
     a: u32,
diff --git a/src/libextra/net_ip.rs b/src/libextra/net_ip.rs
index fc3c765999b..d18aac68481 100644
--- a/src/libextra/net_ip.rs
+++ b/src/libextra/net_ip.rs
@@ -12,13 +12,12 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::libc;
-use core::comm::{stream, SharedChan};
-use core::ptr;
-use core::result;
-use core::str;
+use std::libc;
+use std::comm::{stream, SharedChan};
+use std::ptr;
+use std::result;
+use std::str;
 
 use iotask = uv::iotask::IoTask;
 use interact = uv::iotask::interact;
@@ -149,16 +148,15 @@ pub fn get_addr(node: &str, iotask: &iotask)
 }
 
 pub mod v4 {
-    use core::prelude::*;
 
     use net::ip::{IpAddr, Ipv4, ParseAddrErr};
     use uv::ll;
     use uv_ip4_addr = uv::ll::ip4_addr;
     use uv_ip4_name = uv::ll::ip4_name;
 
-    use core::cast::transmute;
-    use core::result;
-    use core::uint;
+    use std::cast::transmute;
+    use std::result;
+    use std::uint;
 
     /**
      * Convert a str to `ip_addr`
@@ -248,13 +246,12 @@ pub mod v4 {
     }
 }
 pub mod v6 {
-    use core::prelude::*;
 
     use net::ip::{IpAddr, Ipv6, ParseAddrErr};
     use uv_ip6_addr = uv::ll::ip6_addr;
     use uv_ip6_name = uv::ll::ip6_name;
 
-    use core::result;
+    use std::result;
 
     /**
      * Convert a str to `ip_addr`
@@ -371,7 +368,7 @@ mod test {
     use net_ip::v6;
     use uv;
 
-    use core::result;
+    use std::result;
 
     #[test]
     fn test_ip_ipv4_parse_and_format_ip() {
diff --git a/src/libextra/net_tcp.rs b/src/libextra/net_tcp.rs
index f3f6ffde660..6a22950ec04 100644
--- a/src/libextra/net_tcp.rs
+++ b/src/libextra/net_tcp.rs
@@ -13,7 +13,6 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 use future;
 use future_spawn = future::spawn;
@@ -22,18 +21,18 @@ use uv;
 use uv::iotask;
 use uv::iotask::IoTask;
 
-use core::io;
-use core::libc::size_t;
-use core::libc;
-use core::comm::{stream, Port, SharedChan};
-use core::ptr;
-use core::result::{Result};
-use core::result;
-use core::uint;
-use core::vec;
+use std::io;
+use std::libc::size_t;
+use std::libc;
+use std::comm::{stream, Port, SharedChan};
+use std::ptr;
+use std::result::{Result};
+use std::result;
+use std::uint;
+use std::vec;
 
 pub mod rustrt {
-    use core::libc;
+    use std::libc;
 
     #[nolink]
     pub extern {
@@ -360,7 +359,7 @@ pub fn write_future(sock: &TcpSocket, raw_write_data: ~[u8])
  * # Returns
  *
  * * A `Result` instance that will either contain a
- * `core::comm::Port<Result<~[u8], TcpErrData>>` that the user can read
+ * `std::comm::Port<Result<~[u8], TcpErrData>>` that the user can read
  * (and * optionally, loop on) from until `read_stop` is called, or a
  * `TcpErrData` record
  */
@@ -619,7 +618,7 @@ pub fn accept(new_conn: TcpNewConnection)
  * callback's arguments are:
  *     * `new_conn` - an opaque type that can be passed to
  *     `net::tcp::accept` in order to be converted to a `TcpSocket`.
- *     * `kill_ch` - channel of type `core::comm::Chan<Option<tcp_err_data>>`.
+ *     * `kill_ch` - channel of type `std::comm::Chan<Option<tcp_err_data>>`.
  *     this channel can be used to send a message to cause `listen` to begin
  *     closing the underlying libuv data structures.
  *
@@ -683,7 +682,7 @@ fn listen_common(host_ip: ip::IpAddr,
     // will defeat a move sigil, as is done to the host_ip
     // arg above.. this same pattern works w/o complaint in
     // tcp::connect (because the iotask::interact cb isn't
-    // nested within a core::comm::listen block)
+    // nested within a std::comm::listen block)
     let loc_ip = copy(host_ip);
     do iotask::interact(iotask) |loop_ptr| {
         unsafe {
@@ -1429,7 +1428,6 @@ struct TcpBufferedSocketData {
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use net::ip;
     use net::tcp::{GenericListenErr, TcpConnectErrData, TcpListenErrData};
@@ -1438,12 +1436,12 @@ mod test {
     use uv::iotask::IoTask;
     use uv;
 
-    use core::cell::Cell;
-    use core::comm::{stream, SharedChan};
-    use core::io;
-    use core::result;
-    use core::str;
-    use core::task;
+    use std::cell::Cell;
+    use std::comm::{stream, SharedChan};
+    use std::io;
+    use std::result;
+    use std::str;
+    use std::task;
 
     // FIXME don't run on fbsd or linux 32 bit (#2064)
     #[cfg(target_os="win32")]
@@ -1745,7 +1743,7 @@ mod test {
     }
 
     pub fn impl_tcp_socket_impl_reader_handles_eof() {
-        use core::io::{Reader,ReaderUtil};
+        use std::io::{Reader,ReaderUtil};
 
         let hl_loop = &uv::global_loop::get();
         let server_ip = "127.0.0.1";
diff --git a/src/libextra/net_url.rs b/src/libextra/net_url.rs
index a60f51e751e..9ac58efe793 100644
--- a/src/libextra/net_url.rs
+++ b/src/libextra/net_url.rs
@@ -12,14 +12,13 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::cmp::Eq;
-use core::io::{Reader, ReaderUtil};
-use core::io;
-use core::hashmap::HashMap;
-use core::to_bytes;
-use core::uint;
+use std::cmp::Eq;
+use std::io::{Reader, ReaderUtil};
+use std::io;
+use std::hashmap::HashMap;
+use std::to_bytes;
+use std::uint;
 
 #[deriving(Clone, Eq)]
 struct Url {
@@ -803,7 +802,7 @@ mod tests {
 
     use net_url::*;
 
-    use core::hashmap::HashMap;
+    use std::hashmap::HashMap;
 
     #[test]
     fn test_url_parse() {
diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs
index 002d8a7f956..fd61c4f6bfc 100644
--- a/src/libextra/num/bigint.rs
+++ b/src/libextra/num/bigint.rs
@@ -18,13 +18,12 @@ A BigInt is a combination of BigUint and Sign.
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
-use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
-use core::int;
-use core::num::{IntConvertible, Zero, One, ToStrRadix, FromStrRadix, Orderable};
-use core::str;
-use core::uint;
-use core::vec;
+use std::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
+use std::int;
+use std::num::{IntConvertible, Zero, One, ToStrRadix, FromStrRadix, Orderable};
+use std::str;
+use std::uint;
+use std::vec;
 
 /**
 A BigDigit is a BigUint's composing element.
@@ -1148,16 +1147,15 @@ impl BigInt {
 
 #[cfg(test)]
 mod biguint_tests {
-    use core::prelude::*;
 
     use super::*;
 
-    use core::cmp::{Less, Equal, Greater};
-    use core::int;
-    use core::num::{IntConvertible, Zero, One, FromStrRadix};
-    use core::str;
-    use core::uint;
-    use core::vec;
+    use std::cmp::{Less, Equal, Greater};
+    use std::int;
+    use std::num::{IntConvertible, Zero, One, FromStrRadix};
+    use std::str;
+    use std::uint;
+    use std::vec;
 
     #[test]
     fn test_from_slice() {
@@ -1623,15 +1621,14 @@ mod biguint_tests {
 
 #[cfg(test)]
 mod bigint_tests {
-    use core::prelude::*;
 
     use super::*;
 
-    use core::cmp::{Less, Equal, Greater};
-    use core::int;
-    use core::num::{IntConvertible, Zero, One, FromStrRadix};
-    use core::uint;
-    use core::vec;
+    use std::cmp::{Less, Equal, Greater};
+    use std::int;
+    use std::num::{IntConvertible, Zero, One, FromStrRadix};
+    use std::uint;
+    use std::vec;
 
     #[test]
     fn test_from_biguint() {
diff --git a/src/libextra/num/complex.rs b/src/libextra/num/complex.rs
index 3a63549cf3a..915523443fb 100644
--- a/src/libextra/num/complex.rs
+++ b/src/libextra/num/complex.rs
@@ -11,9 +11,8 @@
 
 //! Complex numbers.
 
-use core::prelude::*;
 
-use core::num::{Zero,One,ToStrRadix};
+use std::num::{Zero,One,ToStrRadix};
 
 // FIXME #1284: handle complex NaN & infinity etc. This
 // probably doesn't map to C's _Complex correctly.
@@ -193,7 +192,7 @@ impl<T: ToStrRadix + Num + Ord> ToStrRadix for Cmplx<T> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use core::num::{Zero,One,Real};
+    use std::num::{Zero,One,Real};
 
     pub static _0_0i : Complex = Cmplx { re: 0f, im: 0f };
     pub static _1_0i : Complex = Cmplx { re: 1f, im: 0f };
@@ -287,7 +286,7 @@ mod test {
 
     mod arith {
         use super::*;
-        use core::num::Zero;
+        use std::num::Zero;
 
         #[test]
         fn test_add() {
diff --git a/src/libextra/num/rational.rs b/src/libextra/num/rational.rs
index 339d35e2593..6733599d1ea 100644
--- a/src/libextra/num/rational.rs
+++ b/src/libextra/num/rational.rs
@@ -10,11 +10,10 @@
 
 //! Rational numbers
 
-use core::prelude::*;
 
-use core::cmp;
-use core::from_str::FromStr;
-use core::num::{Zero,One,ToStrRadix,FromStrRadix,Round};
+use std::cmp;
+use std::from_str::FromStr;
+use std::num::{Zero,One,ToStrRadix,FromStrRadix,Round};
 use super::bigint::BigInt;
 
 /// Represents the ratio between 2 numbers.
@@ -277,11 +276,10 @@ impl<T: FromStrRadix + Clone + Integer + Ord>
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use super::*;
-    use core::num::{Zero,One,FromStrRadix,IntConvertible};
-    use core::from_str::FromStr;
+    use std::num::{Zero,One,FromStrRadix,IntConvertible};
+    use std::from_str::FromStr;
 
     pub static _0 : Rational = Ratio { numer: 0, denom: 1};
     pub static _1 : Rational = Ratio { numer: 1, denom: 1};
diff --git a/src/libextra/par.rs b/src/libextra/par.rs
index a3014cf8894..665633eedf8 100644
--- a/src/libextra/par.rs
+++ b/src/libextra/par.rs
@@ -8,13 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::cast;
-use core::ptr;
-use core::sys;
-use core::uint;
-use core::vec;
+use std::cast;
+use std::ptr;
+use std::sys;
+use std::uint;
+use std::vec;
 use future_spawn = future::spawn;
 
 /**
diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs
index fbb4be0febb..4c1163f3d50 100644
--- a/src/libextra/priority_queue.rs
+++ b/src/libextra/priority_queue.rs
@@ -12,11 +12,10 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::unstable::intrinsics::{move_val_init, init};
-use core::util::{replace, swap};
-use core::vec;
+use std::unstable::intrinsics::{move_val_init, init};
+use std::util::{replace, swap};
+use std::vec;
 
 /// A priority queue implemented with a binary heap
 pub struct PriorityQueue<T> {
diff --git a/src/libextra/rc.rs b/src/libextra/rc.rs
index 613c0b1ae41..86080b343c7 100644
--- a/src/libextra/rc.rs
+++ b/src/libextra/rc.rs
@@ -21,13 +21,12 @@ cycle cannot be created with `Rc<T>` because there is no way to modify it after
 
 */
 
-use core::prelude::*;
 
-use core::cast;
-use core::libc::{c_void, size_t, malloc, free};
-use core::ptr;
-use core::sys;
-use core::unstable::intrinsics;
+use std::cast;
+use std::libc::{c_void, size_t, malloc, free};
+use std::ptr;
+use std::sys;
+use std::unstable::intrinsics;
 
 struct RcBox<T> {
     value: T,
@@ -104,7 +103,7 @@ impl<T: DeepClone> DeepClone for Rc<T> {
 #[cfg(test)]
 mod test_rc {
     use super::*;
-    use core::cell::Cell;
+    use std::cell::Cell;
 
     #[test]
     fn test_clone() {
diff --git a/src/libextra/rl.rs b/src/libextra/rl.rs
index 040adcc443d..693e3ecb53f 100644
--- a/src/libextra/rl.rs
+++ b/src/libextra/rl.rs
@@ -11,14 +11,13 @@
 // FIXME #3921. This is unsafe because linenoise uses global mutable
 // state without mutexes.
 
-use core::prelude::*;
 
-use core::libc::{c_char, c_int};
-use core::local_data;
-use core::str;
+use std::libc::{c_char, c_int};
+use std::local_data;
+use std::str;
 
 pub mod rustrt {
-    use core::libc::{c_char, c_int};
+    use std::libc::{c_char, c_int};
 
     pub extern {
         pub unsafe fn linenoise(prompt: *c_char) -> *c_char;
diff --git a/src/libextra/rope.rs b/src/libextra/rope.rs
index 71393ff9fae..8374c1a86e3 100644
--- a/src/libextra/rope.rs
+++ b/src/libextra/rope.rs
@@ -35,11 +35,10 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::uint;
-use core::vec;
-use core::str;
+use std::uint;
+use std::vec;
+use std::str;
 
 /// The type of ropes.
 pub type Rope = node::Root;
@@ -447,7 +446,6 @@ pub fn loop_leaves(rope: Rope, it: &fn(node::Leaf) -> bool) -> bool{
 
 pub mod iterator {
     pub mod leaf {
-        use core::prelude::*;
 
         use rope::{Rope, node};
 
@@ -462,7 +460,6 @@ pub mod iterator {
         }
     }
     pub mod char {
-        use core::prelude::*;
 
         use rope::{Rope, node};
 
@@ -558,13 +555,12 @@ pub fn char_at(rope: Rope, pos: uint) -> char {
  Section: Implementation
 */
 pub mod node {
-    use core::prelude::*;
 
     use rope::node;
 
-    use core::cast;
-    use core::uint;
-    use core::vec;
+    use std::cast;
+    use std::uint;
+    use std::vec;
 
     /// Implementation of type `rope`
     pub enum Root {
@@ -1141,11 +1137,10 @@ pub mod node {
     }
 
     pub mod leaf_iterator {
-        use core::prelude::*;
 
         use rope::node::{Concat, Leaf, Node, height};
 
-        use core::vec;
+        use std::vec;
 
         pub struct T {
             stack: ~[@Node],
@@ -1184,7 +1179,6 @@ pub mod node {
     }
 
     pub mod char_iterator {
-        use core::prelude::*;
 
         use rope::node::{Leaf, Node};
         use rope::node::leaf_iterator;
@@ -1267,12 +1261,11 @@ pub mod node {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use rope::*;
 
-    use core::uint;
-    use core::vec;
+    use std::uint;
+    use std::vec;
 
     //Utility function, used for sanity check
     fn rope_to_string(r: Rope) -> ~str {
diff --git a/src/libextra/semver.rs b/src/libextra/semver.rs
index cb372dd920d..6361de12719 100644
--- a/src/libextra/semver.rs
+++ b/src/libextra/semver.rs
@@ -12,15 +12,14 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
-
-use core::char;
-use core::cmp;
-use core::io::{ReaderUtil};
-use core::io;
-use core::option::{Option, Some, None};
-use core::to_str::ToStr;
-use core::uint;
+
+use std::char;
+use std::cmp;
+use std::io::{ReaderUtil};
+use std::io;
+use std::option::{Option, Some, None};
+use std::to_str::ToStr;
+use std::uint;
 
 #[deriving(Eq)]
 pub enum Identifier {
diff --git a/src/libextra/serialize.rs b/src/libextra/serialize.rs
index 3d35d1332b2..66b178f49f7 100644
--- a/src/libextra/serialize.rs
+++ b/src/libextra/serialize.rs
@@ -17,13 +17,12 @@ Core encoding and decoding interfaces.
 #[allow(missing_doc)];
 #[forbid(non_camel_case_types)];
 
-use core::prelude::*;
 
-use core::at_vec;
-use core::hashmap::{HashMap, HashSet};
-use core::trie::{TrieMap, TrieSet};
-use core::uint;
-use core::vec;
+use std::at_vec;
+use std::hashmap::{HashMap, HashSet};
+use std::trie::{TrieMap, TrieSet};
+use std::uint;
+use std::vec;
 use deque::Deque;
 use dlist::DList;
 use treemap::{TreeMap, TreeSet};
diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs
index 1d163922955..e32c688da37 100644
--- a/src/libextra/smallintmap.rs
+++ b/src/libextra/smallintmap.rs
@@ -15,13 +15,12 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::cmp;
-use core::container::{Container, Mutable, Map, Set};
-use core::uint;
-use core::util::replace;
-use core::vec;
+use std::cmp;
+use std::container::{Container, Mutable, Map, Set};
+use std::uint;
+use std::util::replace;
+use std::vec;
 
 #[allow(missing_doc)]
 pub struct SmallIntMap<T> {
@@ -287,7 +286,6 @@ impl SmallIntSet {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use super::SmallIntMap;
 
@@ -382,11 +380,10 @@ mod tests {
 
 #[cfg(test)]
 mod test_set {
-    use core::prelude::*;
 
     use super::SmallIntSet;
 
-    use core::vec;
+    use std::vec;
 
     #[test]
     fn test_disjoint() {
diff --git a/src/libextra/sort.rs b/src/libextra/sort.rs
index 10dbe2326d7..36c12f314b7 100644
--- a/src/libextra/sort.rs
+++ b/src/libextra/sort.rs
@@ -10,12 +10,11 @@
 
 //! Sorting methods
 
-use core::prelude::*;
 
-use core::cmp::{Eq, Ord};
-use core::uint;
-use core::util::swap;
-use core::vec;
+use std::cmp::{Eq, Ord};
+use std::uint;
+use std::util::swap;
+use std::vec;
 
 type Le<'self, T> = &'self fn(v1: &T, v2: &T) -> bool;
 
@@ -791,12 +790,11 @@ mod test_qsort3 {
 
 #[cfg(test)]
 mod test_qsort {
-    use core::prelude::*;
 
     use sort::*;
 
-    use core::int;
-    use core::vec;
+    use std::int;
+    use std::vec;
 
     fn check_sort(v1: &mut [int], v2: &mut [int]) {
         let len = v1.len();
@@ -857,7 +855,6 @@ mod test_qsort {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use sort::*;
 
@@ -924,12 +921,11 @@ mod tests {
 
 #[cfg(test)]
 mod test_tim_sort {
-    use core::prelude::*;
 
     use sort::tim_sort;
-    use core::rand::RngUtil;
-    use core::rand;
-    use core::vec;
+    use std::rand::RngUtil;
+    use std::rand;
+    use std::vec;
 
     struct CVal {
         val: float,
@@ -1019,15 +1015,14 @@ mod test_tim_sort {
 
 #[cfg(test)]
 mod big_tests {
-    use core::prelude::*;
 
     use sort::*;
 
-    use core::local_data;
-    use core::rand::RngUtil;
-    use core::rand;
-    use core::uint;
-    use core::vec;
+    use std::local_data;
+    use std::rand::RngUtil;
+    use std::rand;
+    use std::uint;
+    use std::vec;
 
     #[test]
     fn test_unique() {
diff --git a/src/libextra/stats.rs b/src/libextra/stats.rs
index 69f75037c7e..8351e4db6b8 100644
--- a/src/libextra/stats.rs
+++ b/src/libextra/stats.rs
@@ -10,12 +10,11 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::f64;
-use core::cmp;
-use core::num;
-use core::vec;
+use std::f64;
+use std::cmp;
+use std::num;
+use std::vec;
 use sort;
 
 // NB: this can probably be rewritten in terms of num::Num
diff --git a/src/libextra/sync.rs b/src/libextra/sync.rs
index 9c6be901d98..b9d25451a8a 100644
--- a/src/libextra/sync.rs
+++ b/src/libextra/sync.rs
@@ -15,14 +15,13 @@
  * in std.
  */
 
-use core::prelude::*;
 
-use core::borrow;
-use core::comm;
-use core::task;
-use core::unstable::sync::{Exclusive, exclusive, UnsafeAtomicRcBox};
-use core::unstable::atomics;
-use core::util;
+use std::borrow;
+use std::comm;
+use std::task;
+use std::unstable::sync::{Exclusive, exclusive, UnsafeAtomicRcBox};
+use std::unstable::atomics;
+use std::util;
 
 /****************************************************************************
  * Internals
@@ -803,15 +802,14 @@ impl<'self> RWlockReadMode<'self> {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use sync::*;
 
-    use core::cast;
-    use core::cell::Cell;
-    use core::comm;
-    use core::result;
-    use core::task;
+    use std::cast;
+    use std::cell::Cell;
+    use std::comm;
+    use std::result;
+    use std::task;
 
     /************************************************************************
      * Semaphore tests
diff --git a/src/libextra/task_pool.rs b/src/libextra/task_pool.rs
index 6a715d7b481..49d5dd93869 100644
--- a/src/libextra/task_pool.rs
+++ b/src/libextra/task_pool.rs
@@ -13,15 +13,14 @@
 /// A task pool abstraction. Useful for achieving predictable CPU
 /// parallelism.
 
-use core::prelude::*;
 
-use core::comm::Chan;
-use core::comm;
-use core::task::SchedMode;
-use core::task;
-use core::vec;
+use std::comm::Chan;
+use std::comm;
+use std::task::SchedMode;
+use std::task;
+use std::vec;
 
-#[cfg(test)] use core::task::SingleThreaded;
+#[cfg(test)] use std::task::SingleThreaded;
 
 enum Msg<T> {
     Execute(~fn(&T)),
diff --git a/src/libextra/tempfile.rs b/src/libextra/tempfile.rs
index 39dcee5eff3..f8948f41101 100644
--- a/src/libextra/tempfile.rs
+++ b/src/libextra/tempfile.rs
@@ -10,11 +10,10 @@
 
 //! Temporary files and directories
 
-use core::prelude::*;
 
-use core::os;
-use core::rand::RngUtil;
-use core::rand;
+use std::os;
+use std::rand::RngUtil;
+use std::rand;
 
 /// Attempts to make a temporary directory inside of `tmpdir` whose name will
 /// have the suffix `suffix`. If no directory can be created, None is returned.
@@ -31,11 +30,10 @@ pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use tempfile::mkdtemp;
 
-    use core::os;
+    use std::os;
 
     #[test]
     fn test_mkdtemp() {
@@ -44,12 +42,12 @@ mod tests {
         assert!(p.to_str().ends_with("foobar"));
     }
 
-    // Ideally these would be in core::os but then core would need
+    // Ideally these would be in std::os but then core would need
     // to depend on std
     #[test]
     fn recursive_mkdir_rel() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
 
         let root = mkdtemp(&os::tmpdir(), "recursive_mkdir_rel").
             expect("recursive_mkdir_rel");
@@ -67,8 +65,8 @@ mod tests {
 
     #[test]
     fn recursive_mkdir_dot() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
 
         let dot = Path(".");
         assert!(os::mkdir_recursive(&dot,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
@@ -78,8 +76,8 @@ mod tests {
 
     #[test]
     fn recursive_mkdir_rel_2() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
 
         let root = mkdtemp(&os::tmpdir(), "recursive_mkdir_rel_2").
             expect("recursive_mkdir_rel_2");
@@ -102,8 +100,8 @@ mod tests {
     // Ideally this would be in core, but needs mkdtemp
     #[test]
     pub fn test_rmdir_recursive_ok() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
 
         let rwx = (S_IRUSR | S_IWUSR | S_IXUSR) as i32;
 
diff --git a/src/libextra/term.rs b/src/libextra/term.rs
index d448a1588a6..e21e5c5fb58 100644
--- a/src/libextra/term.rs
+++ b/src/libextra/term.rs
@@ -12,11 +12,10 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::io;
+use std::io;
 
-#[cfg(not(target_os = "win32"))] use core::os;
+#[cfg(not(target_os = "win32"))] use std::os;
 #[cfg(not(target_os = "win32"))] use terminfo::*;
 #[cfg(not(target_os = "win32"))] use terminfo::searcher::open;
 #[cfg(not(target_os = "win32"))] use terminfo::parser::compiled::parse;
diff --git a/src/libextra/terminfo/parm.rs b/src/libextra/terminfo/parm.rs
index 5180a71939c..f3edd81f9ac 100644
--- a/src/libextra/terminfo/parm.rs
+++ b/src/libextra/terminfo/parm.rs
@@ -10,10 +10,9 @@
 
 //! Parameterized string expansion
 
-use core::prelude::*;
-use core::{char, vec, util};
-use core::num::strconv::{SignNone,SignNeg,SignAll,DigAll,to_str_bytes_common};
-use core::iterator::IteratorUtil;
+use std::{char, vec, util};
+use std::num::strconv::{SignNone,SignNeg,SignAll,DigAll,to_str_bytes_common};
+use std::iterator::IteratorUtil;
 
 #[deriving(Eq)]
 enum States {
@@ -549,7 +548,7 @@ priv fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use core::result::Ok;
+    use std::result::Ok;
 
     #[test]
     fn test_basic_setabf() {
diff --git a/src/libextra/terminfo/parser/compiled.rs b/src/libextra/terminfo/parser/compiled.rs
index 123a388900b..2f36845d79b 100644
--- a/src/libextra/terminfo/parser/compiled.rs
+++ b/src/libextra/terminfo/parser/compiled.rs
@@ -10,11 +10,10 @@
 
 /// ncurses-compatible compiled terminfo format parsing (term(5))
 
-use core::prelude::*;
 
-use core::{vec, int, str};
-use core::io::Reader;
-use core::hashmap::HashMap;
+use std::{vec, int, str};
+use std::io::Reader;
+use std::hashmap::HashMap;
 use super::super::TermInfo;
 
 // These are the orders ncurses uses in its compiled format (as of 5.9). Not sure if portable.
diff --git a/src/libextra/terminfo/searcher.rs b/src/libextra/terminfo/searcher.rs
index da12a1c4203..15aeeb3e654 100644
--- a/src/libextra/terminfo/searcher.rs
+++ b/src/libextra/terminfo/searcher.rs
@@ -11,11 +11,10 @@
 /// Implement ncurses-compatible database discovery
 /// Does not support hashed database, only filesystem!
 
-use core::prelude::*;
-use core::{os, str};
-use core::os::getenv;
-use core::io::{file_reader, Reader};
-use path = core::path::Path;
+use std::{os, str};
+use std::os::getenv;
+use std::io::{file_reader, Reader};
+use path = std::path::Path;
 
 /// Return path to database entry for `term`
 pub fn get_dbpath_for_term(term: &str) -> Option<~path> {
diff --git a/src/libextra/terminfo/terminfo.rs b/src/libextra/terminfo/terminfo.rs
index 141a5b6bf7f..0e0231ad3f4 100644
--- a/src/libextra/terminfo/terminfo.rs
+++ b/src/libextra/terminfo/terminfo.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::hashmap::HashMap;
+use std::hashmap::HashMap;
 
 /// A parsed terminfo entry.
 pub struct TermInfo {
diff --git a/src/libextra/test.rs b/src/libextra/test.rs
index 50ca96e6e21..886bb9293bb 100644
--- a/src/libextra/test.rs
+++ b/src/libextra/test.rs
@@ -15,7 +15,6 @@
 // simplest interface possible for representing and running tests
 // while providing a base that other test frameworks may build off of.
 
-use core::prelude::*;
 
 use getopts;
 use sort;
@@ -23,22 +22,22 @@ use stats::Stats;
 use term;
 use time::precise_time_ns;
 
-use core::comm::{stream, SharedChan};
-use core::either;
-use core::io;
-use core::num;
-use core::option;
-use core::rand::RngUtil;
-use core::rand;
-use core::result;
-use core::task;
-use core::to_str::ToStr;
-use core::u64;
-use core::uint;
-use core::vec;
+use std::comm::{stream, SharedChan};
+use std::either;
+use std::io;
+use std::num;
+use std::option;
+use std::rand::RngUtil;
+use std::rand;
+use std::result;
+use std::task;
+use std::to_str::ToStr;
+use std::u64;
+use std::uint;
+use std::vec;
 
 pub mod rustrt {
-    use core::libc::size_t;
+    use std::libc::size_t;
 
     #[abi = "cdecl"]
     pub extern {
@@ -573,7 +572,7 @@ pub fn run_test(force_ignore: bool,
     fn run_test_inner(desc: TestDesc,
                       monitor_ch: SharedChan<MonitorMsg>,
                       testfn: ~fn()) {
-        let testfn_cell = ::core::cell::Cell::new(testfn);
+        let testfn_cell = ::std::cell::Cell::new(testfn);
         do task::spawn {
             let mut result_future = None; // task::future_result(builder);
 
@@ -781,10 +780,10 @@ mod tests {
                StaticTestName, DynTestName, DynTestFn};
     use test::{TestOpts, run_test};
 
-    use core::either;
-    use core::comm::{stream, SharedChan};
-    use core::option;
-    use core::vec;
+    use std::either;
+    use std::comm::{stream, SharedChan};
+    use std::option;
+    use std::vec;
 
     #[test]
     pub fn do_not_run_ignored_tests() {
diff --git a/src/libextra/time.rs b/src/libextra/time.rs
index 931a42d3c53..e1f42934b39 100644
--- a/src/libextra/time.rs
+++ b/src/libextra/time.rs
@@ -10,12 +10,11 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::i32;
-use core::int;
-use core::io;
-use core::str;
+use std::i32;
+use std::int;
+use std::io;
+use std::str;
 
 static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
 
@@ -862,11 +861,11 @@ priv fn do_strftime(format: &str, tm: &Tm) -> ~str {
 mod tests {
     use time::*;
 
-    use core::float;
-    use core::os;
-    use core::result;
-    use core::result::{Err, Ok};
-    use core::str;
+    use std::float;
+    use std::os;
+    use std::result;
+    use std::result::{Err, Ok};
+    use std::str;
 
     fn test_get_time() {
         static some_recent_date: i64 = 1325376000i64; // 2012-01-01T00:00:00Z
diff --git a/src/libextra/timer.rs b/src/libextra/timer.rs
index e23f9113319..d957ac43801 100644
--- a/src/libextra/timer.rs
+++ b/src/libextra/timer.rs
@@ -10,18 +10,17 @@
 
 //! Utilities that leverage libuv's `uv_timer_*` API
 
-use core::prelude::*;
 
 use uv;
 use uv::iotask;
 use uv::iotask::IoTask;
 
-use core::cast::transmute;
-use core::cast;
-use core::comm::{stream, Chan, SharedChan, Port, select2i};
-use core::either;
-use core::libc::c_void;
-use core::libc;
+use std::cast::transmute;
+use std::cast;
+use std::comm::{stream, Chan, SharedChan, Port, select2i};
+use std::either;
+use std::libc::c_void;
+use std::libc;
 
 /**
  * Wait for timeout period then send provided value over a channel
@@ -111,7 +110,7 @@ pub fn sleep(iotask: &IoTask, msecs: uint) {
  *
  * * `iotask' - `uv::iotask` that the tcp request will run on
  * * msecs - an mount of time, in milliseconds, to wait to receive
- * * wait_port - a `core::comm::port<T>` to receive on
+ * * wait_port - a `std::comm::port<T>` to receive on
  *
  * # Returns
  *
@@ -176,16 +175,15 @@ extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) {
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use timer::*;
     use uv;
 
-    use core::cell::Cell;
-    use core::pipes::{stream, SharedChan};
-    use core::rand::RngUtil;
-    use core::rand;
-    use core::task;
+    use std::cell::Cell;
+    use std::pipes::{stream, SharedChan};
+    use std::rand::RngUtil;
+    use std::rand;
+    use std::task;
 
     #[test]
     fn test_gl_timer_simple_sleep_test() {
@@ -223,7 +221,7 @@ mod test {
                 let ch = ch.clone();
                 let hl_loop_clone = hl_loop.clone();
                 do task::spawn {
-                    use core::rand::*;
+                    use std::rand::*;
                     let mut rng = rng();
                     for times.times {
                         sleep(&hl_loop_clone, rng.next() as uint % maxms);
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
index fcee3a2b796..5e898f8e59d 100644
--- a/src/libextra/treemap.rs
+++ b/src/libextra/treemap.rs
@@ -12,10 +12,9 @@
 //! trees. The only requirement for the types is that the key implements
 //! `TotalOrd`.
 
-use core::prelude::*;
 
-use core::uint;
-use core::util::{swap, replace};
+use std::uint;
+use std::util::{swap, replace};
 
 // This is implemented as an AA tree, which is a simplified variation of
 // a red-black tree where red (horizontal) nodes can only be added
@@ -689,12 +688,11 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
 
 #[cfg(test)]
 mod test_treemap {
-    use core::prelude::*;
 
     use super::*;
 
-    use core::rand::RngUtil;
-    use core::rand;
+    use std::rand::RngUtil;
+    use std::rand;
 
     #[test]
     fn find_empty() {
@@ -1010,7 +1008,6 @@ mod test_treemap {
 
 #[cfg(test)]
 mod test_set {
-    use core::prelude::*;
 
     use super::*;
 
diff --git a/src/libextra/uv_global_loop.rs b/src/libextra/uv_global_loop.rs
index f1dde1b8cb4..5501d73ac86 100644
--- a/src/libextra/uv_global_loop.rs
+++ b/src/libextra/uv_global_loop.rs
@@ -10,16 +10,15 @@
 
 //! A process-wide libuv event loop for library use.
 
-use core::prelude::*;
 
 use iotask = uv_iotask;
 use uv_iotask::{IoTask, spawn_iotask};
 
-use core::comm::Chan;
-use core::option::{Some, None};
-use core::task::task;
-use core::unstable::global::{global_data_clone_create, global_data_clone};
-use core::unstable::weak_task::weaken_task;
+use std::comm::Chan;
+use std::option::{Some, None};
+use std::task::task;
+use std::unstable::global::{global_data_clone_create, global_data_clone};
+use std::unstable::weak_task::weaken_task;
 
 /**
  * Race-free helper to get access to a global task where a libuv
@@ -126,11 +125,11 @@ mod test {
     use uv::ll;
     use uv_iotask::IoTask;
 
-    use core::libc;
-    use core::task;
-    use core::cast::transmute;
-    use core::libc::c_void;
-    use core::comm::{stream, SharedChan, Chan};
+    use std::libc;
+    use std::task;
+    use std::cast::transmute;
+    use std::libc::c_void;
+    use std::comm::{stream, SharedChan, Chan};
 
     extern fn simple_timer_close_cb(timer_ptr: *ll::uv_timer_t) {
         unsafe {
diff --git a/src/libextra/uv_iotask.rs b/src/libextra/uv_iotask.rs
index 817dfa28aee..0a564045d32 100644
--- a/src/libextra/uv_iotask.rs
+++ b/src/libextra/uv_iotask.rs
@@ -17,14 +17,13 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 use ll = uv_ll;
 
-use core::comm::{stream, Port, Chan, SharedChan};
-use core::libc::c_void;
-use core::libc;
-use core::task;
+use std::comm::{stream, Port, Chan, SharedChan};
+use std::libc::c_void;
+use std::libc;
+use std::task;
 
 /// Used to abstract-away direct interaction with a libuv loop.
 pub struct IoTask {
@@ -226,7 +225,7 @@ struct AhData {
 
 #[cfg(test)]
 fn impl_uv_iotask_async(iotask: &IoTask) {
-    use core::ptr;
+    use std::ptr;
 
     let async_handle = ll::async_t();
     let ah_ptr: *ll::uv_async_t = &async_handle;
diff --git a/src/libextra/uv_ll.rs b/src/libextra/uv_ll.rs
index 58b477d4ccf..db960f334fd 100644
--- a/src/libextra/uv_ll.rs
+++ b/src/libextra/uv_ll.rs
@@ -33,14 +33,13 @@
 #[allow(non_camel_case_types)]; // C types
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::libc::{c_void, size_t};
-use core::libc;
-use core::ptr::to_unsafe_ptr;
-use core::ptr;
-use core::str;
-use core::vec;
+use std::libc::{c_void, size_t};
+use std::libc;
+use std::ptr::to_unsafe_ptr;
+use std::ptr;
+use std::str;
+use std::vec;
 
 pub type uv_handle_t = c_void;
 pub type uv_loop_t = c_void;
@@ -362,7 +361,7 @@ pub struct uv_getaddrinfo_t {
 
 pub mod uv_ll_struct_stubgen {
 
-    use core::ptr;
+    use std::ptr;
 
     use super::{
         uv_async_t,
@@ -1228,16 +1227,15 @@ pub unsafe fn addrinfo_as_sockaddr_in6(input: *addrinfo) -> *sockaddr_in6 {
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use super::*;
 
-    use core::comm::{SharedChan, stream, GenericChan, GenericPort};
-    use core::libc;
-    use core::str;
-    use core::sys;
-    use core::task;
-    use core::vec;
+    use std::comm::{SharedChan, stream, GenericChan, GenericPort};
+    use std::libc;
+    use std::str;
+    use std::sys;
+    use std::task;
+    use std::vec;
 
     enum tcp_read_data {
         tcp_read_eof,
diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs
index 4d4f3c3a49b..503bd05b733 100644
--- a/src/libextra/workcache.rs
+++ b/src/libextra/workcache.rs
@@ -10,7 +10,6 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 use digest::DigestUtil;
 use json;
@@ -18,17 +17,17 @@ use sha1::Sha1;
 use serialize::{Encoder, Encodable, Decoder, Decodable};
 use sort;
 
-use core::cell::Cell;
-use core::cmp;
-use core::comm::{PortOne, oneshot, send_one, recv_one};
-use core::either::{Either, Left, Right};
-use core::hashmap::HashMap;
-use core::io;
-use core::result;
-use core::run;
-use core::task;
-use core::to_bytes;
-use core::util::replace;
+use std::cell::Cell;
+use std::cmp;
+use std::comm::{PortOne, oneshot, send_one, recv_one};
+use std::either::{Either, Left, Right};
+use std::hashmap::HashMap;
+use std::io;
+use std::result;
+use std::run;
+use std::task;
+use std::to_bytes;
+use std::util::replace;
 
 /**
 *
@@ -403,7 +402,7 @@ fn unwrap<T:Send +
 
 //#[test]
 fn test() {
-    use core::io::WriterUtil;
+    use std::io::WriterUtil;
 
     let db = @mut Database { db_filename: Path("db.json"),
                              db_cache: HashMap::new(),