Remove a slew of old deprecated functions

12 files changed, 9 insertions, 237 deletions

diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs
index e2934efa43b..c330d44dd96 100644
--- a/src/libcollections/bitv.rs
+++ b/src/libcollections/bitv.rs
@@ -13,7 +13,7 @@
 
 use std::cmp;
 use std::iter::RandomAccessIterator;
-use std::iter::{Rev, Enumerate, Repeat, Map, Zip};
+use std::iter::{Enumerate, Repeat, Map, Zip};
 use std::ops;
 use std::slice;
 use std::strbuf::StrBuf;
@@ -466,12 +466,6 @@ impl Bitv {
         Bits {bitv: self, next_idx: 0, end_idx: self.nbits}
     }
 
-    #[inline]
-    #[deprecated = "replaced by .iter().rev()"]
-    pub fn rev_iter<'a>(&'a self) -> Rev<Bits<'a>> {
-        self.iter().rev()
-    }
-
     /// Returns `true` if all bits are 0
     pub fn none(&self) -> bool {
       match self.rep {
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index 58ced1beeed..c5fa8286f7d 100644
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -21,7 +21,6 @@
 // Backlinks over DList::prev are raw pointers that form a full chain in
 // the reverse direction.
 
-use std::iter::Rev;
 use std::iter;
 use std::mem;
 use std::ptr;
@@ -369,12 +368,6 @@ impl<T> DList<T> {
         Items{nelem: self.len(), head: &self.list_head, tail: self.list_tail}
     }
 
-    #[inline]
-    #[deprecated = "replaced by .iter().rev()"]
-    pub fn rev_iter<'a>(&'a self) -> Rev<Items<'a, T>> {
-        self.iter().rev()
-    }
-
     /// Provide a forward iterator with mutable references
     #[inline]
     pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
@@ -390,24 +383,12 @@ impl<T> DList<T> {
         }
     }
 
-    #[inline]
-    #[deprecated = "replaced by .mut_iter().rev()"]
-    pub fn mut_rev_iter<'a>(&'a mut self) -> Rev<MutItems<'a, T>> {
-        self.mut_iter().rev()
-    }
-
 
     /// Consume the list into an iterator yielding elements by value
     #[inline]
     pub fn move_iter(self) -> MoveItems<T> {
         MoveItems{list: self}
     }
-
-    #[inline]
-    #[deprecated = "replaced by .move_iter().rev()"]
-    pub fn move_rev_iter(self) -> Rev<MoveItems<T>> {
-        self.move_iter().rev()
-    }
 }
 
 impl<T: TotalOrd> DList<T> {
diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs
index 12e4fa8b51f..f45c9685be5 100644
--- a/src/libcollections/ringbuf.rs
+++ b/src/libcollections/ringbuf.rs
@@ -14,7 +14,7 @@
 //! collections::deque::Deque`.
 
 use std::cmp;
-use std::iter::{Rev, RandomAccessIterator};
+use std::iter::RandomAccessIterator;
 
 use deque::Deque;
 
@@ -190,11 +190,6 @@ impl<T> RingBuf<T> {
         Items{index: 0, rindex: self.nelts, lo: self.lo, elts: self.elts.as_slice()}
     }
 
-    #[deprecated = "replaced by .iter().rev()"]
-    pub fn rev_iter<'a>(&'a self) -> Rev<Items<'a, T>> {
-        self.iter().rev()
-    }
-
     /// Front-to-back iterator which returns mutable values.
     pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
         let start_index = raw_index(self.lo, self.elts.len(), 0);
@@ -220,11 +215,6 @@ impl<T> RingBuf<T> {
                                  nelts: self.nelts }
         }
     }
-
-    #[deprecated = "replaced by .mut_iter().rev()"]
-    pub fn mut_rev_iter<'a>(&'a mut self) -> Rev<MutItems<'a, T>> {
-        self.mut_iter().rev()
-    }
 }
 
 /// RingBuf iterator
diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs
index fb02ddd6224..8e4e47405e7 100644
--- a/src/libcollections/smallintmap.rs
+++ b/src/libcollections/smallintmap.rs
@@ -15,7 +15,7 @@
 
 #![allow(missing_doc)]
 
-use std::iter::{Enumerate, FilterMap, Rev};
+use std::iter::{Enumerate, FilterMap};
 use std::mem::replace;
 use std::{vec, slice};
 
@@ -142,16 +142,6 @@ impl<V> SmallIntMap<V> {
         }
     }
 
-    #[deprecated = "replaced by .iter().rev()"]
-    pub fn rev_iter<'r>(&'r self) -> Rev<Entries<'r, V>> {
-        self.iter().rev()
-    }
-
-    #[deprecated = "replaced by .mut_iter().rev()"]
-    pub fn mut_rev_iter<'r>(&'r mut self) -> Rev<MutEntries<'r, V>> {
-        self.mut_iter().rev()
-    }
-
     /// Empties the hash map, moving all values into the specified closure
     pub fn move_iter(&mut self)
         -> FilterMap<(uint, Option<V>), (uint, V),
@@ -243,8 +233,6 @@ pub struct Entries<'a, T> {
 
 iterator!(impl Entries -> (uint, &'a T), get_ref)
 double_ended_iterator!(impl Entries -> (uint, &'a T), get_ref)
-#[deprecated = "replaced by Rev<Entries<'a, T>>"]
-pub type RevEntries<'a, T> = Rev<Entries<'a, T>>;
 
 pub struct MutEntries<'a, T> {
     front: uint,
@@ -254,8 +242,6 @@ pub struct MutEntries<'a, T> {
 
 iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
 double_ended_iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
-#[deprecated = "replaced by Rev<MutEntries<'a, T>"]
-pub type RevMutEntries<'a, T> = Rev<MutEntries<'a, T>>;
 
 #[cfg(test)]
 mod test_map {
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 755c6738b4a..3979a1ad8c8 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -386,9 +386,6 @@ pub trait ImmutableVector<'a, T> {
     fn slice_to(&self, end: uint) -> &'a [T];
     /// Returns an iterator over the vector
     fn iter(self) -> Items<'a, T>;
-    /// Returns a reversed iterator over a vector
-    #[deprecated = "replaced by .iter().rev()"]
-    fn rev_iter(self) -> Rev<Items<'a, T>>;
     /// Returns an iterator over the subslices of the vector which are
     /// separated by elements that match `pred`.  The matched element
     /// is not contained in the subslices.
@@ -399,12 +396,6 @@ pub trait ImmutableVector<'a, T> {
     /// the subslices.
     fn splitn(self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<'a, T>;
     /// Returns an iterator over the subslices of the vector which are
-    /// separated by elements that match `pred`. This starts at the
-    /// end of the vector and works backwards.  The matched element is
-    /// not contained in the subslices.
-    #[deprecated = "replaced by .split(pred).rev()"]
-    fn rsplit(self, pred: |&T|: 'a -> bool) -> Rev<Splits<'a, T>>;
-    /// Returns an iterator over the subslices of the vector which are
     /// separated by elements that match `pred` limited to splitting
     /// at most `n` times. This starts at the end of the vector and
     /// works backwards.  The matched element is not contained in the
@@ -581,12 +572,6 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
     }
 
     #[inline]
-    #[deprecated = "replaced by .iter().rev()"]
-    fn rev_iter(self) -> Rev<Items<'a, T>> {
-        self.iter().rev()
-    }
-
-    #[inline]
     fn split(self, pred: |&T|: 'a -> bool) -> Splits<'a, T> {
         Splits {
             v: self,
@@ -605,12 +590,6 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
     }
 
     #[inline]
-    #[deprecated = "replaced by .split(pred).rev()"]
-    fn rsplit(self, pred: |&T|: 'a -> bool) -> Rev<Splits<'a, T>> {
-        self.split(pred).rev()
-    }
-
-    #[inline]
     fn rsplitn(self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<'a, T> {
         SplitsN {
             iter: self.split(pred),
@@ -806,10 +785,6 @@ pub trait MutableVector<'a, T> {
     /// Returns a mutable pointer to the last item in the vector.
     fn mut_last(self) -> Option<&'a mut T>;
 
-    /// Returns a reversed iterator that allows modifying each value
-    #[deprecated = "replaced by .mut_iter().rev()"]
-    fn mut_rev_iter(self) -> Rev<MutItems<'a, T>>;
-
     /// Returns an iterator over the mutable subslices of the vector
     /// which are separated by elements that match `pred`.  The
     /// matched element is not contained in the subslices.
@@ -1046,12 +1021,6 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] {
     }
 
     #[inline]
-    #[deprecated = "replaced by .mut_iter().rev()"]
-    fn mut_rev_iter(self) -> Rev<MutItems<'a, T>> {
-        self.mut_iter().rev()
-    }
-
-    #[inline]
     fn mut_split(self, pred: |&T|: 'a -> bool) -> MutSplits<'a, T> {
         MutSplits { v: self, pred: pred, finished: false }
     }
@@ -1354,8 +1323,6 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> {
 }
 
 iterator!{struct Items -> *T, &'a T}
-#[deprecated = "replaced by Rev<Items<'a, T>>"]
-pub type RevItems<'a, T> = Rev<Items<'a, T>>;
 
 impl<'a, T> ExactSize<&'a T> for Items<'a, T> {}
 impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {}
@@ -1365,8 +1332,6 @@ impl<'a, T> Clone for Items<'a, T> {
 }
 
 iterator!{struct MutItems -> *mut T, &'a mut T}
-#[deprecated = "replaced by Rev<MutItems<'a, T>>"]
-pub type RevMutItems<'a, T> = Rev<MutItems<'a, T>>;
 
 /// An iterator over the subslices of the vector which are separated
 /// by elements that match `pred`.
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 0d820836377..d6a9b42522c 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -20,7 +20,7 @@ use cmp::{Eq, TotalEq};
 use container::Container;
 use default::Default;
 use iter::{Filter, Map, Iterator};
-use iter::{Rev, DoubleEndedIterator, ExactSize};
+use iter::{DoubleEndedIterator, ExactSize};
 use iter::range;
 use num::Saturating;
 use option::{None, Option, Some};
@@ -174,20 +174,11 @@ impl<'a> DoubleEndedIterator<(uint, char)> for CharOffsets<'a> {
     }
 }
 
-#[deprecated = "replaced by Rev<Chars<'a>>"]
-pub type RevChars<'a> = Rev<Chars<'a>>;
-
-#[deprecated = "replaced by Rev<CharOffsets<'a>>"]
-pub type RevCharOffsets<'a> = Rev<CharOffsets<'a>>;
-
 /// External iterator for a string's bytes.
 /// Use with the `std::iter` module.
 pub type Bytes<'a> =
     Map<'a, &'a u8, u8, slice::Items<'a, u8>>;
 
-#[deprecated = "replaced by Rev<Bytes<'a>>"]
-pub type RevBytes<'a> = Rev<Bytes<'a>>;
-
 /// An iterator over the substrings of a string, separated by `sep`.
 #[deriving(Clone)]
 pub struct CharSplits<'a, Sep> {
@@ -200,9 +191,6 @@ pub struct CharSplits<'a, Sep> {
     finished: bool,
 }
 
-#[deprecated = "replaced by Rev<CharSplits<'a, Sep>>"]
-pub type RevCharSplits<'a, Sep> = Rev<CharSplits<'a, Sep>>;
-
 /// An iterator over the substrings of a string, separated by `sep`,
 /// splitting at most `count` times.
 #[deriving(Clone)]
@@ -1080,24 +1068,12 @@ pub trait StrSlice<'a> {
     /// ```
     fn chars(&self) -> Chars<'a>;
 
-    /// Do not use this - it is deprecated.
-    #[deprecated = "replaced by .chars().rev()"]
-    fn chars_rev(&self) -> Rev<Chars<'a>>;
-
     /// An iterator over the bytes of `self`
     fn bytes(&self) -> Bytes<'a>;
 
-    /// Do not use this - it is deprecated.
-    #[deprecated = "replaced by .bytes().rev()"]
-    fn bytes_rev(&self) -> Rev<Bytes<'a>>;
-
     /// An iterator over the characters of `self` and their byte offsets.
     fn char_indices(&self) -> CharOffsets<'a>;
 
-    /// Do not use this - it is deprecated.
-    #[deprecated = "replaced by .char_indices().rev()"]
-    fn char_indices_rev(&self) -> Rev<CharOffsets<'a>>;
-
     /// An iterator over substrings of `self`, separated by characters
     /// matched by `sep`.
     ///
@@ -1159,10 +1135,6 @@ pub trait StrSlice<'a> {
     /// ```
     fn split_terminator<Sep: CharEq>(&self, sep: Sep) -> CharSplits<'a, Sep>;
 
-    /// Do not use this - it is deprecated.
-    #[deprecated = "replaced by .split(sep).rev()"]
-    fn rsplit<Sep: CharEq>(&self, sep: Sep) -> Rev<CharSplits<'a, Sep>>;
-
     /// An iterator over substrings of `self`, separated by characters
     /// matched by `sep`, starting from the end of the string.
     /// Restricted to splitting at most `count` times.
@@ -1682,34 +1654,16 @@ impl<'a> StrSlice<'a> for &'a str {
     }
 
     #[inline]
-    #[deprecated = "replaced by .chars().rev()"]
-    fn chars_rev(&self) -> RevChars<'a> {
-        self.chars().rev()
-    }
-
-    #[inline]
     fn bytes(&self) -> Bytes<'a> {
         self.as_bytes().iter().map(|&b| b)
     }
 
     #[inline]
-    #[deprecated = "replaced by .bytes().rev()"]
-    fn bytes_rev(&self) -> RevBytes<'a> {
-        self.bytes().rev()
-    }
-
-    #[inline]
     fn char_indices(&self) -> CharOffsets<'a> {
         CharOffsets{string: *self, iter: self.chars()}
     }
 
     #[inline]
-    #[deprecated = "replaced by .char_indices().rev()"]
-    fn char_indices_rev(&self) -> RevCharOffsets<'a> {
-        self.char_indices().rev()
-    }
-
-    #[inline]
     fn split<Sep: CharEq>(&self, sep: Sep) -> CharSplits<'a, Sep> {
         CharSplits {
             string: *self,
@@ -1740,12 +1694,6 @@ impl<'a> StrSlice<'a> for &'a str {
     }
 
     #[inline]
-    #[deprecated = "replaced by .split(sep).rev()"]
-    fn rsplit<Sep: CharEq>(&self, sep: Sep) -> RevCharSplits<'a, Sep> {
-        self.split(sep).rev()
-    }
-
-    #[inline]
     fn rsplitn<Sep: CharEq>(&self, sep: Sep, count: uint)
         -> CharSplitsN<'a, Sep> {
         CharSplitsN {
diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index c7a29ff7285..a2486b6e047 100644
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -323,12 +323,6 @@ pub trait Rng {
         }
     }
 
-    /// Shuffle a mutable slice in place.
-    #[deprecated="renamed to `.shuffle`"]
-    fn shuffle_mut<T>(&mut self, values: &mut [T]) {
-        self.shuffle(values)
-    }
-
     /// Randomly sample up to `n` elements from an iterator.
     ///
     /// # Example
@@ -387,23 +381,6 @@ pub trait SeedableRng<Seed>: Rng {
     fn from_seed(seed: Seed) -> Self;
 }
 
-/// Create a random number generator with a default algorithm and seed.
-///
-/// It returns the strongest `Rng` algorithm currently implemented in
-/// pure Rust. If you require a specifically seeded `Rng` for
-/// consistency over time you should pick one algorithm and create the
-/// `Rng` yourself.
-///
-/// This is a very expensive operation as it has to read randomness
-/// from the operating system and use this in an expensive seeding
-/// operation. If one does not require high performance generation of
-/// random numbers, `task_rng` and/or `random` may be more
-/// appropriate.
-#[deprecated="use `task_rng` or `StdRng::new`"]
-pub fn rng() -> StdRng {
-    StdRng::new().unwrap()
-}
-
 /// The standard RNG. This is designed to be efficient on the current
 /// platform.
 #[cfg(not(target_word_size="64"))]
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 2960d55f337..b6550a9d77b 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -96,28 +96,16 @@ pub use Path = self::windows::Path;
 /// Typedef for the platform-native component iterator
 #[cfg(unix)]
 pub use Components = self::posix::Components;
-/// Typedef for the platform-native reverse component iterator
-#[cfg(unix)]
-pub use RevComponents = self::posix::RevComponents;
 /// Typedef for the platform-native component iterator
 #[cfg(windows)]
 pub use Components = self::windows::Components;
-/// Typedef for the platform-native reverse component iterator
-#[cfg(windows)]
-pub use RevComponents = self::windows::RevComponents;
 
 /// Typedef for the platform-native str component iterator
 #[cfg(unix)]
 pub use StrComponents = self::posix::StrComponents;
-/// Typedef for the platform-native reverse str component iterator
-#[cfg(unix)]
-pub use RevStrComponents = self::posix::RevStrComponents;
 /// Typedef for the platform-native str component iterator
 #[cfg(windows)]
 pub use StrComponents = self::windows::StrComponents;
-/// Typedef for the platform-native reverse str component iterator
-#[cfg(windows)]
-pub use RevStrComponents = self::windows::RevStrComponents;
 
 /// Alias for the platform-native separator character.
 #[cfg(unix)]
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 4f7132dc6e4..9517d6618a9 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -16,7 +16,7 @@ use clone::Clone;
 use cmp::{Eq, TotalEq};
 use from_str::FromStr;
 use io::Writer;
-use iter::{DoubleEndedIterator, Rev, AdditiveIterator, Extendable, Iterator, Map};
+use iter::{DoubleEndedIterator, AdditiveIterator, Extendable, Iterator, Map};
 use option::{Option, None, Some};
 use str;
 use str::Str;
@@ -28,16 +28,10 @@ use super::{BytesContainer, GenericPath, GenericPathUnsafe};
 
 /// Iterator that yields successive components of a Path as &[u8]
 pub type Components<'a> = Splits<'a, u8>;
-/// Iterator that yields components of a Path in reverse as &[u8]
-#[deprecated = "replaced by Rev<Components<'a>>"]
-pub type RevComponents<'a> = Rev<Components<'a>>;
 
 /// Iterator that yields successive components of a Path as Option<&str>
 pub type StrComponents<'a> = Map<'a, &'a [u8], Option<&'a str>,
                                        Components<'a>>;
-/// Iterator that yields components of a Path in reverse as Option<&str>
-#[deprecated = "replaced by Rev<StrComponents<'a>>"]
-pub type RevStrComponents<'a> = Rev<StrComponents<'a>>;
 
 /// Represents a POSIX file path
 #[deriving(Clone)]
@@ -414,25 +408,11 @@ impl Path {
         ret
     }
 
-    /// Returns an iterator that yields each component of the path in reverse.
-    /// See components() for details.
-    #[deprecated = "replaced by .components().rev()"]
-    pub fn rev_components<'a>(&'a self) -> Rev<Components<'a>> {
-        self.components().rev()
-    }
-
     /// Returns an iterator that yields each component of the path as Option<&str>.
     /// See components() for details.
     pub fn str_components<'a>(&'a self) -> StrComponents<'a> {
         self.components().map(str::from_utf8)
     }
-
-    /// Returns an iterator that yields each component of the path in reverse as Option<&str>.
-    /// See components() for details.
-    #[deprecated = "replaced by .str_components().rev()"]
-    pub fn rev_str_components<'a>(&'a self) -> Rev<StrComponents<'a>> {
-        self.str_components().rev()
-    }
 }
 
 // None result means the byte vector didn't need normalizing
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 176788edcc4..be9472338cd 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -17,7 +17,7 @@ use cmp::{Eq, TotalEq};
 use container::Container;
 use from_str::FromStr;
 use io::Writer;
-use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Rev, Iterator, Map};
+use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Iterator, Map};
 use mem;
 use option::{Option, Some, None};
 use slice::{Vector, OwnedVector, ImmutableVector};
@@ -33,19 +33,10 @@ use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe};
 /// every component in WindowsPath is guaranteed to be Some.
 pub type StrComponents<'a> = Map<'a, &'a str, Option<&'a str>,
                                        CharSplits<'a, char>>;
-/// Iterator that yields components of a Path in reverse as &str
-///
-/// Each component is yielded as Option<&str> for compatibility with PosixPath, but
-/// every component in WindowsPath is guaranteed to be Some.
-#[deprecated = "replaced by Rev<StrComponents<'a>>"]
-pub type RevStrComponents<'a> = Rev<StrComponents<'a>>;
 
 /// Iterator that yields successive components of a Path as &[u8]
 pub type Components<'a> = Map<'a, Option<&'a str>, &'a [u8],
                                     StrComponents<'a>>;
-/// Iterator that yields components of a Path in reverse as &[u8]
-#[deprecated = "replaced by Rev<Components<'a>>"]
-pub type RevComponents<'a> = Rev<Components<'a>>;
 
 /// Represents a Windows path
 // Notes for Windows path impl:
@@ -650,13 +641,6 @@ impl Path {
         ret
     }
 
-    /// Returns an iterator that yields each component of the path in reverse as an Option<&str>
-    /// See str_components() for details.
-    #[deprecated = "replaced by .str_components().rev()"]
-    pub fn rev_str_components<'a>(&'a self) -> Rev<StrComponents<'a>> {
-        self.str_components().rev()
-    }
-
     /// Returns an iterator that yields each component of the path in turn as a &[u8].
     /// See str_components() for details.
     pub fn components<'a>(&'a self) -> Components<'a> {
@@ -667,13 +651,6 @@ impl Path {
         self.str_components().map(convert)
     }
 
-    /// Returns an iterator that yields each component of the path in reverse as a &[u8].
-    /// See str_components() for details.
-    #[deprecated = "replaced by .components().rev()"]
-    pub fn rev_components<'a>(&'a self) -> Rev<Components<'a>> {
-        self.components().rev()
-    }
-
     fn equiv_prefix(&self, other: &Path) -> bool {
         let s_repr = self.repr.as_slice();
         let o_repr = other.repr.as_slice();
diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs
index e78122f699d..4f7bb2aec08 100644
--- a/src/libstd/slice.rs
+++ b/src/libstd/slice.rs
@@ -116,7 +116,7 @@ use vec::Vec;
 pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows};
 pub use core::slice::{Chunks, Vector, ImmutableVector, ImmutableEqVector};
 pub use core::slice::{ImmutableTotalOrdVector, MutableVector, Items, MutItems};
-pub use core::slice::{RevItems, RevMutItems, MutSplits, MutChunks};
+pub use core::slice::{MutSplits, MutChunks};
 pub use core::slice::{bytes, MutableCloneableVector};
 
 // Functional utilities
@@ -403,10 +403,6 @@ pub trait OwnedVector<T> {
     /// }
     /// ```
     fn move_iter(self) -> MoveItems<T>;
-    /// Creates a consuming iterator that moves out of the vector in
-    /// reverse order.
-    #[deprecated = "replaced by .move_iter().rev()"]
-    fn move_rev_iter(self) -> Rev<MoveItems<T>>;
 
     /**
      * Partitions the vector into two vectors `(A,B)`, where all
@@ -426,12 +422,6 @@ impl<T> OwnedVector<T> for ~[T] {
     }
 
     #[inline]
-    #[deprecated = "replaced by .move_iter().rev()"]
-    fn move_rev_iter(self) -> Rev<MoveItems<T>> {
-        self.move_iter().rev()
-    }
-
-    #[inline]
     fn partition(self, f: |&T| -> bool) -> (Vec<T>, Vec<T>) {
         let mut lefts  = Vec::new();
         let mut rights = Vec::new();
@@ -776,10 +766,6 @@ impl<T> Drop for MoveItems<T> {
     }
 }
 
-/// An iterator that moves out of a vector in reverse order.
-#[deprecated = "replaced by Rev<MoveItems<'a, T>>"]
-pub type RevMoveItems<T> = Rev<MoveItems<T>>;
-
 #[cfg(test)]
 mod tests {
     use prelude::*;
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 617887e8af3..0c77830ee86 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -93,8 +93,8 @@ use slice::{ImmutableVector, MutableVector, CloneableVector};
 use strbuf::StrBuf;
 use vec::Vec;
 
-pub use core::str::{from_utf8, CharEq, Chars, CharOffsets, RevChars};
-pub use core::str::{RevCharOffsets, Bytes, RevBytes, CharSplits, RevCharSplits};
+pub use core::str::{from_utf8, CharEq, Chars, CharOffsets};
+pub use core::str::{Bytes, CharSplits};
 pub use core::str::{CharSplitsN, Words, AnyLines, MatchIndices, StrSplits};
 pub use core::str::{eq_slice, eq, is_utf8, is_utf16, UTF16Items};
 pub use core::str::{UTF16Item, ScalarValue, LoneSurrogate, utf16_items};