Stop returning k from [T]::rotate

Author: scottmcm

src/libcollections/slice.rs

@@ -1342,14 +1342,12 @@ impl<T> [T] {
     /// slice.  Equivalently, rotates the slice `mid` places to the left
     /// or `k = self.len() - mid` places to the right.
     ///
-    /// Rotation by `mid` and rotation by `k` are inverse operations.
-    /// The method returns `k`, which is also the new location of
-    /// the formerly-first element.
-    ///
     /// This is a "k-rotation", a permutation in which item `i` moves to
     /// position `i + k`, modulo the length of the slice.  See _Elements
     /// of Programming_ [§10.4][eop].
     ///
+    /// Rotation by `mid` and rotation by `k` are inverse operations.
+    ///
     /// [eop]: https://books.google.com/books?id=CO9ULZGINlsC&pg=PA178&q=k-rotation
     ///
     /// # Panics
@@ -1368,8 +1366,10 @@ impl<T> [T] {
     /// #![feature(slice_rotate)]
     ///
     /// let mut a = [1, 2, 3, 4, 5, 6, 7];
-    /// let k = a.rotate(2);
+    /// let mid = 2;
+    /// a.rotate(mid);
     /// assert_eq!(&a, &[3, 4, 5, 6, 7, 1, 2]);
+    /// let k = a.len() - mid;
     /// a.rotate(k);
     /// assert_eq!(&a, &[1, 2, 3, 4, 5, 6, 7]);
     ///
@@ -1388,8 +1388,8 @@ impl<T> [T] {
     /// assert_eq!(&v, &[0, 3, 7, 4, 5, 6, 1, 2, 8, 9]);
     /// ```
     #[unstable(feature = "slice_rotate", issue = "41891")]
-    pub fn rotate(&mut self, mid: usize) -> usize {
-        core_slice::SliceExt::rotate(self, mid)
+    pub fn rotate(&mut self, mid: usize) {
+        core_slice::SliceExt::rotate(self, mid);
     }
 
     /// Copies the elements from `src` into `self`.

src/libcollections/tests/slice.rs

@@ -482,9 +482,8 @@ fn test_rotate() {
 
     // happy path
     v = (5..13).chain(0..5).collect();
-    let k = v.rotate(8);
+    v.rotate(8);
     assert_eq!(v, expected);
-    assert_eq!(k, 5);
 
     let expected: Vec<_> = (0..1000).collect();
 

src/libcore/slice/mod.rs

@@ -204,7 +204,7 @@ pub trait SliceExt {
     fn ends_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq;
 
     #[unstable(feature = "slice_rotate", issue = "41891")]
-    fn rotate(&mut self, mid: usize) -> usize;
+    fn rotate(&mut self, mid: usize);
 
     #[stable(feature = "clone_from_slice", since = "1.7.0")]
     fn clone_from_slice(&mut self, src: &[Self::Item]) where Self::Item: Clone;
@@ -639,16 +639,14 @@ impl<T> SliceExt for [T] {
         self.binary_search_by(|p| p.borrow().cmp(x))
     }
 
-    fn rotate(&mut self, mid: usize) -> usize {
+    fn rotate(&mut self, mid: usize) {
         assert!(mid <= self.len());
         let k = self.len() - mid;
 
         unsafe {
             let p = self.as_mut_ptr();
             rotate::ptr_rotate(mid, p.offset(mid as isize), k);
         }
-
-        k
     }
 
     #[inline]

src/libcore/tests/slice.rs

@@ -246,9 +246,9 @@ fn test_rotate() {
         a[i] = i;
     }
 
-    let k = a.rotate(42);
+    a.rotate(42);
+    let k = N - 42;
 
-    assert_eq!(k, N - 42);
     for i in 0..N {
         assert_eq!(a[(i+k)%N], i);
     }