option: rewrite the API to use composition

8 files changed, 37 insertions, 35 deletions

diff --git a/src/libextra/comm.rs b/src/libextra/comm.rs
index 476755919a4..4da8bc89ea6 100644
--- a/src/libextra/comm.rs
+++ b/src/libextra/comm.rs
@@ -114,7 +114,7 @@ impl<T: Send> GenericPort<T> for SyncPort<T> {
     }
 
     fn try_recv(&self) -> Option<T> {
-        do self.duplex_stream.try_recv().map_move |val| {
+        do self.duplex_stream.try_recv().map |val| {
             self.duplex_stream.try_send(());
             val
         }
diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs
index bf91c5c5d7e..6668e9871f4 100644
--- a/src/libextra/dlist.rs
+++ b/src/libextra/dlist.rs
@@ -165,7 +165,7 @@ impl<T> DList<T> {
     /// Remove the first Node and return it, or None if the list is empty
     #[inline]
     fn pop_front_node(&mut self) -> Option<~Node<T>> {
-        do self.list_head.take().map_move |mut front_node| {
+        do self.list_head.take().map |mut front_node| {
             self.length -= 1;
             match front_node.next.take() {
                 Some(node) => self.list_head = link_with_prev(node, Rawlink::none()),
@@ -191,7 +191,7 @@ impl<T> DList<T> {
     /// Remove the last Node and return it, or None if the list is empty
     #[inline]
     fn pop_back_node(&mut self) -> Option<~Node<T>> {
-        do self.list_tail.resolve().map_move_default(None) |tail| {
+        do self.list_tail.resolve().map_default(None) |tail| {
             self.length -= 1;
             self.list_tail = tail.prev;
             match tail.prev.resolve() {
@@ -206,25 +206,27 @@ impl<T> Deque<T> for DList<T> {
     /// Provide a reference to the front element, or None if the list is empty
     #[inline]
     fn front<'a>(&'a self) -> Option<&'a T> {
-        self.list_head.map(|head| &head.value)
+        self.list_head.as_ref().map(|head| &head.value)
     }
 
     /// Provide a mutable reference to the front element, or None if the list is empty
     #[inline]
     fn front_mut<'a>(&'a mut self) -> Option<&'a mut T> {
-        self.list_head.map_mut(|head| &mut head.value)
+        self.list_head.as_mut().map(|head| &mut head.value)
     }
 
     /// Provide a reference to the back element, or None if the list is empty
     #[inline]
     fn back<'a>(&'a self) -> Option<&'a T> {
-        self.list_tail.resolve_immut().map(|tail| &tail.value)
+        let tmp = self.list_tail.resolve_immut(); // FIXME: #3511: shouldn't need variable
+        tmp.as_ref().map(|tail| &tail.value)
     }
 
     /// Provide a mutable reference to the back element, or None if the list is empty
     #[inline]
     fn back_mut<'a>(&'a mut self) -> Option<&'a mut T> {
-        self.list_tail.resolve().map_mut(|tail| &mut tail.value)
+        let mut tmp = self.list_tail.resolve(); // FIXME: #3511: shouldn't need variable
+        tmp.as_mut().map(|tail| &mut tail.value)
     }
 
     /// Add an element first in the list
@@ -238,7 +240,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn pop_front(&mut self) -> Option<T> {
-        self.pop_front_node().map_move(|~Node{value, _}| value)
+        self.pop_front_node().map(|~Node{value, _}| value)
     }
 
     /// Add an element last in the list
@@ -252,7 +254,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn pop_back(&mut self) -> Option<T> {
-        self.pop_back_node().map_move(|~Node{value, _}| value)
+        self.pop_back_node().map(|~Node{value, _}| value)
     }
 }
 
@@ -268,7 +270,7 @@ impl<T> DList<T> {
     /// If the list is empty, do nothing.
     #[inline]
     pub fn rotate_forward(&mut self) {
-        do self.pop_back_node().map_move |tail| {
+        do self.pop_back_node().map |tail| {
             self.push_front_node(tail)
         };
     }
@@ -278,7 +280,7 @@ impl<T> DList<T> {
     /// If the list is empty, do nothing.
     #[inline]
     pub fn rotate_backward(&mut self) {
-        do self.pop_front_node().map_move |head| {
+        do self.pop_front_node().map |head| {
             self.push_back_node(head)
         };
     }
@@ -442,7 +444,7 @@ impl<'self, A> Iterator<&'self A> for DListIterator<'self, A> {
         if self.nelem == 0 {
             return None;
         }
-        do self.head.map |head| {
+        do self.head.as_ref().map |head| {
             self.nelem -= 1;
             self.head = &head.next;
             &head.value
@@ -461,7 +463,8 @@ impl<'self, A> DoubleEndedIterator<&'self A> for DListIterator<'self, A> {
         if self.nelem == 0 {
             return None;
         }
-        do self.tail.resolve().map_move |prev| {
+        let tmp = self.tail.resolve_immut(); // FIXME: #3511: shouldn't need variable
+        do tmp.as_ref().map |prev| {
             self.nelem -= 1;
             self.tail = prev.prev;
             &prev.value
@@ -477,7 +480,7 @@ impl<'self, A> Iterator<&'self mut A> for MutDListIterator<'self, A> {
         if self.nelem == 0 {
             return None;
         }
-        do self.head.resolve().map_move |next| {
+        do self.head.resolve().map |next| {
             self.nelem -= 1;
             self.head = match next.next {
                 Some(ref mut node) => Rawlink::some(&mut **node),
@@ -499,7 +502,7 @@ impl<'self, A> DoubleEndedIterator<&'self mut A> for MutDListIterator<'self, A>
         if self.nelem == 0 {
             return None;
         }
-        do self.tail.resolve().map_move |prev| {
+        do self.tail.resolve().map |prev| {
             self.nelem -= 1;
             self.tail = prev.prev;
             &mut prev.value
@@ -554,7 +557,7 @@ impl<'self, A> ListInsertion<A> for MutDListIterator<'self, A> {
         if self.nelem == 0 {
             return None
         }
-        self.head.resolve().map_move(|head| &mut head.value)
+        self.head.resolve().map(|head| &mut head.value)
     }
 }
 
diff --git a/src/libextra/fileinput.rs b/src/libextra/fileinput.rs
index e85b715b21a..bf3fe4b39b2 100644
--- a/src/libextra/fileinput.rs
+++ b/src/libextra/fileinput.rs
@@ -596,8 +596,7 @@ mod test {
             |i| format!("tmp/lib-fileinput-test-next-file-{}.tmp", i)),true);
 
         for (i, filename) in filenames.iter().enumerate() {
-            let contents =
-                vec::from_fn(3, |j| format!("{} {}", i, j + 1));
+            let contents = vec::from_fn(3, |j| format!("{} {}", i, j + 1));
             make_file(filename.get_ref(), contents);
         }
 
diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs
index 8604674ea12..ed68f3162aa 100644
--- a/src/libextra/num/bigint.rs
+++ b/src/libextra/num/bigint.rs
@@ -698,7 +698,7 @@ impl BigUint {
     #[inline]
     pub fn new(v: ~[BigDigit]) -> BigUint {
         // omit trailing zeros
-        let new_len = v.iter().rposition(|n| *n != 0).map_move_default(0, |p| p + 1);
+        let new_len = v.iter().rposition(|n| *n != 0).map_default(0, |p| p + 1);
 
         if new_len == v.len() { return BigUint { data: v }; }
         let mut v = v;
@@ -1417,7 +1417,7 @@ impl BigInt {
             start = 1;
         }
         return BigUint::parse_bytes(buf.slice(start, buf.len()), radix)
-            .map_move(|bu| BigInt::from_biguint(sign, bu));
+            .map(|bu| BigInt::from_biguint(sign, bu));
     }
 
     /// Converts this `BigInt` into a `BigUint`, if it's not negative.
@@ -2507,7 +2507,7 @@ mod bigint_tests {
     #[test]
     fn test_from_str_radix() {
         fn check(s: &str, ans: Option<int>) {
-            let ans = ans.map_move(|n| {
+            let ans = ans.map(|n| {
                 let x: BigInt = FromPrimitive::from_int(n).unwrap();
                 x
             });
diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs
index 2108415f468..794b25c2e38 100644
--- a/src/libextra/smallintmap.rs
+++ b/src/libextra/smallintmap.rs
@@ -158,7 +158,7 @@ impl<V> SmallIntMap<V> {
     {
         let values = replace(&mut self.v, ~[]);
         values.move_iter().enumerate().filter_map(|(i, v)| {
-            v.map_move(|v| (i, v))
+            v.map(|v| (i, v))
         })
     }
 }
diff --git a/src/libextra/term.rs b/src/libextra/term.rs
index c7f26507902..85975ba6347 100644
--- a/src/libextra/term.rs
+++ b/src/libextra/term.rs
@@ -127,7 +127,7 @@ impl Terminal {
         let inf = ti.unwrap();
         let nc = if inf.strings.find_equiv(&("setaf")).is_some()
                  && inf.strings.find_equiv(&("setab")).is_some() {
-                     inf.numbers.find_equiv(&("colors")).map_move_default(0, |&n| n)
+                     inf.numbers.find_equiv(&("colors")).map_default(0, |&n| n)
                  } else { 0 };
 
         return Ok(Terminal {out: out, ti: inf, num_colors: nc});
@@ -220,7 +220,7 @@ impl Terminal {
                 cap = self.ti.strings.find_equiv(&("op"));
             }
         }
-        let s = do cap.map_move_default(Err(~"can't find terminfo capability `sgr0`")) |op| {
+        let s = do cap.map_default(Err(~"can't find terminfo capability `sgr0`")) |op| {
             expand(*op, [], &mut Variables::new())
         };
         if s.is_ok() {
diff --git a/src/libextra/test.rs b/src/libextra/test.rs
index 9e30e5bcaab..09e1fae14af 100644
--- a/src/libextra/test.rs
+++ b/src/libextra/test.rs
@@ -241,20 +241,20 @@ pub fn parse_opts(args: &[~str]) -> Option<OptRes> {
     let run_ignored = matches.opt_present("ignored");
 
     let logfile = matches.opt_str("logfile");
-    let logfile = logfile.map_move(|s| Path(s));
+    let logfile = logfile.map(|s| Path(s));
 
     let run_benchmarks = matches.opt_present("bench");
     let run_tests = ! run_benchmarks ||
         matches.opt_present("test");
 
     let ratchet_metrics = matches.opt_str("ratchet-metrics");
-    let ratchet_metrics = ratchet_metrics.map_move(|s| Path(s));
+    let ratchet_metrics = ratchet_metrics.map(|s| Path(s));
 
     let ratchet_noise_percent = matches.opt_str("ratchet-noise-percent");
-    let ratchet_noise_percent = ratchet_noise_percent.map_move(|s| from_str::<f64>(s).unwrap());
+    let ratchet_noise_percent = ratchet_noise_percent.map(|s| from_str::<f64>(s).unwrap());
 
     let save_metrics = matches.opt_str("save-metrics");
-    let save_metrics = save_metrics.map_move(|s| Path(s));
+    let save_metrics = save_metrics.map(|s| Path(s));
 
     let test_shard = matches.opt_str("test-shard");
     let test_shard = opt_shard(test_shard);
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
index 66e1fd0c2c3..432d854ad54 100644
--- a/src/libextra/treemap.rs
+++ b/src/libextra/treemap.rs
@@ -385,7 +385,7 @@ impl<'self, T> Iterator<&'self T> for TreeSetIterator<'self, T> {
     /// Advance the iterator to the next node (in order). If there are no more nodes, return `None`.
     #[inline]
     fn next(&mut self) -> Option<&'self T> {
-        do self.iter.next().map_move |(value, _)| { value }
+        do self.iter.next().map |(value, _)| { value }
     }
 }
 
@@ -393,7 +393,7 @@ impl<'self, T> Iterator<&'self T> for TreeSetRevIterator<'self, T> {
     /// Advance the iterator to the next node (in order). If there are no more nodes, return `None`.
     #[inline]
     fn next(&mut self) -> Option<&'self T> {
-        do self.iter.next().map |&(value, _)| { value }
+        do self.iter.next().map |(value, _)| { value }
     }
 }
 
@@ -686,7 +686,7 @@ fn mutate_values<'r, K: TotalOrd, V>(node: &'r mut Option<~TreeNode<K, V>>,
 
 // Remove left horizontal link by rotating right
 fn skew<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
-    if node.left.map_default(false, |x| x.level == node.level) {
+    if node.left.as_ref().map_default(false, |x| x.level == node.level) {
         let mut save = node.left.take_unwrap();
         swap(&mut node.left, &mut save.right); // save.right now None
         swap(node, &mut save);
@@ -697,8 +697,8 @@ fn skew<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
 // Remove dual horizontal link by rotating left and increasing level of
 // the parent
 fn split<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
-    if node.right.map_default(false,
-      |x| x.right.map_default(false, |y| y.level == node.level)) {
+    if node.right.as_ref().map_default(false,
+      |x| x.right.as_ref().map_default(false, |y| y.level == node.level)) {
         let mut save = node.right.take_unwrap();
         swap(&mut node.right, &mut save.left); // save.left now None
         save.level += 1;
@@ -804,8 +804,8 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
         };
 
         if rebalance {
-            let left_level = save.left.map_default(0, |x| x.level);
-            let right_level = save.right.map_default(0, |x| x.level);
+            let left_level = save.left.as_ref().map_default(0, |x| x.level);
+            let right_level = save.right.as_ref().map_default(0, |x| x.level);
 
             // re-balance, if necessary
             if left_level < save.level - 1 || right_level < save.level - 1 {