Prelude: rename and consolidate extension traits

This commit renames a number of extension traits for slices and string
slices, now that they have been refactored for DST. In many cases,
multiple extension traits could now be consolidated. Further
consolidation will be possible with generalized where clauses.

The renamings are consistent with the [new `-Prelude`
suffix](https://github.com/rust-lang/rfcs/pull/344). There are probably
a few more candidates for being renamed this way, but that is left for
API stabilization of the relevant modules.

Because this renames traits, it is a:

[breaking-change]

However, I do not expect any code that currently uses the standard
library to actually break.

Closes #17917

21 files changed, 51 insertions, 54 deletions

diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index 2953b60e674..ff83027d280 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -19,8 +19,8 @@ use fmt;
 use iter::Iterator;
 use mem;
 use option::{Option, Some, None};
-use slice::{ImmutableSlice, MutableSlice, AsSlice};
-use str::{Str, StrSlice};
+use slice::{SlicePrelude, AsSlice};
+use str::{Str, StrPrelude};
 use string::{mod, String};
 use to_string::IntoStr;
 use vec::Vec;
@@ -578,7 +578,7 @@ mod tests {
     use prelude::*;
     use super::*;
     use char::from_u32;
-    use str::StrSlice;
+    use str::StrPrelude;
 
     macro_rules! v2ascii (
         ( [$($e:expr),*]) => (&[$(Ascii{chr:$e}),*]);
diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index 688036d22dd..cde862a1d17 100644
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -594,7 +594,7 @@ mod test_set {
     use prelude::*;
 
     use super::HashSet;
-    use slice::ImmutablePartialEqSlice;
+    use slice::PartialEqSlicePrelude;
 
     #[test]
     fn test_disjoint() {
diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs
index 4c133fc7397..e3dfa8cabee 100644
--- a/src/libstd/dynamic_lib.rs
+++ b/src/libstd/dynamic_lib.rs
@@ -28,7 +28,7 @@ use option::*;
 use os;
 use path::{Path,GenericPath};
 use result::*;
-use slice::{AsSlice,ImmutableSlice};
+use slice::{AsSlice,SlicePrelude};
 use str;
 use string::String;
 use vec::Vec;
@@ -284,8 +284,8 @@ pub mod dl {
     use os;
     use ptr;
     use result::{Ok, Err, Result};
-    use slice::ImmutableSlice;
-    use str::StrSlice;
+    use slice::SlicePrelude;
+    use str::StrPrelude;
     use str;
     use string::String;
     use vec::Vec;
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 49c688da31c..f5c6c15857a 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -18,7 +18,7 @@ use iter::ExactSize;
 use ops::Drop;
 use option::{Some, None, Option};
 use result::{Ok, Err};
-use slice::{ImmutableSlice, MutableSlice};
+use slice::{SlicePrelude};
 use slice;
 use vec::Vec;
 
@@ -376,7 +376,7 @@ mod test {
     use super::super::{IoResult, EndOfFile};
     use super::super::mem::{MemReader, MemWriter, BufReader};
     use self::test::Bencher;
-    use str::StrSlice;
+    use str::StrPrelude;
 
     /// A type, free to create, primarily intended for benchmarking creation of
     /// wrappers that, just for construction, don't need a Reader/Writer that
diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index c925208c3ee..6b4a952f909 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -14,7 +14,7 @@ use comm::{Sender, Receiver};
 use io;
 use option::{None, Some};
 use result::{Ok, Err};
-use slice::{bytes, CloneableVector, ImmutableSlice};
+use slice::{bytes, CloneSliceAllocPrelude, SlicePrelude};
 use super::{Buffer, Reader, Writer, IoResult};
 use vec::Vec;
 
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 6d0b8ebc3d9..07aa25bc044 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -22,7 +22,7 @@ use num::Int;
 use option::{Option, Some, None};
 use ptr::RawPtr;
 use result::{Ok, Err};
-use slice::{ImmutableSlice, AsSlice};
+use slice::{SlicePrelude, AsSlice};
 
 /// An iterator that reads a single byte on each iteration,
 /// until `.read_byte()` returns `EndOfFile`.
@@ -150,7 +150,7 @@ pub fn u64_to_be_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
 ///           32-bit value is parsed.
 pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
     use ptr::{copy_nonoverlapping_memory};
-    use slice::MutableSlice;
+    use slice::SlicePrelude;
 
     assert!(size <= 8u);
 
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index c8524676a6d..c95d2c3f328 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -70,7 +70,7 @@ use path;
 use result::{Err, Ok};
 use rt::rtio::LocalIo;
 use rt::rtio;
-use slice::ImmutableSlice;
+use slice::SlicePrelude;
 use string::String;
 use vec::Vec;
 
@@ -951,7 +951,7 @@ mod test {
     use path::Path;
     use io;
     use ops::Drop;
-    use str::StrSlice;
+    use str::StrPrelude;
 
     macro_rules! check( ($e:expr) => (
         match $e {
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 60104365817..51935862600 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -17,7 +17,7 @@ use option::None;
 use result::{Err, Ok};
 use io;
 use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
-use slice::{mod, AsSlice, ImmutableSlice};
+use slice::{mod, AsSlice, SlicePrelude};
 use vec::Vec;
 
 const BUF_CAPACITY: uint = 128;
@@ -341,7 +341,7 @@ mod test {
     use io::*;
     use io;
     use self::test::Bencher;
-    use str::StrSlice;
+    use str::StrPrelude;
 
     #[test]
     fn test_mem_writer() {
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index ebf541a63da..da5286b16ae 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -236,8 +236,8 @@ use os;
 use boxed::Box;
 use result::{Ok, Err, Result};
 use rt::rtio;
-use slice::{AsSlice, ImmutableSlice};
-use str::{Str, StrSlice};
+use slice::{AsSlice, SlicePrelude};
+use str::{Str, StrPrelude};
 use str;
 use string::String;
 use uint;
diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs
index b4e9f7502e4..2a2d978ef49 100644
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -22,8 +22,8 @@ use io::net;
 use iter::Iterator;
 use option::{Option, None, Some};
 use result::{Ok, Err};
-use str::StrSlice;
-use slice::{MutableCloneableSlice, MutableSlice, ImmutableSlice};
+use str::StrPrelude;
+use slice::{CloneSlicePrelude, SlicePrelude};
 use vec::Vec;
 
 pub type Port = u16;
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index 5fd4faff6d2..7bae67c0aa6 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -41,8 +41,8 @@ use rt;
 use rt::local::Local;
 use rt::task::Task;
 use rt::rtio::{DontClose, IoFactory, LocalIo, RtioFileStream, RtioTTY};
-use slice::ImmutableSlice;
-use str::StrSlice;
+use slice::SlicePrelude;
+use str::StrPrelude;
 use uint;
 
 // And so begins the tale of acquiring a uv handle to a stdio stream on all
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index 55e364b1961..d82147947de 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -330,7 +330,7 @@ macro_rules! try (
 #[macro_export]
 macro_rules! vec[
     ($($x:expr),*) => ({
-        use std::slice::BoxedSlice;
+        use std::slice::BoxedSlicePrelude;
         let xs: ::std::boxed::Box<[_]> = box [$($x),*];
         xs.into_vec()
     });
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index 7a02d8d77b0..612090a3a51 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -20,8 +20,8 @@ use num;
 use num::{Int, Bounded};
 use num::{Float, FPNaN, FPInfinite, ToPrimitive};
 use option::{None, Option, Some};
-use slice::{ImmutableSlice, MutableSlice, CloneableVector};
-use str::StrSlice;
+use slice::{SlicePrelude, CloneSliceAllocPrelude};
+use str::StrPrelude;
 use string::String;
 use vec::Vec;
 
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 9846f7b653e..0042a3ae205 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -46,9 +46,9 @@ use path::{Path, GenericPath, BytesContainer};
 use ptr::RawPtr;
 use ptr;
 use result::{Err, Ok, Result};
-use slice::{AsSlice, ImmutableSlice, MutableSlice, ImmutablePartialEqSlice};
-use slice::CloneableVector;
-use str::{Str, StrSlice, StrAllocating};
+use slice::{AsSlice, SlicePrelude, PartialEqSlicePrelude};
+use slice::CloneSliceAllocPrelude;
+use str::{Str, StrPrelude, StrAllocating};
 use string::String;
 use to_string::ToString;
 use sync::atomic::{AtomicInt, INIT_ATOMIC_INT, SeqCst};
@@ -146,9 +146,9 @@ pub mod windows {
     use option::{None, Option};
     use option;
     use os::TMPBUF_SZ;
-    use slice::{MutableSlice, ImmutableSlice};
+    use slice::{SlicePrelude};
     use string::String;
-    use str::StrSlice;
+    use str::StrPrelude;
     use vec::Vec;
 
     pub fn fill_utf16_buf_and_decode(f: |*mut u16, DWORD| -> DWORD)
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 8949a881c9d..e55933c4262 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -74,10 +74,10 @@ use fmt;
 use iter::Iterator;
 use option::{Option, None, Some};
 use str;
-use str::{MaybeOwned, Str, StrSlice};
+use str::{MaybeOwned, Str, StrPrelude};
 use string::String;
-use slice::{AsSlice, CloneableVector};
-use slice::{ImmutablePartialEqSlice, ImmutableSlice};
+use slice::{AsSlice, CloneSliceAllocPrelude};
+use slice::{PartialEqSlicePrelude, SlicePrelude};
 use vec::Vec;
 
 /// Typedef for POSIX file paths.
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 60cfa7a13de..a927e091840 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -20,8 +20,8 @@ use iter::{DoubleEndedIterator, AdditiveIterator, Extendable, Iterator, Map};
 use option::{Option, None, Some};
 use str::Str;
 use str;
-use slice::{CloneableVector, Splits, AsSlice, VectorVector,
-            ImmutablePartialEqSlice, ImmutableSlice};
+use slice::{CloneSliceAllocPrelude, Splits, AsSlice, VectorVector,
+            PartialEqSlicePrelude, SlicePrelude};
 use vec::Vec;
 
 use super::{BytesContainer, GenericPath, GenericPathUnsafe};
@@ -444,7 +444,7 @@ mod tests {
     use super::*;
     use mem;
     use str;
-    use str::StrSlice;
+    use str::StrPrelude;
 
     macro_rules! t(
         (s: $path:expr, $exp:expr) => (
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 3ef142a2e82..c5f84244928 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -22,8 +22,8 @@ use io::Writer;
 use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Iterator, Map};
 use mem;
 use option::{Option, Some, None};
-use slice::{AsSlice, ImmutableSlice};
-use str::{CharSplits, Str, StrAllocating, StrVector, StrSlice};
+use slice::{AsSlice, SlicePrelude};
+use str::{CharSplits, Str, StrAllocating, StrVector, StrPrelude};
 use string::String;
 use unicode::char::UnicodeChar;
 use vec::Vec;
diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs
index 4dcdde6726a..449d3a14bc9 100644
--- a/src/libstd/prelude.rs
+++ b/src/libstd/prelude.rs
@@ -76,18 +76,15 @@
 #[doc(no_inline)] pub use ptr::{RawPtr, RawMutPtr};
 #[doc(no_inline)] pub use result::{Result, Ok, Err};
 #[doc(no_inline)] pub use io::{Buffer, Writer, Reader, Seek};
-#[doc(no_inline)] pub use str::{Str, StrVector, StrSlice};
-#[doc(no_inline)] pub use str::{IntoMaybeOwned, StrAllocating, UnicodeStrSlice};
+#[doc(no_inline)] pub use str::{Str, StrVector, StrPrelude};
+#[doc(no_inline)] pub use str::{IntoMaybeOwned, StrAllocating, UnicodeStrPrelude};
 #[doc(no_inline)] pub use to_string::{ToString, IntoStr};
 #[doc(no_inline)] pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4};
 #[doc(no_inline)] pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8};
 #[doc(no_inline)] pub use tuple::{Tuple9, Tuple10, Tuple11, Tuple12};
-#[doc(no_inline)] pub use slice::{CloneableVector, ImmutableCloneableVector};
-#[doc(no_inline)] pub use slice::{MutableCloneableSlice, MutableOrdSlice};
-#[doc(no_inline)] pub use slice::{ImmutableSlice, MutableSlice};
-#[doc(no_inline)] pub use slice::{ImmutablePartialEqSlice, ImmutableOrdSlice};
-#[doc(no_inline)] pub use slice::{AsSlice, VectorVector, BoxedSlice};
-#[doc(no_inline)] pub use slice::MutableSliceAllocating;
+#[doc(no_inline)] pub use slice::{SlicePrelude, AsSlice, CloneSlicePrelude};
+#[doc(no_inline)] pub use slice::{VectorVector, PartialEqSlicePrelude, OrdSlicePrelude};
+#[doc(no_inline)] pub use slice::{CloneSliceAllocPrelude, OrdSliceAllocPrelude, SliceAllocPrelude};
 #[doc(no_inline)] pub use string::String;
 #[doc(no_inline)] pub use vec::Vec;
 
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index b7b08581230..b6b66e593a2 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -69,7 +69,7 @@ mod imp {
     use rand::Rng;
     use result::{Ok};
     use self::libc::{c_int, size_t};
-    use slice::{ImmutableSlice, MutableSlice};
+    use slice::{SlicePrelude};
 
     /// A random number generator that retrieves randomness straight from
     /// the operating system. Platform sources:
@@ -137,7 +137,7 @@ mod imp {
     use result::{Ok, Err};
     use self::libc::{DWORD, BYTE, LPCSTR, BOOL};
     use self::libc::types::os::arch::extra::{LONG_PTR};
-    use slice::{ImmutableSlice, MutableSlice};
+    use slice::{SlicePrelude};
 
     type HCRYPTPROV = LONG_PTR;
 
diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs
index c1bb6970f71..c8ed9805215 100644
--- a/src/libstd/rand/reader.rs
+++ b/src/libstd/rand/reader.rs
@@ -13,7 +13,7 @@
 use io::Reader;
 use rand::Rng;
 use result::{Ok, Err};
-use slice::ImmutableSlice;
+use slice::SlicePrelude;
 
 /// An RNG that reads random bytes straight from a `Reader`. This will
 /// work best with an infinite reader, but this is not required.
diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index 5d7aa0509c5..b08b92b8587 100644
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -18,7 +18,7 @@ use iter::Iterator;
 use option::{Some, None};
 use os;
 use result::{Ok, Err};
-use str::StrSlice;
+use str::StrPrelude;
 use sync::atomic;
 use unicode::char::UnicodeChar;
 
@@ -255,7 +255,7 @@ mod imp {
     pub fn write(w: &mut Writer) -> IoResult<()> {
         use iter::{Iterator, range};
         use result;
-        use slice::{MutableSlice};
+        use slice::{SlicePrelude};
 
         extern {
             fn backtrace(buf: *mut *mut libc::c_void,
@@ -394,7 +394,7 @@ mod imp {
         use path::GenericPath;
         use ptr::RawPtr;
         use ptr;
-        use slice::{ImmutableSlice, MutableSlice};
+        use slice::{SlicePrelude};
 
         ////////////////////////////////////////////////////////////////////////
         // libbacktrace.h API
@@ -666,8 +666,8 @@ mod imp {
     use path::Path;
     use result::{Ok, Err};
     use rt::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
-    use slice::ImmutableSlice;
-    use str::StrSlice;
+    use slice::SlicePrelude;
+    use str::StrPrelude;
     use dynamic_lib::DynamicLibrary;
 
     #[allow(non_snake_case)]