about summary refs log tree commit diff
path: root/src/libstd
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd')
-rw-r--r--src/libstd/ascii.rs6
-rw-r--r--src/libstd/collections/hash/set.rs2
-rw-r--r--src/libstd/dynamic_lib.rs6
-rw-r--r--src/libstd/io/buffered.rs4
-rw-r--r--src/libstd/io/comm_adapters.rs2
-rw-r--r--src/libstd/io/extensions.rs4
-rw-r--r--src/libstd/io/fs.rs4
-rw-r--r--src/libstd/io/mem.rs4
-rw-r--r--src/libstd/io/mod.rs4
-rw-r--r--src/libstd/io/net/ip.rs4
-rw-r--r--src/libstd/io/stdio.rs4
-rw-r--r--src/libstd/macros.rs2
-rw-r--r--src/libstd/num/strconv.rs4
-rw-r--r--src/libstd/os.rs10
-rw-r--r--src/libstd/path/mod.rs6
-rw-r--r--src/libstd/path/posix.rs6
-rw-r--r--src/libstd/path/windows.rs4
-rw-r--r--src/libstd/prelude.rs13
-rw-r--r--src/libstd/rand/os.rs4
-rw-r--r--src/libstd/rand/reader.rs2
-rw-r--r--src/libstd/rt/backtrace.rs10
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)]
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-03-13 01:32:20 +0000