option: rewrite the API to use composition

10 files changed, 26 insertions, 26 deletions

diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs
index 100ea3e0546..315de4b9af3 100644
--- a/src/libstd/rt/args.rs
+++ b/src/libstd/rt/args.rs
@@ -74,7 +74,7 @@ mod imp {
         with_lock(|| unsafe {
             let ptr = get_global_ptr();
             let val = util::replace(&mut *ptr, None);
-            val.map(|s: &~~[~str]| (**s).clone())
+            val.as_ref().map(|s: &~~[~str]| (**s).clone())
         })
     }
 
@@ -89,7 +89,7 @@ mod imp {
     pub fn clone() -> Option<~[~str]> {
         with_lock(|| unsafe {
             let ptr = get_global_ptr();
-            (*ptr).map(|s: &~~[~str]| (**s).clone())
+            (*ptr).as_ref().map(|s: &~~[~str]| (**s).clone())
         })
     }
 
diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs
index 7d61b556bb5..3e3431b32c9 100644
--- a/src/libstd/rt/comm.rs
+++ b/src/libstd/rt/comm.rs
@@ -165,7 +165,7 @@ impl<T> ChanOne<T> {
                     // Port is blocked. Wake it up.
                     let recvr = BlockedTask::cast_from_uint(task_as_state);
                     if do_resched {
-                        do recvr.wake().map_move |woken_task| {
+                        do recvr.wake().map |woken_task| {
                             Scheduler::run_task(woken_task);
                         };
                     } else {
@@ -391,7 +391,7 @@ impl<T> Drop for ChanOne<T> {
                     // The port is blocked waiting for a message we will never send. Wake it.
                     rtassert!((*this.packet()).payload.is_none());
                     let recvr = BlockedTask::cast_from_uint(task_as_state);
-                    do recvr.wake().map_move |woken_task| {
+                    do recvr.wake().map |woken_task| {
                         Scheduler::run_task(woken_task);
                     };
                 }
@@ -501,7 +501,7 @@ impl<T> GenericPort<T> for Port<T> {
     }
 
     fn try_recv(&self) -> Option<T> {
-        do self.next.take_opt().map_move_default(None) |pone| {
+        do self.next.take_opt().map_default(None) |pone| {
             match pone.try_recv() {
                 Some(StreamPayload { val, next }) => {
                     self.next.put_back(next);
diff --git a/src/libstd/rt/io/net/ip.rs b/src/libstd/rt/io/net/ip.rs
index 6a6619cc548..f72d2e1f19b 100644
--- a/src/libstd/rt/io/net/ip.rs
+++ b/src/libstd/rt/io/net/ip.rs
@@ -203,7 +203,7 @@ impl<'self> Parser<'self> {
                 return None;
             }
 
-            let octet = self.read_number(10, 3, 0x100).map(|&n| n as u8);
+            let octet = self.read_number(10, 3, 0x100).map(|n| n as u8);
             match octet {
                 Some(d) => bs[i] = d,
                 None => return None,
@@ -252,7 +252,7 @@ impl<'self> Parser<'self> {
 
                 let group = do p.read_atomically |p| {
                     if i == 0 || p.read_given_char(':').is_some() {
-                        p.read_number(16, 4, 0x10000).map(|&n| n as u16)
+                        p.read_number(16, 4, 0x10000).map(|n| n as u16)
                     } else {
                         None
                     }
@@ -310,16 +310,16 @@ impl<'self> Parser<'self> {
                 let ip_addr = |p: &mut Parser| p.read_ipv6_addr();
                 let clos_br = |p: &mut Parser| p.read_given_char(']');
                 p.read_seq_3::<char, IpAddr, char>(open_br, ip_addr, clos_br)
-                        .map(|&t| match t { (_, ip, _) => ip })
+                        .map(|t| match t { (_, ip, _) => ip })
             };
             p.read_or([ipv4_p, ipv6_p])
         };
         let colon = |p: &mut Parser| p.read_given_char(':');
-        let port  = |p: &mut Parser| p.read_number(10, 5, 0x10000).map(|&n| n as u16);
+        let port  = |p: &mut Parser| p.read_number(10, 5, 0x10000).map(|n| n as u16);
 
         // host, colon, port
         self.read_seq_3::<IpAddr, char, u16>(ip_addr, colon, port)
-                .map(|&t| match t { (ip, _, port) => SocketAddr { ip: ip, port: port } })
+                .map(|t| match t { (ip, _, port) => SocketAddr { ip: ip, port: port } })
     }
 }
 
diff --git a/src/libstd/rt/io/process.rs b/src/libstd/rt/io/process.rs
index b2dbd8ee1f4..c190547889d 100644
--- a/src/libstd/rt/io/process.rs
+++ b/src/libstd/rt/io/process.rs
@@ -93,7 +93,7 @@ impl Process {
             Ok((p, io)) => Some(Process{
                 handle: p,
                 io: io.move_iter().map(|p|
-                    p.map_move(|p| io::PipeStream::bind(p))
+                    p.map(|p| io::PipeStream::bind(p))
                 ).collect()
             }),
             Err(ioerr) => {
diff --git a/src/libstd/rt/io/timer.rs b/src/libstd/rt/io/timer.rs
index c2cf9be3980..b41d7541a60 100644
--- a/src/libstd/rt/io/timer.rs
+++ b/src/libstd/rt/io/timer.rs
@@ -58,7 +58,7 @@ mod test {
     fn test_io_timer_sleep_simple() {
         do run_in_mt_newsched_task {
             let timer = Timer::new();
-            do timer.map_move |mut t| { t.sleep(1) };
+            do timer.map |mut t| { t.sleep(1) };
         }
     }
 
diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index 09f99b9302e..6043ae318fe 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -486,10 +486,10 @@ impl KillHandle {
                     || {
                         // Prefer to check tombstones that were there first,
                         // being "more fair" at the expense of tail-recursion.
-                        others.take().map_move_default(true, |f| f()) && {
+                        others.take().map_default(true, |f| f()) && {
                             let mut inner = this.take().unwrap();
                             (!inner.any_child_failed) &&
-                                inner.child_tombstones.take().map_move_default(true, |f| f())
+                                inner.child_tombstones.take().map_default(true, |f| f())
                         }
                     }
                 }
@@ -508,7 +508,7 @@ impl KillHandle {
                     let others = Cell::new(other_tombstones); // :(
                     || {
                         // Prefer fairness to tail-recursion, as in above case.
-                        others.take().map_move_default(true, |f| f()) &&
+                        others.take().map_default(true, |f| f()) &&
                             f.take()()
                     }
                 }
@@ -577,7 +577,7 @@ impl Death {
         { use util; util::ignore(group); }
 
         // Step 1. Decide if we need to collect child failures synchronously.
-        do self.on_exit.take().map_move |on_exit| {
+        do self.on_exit.take().map |on_exit| {
             if success {
                 // We succeeded, but our children might not. Need to wait for them.
                 let mut inner = self.kill_handle.take_unwrap().unwrap();
@@ -585,7 +585,7 @@ impl Death {
                     success = false;
                 } else {
                     // Lockless access to tombstones protected by unwrap barrier.
-                    success = inner.child_tombstones.take().map_move_default(true, |f| f());
+                    success = inner.child_tombstones.take().map_default(true, |f| f());
                 }
             }
             on_exit(success);
@@ -594,12 +594,12 @@ impl Death {
         // Step 2. Possibly alert possibly-watching parent to failure status.
         // Note that as soon as parent_handle goes out of scope, the parent
         // can successfully unwrap its handle and collect our reported status.
-        do self.watching_parent.take().map_move |mut parent_handle| {
+        do self.watching_parent.take().map |mut parent_handle| {
             if success {
                 // Our handle might be None if we had an exit callback, and
                 // already unwrapped it. But 'success' being true means no
                 // child failed, so there's nothing to do (see below case).
-                do self.kill_handle.take().map_move |own_handle| {
+                do self.kill_handle.take().map |own_handle| {
                     own_handle.reparent_children_to(&mut parent_handle);
                 };
             } else {
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index ee43ced44ab..0a4622bc65e 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -538,7 +538,7 @@ impl Scheduler {
     /// As enqueue_task, but with the possibility for the blocked task to
     /// already have been killed.
     pub fn enqueue_blocked_task(&mut self, blocked_task: BlockedTask) {
-        do blocked_task.wake().map_move |task| {
+        do blocked_task.wake().map |task| {
             self.enqueue_task(task);
         };
     }
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index 48b894f51e0..71ab3b571c4 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -485,10 +485,10 @@ mod test {
         do run_in_newsched_task() {
             local_data_key!(key: @~str)
             local_data::set(key, @~"data");
-            assert!(*local_data::get(key, |k| k.map_move(|k| *k)).unwrap() == ~"data");
+            assert!(*local_data::get(key, |k| k.map(|k| *k)).unwrap() == ~"data");
             local_data_key!(key2: @~str)
             local_data::set(key2, @~"data");
-            assert!(*local_data::get(key2, |k| k.map_move(|k| *k)).unwrap() == ~"data");
+            assert!(*local_data::get(key2, |k| k.map(|k| *k)).unwrap() == ~"data");
         }
     }
 
diff --git a/src/libstd/rt/uv/process.rs b/src/libstd/rt/uv/process.rs
index ddaf0c28725..176754de8f7 100644
--- a/src/libstd/rt/uv/process.rs
+++ b/src/libstd/rt/uv/process.rs
@@ -46,7 +46,7 @@ impl Process {
                  exit_cb: uv::ExitCallback)
                     -> Result<~[Option<UvPipeStream>], uv::UvError>
     {
-        let cwd = config.cwd.map_move(|s| s.to_c_str());
+        let cwd = config.cwd.map(|s| s.to_c_str());
 
         extern fn on_exit(p: *uvll::uv_process_t,
                           exit_status: libc::c_int,
diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs
index f9b71db7043..1de6042003c 100644
--- a/src/libstd/rt/uv/uvio.rs
+++ b/src/libstd/rt/uv/uvio.rs
@@ -74,7 +74,7 @@ trait HomingIO {
                      *
                      * RESOLUTION IDEA: Since the task is dead, we should just abort the IO action.
                      */
-                    do task.wake().map_move |mut task| {
+                    do task.wake().map |mut task| {
                         *ptr = Some(task.take_unwrap_home());
                         self.home().send(PinnedTask(task));
                     };
@@ -97,7 +97,7 @@ trait HomingIO {
                  *
                  * RESOLUTION IDEA: Since the task is dead, we should just abort the IO action.
                  */
-                do task.wake().map_move |mut task| {
+                do task.wake().map |mut task| {
                     task.give_home(old.take());
                     scheduler.make_handle().send(TaskFromFriend(task));
                 };
@@ -1672,7 +1672,7 @@ fn test_simple_homed_udp_io_bind_then_move_task_then_home_and_close() {
                 let scheduler: ~Scheduler = Local::take();
                 do scheduler.deschedule_running_task_and_then |_, task| {
                     // unblock task
-                    do task.wake().map_move |task| {
+                    do task.wake().map |task| {
                       // send self to sched2
                       tasksFriendHandle.take().send(TaskFromFriend(task));
                     };