[std::vec] Rename .remove_opt() to .remove(), drop the old .remove() behavior

4 files changed, 16 insertions, 50 deletions

diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
index 683fe2e070b..62b28074a27 100644
--- a/src/libextra/treemap.rs
+++ b/src/libextra/treemap.rs
@@ -1164,7 +1164,7 @@ mod test_treemap {
 
             30.times(|| {
                 let r = rng.gen_range(0, ctrl.len());
-                let (key, _) = ctrl.remove(r);
+                let (key, _) = ctrl.remove(r).unwrap();
                 assert!(map.remove(&key));
                 check_structure(&map);
                 check_equal(ctrl, &map);
diff --git a/src/libgreen/basic.rs b/src/libgreen/basic.rs
index 0574792c18d..ef96f554515 100644
--- a/src/libgreen/basic.rs
+++ b/src/libgreen/basic.rs
@@ -84,7 +84,7 @@ impl BasicLoop {
             }
             RemoveRemote(i) => {
                 match self.remotes.iter().position(|&(id, _)| id == i) {
-                    Some(i) => { self.remotes.remove(i); }
+                    Some(i) => { self.remotes.remove(i).unwrap(); }
                     None => unreachable!()
                 }
             }
diff --git a/src/libstd/sync/deque.rs b/src/libstd/sync/deque.rs
index 4d0efcd6ee1..e99e9ef0940 100644
--- a/src/libstd/sync/deque.rs
+++ b/src/libstd/sync/deque.rs
@@ -157,7 +157,7 @@ impl<T: Send> BufferPool<T> {
         unsafe {
             self.pool.with(|pool| {
                 match pool.iter().position(|x| x.size() >= (1 << bits)) {
-                    Some(i) => pool.remove(i),
+                    Some(i) => pool.remove(i).unwrap(),
                     None => ~Buffer::new(bits)
                 }
             })
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 6300abb55a1..27e949a5640 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -1399,18 +1399,14 @@ pub trait OwnedVector<T> {
     /// # Example
     /// ```rust
     /// let mut v = ~[1, 2, 3];
-    /// assert_eq!(v.remove_opt(1), Some(2));
+    /// assert_eq!(v.remove(1), Some(2));
     /// assert_eq!(v, ~[1, 3]);
     ///
-    /// assert_eq!(v.remove_opt(4), None);
+    /// assert_eq!(v.remove(4), None);
     /// // v is unchanged:
     /// assert_eq!(v, ~[1, 3]);
     /// ```
-    fn remove_opt(&mut self, i: uint) -> Option<T>;
-
-    /// Remove and return the element at position i within v, shifting
-    /// all elements after position i one position to the left.
-    fn remove(&mut self, i: uint) -> T;
+    fn remove(&mut self, i: uint) -> Option<T>;
 
     /**
      * Remove an element from anywhere in the vector and return it, replacing it
@@ -1577,7 +1573,7 @@ impl<T> OwnedVector<T> for ~[T] {
 
     #[inline]
     fn shift(&mut self) -> Option<T> {
-        self.remove_opt(0)
+        self.remove(0)
     }
 
     #[inline]
@@ -1604,15 +1600,7 @@ impl<T> OwnedVector<T> for ~[T] {
         }
     }
 
-    #[inline]
-    fn remove(&mut self, i: uint) -> T {
-        match self.remove_opt(i) {
-            Some(t) => t,
-            None => fail!("remove: the len is {} but the index is {}", self.len(), i)
-        }
-    }
-
-    fn remove_opt(&mut self, i: uint) -> Option<T> {
+    fn remove(&mut self, i: uint) -> Option<T> {
         let len = self.len();
         if i < len {
             unsafe { // infallible
@@ -3617,48 +3605,26 @@ mod tests {
     }
 
     #[test]
-    fn test_remove_opt() {
+    fn test_remove() {
         let mut a = ~[1,2,3,4];
 
-        assert_eq!(a.remove_opt(2), Some(3));
+        assert_eq!(a.remove(2), Some(3));
         assert_eq!(a, ~[1,2,4]);
 
-        assert_eq!(a.remove_opt(2), Some(4));
+        assert_eq!(a.remove(2), Some(4));
         assert_eq!(a, ~[1,2]);
 
-        assert_eq!(a.remove_opt(2), None);
+        assert_eq!(a.remove(2), None);
         assert_eq!(a, ~[1,2]);
 
-        assert_eq!(a.remove_opt(0), Some(1));
+        assert_eq!(a.remove(0), Some(1));
         assert_eq!(a, ~[2]);
 
-        assert_eq!(a.remove_opt(0), Some(2));
+        assert_eq!(a.remove(0), Some(2));
         assert_eq!(a, ~[]);
 
-        assert_eq!(a.remove_opt(0), None);
-        assert_eq!(a.remove_opt(10), None);
-    }
-
-    #[test]
-    fn test_remove() {
-        let mut a = ~[1, 2, 3, 4];
-        a.remove(2);
-        assert_eq!(a, ~[1, 2, 4]);
-
-        let mut a = ~[1, 2, 3];
-        a.remove(0);
-        assert_eq!(a, ~[2, 3]);
-
-        let mut a = ~[1];
-        a.remove(0);
-        assert_eq!(a, ~[]);
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_remove_oob() {
-        let mut a = ~[1, 2, 3];
-        a.remove(3);
+        assert_eq!(a.remove(0), None);
+        assert_eq!(a.remove(10), None);
     }
 
     #[test]