Add try_remove to Vec

library/alloc/src/vec.rs

@@ -1065,26 +1065,44 @@ impl<T> Vec<T> {
         fn assert_failed(index: usize, len: usize) -> ! {
             panic!("removal index (is {}) should be < len (is {})", index, len);
         }
+        if let Some(retval) = self.try_remove(index) {
+            retval
+        } else {
+            assert_failed(index, self.len());
+        }
+    }
 
+    /// Tries to remove an element from the vector. If the element at `index` does not exist,
+    /// `None` is returned. Otherwise `Some(T)` is returned
+    ///
+    /// # Examples
+    /// ```
+    /// #![feature(vec_try_remove)]
+    /// let mut v = vec![1, 2, 3];
+    /// assert_eq!(v.try_remove(0), Some(1));
+    /// assert_eq!(v.try_remove(2), None);
+    /// ```
+    #[unstable(feature = "vec_try_remove", issue = "77481")]
+    pub fn try_remove(&mut self, index: usize) -> Option<T> {
         let len = self.len();
         if index >= len {
-            assert_failed(index, len);
-        }
-        unsafe {
-            // infallible
-            let ret;
-            {
-                // the place we are taking from.
-                let ptr = self.as_mut_ptr().add(index);
-                // copy it out, unsafely having a copy of the value on
-                // the stack and in the vector at the same time.
-                ret = ptr::read(ptr);
-
-                // Shift everything down to fill in that spot.
-                ptr::copy(ptr.offset(1), ptr, len - index - 1);
+            None
+        } else {
+            unsafe {
+                // infallible
+                let ret;
+                {
+                    // the place we are taking from.
+                    let ptr = self.as_mut_ptr().add(index);
+                    // copy it out, unsafely having a copy of the value on
+                    // the stack and in the vector at the same time.
+                    ret = ptr::read(ptr);
+                    // Shift everything down to fill in that spot.
+                    ptr::copy(ptr.offset(1), ptr, len - index - 1);
+                }
+                self.set_len(len - 1);
+                Some(ret)
             }
-            self.set_len(len - 1);
-            ret
         }
     }
 

library/alloc/tests/lib.rs

@@ -20,6 +20,7 @@
 #![feature(inplace_iteration)]
 #![feature(iter_map_while)]
 #![feature(int_bits_const)]
+#![feature(vec_try_remove)]
 
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};

library/alloc/tests/vec.rs

@@ -518,6 +518,21 @@ fn test_swap_remove_empty() {
     vec.swap_remove(0);
 }
 
+#[test]
+fn test_try_remove() {
+    let mut vec = vec![1, 2, 3];
+    // We are attempting to remove vec[0] which contains 1
+    assert_eq!(vec.try_remove(0), Some(1));
+    // Now `vec` looks like: [2, 3]
+    // We will now try to remove vec[2] which does not exist
+    // This should return `None`
+    assert_eq!(vec.try_remove(2), None);
+
+    // We will try the same thing with an empty vector
+    let mut v: Vec<u8> = vec![];
+    assert!(v.try_remove(0).is_none());
+}
+
 #[test]
 fn test_move_items() {
     let vec = vec![1, 2, 3];