Change Mut::map to Mut::with

src/libstd/mutable.rs

@@ -118,7 +118,7 @@ impl<T> Mut<T> {
     ///
     /// Fails if the value is currently mutably borrowed.
     #[inline]
-    pub fn map<U>(&self, blk: |&T| -> U) -> U {
+    pub fn with<U>(&self, blk: |&T| -> U) -> U {
         let ptr = self.borrow();
         blk(ptr.get())
     }
@@ -129,7 +129,7 @@ impl<T> Mut<T> {
     ///
     /// Fails if the value is currently borrowed.
     #[inline]
-    pub fn map_mut<U>(&self, blk: |&mut T| -> U) -> U {
+    pub fn with_mut<U>(&self, blk: |&mut T| -> U) -> U {
         let mut ptr = self.borrow_mut();
         blk(ptr.get())
     }
@@ -260,39 +260,39 @@ mod test {
     }
 
     #[test]
-    fn map_ok() {
+    fn with_ok() {
         let x = Mut::new(0);
-        assert_eq!(1, x.map(|x| *x+1));
+        assert_eq!(1, x.with(|x| *x+1));
     }
 
     #[test]
     #[should_fail]
-    fn mut_borrow_map() {
+    fn mut_borrow_with() {
         let x = Mut::new(0);
         let _b1 = x.borrow_mut();
-        x.map(|x| *x+1);
+        x.with(|x| *x+1);
     }
 
     #[test]
-    fn borrow_map() {
+    fn borrow_with() {
         let x = Mut::new(0);
         let _b1 = x.borrow();
-        assert_eq!(1, x.map(|x| *x+1));
+        assert_eq!(1, x.with(|x| *x+1));
     }
 
     #[test]
-    fn map_mut_ok() {
+    fn with_mut_ok() {
         let x = Mut::new(0);
-        x.map_mut(|x| *x += 1);
+        x.with_mut(|x| *x += 1);
         let b = x.borrow();
         assert_eq!(1, *b.get());
     }
 
     #[test]
     #[should_fail]
-    fn borrow_map_mut() {
+    fn borrow_with_mut() {
         let x = Mut::new(0);
         let _b = x.borrow();
-        x.map_mut(|x| *x += 1);
+        x.with_mut(|x| *x += 1);
     }
 }

src/libstd/rc.rs

@@ -111,20 +111,20 @@ mod test_rc {
     fn test_clone() {
         let x = Rc::from_send(Mut::new(5));
         let y = x.clone();
-        do x.borrow().map_mut |inner| {
+        do x.borrow().with_mut |inner| {
             *inner = 20;
         }
-        assert_eq!(y.borrow().map(|v| *v), 20);
+        assert_eq!(y.borrow().with(|v| *v), 20);
     }
 
     #[test]
     fn test_deep_clone() {
         let x = Rc::from_send(Mut::new(5));
         let y = x.deep_clone();
-        do x.borrow().map_mut |inner| {
+        do x.borrow().with_mut |inner| {
             *inner = 20;
         }
-        assert_eq!(y.borrow().map(|v| *v), 5);
+        assert_eq!(y.borrow().with(|v| *v), 5);
     }
 
     #[test]

src/libstd/rt/comm.rs

@@ -506,7 +506,7 @@ impl<T: Send> GenericPort<T> for Port<T> {
 
 impl<T: Send> Peekable<T> for Port<T> {
     fn peek(&self) -> bool {
-        self.next.map_mut(|p| p.get_mut_ref().peek())
+        self.next.with_mut(|p| p.get_mut_ref().peek())
     }
 }
 
@@ -517,7 +517,7 @@ impl<T: Send> Peekable<T> for Port<T> {
 impl<'self, T: Send> SelectInner for &'self Port<T> {
     #[inline]
     fn optimistic_check(&mut self) -> bool {
-        do self.next.map_mut |pone| { pone.get_mut_ref().optimistic_check() }
+        do self.next.with_mut |pone| { pone.get_mut_ref().optimistic_check() }
     }
 
     #[inline]
@@ -528,7 +528,7 @@ impl<'self, T: Send> SelectInner for &'self Port<T> {
 
     #[inline]
     fn unblock_from(&mut self) -> bool {
-        do self.next.map_mut |pone| { pone.get_mut_ref().unblock_from() }
+        do self.next.with_mut |pone| { pone.get_mut_ref().unblock_from() }
     }
 }