diff --git a/src/etc/unicode.py b/src/etc/unicode.py
index 52e02febd96c1..fb003f47c3e43 100755
--- a/src/etc/unicode.py
+++ b/src/etc/unicode.py
@@ -293,7 +293,7 @@ def emit_bsearch_range_table(f):
f.write("""
fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
use core::cmp::{Equal, Less, Greater};
- use core::slice::ImmutableSlice;
+ use core::slice::SlicePrelude;
r.binary_search(|&(lo,hi)| {
if lo <= c && c <= hi { Equal }
else if hi < c { Less }
@@ -351,7 +351,7 @@ def emit_conversions_module(f, lowerupper, upperlower):
f.write("pub mod conversions {")
f.write("""
use core::cmp::{Equal, Less, Greater};
- use core::slice::ImmutableSlice;
+ use core::slice::SlicePrelude;
use core::tuple::Tuple2;
use core::option::{Option, Some, None};
use core::slice;
@@ -390,7 +390,7 @@ def emit_conversions_module(f, lowerupper, upperlower):
def emit_grapheme_module(f, grapheme_table, grapheme_cats):
f.write("""pub mod grapheme {
- use core::slice::ImmutableSlice;
+ use core::slice::SlicePrelude;
use core::slice;
#[allow(non_camel_case_types)]
@@ -430,7 +430,7 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
def emit_charwidth_module(f, width_table):
f.write("pub mod charwidth {\n")
f.write(" use core::option::{Option, Some, None};\n")
- f.write(" use core::slice::ImmutableSlice;\n")
+ f.write(" use core::slice::SlicePrelude;\n")
f.write(" use core::slice;\n")
f.write("""
fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {
@@ -530,7 +530,7 @@ def comp_pfun(char):
f.write("""
fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
use core::cmp::{Equal, Less, Greater};
- use core::slice::ImmutableSlice;
+ use core::slice::SlicePrelude;
use core::slice;
match r.binary_search(|&(lo, hi, _)| {
if lo <= c && c <= hi { Equal }
diff --git a/src/libcollections/hash/mod.rs b/src/libcollections/hash/mod.rs
index 6c1a4019bd83f..43faaac39523c 100644
--- a/src/libcollections/hash/mod.rs
+++ b/src/libcollections/hash/mod.rs
@@ -290,7 +290,7 @@ mod tests {
use core::kinds::Sized;
use std::mem;
- use slice::ImmutableSlice;
+ use slice::SlicePrelude;
use super::{Hash, Hasher, Writer};
struct MyWriterHasher;
diff --git a/src/libcollections/hash/sip.rs b/src/libcollections/hash/sip.rs
index dd105c44ad336..788ea13678f31 100644
--- a/src/libcollections/hash/sip.rs
+++ b/src/libcollections/hash/sip.rs
@@ -273,7 +273,7 @@ mod tests {
use str::Str;
use string::String;
- use slice::{AsSlice, ImmutableSlice};
+ use slice::{AsSlice, SlicePrelude};
use vec::Vec;
use super::super::{Hash, Writer};
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index e4af5795e1cc9..0d9a166c7ff96 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -42,10 +42,10 @@
//!
//! ## Traits
//!
-//! A number of traits add methods that allow you to accomplish tasks with slices.
-//! These traits include `ImmutableSlice`, which is defined for `&[T]` types,
-//! `MutableSlice`, defined for `&mut [T]` types, and `Slice` and `SliceMut`
-//! which are defined for `[T]`.
+//! A number of traits add methods that allow you to accomplish tasks
+//! with slices, the most important being `SlicePrelude`. Other traits
+//! apply only to slices of elements satisfying certain bounds (like
+//! `Ord`).
//!
//! An example is the `slice` method which enables slicing syntax `[a..b]` that
//! returns an immutable "view" into a `Vec` or another slice from the index
@@ -99,11 +99,11 @@ use core::iter::{range_step, MultiplicativeIterator};
use vec::Vec;
-pub use core::slice::{Chunks, AsSlice, ImmutableSlice, ImmutablePartialEqSlice};
-pub use core::slice::{ImmutableOrdSlice, MutableSlice, Items, MutItems};
+pub use core::slice::{Chunks, AsSlice, SlicePrelude, PartialEqSlicePrelude};
+pub use core::slice::{OrdSlicePrelude, SlicePrelude, Items, MutItems};
pub use core::slice::{ImmutableIntSlice, MutableIntSlice};
pub use core::slice::{MutSplits, MutChunks, Splits};
-pub use core::slice::{bytes, mut_ref_slice, ref_slice, MutableCloneableSlice};
+pub use core::slice::{bytes, mut_ref_slice, ref_slice, CloneSlicePrelude};
pub use core::slice::{Found, NotFound};
// Functional utilities
@@ -266,29 +266,13 @@ impl<T: Clone> Iterator<Vec<T>> for Permutations<T> {
}
}
-/// Extension methods for vector slices with cloneable elements
-pub trait CloneableVector<T> for Sized? {
- /// Copies `self` into a new `Vec`.
- fn to_vec(&self) -> Vec<T>;
-}
-
-impl<T: Clone> CloneableVector<T> for [T] {
- /// Returns a copy of `v`.
- #[inline]
- fn to_vec(&self) -> Vec<T> {
- let mut vector = Vec::with_capacity(self.len());
- vector.push_all(self);
- vector
- }
-}
-
-#[experimental]
-pub trait BoxedSlice<T> {
+/// Extension methods for boxed slices.
+pub trait BoxedSlicePrelude<T> {
/// Convert `self` into a vector without clones or allocation.
fn into_vec(self) -> Vec<T>;
}
-impl<T> BoxedSlice<T> for Box<[T]> {
+impl<T> BoxedSlicePrelude<T> for Box<[T]> {
#[experimental]
fn into_vec(mut self) -> Vec<T> {
unsafe {
@@ -299,8 +283,11 @@ impl<T> BoxedSlice<T> for Box<[T]> {
}
}
-/// Extension methods for vectors containing `Clone` elements.
-pub trait ImmutableCloneableVector<T> for Sized? {
+/// Allocating extension methods for slices containing `Clone` elements.
+pub trait CloneSliceAllocPrelude<T> for Sized? {
+ /// Copies `self` into a new `Vec`.
+ fn to_vec(&self) -> Vec<T>;
+
/// Partitions the vector into two vectors `(a, b)`, where all
/// elements of `a` satisfy `f` and all elements of `b` do not.
fn partitioned(&self, f: |&T| -> bool) -> (Vec<T>, Vec<T>);
@@ -332,7 +319,16 @@ pub trait ImmutableCloneableVector<T> for Sized? {
fn permutations(&self) -> Permutations<T>;
}
-impl<T: Clone> ImmutableCloneableVector<T> for [T] {
+impl<T: Clone> CloneSliceAllocPrelude<T> for [T] {
+ /// Returns a copy of `v`.
+ #[inline]
+ fn to_vec(&self) -> Vec<T> {
+ let mut vector = Vec::with_capacity(self.len());
+ vector.push_all(self);
+ vector
+ }
+
+
#[inline]
fn partitioned(&self, f: |&T| -> bool) -> (Vec<T>, Vec<T>) {
let mut lefts = Vec::new();
@@ -562,9 +558,36 @@ fn merge_sort<T>(v: &mut [T], compare: |&T, &T| -> Ordering) {
}
}
-/// Extension methods for vectors such that their elements are
-/// mutable.
-pub trait MutableSliceAllocating<T> for Sized? {
+/// Allocating extension methods for slices on Ord values.
+#[experimental = "likely to merge with other traits"]
+pub trait OrdSliceAllocPrelude<T> for Sized? {
+ /// Sorts the slice, in place.
+ ///
+ /// This is equivalent to `self.sort_by(|a, b| a.cmp(b))`.
+ ///
+ /// # Example
+ ///
+ /// ```rust
+ /// let mut v = [-5i, 4, 1, -3, 2];
+ ///
+ /// v.sort();
+ /// assert!(v == [-5i, -3, 1, 2, 4]);
+ /// ```
+ #[experimental]
+ fn sort(&mut self);
+}
+
+impl<T: Ord> OrdSliceAllocPrelude<T> for [T] {
+ #[experimental]
+ #[inline]
+ fn sort(&mut self) {
+ self.sort_by(|a, b| a.cmp(b))
+ }
+}
+
+/// Allocating extension methods for slices.
+#[experimental = "likely to merge with other traits"]
+pub trait SliceAllocPrelude<T> for Sized? {
/// Sorts the slice, in place, using `compare` to compare
/// elements.
///
@@ -608,7 +631,7 @@ pub trait MutableSliceAllocating<T> for Sized? {
fn move_from(&mut self, src: Vec<T>, start: uint, end: uint) -> uint;
}
-impl<T> MutableSliceAllocating<T> for [T] {
+impl<T> SliceAllocPrelude<T> for [T] {
#[inline]
fn sort_by(&mut self, compare: |&T, &T| -> Ordering) {
merge_sort(self, compare)
@@ -623,127 +646,6 @@ impl<T> MutableSliceAllocating<T> for [T] {
}
}
-/// Methods for mutable vectors with orderable elements, such as
-/// in-place sorting.
-pub trait MutableOrdSlice<T> for Sized? {
- /// Sorts the slice, in place.
- ///
- /// This is equivalent to `self.sort_by(|a, b| a.cmp(b))`.
- ///
- /// # Example
- ///
- /// ```rust
- /// let mut v = [-5i, 4, 1, -3, 2];
- ///
- /// v.sort();
- /// assert!(v == [-5i, -3, 1, 2, 4]);
- /// ```
- fn sort(&mut self);
-
- /// Mutates the slice to the next lexicographic permutation.
- ///
- /// Returns `true` if successful and `false` if the slice is at the
- /// last-ordered permutation.
- ///
- /// # Example
- ///
- /// ```rust
- /// let v: &mut [_] = &mut [0i, 1, 2];
- /// v.next_permutation();
- /// let b: &mut [_] = &mut [0i, 2, 1];
- /// assert!(v == b);
- /// v.next_permutation();
- /// let b: &mut [_] = &mut [1i, 0, 2];
- /// assert!(v == b);
- /// ```
- fn next_permutation(&mut self) -> bool;
-
- /// Mutates the slice to the previous lexicographic permutation.
- ///
- /// Returns `true` if successful and `false` if the slice is at the
- /// first-ordered permutation.
- ///
- /// # Example
- ///
- /// ```rust
- /// let v: &mut [_] = &mut [1i, 0, 2];
- /// v.prev_permutation();
- /// let b: &mut [_] = &mut [0i, 2, 1];
- /// assert!(v == b);
- /// v.prev_permutation();
- /// let b: &mut [_] = &mut [0i, 1, 2];
- /// assert!(v == b);
- /// ```
- fn prev_permutation(&mut self) -> bool;
-}
-
-impl<T: Ord> MutableOrdSlice<T> for [T] {
- #[inline]
- fn sort(&mut self) {
- self.sort_by(|a, b| a.cmp(b))
- }
-
- fn next_permutation(&mut self) -> bool {
- // These cases only have 1 permutation each, so we can't do anything.
- if self.len() < 2 { return false; }
-
- // Step 1: Identify the longest, rightmost weakly decreasing part of the vector
- let mut i = self.len() - 1;
- while i > 0 && self[i-1] >= self[i] {
- i -= 1;
- }
-
- // If that is the entire vector, this is the last-ordered permutation.
- if i == 0 {
- return false;
- }
-
- // Step 2: Find the rightmost element larger than the pivot (i-1)
- let mut j = self.len() - 1;
- while j >= i && self[j] <= self[i-1] {
- j -= 1;
- }
-
- // Step 3: Swap that element with the pivot
- self.swap(j, i-1);
-
- // Step 4: Reverse the (previously) weakly decreasing part
- self[mut i..].reverse();
-
- true
- }
-
- fn prev_permutation(&mut self) -> bool {
- // These cases only have 1 permutation each, so we can't do anything.
- if self.len() < 2 { return false; }
-
- // Step 1: Identify the longest, rightmost weakly increasing part of the vector
- let mut i = self.len() - 1;
- while i > 0 && self[i-1] <= self[i] {
- i -= 1;
- }
-
- // If that is the entire vector, this is the first-ordered permutation.
- if i == 0 {
- return false;
- }
-
- // Step 2: Reverse the weakly increasing part
- self[mut i..].reverse();
-
- // Step 3: Find the rightmost element equal to or bigger than the pivot (i-1)
- let mut j = self.len() - 1;
- while j >= i && self[j-1] < self[i-1] {
- j -= 1;
- }
-
- // Step 4: Swap that element with the pivot
- self.swap(i-1, j);
-
- true
- }
-}
-
/// Unsafe operations
pub mod raw {
pub use core::slice::raw::{buf_as_slice, mut_buf_as_slice};
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index cdca0d10eedde..ac840503aa2af 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -56,8 +56,8 @@ use core::fmt;
use core::cmp;
use core::iter::AdditiveIterator;
use core::kinds::Sized;
-use core::prelude::{Char, Clone, Eq, Equiv, ImmutableSlice};
-use core::prelude::{Iterator, MutableSlice, None, Option, Ord, Ordering};
+use core::prelude::{Char, Clone, Eq, Equiv};
+use core::prelude::{Iterator, SlicePrelude, None, Option, Ord, Ordering};
use core::prelude::{PartialEq, PartialOrd, Result, AsSlice, Some, Tuple2};
use core::prelude::{range};
@@ -73,8 +73,8 @@ pub use core::str::{CharSplitsN, AnyLines, MatchIndices, StrSplits};
pub use core::str::{Utf16CodeUnits, eq_slice, is_utf8, is_utf16, Utf16Items};
pub use core::str::{Utf16Item, ScalarValue, LoneSurrogate, utf16_items};
pub use core::str::{truncate_utf16_at_nul, utf8_char_width, CharRange};
-pub use core::str::{Str, StrSlice};
-pub use unicode::str::{UnicodeStrSlice, Words, Graphemes, GraphemeIndices};
+pub use core::str::{Str, StrPrelude};
+pub use unicode::str::{UnicodeStrPrelude, Words, Graphemes, GraphemeIndices};
/*
Section: Creating a string
@@ -790,10 +790,10 @@ mod tests {
use std::iter::{Iterator, DoubleEndedIterator};
use super::*;
- use std::slice::{AsSlice, ImmutableSlice};
+ use std::slice::{AsSlice, SlicePrelude};
use string::String;
use vec::Vec;
- use slice::CloneableVector;
+ use slice::CloneSliceAllocPrelude;
use unicode::char::UnicodeChar;
@@ -2240,8 +2240,8 @@ mod bench {
use test::black_box;
use super::*;
use std::iter::{Iterator, DoubleEndedIterator};
- use std::str::StrSlice;
- use std::slice::ImmutableSlice;
+ use std::str::StrPrelude;
+ use std::slice::SlicePrelude;
#[bench]
fn char_iterator(b: &mut Bencher) {
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index b3c83ba55598b..b32760818b7c2 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -23,7 +23,7 @@ use core::ops;
use core::raw::Slice as RawSlice;
use hash;
-use slice::CloneableVector;
+use slice::CloneSliceAllocPrelude;
use str;
use str::{CharRange, StrAllocating, MaybeOwned, Owned};
use str::Slice as MaybeOwnedSlice; // So many `Slice`s...
@@ -815,7 +815,7 @@ pub mod raw {
/// * A raw pointer is dereferenced and transmuted to `&[u8]`;
/// * The slice is not checked to see whether it contains valid UTF-8.
pub unsafe fn from_buf_len(buf: *const u8, len: uint) -> String {
- use slice::CloneableVector;
+ use slice::CloneSliceAllocPrelude;
let slice: &[u8] = mem::transmute(Slice {
data: buf,
len: len,
@@ -851,10 +851,10 @@ mod tests {
use test::Bencher;
use str;
- use str::{Str, StrSlice, Owned};
+ use str::{Str, StrPrelude, Owned};
use super::{as_string, String};
use vec::Vec;
- use slice::CloneableVector;
+ use slice::CloneSliceAllocPrelude;
#[test]
fn test_as_string() {
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 4b6921ed0c0d9..39f636a2438aa 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -27,7 +27,7 @@ use core::ptr;
use core::raw::Slice as RawSlice;
use core::uint;
-use slice::{CloneableVector};
+use slice::{CloneSliceAllocPrelude};
/// An owned, growable vector.
///
@@ -1389,7 +1389,7 @@ pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> {
pub mod raw {
use super::Vec;
use core::ptr;
- use core::slice::MutableSlice;
+ use core::slice::SlicePrelude;
/// Constructs a vector from an unsafe pointer to a buffer.
///
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 0fab0e96fe61c..f769eea377a18 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -18,7 +18,7 @@
use mem::transmute;
use option::{None, Option, Some};
use iter::range_step;
-use slice::ImmutableSlice;
+use slice::SlicePrelude;
// UTF-8 ranges and tags for encoding characters
static TAG_CONT: u8 = 0b1000_0000u8;
diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
index f51d3948757c7..a6e5b0cff5592 100644
--- a/src/libcore/fmt/float.rs
+++ b/src/libcore/fmt/float.rs
@@ -16,8 +16,8 @@ use iter::{range, DoubleEndedIterator};
use num::{Float, FPNaN, FPInfinite, ToPrimitive, Primitive};
use num::{Zero, One, cast};
use result::Ok;
-use slice::{mod, ImmutableSlice, MutableSlice};
-use str::StrSlice;
+use slice::{mod, SlicePrelude};
+use str::StrPrelude;
/// A flag that specifies whether to use exponential (scientific) notation.
pub enum ExponentFormat {
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 013ed999b032b..081f373b8310c 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -21,9 +21,9 @@ use option::{Option, Some, None};
use ops::Deref;
use result::{Ok, Err};
use result;
-use slice::{AsSlice, ImmutableSlice};
+use slice::{AsSlice, SlicePrelude};
use slice;
-use str::StrSlice;
+use str::StrPrelude;
use str;
pub use self::num::radix;
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 190e1ecea5921..e4a6c1a97584f 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -17,7 +17,7 @@
use fmt;
use iter::DoubleEndedIterator;
use num::{Int, cast, zero};
-use slice::{ImmutableSlice, MutableSlice};
+use slice::SlicePrelude;
/// A type that represents a specific radix
#[doc(hidden)]
diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
index 4b08d4f339118..996f2e56ad35e 100644
--- a/src/libcore/prelude.rs
+++ b/src/libcore/prelude.rs
@@ -57,9 +57,9 @@ pub use num::{Primitive, Int, ToPrimitive, FromPrimitive};
pub use option::{Option, Some, None};
pub use ptr::RawPtr;
pub use result::{Result, Ok, Err};
-pub use str::{Str, StrSlice};
+pub use str::{Str, StrPrelude};
pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4};
pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8};
pub use tuple::{Tuple9, Tuple10, Tuple11, Tuple12};
-pub use slice::{ImmutablePartialEqSlice, ImmutableOrdSlice};
-pub use slice::{AsSlice, ImmutableSlice, MutableSlice};
+pub use slice::{PartialEqSlicePrelude, OrdSlicePrelude};
+pub use slice::{AsSlice, SlicePrelude};
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 3cc904162a134..eaa52c99c4a23 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -57,9 +57,9 @@ use raw::Slice as RawSlice;
// Extension traits
//
-/// Extension methods for immutable slices.
-#[unstable = "may merge with other traits; region parameter may disappear"]
-pub trait ImmutableSlice<T> for Sized? {
+/// Extension methods for slices.
+#[unstable = "may merge with other traits"]
+pub trait SlicePrelude<T> for Sized? {
/// Returns a subslice spanning the interval [`start`, `end`).
///
/// Fails when the end of the new slice lies beyond the end of the
@@ -256,216 +256,12 @@ pub trait ImmutableSlice<T> for Sized? {
#[inline]
#[experimental = "not triaged yet"]
fn is_empty(&self) -> bool { self.len() == 0 }
-}
-
-#[unstable]
-impl<T> ImmutableSlice<T> for [T] {
- #[inline]
- fn slice(&self, start: uint, end: uint) -> &[T] {
- assert!(start <= end);
- assert!(end <= self.len());
- unsafe {
- transmute(RawSlice {
- data: self.as_ptr().offset(start as int),
- len: (end - start)
- })
- }
- }
-
- #[inline]
- fn slice_from(&self, start: uint) -> &[T] {
- self.slice(start, self.len())
- }
-
- #[inline]
- fn slice_to(&self, end: uint) -> &[T] {
- self.slice(0, end)
- }
-
- #[inline]
- fn split_at(&self, mid: uint) -> (&[T], &[T]) {
- (self[..mid], self[mid..])
- }
-
- #[inline]
- fn iter<'a>(&'a self) -> Items<'a, T> {
- unsafe {
- let p = self.as_ptr();
- if mem::size_of::<T>() == 0 {
- Items{ptr: p,
- end: (p as uint + self.len()) as *const T,
- marker: marker::ContravariantLifetime::<'a>}
- } else {
- Items{ptr: p,
- end: p.offset(self.len() as int),
- marker: marker::ContravariantLifetime::<'a>}
- }
- }
- }
-
- #[inline]
- fn split<'a>(&'a self, pred: |&T|: 'a -> bool) -> Splits<'a, T> {
- Splits {
- v: self,
- pred: pred,
- finished: false
- }
- }
- #[inline]
- fn splitn<'a>(&'a self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<Splits<'a, T>> {
- SplitsN {
- iter: self.split(pred),
- count: n,
- invert: false
- }
- }
-
- #[inline]
- fn rsplitn<'a>(&'a self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<Splits<'a, T>> {
- SplitsN {
- iter: self.split(pred),
- count: n,
- invert: true
- }
- }
-
- #[inline]
- fn windows(&self, size: uint) -> Windows<T> {
- assert!(size != 0);
- Windows { v: self, size: size }
- }
-
- #[inline]
- fn chunks(&self, size: uint) -> Chunks<T> {
- assert!(size != 0);
- Chunks { v: self, size: size }
- }
-
- #[inline]
- fn get(&self, index: uint) -> Option<&T> {
- if index < self.len() { Some(&self[index]) } else { None }
- }
-
- #[inline]
- fn head(&self) -> Option<&T> {
- if self.len() == 0 { None } else { Some(&self[0]) }
- }
-
- #[inline]
- fn tail(&self) -> &[T] { self[1..] }
-
- #[inline]
- fn init(&self) -> &[T] {
- self[..self.len() - 1]
- }
-
- #[inline]
- fn last(&self) -> Option<&T> {
- if self.len() == 0 { None } else { Some(&self[self.len() - 1]) }
- }
-
- #[inline]
- unsafe fn unsafe_get(&self, index: uint) -> &T {
- transmute(self.repr().data.offset(index as int))
- }
-
- #[inline]
- fn as_ptr(&self) -> *const T {
- self.repr().data
- }
-
- #[unstable]
- fn binary_search(&self, f: |&T| -> Ordering) -> BinarySearchResult {
- let mut base : uint = 0;
- let mut lim : uint = self.len();
-
- while lim != 0 {
- let ix = base + (lim >> 1);
- match f(&self[ix]) {
- Equal => return Found(ix),
- Less => {
- base = ix + 1;
- lim -= 1;
- }
- Greater => ()
- }
- lim >>= 1;
- }
- return NotFound(base);
- }
-
- #[inline]
- fn len(&self) -> uint { self.repr().len }
-}
-
-
-
-impl<T> ops::Slice<uint, [T]> for [T] {
- #[inline]
- fn as_slice_<'a>(&'a self) -> &'a [T] {
- self
- }
-
- #[inline]
- fn slice_from_or_fail<'a>(&'a self, start: &uint) -> &'a [T] {
- self.slice_or_fail(start, &self.len())
- }
-
- #[inline]
- fn slice_to_or_fail<'a>(&'a self, end: &uint) -> &'a [T] {
- self.slice_or_fail(&0, end)
- }
- #[inline]
- fn slice_or_fail<'a>(&'a self, start: &uint, end: &uint) -> &'a [T] {
- assert!(*start <= *end);
- assert!(*end <= self.len());
- unsafe {
- transmute(RawSlice {
- data: self.as_ptr().offset(*start as int),
- len: (*end - *start)
- })
- }
- }
-}
-
-impl<T> ops::SliceMut<uint, [T]> for [T] {
- #[inline]
- fn as_mut_slice_<'a>(&'a mut self) -> &'a mut [T] {
- self
- }
-
- #[inline]
- fn slice_from_or_fail_mut<'a>(&'a mut self, start: &uint) -> &'a mut [T] {
- let len = &self.len();
- self.slice_or_fail_mut(start, len)
- }
-
- #[inline]
- fn slice_to_or_fail_mut<'a>(&'a mut self, end: &uint) -> &'a mut [T] {
- self.slice_or_fail_mut(&0, end)
- }
- #[inline]
- fn slice_or_fail_mut<'a>(&'a mut self, start: &uint, end: &uint) -> &'a mut [T] {
- assert!(*start <= *end);
- assert!(*end <= self.len());
- unsafe {
- transmute(RawSlice {
- data: self.as_ptr().offset(*start as int),
- len: (*end - *start)
- })
- }
- }
-}
-
-/// Extension methods for slices such that their elements are
-/// mutable.
-#[experimental = "may merge with other traits; may lose region param; needs review"]
-pub trait MutableSlice<T> for Sized? {
/// Returns a mutable reference to the element at the given index,
/// or `None` if the index is out of bounds
#[unstable = "waiting on final error conventions"]
fn get_mut<'a>(&'a mut self, index: uint) -> Option<&'a mut T>;
+
/// Work with `self` as a mut slice.
/// Primarily intended for getting a &mut [T] from a [T, ..N].
fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T];
@@ -626,8 +422,146 @@ pub trait MutableSlice<T> for Sized? {
fn as_mut_ptr(&mut self) -> *mut T;
}
-#[experimental = "trait is experimental"]
-impl<T> MutableSlice<T> for [T] {
+#[unstable]
+impl<T> SlicePrelude<T> for [T] {
+ #[inline]
+ fn slice(&self, start: uint, end: uint) -> &[T] {
+ assert!(start <= end);
+ assert!(end <= self.len());
+ unsafe {
+ transmute(RawSlice {
+ data: self.as_ptr().offset(start as int),
+ len: (end - start)
+ })
+ }
+ }
+
+ #[inline]
+ fn slice_from(&self, start: uint) -> &[T] {
+ self.slice(start, self.len())
+ }
+
+ #[inline]
+ fn slice_to(&self, end: uint) -> &[T] {
+ self.slice(0, end)
+ }
+
+ #[inline]
+ fn split_at(&self, mid: uint) -> (&[T], &[T]) {
+ (self[..mid], self[mid..])
+ }
+
+ #[inline]
+ fn iter<'a>(&'a self) -> Items<'a, T> {
+ unsafe {
+ let p = self.as_ptr();
+ if mem::size_of::<T>() == 0 {
+ Items{ptr: p,
+ end: (p as uint + self.len()) as *const T,
+ marker: marker::ContravariantLifetime::<'a>}
+ } else {
+ Items{ptr: p,
+ end: p.offset(self.len() as int),
+ marker: marker::ContravariantLifetime::<'a>}
+ }
+ }
+ }
+
+ #[inline]
+ fn split<'a>(&'a self, pred: |&T|: 'a -> bool) -> Splits<'a, T> {
+ Splits {
+ v: self,
+ pred: pred,
+ finished: false
+ }
+ }
+
+ #[inline]
+ fn splitn<'a>(&'a self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<Splits<'a, T>> {
+ SplitsN {
+ iter: self.split(pred),
+ count: n,
+ invert: false
+ }
+ }
+
+ #[inline]
+ fn rsplitn<'a>(&'a self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<Splits<'a, T>> {
+ SplitsN {
+ iter: self.split(pred),
+ count: n,
+ invert: true
+ }
+ }
+
+ #[inline]
+ fn windows(&self, size: uint) -> Windows<T> {
+ assert!(size != 0);
+ Windows { v: self, size: size }
+ }
+
+ #[inline]
+ fn chunks(&self, size: uint) -> Chunks<T> {
+ assert!(size != 0);
+ Chunks { v: self, size: size }
+ }
+
+ #[inline]
+ fn get(&self, index: uint) -> Option<&T> {
+ if index < self.len() { Some(&self[index]) } else { None }
+ }
+
+ #[inline]
+ fn head(&self) -> Option<&T> {
+ if self.len() == 0 { None } else { Some(&self[0]) }
+ }
+
+ #[inline]
+ fn tail(&self) -> &[T] { self[1..] }
+
+ #[inline]
+ fn init(&self) -> &[T] {
+ self[..self.len() - 1]
+ }
+
+ #[inline]
+ fn last(&self) -> Option<&T> {
+ if self.len() == 0 { None } else { Some(&self[self.len() - 1]) }
+ }
+
+ #[inline]
+ unsafe fn unsafe_get(&self, index: uint) -> &T {
+ transmute(self.repr().data.offset(index as int))
+ }
+
+ #[inline]
+ fn as_ptr(&self) -> *const T {
+ self.repr().data
+ }
+
+ #[unstable]
+ fn binary_search(&self, f: |&T| -> Ordering) -> BinarySearchResult {
+ let mut base : uint = 0;
+ let mut lim : uint = self.len();
+
+ while lim != 0 {
+ let ix = base + (lim >> 1);
+ match f(&self[ix]) {
+ Equal => return Found(ix),
+ Less => {
+ base = ix + 1;
+ lim -= 1;
+ }
+ Greater => ()
+ }
+ lim >>= 1;
+ }
+ return NotFound(base);
+ }
+
+ #[inline]
+ fn len(&self) -> uint { self.repr().len }
+
#[inline]
fn get_mut(&mut self, index: uint) -> Option<&mut T> {
if index < self.len() { Some(&mut self[index]) } else { None }
@@ -764,9 +698,66 @@ impl<T> MutableSlice<T> for [T] {
}
}
+impl<T> ops::Slice<uint, [T]> for [T] {
+ #[inline]
+ fn as_slice_<'a>(&'a self) -> &'a [T] {
+ self
+ }
+
+ #[inline]
+ fn slice_from_or_fail<'a>(&'a self, start: &uint) -> &'a [T] {
+ self.slice_or_fail(start, &self.len())
+ }
+
+ #[inline]
+ fn slice_to_or_fail<'a>(&'a self, end: &uint) -> &'a [T] {
+ self.slice_or_fail(&0, end)
+ }
+ #[inline]
+ fn slice_or_fail<'a>(&'a self, start: &uint, end: &uint) -> &'a [T] {
+ assert!(*start <= *end);
+ assert!(*end <= self.len());
+ unsafe {
+ transmute(RawSlice {
+ data: self.as_ptr().offset(*start as int),
+ len: (*end - *start)
+ })
+ }
+ }
+}
+
+impl<T> ops::SliceMut<uint, [T]> for [T] {
+ #[inline]
+ fn as_mut_slice_<'a>(&'a mut self) -> &'a mut [T] {
+ self
+ }
+
+ #[inline]
+ fn slice_from_or_fail_mut<'a>(&'a mut self, start: &uint) -> &'a mut [T] {
+ let len = &self.len();
+ self.slice_or_fail_mut(start, len)
+ }
+
+ #[inline]
+ fn slice_to_or_fail_mut<'a>(&'a mut self, end: &uint) -> &'a mut [T] {
+ self.slice_or_fail_mut(&0, end)
+ }
+ #[inline]
+ fn slice_or_fail_mut<'a>(&'a mut self, start: &uint, end: &uint) -> &'a mut [T] {
+ assert!(*start <= *end);
+ assert!(*end <= self.len());
+ unsafe {
+ transmute(RawSlice {
+ data: self.as_ptr().offset(*start as int),
+ len: (*end - *start)
+ })
+ }
+ }
+}
+
/// Extension methods for slices containing `PartialEq` elements.
#[unstable = "may merge with other traits"]
-pub trait ImmutablePartialEqSlice<T: PartialEq> for Sized? {
+pub trait PartialEqSlicePrelude<T: PartialEq> for Sized? {
/// Find the first index containing a matching value.
fn position_elem(&self, t: &T) -> Option<uint>;
@@ -784,7 +775,7 @@ pub trait ImmutablePartialEqSlice<T: PartialEq> for Sized? {
}
#[unstable = "trait is unstable"]
-impl<T: PartialEq> ImmutablePartialEqSlice<T> for [T] {
+impl<T: PartialEq> PartialEqSlicePrelude<T> for [T] {
#[inline]
fn position_elem(&self, x: &T) -> Option<uint> {
self.iter().position(|y| *x == *y)
@@ -815,7 +806,7 @@ impl<T: PartialEq> ImmutablePartialEqSlice<T> for [T] {
/// Extension methods for slices containing `Ord` elements.
#[unstable = "may merge with other traits"]
-pub trait ImmutableOrdSlice<T: Ord> for Sized? {
+pub trait OrdSlicePrelude<T: Ord> for Sized? {
/// Binary search a sorted slice for a given element.
///
/// If the value is found then `Found` is returned, containing the
@@ -842,19 +833,119 @@ pub trait ImmutableOrdSlice<T: Ord> for Sized? {
/// ```
#[unstable = "name likely to change"]
fn binary_search_elem(&self, x: &T) -> BinarySearchResult;
+
+ /// Mutates the slice to the next lexicographic permutation.
+ ///
+ /// Returns `true` if successful and `false` if the slice is at the
+ /// last-ordered permutation.
+ ///
+ /// # Example
+ ///
+ /// ```rust
+ /// let v: &mut [_] = &mut [0i, 1, 2];
+ /// v.next_permutation();
+ /// let b: &mut [_] = &mut [0i, 2, 1];
+ /// assert!(v == b);
+ /// v.next_permutation();
+ /// let b: &mut [_] = &mut [1i, 0, 2];
+ /// assert!(v == b);
+ /// ```
+ #[experimental]
+ fn next_permutation(&mut self) -> bool;
+
+ /// Mutates the slice to the previous lexicographic permutation.
+ ///
+ /// Returns `true` if successful and `false` if the slice is at the
+ /// first-ordered permutation.
+ ///
+ /// # Example
+ ///
+ /// ```rust
+ /// let v: &mut [_] = &mut [1i, 0, 2];
+ /// v.prev_permutation();
+ /// let b: &mut [_] = &mut [0i, 2, 1];
+ /// assert!(v == b);
+ /// v.prev_permutation();
+ /// let b: &mut [_] = &mut [0i, 1, 2];
+ /// assert!(v == b);
+ /// ```
+ #[experimental]
+ fn prev_permutation(&mut self) -> bool;
}
#[unstable = "trait is unstable"]
-impl<T: Ord> ImmutableOrdSlice<T> for [T] {
+impl<T: Ord> OrdSlicePrelude<T> for [T] {
#[unstable]
fn binary_search_elem(&self, x: &T) -> BinarySearchResult {
self.binary_search(|p| p.cmp(x))
}
+
+ #[experimental]
+ fn next_permutation(&mut self) -> bool {
+ // These cases only have 1 permutation each, so we can't do anything.
+ if self.len() < 2 { return false; }
+
+ // Step 1: Identify the longest, rightmost weakly decreasing part of the vector
+ let mut i = self.len() - 1;
+ while i > 0 && self[i-1] >= self[i] {
+ i -= 1;
+ }
+
+ // If that is the entire vector, this is the last-ordered permutation.
+ if i == 0 {
+ return false;
+ }
+
+ // Step 2: Find the rightmost element larger than the pivot (i-1)
+ let mut j = self.len() - 1;
+ while j >= i && self[j] <= self[i-1] {
+ j -= 1;
+ }
+
+ // Step 3: Swap that element with the pivot
+ self.swap(j, i-1);
+
+ // Step 4: Reverse the (previously) weakly decreasing part
+ self[mut i..].reverse();
+
+ true
+ }
+
+ #[experimental]
+ fn prev_permutation(&mut self) -> bool {
+ // These cases only have 1 permutation each, so we can't do anything.
+ if self.len() < 2 { return false; }
+
+ // Step 1: Identify the longest, rightmost weakly increasing part of the vector
+ let mut i = self.len() - 1;
+ while i > 0 && self[i-1] <= self[i] {
+ i -= 1;
+ }
+
+ // If that is the entire vector, this is the first-ordered permutation.
+ if i == 0 {
+ return false;
+ }
+
+ // Step 2: Reverse the weakly increasing part
+ self[mut i..].reverse();
+
+ // Step 3: Find the rightmost element equal to or bigger than the pivot (i-1)
+ let mut j = self.len() - 1;
+ while j >= i && self[j-1] < self[i-1] {
+ j -= 1;
+ }
+
+ // Step 4: Swap that element with the pivot
+ self.swap(i-1, j);
+
+ true
+ }
}
-/// Trait for &[T] where T is Cloneable
+/// Extension methods for slices on Clone elements
#[unstable = "may merge with other traits"]
-pub trait MutableCloneableSlice<T> for Sized? {
+pub trait CloneSlicePrelude<T> for Sized? {
/// Copies as many elements from `src` as it can into `self` (the
/// shorter of `self.len()` and `src.len()`). Returns the number
/// of elements copied.
@@ -862,7 +953,7 @@ pub trait MutableCloneableSlice<T> for Sized? {
/// # Example
///
/// ```rust
- /// use std::slice::MutableCloneableSlice;
+ /// use std::slice::CloneSlicePrelude;
///
/// let mut dst = [0i, 0, 0];
/// let src = [1i, 2];
@@ -878,7 +969,7 @@ pub trait MutableCloneableSlice<T> for Sized? {
}
#[unstable = "trait is unstable"]
-impl<T: Clone> MutableCloneableSlice<T> for [T] {
+impl<T: Clone> CloneSlicePrelude<T> for [T] {
#[inline]
fn clone_from_slice(&mut self, src: &[T]) -> uint {
let min = cmp::min(self.len(), src.len());
@@ -1517,7 +1608,7 @@ pub mod raw {
pub mod bytes {
use kinds::Sized;
use ptr;
- use slice::{ImmutableSlice, MutableSlice};
+ use slice::SlicePrelude;
/// A trait for operations on mutable `[u8]`s.
pub trait MutableByteVector for Sized? {
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 175f9f3f5771c..4c1bfb6170907 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -28,8 +28,7 @@ use kinds::Sized;
use num::{CheckedMul, Saturating};
use option::{Option, None, Some};
use raw::Repr;
-use slice::ImmutableSlice;
-use slice;
+use slice::{mod, SlicePrelude};
use uint;
/*
@@ -1056,8 +1055,8 @@ pub mod raw {
use mem;
use ptr::RawPtr;
use raw::Slice;
- use slice::{ImmutableSlice};
- use str::{is_utf8, StrSlice};
+ use slice::SlicePrelude;
+ use str::{is_utf8, StrPrelude};
/// Converts a slice of bytes to a string slice without checking
/// that the string contains valid UTF-8.
@@ -1120,7 +1119,7 @@ pub mod traits {
use iter::Iterator;
use option::{Option, Some};
use ops;
- use str::{Str, StrSlice, eq_slice};
+ use str::{Str, StrPrelude, eq_slice};
// NOTE(stage0): remove impl after a snapshot
#[cfg(stage0)]
@@ -1240,7 +1239,7 @@ impl<'a> Str for &'a str {
}
/// Methods for string slices
-pub trait StrSlice for Sized? {
+pub trait StrPrelude for Sized? {
/// Returns true if one string contains another
///
/// # Arguments
@@ -1891,7 +1890,7 @@ fn slice_error_fail(s: &str, begin: uint, end: uint) -> ! {
begin, end, s);
}
-impl StrSlice for str {
+impl StrPrelude for str {
#[inline]
fn contains(&self, needle: &str) -> bool {
self.find_str(needle).is_some()
diff --git a/src/libgraphviz/maybe_owned_vec.rs b/src/libgraphviz/maybe_owned_vec.rs
index 3a89d8b3f81cd..2c516affeb274 100644
--- a/src/libgraphviz/maybe_owned_vec.rs
+++ b/src/libgraphviz/maybe_owned_vec.rs
@@ -12,7 +12,7 @@ use std::default::Default;
use std::fmt;
use std::iter::FromIterator;
use std::path::BytesContainer;
-use std::slice;
+use std::slice::{mod, Permutations};
// Note 1: It is not clear whether the flexibility of providing both
// the `Growable` and `FixedLen` variants is sufficiently useful.
@@ -137,11 +137,19 @@ impl<'a,T:fmt::Show> fmt::Show for MaybeOwnedVector<'a,T> {
}
}
-impl<'a,T:Clone> CloneableVector<T> for MaybeOwnedVector<'a,T> {
+impl<'a,T:Clone> CloneSliceAllocPrelude<T> for MaybeOwnedVector<'a,T> {
/// Returns a copy of `self`.
fn to_vec(&self) -> Vec<T> {
self.as_slice().to_vec()
}
+
+ fn partitioned(&self, f: |&T| -> bool) -> (Vec<T>, Vec<T>) {
+ self.as_slice().partitioned(f)
+ }
+
+ fn permutations(&self) -> Permutations<T> {
+ self.as_slice().permutations()
+ }
}
impl<'a, T: Clone> Clone for MaybeOwnedVector<'a, T> {
@@ -153,7 +161,6 @@ impl<'a, T: Clone> Clone for MaybeOwnedVector<'a, T> {
}
}
-
impl<'a, T> Default for MaybeOwnedVector<'a, T> {
fn default() -> MaybeOwnedVector<'a, T> {
Growable(Vec::new())
diff --git a/src/libnative/io/process.rs b/src/libnative/io/process.rs
index fed4a46b9df7f..30c916f330346 100644
--- a/src/libnative/io/process.rs
+++ b/src/libnative/io/process.rs
@@ -296,7 +296,7 @@ fn spawn_process_os(cfg: ProcessConfig,
use std::mem;
use std::iter::Iterator;
- use std::str::StrSlice;
+ use std::str::StrPrelude;
if cfg.gid.is_some() || cfg.uid.is_some() {
return Err(IoError {
diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs
index ce06828e7643f..aa18a65dc58bb 100644
--- a/src/libregex/vm.rs
+++ b/src/libregex/vm.rs
@@ -35,7 +35,7 @@
use std::cmp;
use std::mem;
-use std::slice::MutableSlice;
+use std::slice::SlicePrelude;
use compile::{
Program,
Match, OneChar, CharClass, Any, EmptyBegin, EmptyEnd, EmptyWordBoundary,
diff --git a/src/librlibc/lib.rs b/src/librlibc/lib.rs
index dd88eb3251b63..128243187757a 100644
--- a/src/librlibc/lib.rs
+++ b/src/librlibc/lib.rs
@@ -108,8 +108,8 @@ pub unsafe extern "C" fn memcmp(s1: *const u8, s2: *const u8, n: uint) -> i32 {
#[cfg(test)]
mod test {
- use core::str::StrSlice;
- use core::slice::{MutableSlice, ImmutableSlice};
+ use core::str::StrPrelude;
+ use core::slice::{SlicePrelude};
use super::{memcmp, memset, memcpy, memmove};
diff --git a/src/librustrt/args.rs b/src/librustrt/args.rs
index 20a63f655b8ff..5eecc0a53e048 100644
--- a/src/librustrt/args.rs
+++ b/src/librustrt/args.rs
@@ -47,7 +47,7 @@ mod imp {
use core::prelude::*;
use alloc::boxed::Box;
- use collections::slice::CloneableVector;
+ use collections::slice::CloneSliceAllocPrelude;
use collections::vec::Vec;
use core::mem;
use core::slice;
diff --git a/src/librustrt/c_str.rs b/src/librustrt/c_str.rs
index b7a2c8f947341..68c2d2031c48d 100644
--- a/src/librustrt/c_str.rs
+++ b/src/librustrt/c_str.rs
@@ -76,9 +76,9 @@ use collections::hash;
use core::fmt;
use core::kinds::{Sized, marker};
use core::mem;
-use core::prelude::{Clone, Drop, Eq, ImmutableSlice, Iterator};
-use core::prelude::{MutableSlice, None, Option, Ordering, PartialEq};
-use core::prelude::{PartialOrd, RawPtr, Some, StrSlice, range};
+use core::prelude::{Clone, Drop, Eq, Iterator};
+use core::prelude::{SlicePrelude, None, Option, Ordering, PartialEq};
+use core::prelude::{PartialOrd, RawPtr, Some, StrPrelude, range};
use core::ptr;
use core::raw::Slice;
use core::slice;
diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index 2953b60e674eb..ff83027d28008 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 688036d22dd6e..cde862a1d1741 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 4c133fc739739..e3dfa8cabee3f 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 49c688da31cbf..f5c6c15857aec 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 c925208c3eee7..6b4a952f90942 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 6d0b8ebc3d9c4..07aa25bc044a5 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 c8524676a6dd4..c95d2c3f328b7 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 6010436581764..51935862600d0 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 ebf541a63dafa..da5286b16ae11 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 b4e9f7502e47c..2a2d978ef495b 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 5fd4faff6d250..7bae67c0aa6b6 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 55e364b1961a2..d82147947de65 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 7a02d8d77b0b1..612090a3a51f2 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 9846f7b653e2b..0042a3ae20592 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 8949a881c9de6..e55933c426242 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 60cfa7a13de94..a927e09184036 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 3ef142a2e824c..c5f84244928b7 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 4dcdde6726a0f..449d3a14bc977 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 b7b0858123042..b6b66e593a2da 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 c1bb6970f7150..c8ed980521542 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 5d7aa0509c5d8..b08b92b8587b6 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)]
diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs
index b84aec77a09c3..0db0ffd5cb4ed 100644
--- a/src/libunicode/lib.rs
+++ b/src/libunicode/lib.rs
@@ -73,7 +73,7 @@ pub mod char {
}
pub mod str {
- pub use u_str::{UnicodeStrSlice, Words, Graphemes, GraphemeIndices};
+ pub use u_str::{UnicodeStrPrelude, Words, Graphemes, GraphemeIndices};
}
// this lets us use #[deriving(Clone)]
diff --git a/src/libunicode/normalize.rs b/src/libunicode/normalize.rs
index 76a9476d1fc8d..ad36215c11bcb 100644
--- a/src/libunicode/normalize.rs
+++ b/src/libunicode/normalize.rs
@@ -16,7 +16,7 @@
use core::cmp::{Equal, Less, Greater};
use core::option::{Option, Some, None};
use core::slice;
-use core::slice::ImmutableSlice;
+use core::slice::SlicePrelude;
use tables::normalization::{canonical_table, compatibility_table, composition_table};
fn bsearch_table<T>(c: char, r: &'static [(char, &'static [T])]) -> Option<&'static [T]> {
diff --git a/src/libunicode/tables.rs b/src/libunicode/tables.rs
index 87ee3220ee583..212502fd18124 100644
--- a/src/libunicode/tables.rs
+++ b/src/libunicode/tables.rs
@@ -13,12 +13,12 @@
#![allow(missing_doc, non_uppercase_statics, non_snake_case)]
/// The version of [Unicode](http://www.unicode.org/)
-/// that the `UnicodeChar` and `UnicodeStrSlice` traits are based on.
+/// that the `UnicodeChar` and `UnicodeStrPrelude` traits are based on.
pub const UNICODE_VERSION: (uint, uint, uint) = (7, 0, 0);
fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
use core::cmp::{Equal, Less, Greater};
- use core::slice::ImmutableSlice;
+ use core::slice::SlicePrelude;
r.binary_search(|&(lo,hi)| {
if lo <= c && c <= hi { Equal }
else if hi < c { Less }
@@ -6242,7 +6242,7 @@ pub mod normalization {
fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
use core::cmp::{Equal, Less, Greater};
- use core::slice::ImmutableSlice;
+ use core::slice::SlicePrelude;
use core::slice;
match r.binary_search(|&(lo, hi, _)| {
if lo <= c && c <= hi { Equal }
@@ -6367,7 +6367,7 @@ pub mod normalization {
pub mod conversions {
use core::cmp::{Equal, Less, Greater};
- use core::slice::ImmutableSlice;
+ use core::slice::SlicePrelude;
use core::tuple::Tuple2;
use core::option::{Option, Some, None};
use core::slice;
@@ -6935,7 +6935,7 @@ pub mod conversions {
pub mod charwidth {
use core::option::{Option, Some, None};
- use core::slice::ImmutableSlice;
+ use core::slice::SlicePrelude;
use core::slice;
fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {
@@ -7134,7 +7134,7 @@ pub mod charwidth {
}
pub mod grapheme {
- use core::slice::ImmutableSlice;
+ use core::slice::SlicePrelude;
use core::slice;
#[allow(non_camel_case_types)]
diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs
index 9e3830c1f6090..50f257c9c859e 100644
--- a/src/libunicode/u_str.rs
+++ b/src/libunicode/u_str.rs
@@ -18,11 +18,11 @@
*/
use core::cmp;
-use core::slice::ImmutableSlice;
+use core::slice::SlicePrelude;
use core::iter::{Filter, AdditiveIterator, Iterator, DoubleEndedIterator};
use core::kinds::Sized;
use core::option::{Option, None, Some};
-use core::str::{CharSplits, StrSlice};
+use core::str::{CharSplits, StrPrelude};
use u_char;
use u_char::UnicodeChar;
use tables::grapheme::GraphemeCat;
@@ -32,7 +32,7 @@ pub type Words<'a> =
Filter<'a, &'a str, CharSplits<'a, extern "Rust" fn(char) -> bool>>;
/// Methods for Unicode string slices
-pub trait UnicodeStrSlice for Sized? {
+pub trait UnicodeStrPrelude for Sized? {
/// Returns an iterator over the
/// [grapheme clusters](http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries)
/// of the string.
@@ -129,7 +129,7 @@ pub trait UnicodeStrSlice for Sized? {
fn trim_right<'a>(&'a self) -> &'a str;
}
-impl UnicodeStrSlice for str {
+impl UnicodeStrPrelude for str {
#[inline]
fn graphemes(&self, is_extended: bool) -> Graphemes {
Graphemes { string: self, extended: is_extended, cat: None, catb: None }