Slice retain

src/liballoc/lib.rs

@@ -125,6 +125,7 @@
 #![feature(alloc_layout_extra)]
 #![feature(try_trait)]
 #![feature(associated_type_bounds)]
+#![feature(slice_retain)]
 
 // Allow testing this library
 

src/liballoc/vec.rs

@@ -1103,26 +1103,12 @@ impl<T> Vec<T> {
     /// assert_eq!(vec, [2, 3, 5]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn retain<F>(&mut self, mut f: F)
+    pub fn retain<F>(&mut self, f: F)
     where
         F: FnMut(&T) -> bool,
     {
-        let len = self.len();
-        let mut del = 0;
-        {
-            let v = &mut **self;
-
-            for i in 0..len {
-                if !f(&v[i]) {
-                    del += 1;
-                } else if del > 0 {
-                    v.swap(i - del, i);
-                }
-            }
-        }
-        if del > 0 {
-            self.truncate(len - del);
-        }
+        let retained_len = self.as_mut_slice().retain(f).len();
+        self.truncate(retained_len);
     }
 
     /// Removes all but the first of consecutive elements in the vector that resolve to the same

src/libcore/slice/mod.rs

@@ -2063,6 +2063,51 @@ impl<T> [T] {
         self.partition_dedup_by(|a, b| key(a) == key(b))
     }
 
+    /// Retains only the elements specified by the predicate.
+    ///
+    /// In other words, remove all elements `e` such that `f(&e)` returns `false`.
+    /// This method operates in place, visiting each element exactly once in the
+    /// original order, and preserves the order of the retained elements.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(slice_retain)]
+    ///
+    /// let mut slice = [1, 2, 3, 4];
+    /// let retained = slice.retain(|&x| x % 2 == 0);
+    /// assert_eq!(retained, [2, 4]);
+    /// ```
+    ///
+    /// The exact order may be useful for tracking external state, like an index.
+    ///
+    /// ```
+    /// #![feature(slice_retain)]
+    ///
+    /// let mut slice = [1, 2, 3, 4, 5];
+    /// let keep = [false, true, true, false, true];
+    /// let mut i = 0;
+    /// let retained = slice.retain(|_| (keep[i], i += 1).0);
+    /// assert_eq!(retained, [2, 3, 5]);
+    /// ```
+    #[unstable(feature = "slice_retain", issue = "71831")]
+    #[must_use]
+    pub fn retain<F>(&mut self, mut f: F) -> &mut Self
+    where
+        F: FnMut(&T) -> bool,
+    {
+        let len = self.len();
+        let mut del = 0;
+        for i in 0..len {
+            if !f(&self[i]) {
+                del += 1;
+            } else if del > 0 {
+                self.swap(i - del, i);
+            }
+        }
+        self.split_at_mut(len - del).0
+    }
+
     /// Rotates the slice in-place such that the first `mid` elements of the
     /// slice move to the end while the last `self.len() - mid` elements move to
     /// the front. After calling `rotate_left`, the element previously at index

src/libcore/tests/lib.rs

@@ -43,6 +43,7 @@
 #![feature(leading_trailing_ones)]
 #![feature(const_forget)]
 #![feature(option_unwrap_none)]
+#![feature(slice_retain)]
 
 extern crate test;
 

src/libcore/tests/slice.rs

@@ -1635,6 +1635,17 @@ fn test_slice_partition_dedup_partialeq() {
     assert_eq!(duplicates, [Foo(0, 5), Foo(1, 9)]);
 }
 
+#[test]
+fn test_slice_retain() {
+    let mut slice = [1, 2, 2, 3, 1, 4];
+    let retained = slice.retain(|&x| x == 1);
+    assert_eq!(retained, &[1, 1]);
+
+    let mut slice = [1, 2, 2, 3, 1, 4];
+    let retained = slice.retain(|&x| x % 2 == 0);
+    assert_eq!(retained, &[2, 2, 4]);
+}
+
 #[test]
 fn test_copy_within() {
     // Start to end, with a RangeTo.