Eliminate usages of old sugared call syntax

16 files changed, 155 insertions, 155 deletions

diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index c6fac371719..e3152839793 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -222,19 +222,19 @@ impl writer for writer {
     }
 
     fn wr_tagged_u64(tag_id: uint, v: u64) {
-        io::u64_to_be_bytes(v, 8u) {|v|
+        do io::u64_to_be_bytes(v, 8u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
 
     fn wr_tagged_u32(tag_id: uint, v: u32) {
-        io::u64_to_be_bytes(v as u64, 4u) {|v|
+        do io::u64_to_be_bytes(v as u64, 4u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
 
     fn wr_tagged_u16(tag_id: uint, v: u16) {
-        io::u64_to_be_bytes(v as u64, 2u) {|v|
+        do io::u64_to_be_bytes(v as u64, 2u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
@@ -244,19 +244,19 @@ impl writer for writer {
     }
 
     fn wr_tagged_i64(tag_id: uint, v: i64) {
-        io::u64_to_be_bytes(v as u64, 8u) {|v|
+        do io::u64_to_be_bytes(v as u64, 8u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
 
     fn wr_tagged_i32(tag_id: uint, v: i32) {
-        io::u64_to_be_bytes(v as u64, 4u) {|v|
+        do io::u64_to_be_bytes(v as u64, 4u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
 
     fn wr_tagged_i16(tag_id: uint, v: i16) {
-        io::u64_to_be_bytes(v as u64, 2u) {|v|
+        do io::u64_to_be_bytes(v as u64, 2u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
@@ -355,7 +355,7 @@ impl serializer of serialization::serializer for ebml::writer {
     fn emit_enum_variant_arg(_idx: uint, f: fn()) { f() }
 
     fn emit_vec(len: uint, f: fn()) {
-        self.wr_tag(es_vec as uint) {||
+        do self.wr_tag(es_vec as uint) {||
             self._emit_tagged_uint(es_vec_len, len);
             f()
         }
@@ -482,7 +482,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer {
         #debug["read_enum_variant()"];
         let idx = self._next_uint(es_enum_vid);
         #debug["  idx=%u", idx];
-        self.push_doc(self.next_doc(es_enum_body)) {||
+        do self.push_doc(self.next_doc(es_enum_body)) {||
             f(idx)
         }
     }
@@ -494,7 +494,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer {
 
     fn read_vec<T:copy>(f: fn(uint) -> T) -> T {
         #debug["read_vec()"];
-        self.push_doc(self.next_doc(es_vec)) {||
+        do self.push_doc(self.next_doc(es_vec)) {||
             let len = self._next_uint(es_vec_len);
             #debug["  len=%u", len];
             f(len)
@@ -549,14 +549,14 @@ fn test_option_int() {
     }
 
     fn serialize_0<S: serialization::serializer>(s: S, v: option<int>) {
-        s.emit_enum("core::option::t") {||
+        do s.emit_enum("core::option::t") {||
             alt v {
               none {
-                s.emit_enum_variant("core::option::none", 0u, 0u) {||}
+                s.emit_enum_variant("core::option::none", 0u, 0u, {||});
               }
               some(v0) {
-                s.emit_enum_variant("core::option::some", 1u, 1u) {||
-                    s.emit_enum_variant_arg(0u) {|| serialize_1(s, v0) }
+                do s.emit_enum_variant("core::option::some", 1u, 1u) {||
+                    s.emit_enum_variant_arg(0u, {|| serialize_1(s, v0) });
                 }
               }
             }
@@ -568,12 +568,12 @@ fn test_option_int() {
     }
 
     fn deserialize_0<S: serialization::deserializer>(s: S) -> option<int> {
-        s.read_enum("core::option::t") {||
-            s.read_enum_variant {|i|
+        do s.read_enum("core::option::t") {||
+            do s.read_enum_variant {|i|
                 alt check i {
                   0u { none }
                   1u {
-                    let v0 = s.read_enum_variant_arg(0u) {||
+                    let v0 = do s.read_enum_variant_arg(0u) {||
                         deserialize_1(s)
                     };
                     some(v0)
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index e68f41a7c38..51f59f59d13 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -90,7 +90,7 @@ fn to_writer(wr: io::writer, j: json) {
 
 fn escape_str(s: str) -> str {
     let mut escaped = "\"";
-    str::chars_iter(s) { |c|
+    do str::chars_iter(s) { |c|
         alt c {
           '"' { escaped += "\\\""; }
           '\\' { escaped += "\\\\"; }
@@ -110,7 +110,7 @@ fn escape_str(s: str) -> str {
 
 #[doc = "Serializes a json value into a string"]
 fn to_str(j: json) -> str {
-    io::with_str_writer { |wr| to_writer(wr, j) }
+    io::with_str_writer({ |wr| to_writer(wr, j) })
 }
 
 type parser = {
@@ -598,7 +598,7 @@ impl <A: to_json copy, B: to_json copy, C: to_json copy>
 }
 
 impl <A: to_json> of to_json for ~[A] {
-    fn to_json() -> json { list(@self.map { |elt| elt.to_json() }) }
+    fn to_json() -> json { list(@self.map({ |elt| elt.to_json() })) }
 }
 
 impl <A: to_json copy> of to_json for hashmap<str, A> {
@@ -635,7 +635,7 @@ mod tests {
     fn mk_dict(items: ~[(str, json)]) -> json {
         let d = map::str_hash();
 
-        vec::iter(items) { |item|
+        do vec::iter(items) { |item|
             let (key, value) = copy item;
             d.insert(key, value);
         };
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index 471abfe0856..5018f9860ce 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -29,7 +29,7 @@ accumulated result.
 "]
 fn foldl<T: copy, U>(z: T, ls: @list<U>, f: fn(T, U) -> T) -> T {
     let mut accum: T = z;
-    iter(ls) {|elt| accum = f(accum, elt);}
+    do iter(ls) {|elt| accum = f(accum, elt);}
     accum
 }
 
@@ -77,7 +77,7 @@ pure fn is_not_empty<T: copy>(ls: @list<T>) -> bool {
 #[doc = "Returns the length of a list"]
 fn len<T>(ls: @list<T>) -> uint {
     let mut count = 0u;
-    iter(ls) {|_e| count += 1u;}
+    iter(ls, {|_e| count += 1u;});
     count
 }
 
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 3475a0e5e7c..331bc6dcced 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -261,9 +261,9 @@ mod chained {
             }
         }
 
-        fn each_key(blk: fn(K) -> bool) { self.each { |k, _v| blk(k)} }
+        fn each_key(blk: fn(K) -> bool) { self.each({ |k, _v| blk(k)}) }
 
-        fn each_value(blk: fn(V) -> bool) { self.each { |_k, v| blk(v)} }
+        fn each_value(blk: fn(V) -> bool) { self.each({ |_k, v| blk(v)}) }
     }
 
     fn chains<K,V>(nchains: uint) -> ~[mut chain<K,V>] {
@@ -332,7 +332,7 @@ Convert a set into a vector.
 "]
 fn vec_from_set<T: copy>(s: set<T>) -> ~[T] {
     let mut v = ~[];
-    s.each_key() {|k|
+    do s.each_key() {|k|
         vec::push(v, k);
         true
     };
@@ -343,7 +343,7 @@ fn vec_from_set<T: copy>(s: set<T>) -> ~[T] {
 fn hash_from_vec<K: const copy, V: copy>(hasher: hashfn<K>, eqer: eqfn<K>,
                                          items: ~[(K, V)]) -> hashmap<K, V> {
     let map = hashmap(hasher, eqer);
-    vec::iter(items) { |item|
+    do vec::iter(items) { |item|
         let (key, value) = item;
         map.insert(key, value);
     }
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index 8f852ab7a13..f923b6fedea 100644
--- a/src/libstd/md4.rs
+++ b/src/libstd/md4.rs
@@ -88,7 +88,7 @@ fn md4_str(msg: ~[u8]) -> str {
         f(a); f(b); f(c); f(d);
     }
     let mut result = "";
-    app(a, b, c, d) {|u|
+    do app(a, b, c, d) {|u|
         let mut i = 0u32;
         while i < 4u32 {
             let byte = (u >> (i * 8u32)) as u8;
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index 20598777f11..f1e28ed0290 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -48,7 +48,7 @@ class tcp_socket {
        };
        let close_data_ptr = ptr::addr_of(close_data);
        let stream_handle_ptr = (*(self.socket_data)).stream_handle_ptr;
-       iotask::interact((*(self.socket_data)).iotask) {|loop_ptr|
+       do iotask::interact((*(self.socket_data)).iotask) {|loop_ptr|
           log(debug, #fmt("interact dtor for tcp_socket stream %? loop %?",
             stream_handle_ptr, loop_ptr));
            uv::ll::set_data_for_uv_handle(stream_handle_ptr,
@@ -72,7 +72,7 @@ class tcp_conn_port {
     let server_stream_ptr = ptr::addr_of((*conn_data_ptr).server_stream);
     let stream_closed_po = (*(self.conn_data)).stream_closed_po;
     let iotask = (*conn_data_ptr).iotask;
-    iotask::interact(iotask) {|loop_ptr|
+    do iotask::interact(iotask) {|loop_ptr|
         log(debug, #fmt("dtor for tcp_conn_port loop: %?",
                        loop_ptr));
         uv::ll::close(server_stream_ptr, tcp_nl_close_cb);
@@ -131,7 +131,7 @@ fn connect(input_ip: ip::ip_addr, port: uint,
     // we can send into the interact cb to be handled in libuv..
     log(debug, #fmt("stream_handle_ptr outside interact %?",
         stream_handle_ptr));
-    iotask::interact(iotask) {|loop_ptr|
+    do iotask::interact(iotask) {|loop_ptr|
         log(debug, "in interact cb for tcp client connect..");
         log(debug, #fmt("stream_handle_ptr in interact %?",
             stream_handle_ptr));
@@ -251,7 +251,7 @@ value as the `err` variant
 fn write_future(sock: tcp_socket, raw_write_data: ~[u8])
     -> future<result::result<(), tcp_err_data>> unsafe {
     let socket_data_ptr = ptr::addr_of(*(sock.socket_data));
-    future_spawn {||
+    do future_spawn {||
         write_common_impl(socket_data_ptr, raw_write_data)
     }
 }
@@ -340,7 +340,7 @@ read attempt. Pass `0u` to wait indefinitely
 fn read_future(sock: tcp_socket, timeout_msecs: uint)
     -> future<result::result<~[u8],tcp_err_data>> {
     let socket_data = ptr::addr_of(*(sock.socket_data));
-    future_spawn {||
+    do future_spawn {||
         read_common_impl(socket_data, timeout_msecs)
     }
 }
@@ -387,7 +387,7 @@ fn new_listener(host_ip: ip::ip_addr, port: uint, backlog: uint,
 
     let setup_po = comm::port::<option<tcp_err_data>>();
     let setup_ch = comm::chan(setup_po);
-    iotask::interact(iotask) {|loop_ptr|
+    do iotask::interact(iotask) {|loop_ptr|
         let tcp_addr = ipv4_ip_addr_to_sockaddr_in(host_ip,
                                                    port);
         alt uv::ll::tcp_init(loop_ptr, server_stream_ptr) {
@@ -488,7 +488,7 @@ fn conn_recv_spawn(server_port: tcp_conn_port,
     let new_conn_po = (*(server_port.conn_data)).new_conn_po;
     let iotask = (*(server_port.conn_data)).iotask;
     let new_conn_result = comm::recv(new_conn_po);
-    task::spawn {||
+    do task::spawn {||
         let sock_create_result = alt new_conn_result {
           ok(client_stream_ptr) {
             conn_port_new_tcp_socket(client_stream_ptr, iotask)
@@ -709,7 +709,7 @@ fn listen_for_conn(host_ip: ip::ip_addr, port: uint, backlog: uint,
 
     let setup_po = comm::port::<option<tcp_err_data>>();
     let setup_ch = comm::chan(setup_po);
-    iotask::interact(iotask) {|loop_ptr|
+    do iotask::interact(iotask) {|loop_ptr|
         let tcp_addr = ipv4_ip_addr_to_sockaddr_in(host_ip,
                                                    port);
         alt uv::ll::tcp_init(loop_ptr, server_stream_ptr) {
@@ -755,7 +755,7 @@ fn listen_for_conn(host_ip: ip::ip_addr, port: uint, backlog: uint,
       none {
         on_establish_cb(kill_ch);
         let kill_result = comm::recv(kill_po);
-        iotask::interact(iotask) {|loop_ptr|
+        do iotask::interact(iotask) {|loop_ptr|
             log(debug, #fmt("tcp::listen post-kill recv hl interact %?",
                             loop_ptr));
             (*server_data_ptr).active = false;
@@ -861,7 +861,7 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
     let stream_handle_ptr = (*socket_data).stream_handle_ptr;
     let stop_po = comm::port::<option<tcp_err_data>>();
     let stop_ch = comm::chan(stop_po);
-    iotask::interact((*socket_data).iotask) {|loop_ptr|
+    do iotask::interact((*socket_data).iotask) {|loop_ptr|
         log(debug, "in interact cb for tcp::read_stop");
         alt uv::ll::read_stop(stream_handle_ptr as *uv::ll::uv_stream_t) {
           0i32 {
@@ -893,7 +893,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
     let start_po = comm::port::<option<uv::ll::uv_err_data>>();
     let start_ch = comm::chan(start_po);
     log(debug, "in tcp::read_start before interact loop");
-    iotask::interact((*socket_data).iotask) {|loop_ptr|
+    do iotask::interact((*socket_data).iotask) {|loop_ptr|
         log(debug, #fmt("in tcp::read_start interact cb %?", loop_ptr));
         alt uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t,
                                on_alloc_cb,
@@ -935,7 +935,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
         result_ch: comm::chan(result_po)
     };
     let write_data_ptr = ptr::addr_of(write_data);
-    iotask::interact((*socket_data_ptr).iotask) {|loop_ptr|
+    do iotask::interact((*socket_data_ptr).iotask) {|loop_ptr|
         log(debug, #fmt("in interact cb for tcp::write %?", loop_ptr));
         alt uv::ll::write(write_req_ptr,
                           stream_handle_ptr,
@@ -979,8 +979,8 @@ fn conn_port_new_tcp_socket(
         iotask : iotask
     };
     let client_socket_data_ptr = ptr::addr_of(*client_socket_data);
-    comm::listen {|cont_ch|
-        iotask::interact(iotask) {|loop_ptr|
+    do comm::listen {|cont_ch|
+        do iotask::interact(iotask) {|loop_ptr|
             log(debug, #fmt("in interact cb 4 conn_port_new_tcp.. loop %?",
                 loop_ptr));
             uv::ll::set_data_for_uv_handle(stream_handle_ptr,
@@ -1332,8 +1332,8 @@ mod test {
         let cont_po = comm::port::<()>();
         let cont_ch = comm::chan(cont_po);
         // server
-        task::spawn_sched(task::manual_threads(1u)) {||
-            let actual_req = comm::listen {|server_ch|
+        do task::spawn_sched(task::manual_threads(1u)) {||
+            let actual_req = do comm::listen {|server_ch|
                 run_tcp_test_server(
                     server_ip,
                     server_port,
@@ -1347,7 +1347,7 @@ mod test {
         comm::recv(cont_po);
         // client
         log(debug, "server started, firing up client..");
-        let actual_resp = comm::listen {|client_ch|
+        let actual_resp = do comm::listen {|client_ch|
             run_tcp_test_client(
                 server_ip,
                 server_port,
@@ -1376,8 +1376,8 @@ mod test {
         let cont_po = comm::port::<()>();
         let cont_ch = comm::chan(cont_po);
         // server
-        task::spawn_sched(task::manual_threads(1u)) {||
-            let actual_req = comm::listen {|server_ch|
+        do task::spawn_sched(task::manual_threads(1u)) {||
+            let actual_req = do comm::listen {|server_ch|
                 run_tcp_test_server_listener(
                     server_ip,
                     server_port,
@@ -1391,7 +1391,7 @@ mod test {
         comm::recv(cont_po);
         // client
         log(debug, "server started, firing up client..");
-        let actual_resp = comm::listen {|client_ch|
+        let actual_resp = do comm::listen {|client_ch|
             run_tcp_test_client(
                 server_ip,
                 server_port,
@@ -1413,7 +1413,7 @@ mod test {
                           cont_ch: comm::chan<()>,
                           iotask: iotask) -> str {
 
-        task::spawn_sched(task::manual_threads(1u)) {||
+        do task::spawn_sched(task::manual_threads(1u)) {||
             let server_ip_addr = ip::v4::parse_addr(server_ip);
             let listen_result =
                 listen_for_conn(server_ip_addr, server_port, 128u,
@@ -1428,8 +1428,8 @@ mod test {
                 // will want the POWER
                 {|new_conn, kill_ch|
                 log(debug, "SERVER: new connection!");
-                comm::listen {|cont_ch|
-                    task::spawn_sched(task::manual_threads(1u)) {||
+                do comm::listen {|cont_ch|
+                    do task::spawn_sched(task::manual_threads(1u)) {||
                         log(debug, "SERVER: starting worker for new req");
 
                         let accept_result = accept(new_conn);
@@ -1492,7 +1492,7 @@ mod test {
                                     cont_ch: comm::chan<()>,
                                     iotask: iotask) -> str {
 
-        task::spawn_sched(task::manual_threads(1u)) {||
+        do task::spawn_sched(task::manual_threads(1u)) {||
             let server_ip_addr = ip::v4::parse_addr(server_ip);
             let new_listener_result =
                 new_listener(server_ip_addr, server_port, 128u, iotask);
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index 91460b3a1d7..eab0fa6980f 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -41,9 +41,9 @@ fn map_slices<A: copy send, B: copy send>(
         while base < len {
             let end = uint::min(len, base + items_per_task);
             // FIXME: why is the ::<A, ()> annotation required here? (#2617)
-            vec::unpack_slice::<A, ()>(xs) {|p, _len|
+            do vec::unpack_slice::<A, ()>(xs) {|p, _len|
                 let f = f();
-                let f = future_spawn() {|copy base|
+                let f = do future_spawn() {|copy base|
                     unsafe {
                         let len = end - base;
                         let slice = (ptr::offset(p, base),
@@ -66,7 +66,7 @@ fn map_slices<A: copy send, B: copy send>(
         log(info, #fmt("num_tasks: %?", (num_tasks, futures.len())));
         assert(num_tasks == futures.len());
 
-        let r = futures.map() {|ys|
+        let r = do futures.map() {|ys|
             ys.get()
         };
         assert(r.len() == futures.len());
@@ -76,23 +76,23 @@ fn map_slices<A: copy send, B: copy send>(
 
 #[doc="A parallel version of map."]
 fn map<A: copy send, B: copy send>(xs: ~[A], f: fn~(A) -> B) -> ~[B] {
-    vec::concat(map_slices(xs) {||
+    vec::concat(map_slices(xs, {||
         fn~(_base: uint, slice : &[A], copy f) -> ~[B] {
             vec::map(slice, f)
         }
-    })
+    }))
 }
 
 #[doc="A parallel version of mapi."]
 fn mapi<A: copy send, B: copy send>(xs: ~[A],
                                     f: fn~(uint, A) -> B) -> ~[B] {
-    let slices = map_slices(xs) {||
+    let slices = map_slices(xs, {||
         fn~(base: uint, slice : &[A], copy f) -> ~[B] {
-            vec::mapi(slice) {|i, x|
+            vec::mapi(slice, {|i, x|
                 f(i + base, x)
-            }
+            })
         }
-    };
+    });
     let r = vec::concat(slices);
     log(info, (r.len(), xs.len()));
     assert(r.len() == xs.len());
@@ -105,14 +105,14 @@ In this case, f is a function that creates functions to run over the
 inner elements. This is to skirt the need for copy constructors."]
 fn mapi_factory<A: copy send, B: copy send>(
     xs: ~[A], f: fn() -> fn~(uint, A) -> B) -> ~[B] {
-    let slices = map_slices(xs) {||
+    let slices = map_slices(xs, {||
         let f = f();
         fn~(base: uint, slice : &[A], move f) -> ~[B] {
-            vec::mapi(slice) {|i, x|
+            vec::mapi(slice, {|i, x|
                 f(i + base, x)
-            }
+            })
         }
-    };
+    });
     let r = vec::concat(slices);
     log(info, (r.len(), xs.len()));
     assert(r.len() == xs.len());
@@ -121,20 +121,20 @@ fn mapi_factory<A: copy send, B: copy send>(
 
 #[doc="Returns true if the function holds for all elements in the vector."]
 fn alli<A: copy send>(xs: ~[A], f: fn~(uint, A) -> bool) -> bool {
-    vec::all(map_slices(xs) {||
+    do vec::all(map_slices(xs, {||
         fn~(base: uint, slice : &[A], copy f) -> bool {
-            vec::alli(slice) {|i, x|
+            vec::alli(slice, {|i, x|
                 f(i + base, x)
-            }
+            })
         }
-    }) {|x| x }
+    })) {|x| x }
 }
 
 #[doc="Returns true if the function holds for any elements in the vector."]
 fn any<A: copy send>(xs: ~[A], f: fn~(A) -> bool) -> bool {
-    vec::any(map_slices(xs) {||
+    do vec::any(map_slices(xs, {||
         fn~(_base : uint, slice: &[A], copy f) -> bool {
             vec::any(slice, f)
         }
-    }) {|x| x }
+    })) {|x| x }
 }
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 28b6ac7acb2..374add74404 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -397,7 +397,7 @@ Loop through a rope, char by char, until the end.
 * it - A block to execute with each consecutive character of the rope.
 "]
 fn iter_chars(rope: rope, it: fn(char)) {
-    loop_chars(rope) {|x|
+    do loop_chars(rope) {|x|
         it(x);
         true
     };
diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs
index c6d75f538c8..6819711aad6 100644
--- a/src/libstd/serialization.rs
+++ b/src/libstd/serialization.rs
@@ -84,9 +84,9 @@ iface deserializer {
 // In some cases, these should eventually be coded as traits.
 
 fn emit_from_vec<S: serializer, T>(s: S, v: ~[T], f: fn(T)) {
-    s.emit_vec(vec::len(v)) {||
-        vec::iteri(v) {|i,e|
-            s.emit_vec_elt(i) {||
+    do s.emit_vec(vec::len(v)) {||
+        do vec::iteri(v) {|i,e|
+            do s.emit_vec_elt(i) {||
                 f(e)
             }
         }
@@ -94,9 +94,9 @@ fn emit_from_vec<S: serializer, T>(s: S, v: ~[T], f: fn(T)) {
 }
 
 fn read_to_vec<D: deserializer, T: copy>(d: D, f: fn() -> T) -> ~[T] {
-    d.read_vec {|len|
-        vec::from_fn(len) {|i|
-            d.read_vec_elt(i) {|| f() }
+    do d.read_vec {|len|
+        do vec::from_fn(len) {|i|
+            do d.read_vec_elt(i) {|| f() }
         }
     }
 }
@@ -234,16 +234,16 @@ fn deserialize_bool<D: deserializer>(d: D) -> bool {
 }
 
 fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) {
-    s.emit_enum("option") {||
+    do s.emit_enum("option") {||
         alt v {
           none {
-            s.emit_enum_variant("none", 0u, 0u) {||
+            do s.emit_enum_variant("none", 0u, 0u) {||
             }
           }
 
           some(v) {
-            s.emit_enum_variant("some", 1u, 1u) {||
-                s.emit_enum_variant_arg(0u) {||
+            do s.emit_enum_variant("some", 1u, 1u) {||
+                do s.emit_enum_variant_arg(0u) {||
                     st(v)
                 }
             }
@@ -254,16 +254,16 @@ fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) {
 
 fn deserialize_option<D: deserializer,T: copy>(d: D, st: fn() -> T)
     -> option<T> {
-    d.read_enum("option") {||
-        d.read_enum_variant {|i|
+    do d.read_enum("option") {||
+        do d.read_enum_variant {|i|
             alt check i {
               0u { // none
                 none
               }
               1u { // some(v)
-                some(d.read_enum_variant_arg(0u) {||
+                some(d.read_enum_variant_arg(0u, {||
                     st()
-                })
+                }))
               }
             }
         }
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index 3369e95f1a3..a7df6df281a 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -102,7 +102,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
         }
     }
     fn each_value(it: fn(V) -> bool) {
-        self.each {|_i, v| it(v)}
+        self.each({|_i, v| it(v)});
     }
 }
 
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 8358123bf1f..6c18afb6474 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -216,7 +216,7 @@ fn run_tests_console(opts: test_opts,
 fn print_failures(st: console_test_state) {
     st.out.write_line("\nfailures:");
     let failures = copy st.failures;
-    let failures = vec::map(failures) {|test| test.name};
+    let failures = vec::map(failures, {|test| test.name});
     let failures = sort::merge_sort(str::le, failures);
     for vec::each(failures) {|name|
         st.out.write_line(#fmt["    %s", name]);
@@ -390,7 +390,7 @@ fn run_test(+test: test_desc, monitor_ch: comm::chan<monitor_msg>) {
         ret;
     }
 
-    task::spawn {||
+    do task::spawn {||
         let testfn = copy test.fn;
         let mut builder = task::builder();
         let result_future = task::future_result(builder);
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 5cfcbc7fd8c..e38f72ab189 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -283,21 +283,21 @@ fn strptime(s: str, format: str) -> result<tm, str> {
           }
           'c' {
             parse_type(s, pos, 'a', tm)
-                .chain { |pos| parse_char(s, pos, ' ') }
-                .chain { |pos| parse_type(s, pos, 'b', tm) }
-                .chain { |pos| parse_char(s, pos, ' ') }
-                .chain { |pos| parse_type(s, pos, 'e', tm) }
-                .chain { |pos| parse_char(s, pos, ' ') }
-                .chain { |pos| parse_type(s, pos, 'T', tm) }
-                .chain { |pos| parse_char(s, pos, ' ') }
-                .chain { |pos| parse_type(s, pos, 'Y', tm) }
+                .chain({ |pos| parse_char(s, pos, ' ') })
+                .chain({ |pos| parse_type(s, pos, 'b', tm) })
+                .chain({ |pos| parse_char(s, pos, ' ') })
+                .chain({ |pos| parse_type(s, pos, 'e', tm) })
+                .chain({ |pos| parse_char(s, pos, ' ') })
+                .chain({ |pos| parse_type(s, pos, 'T', tm) })
+                .chain({ |pos| parse_char(s, pos, ' ') })
+                .chain({ |pos| parse_type(s, pos, 'Y', tm) })
           }
           'D' | 'x' {
             parse_type(s, pos, 'm', tm)
-                .chain { |pos| parse_char(s, pos, '/') }
-                .chain { |pos| parse_type(s, pos, 'd', tm) }
-                .chain { |pos| parse_char(s, pos, '/') }
-                .chain { |pos| parse_type(s, pos, 'y', tm) }
+                .chain({ |pos| parse_char(s, pos, '/') })
+                .chain({ |pos| parse_type(s, pos, 'd', tm) })
+                .chain({ |pos| parse_char(s, pos, '/') })
+                .chain({ |pos| parse_type(s, pos, 'y', tm) })
           }
           'd' {
             alt match_digits(s, pos, 2u, false) {
@@ -313,10 +313,10 @@ fn strptime(s: str, format: str) -> result<tm, str> {
           }
           'F' {
             parse_type(s, pos, 'Y', tm)
-                .chain { |pos| parse_char(s, pos, '-') }
-                .chain { |pos| parse_type(s, pos, 'm', tm) }
-                .chain { |pos| parse_char(s, pos, '-') }
-                .chain { |pos| parse_type(s, pos, 'd', tm) }
+                .chain({ |pos| parse_char(s, pos, '-') })
+                .chain({ |pos| parse_type(s, pos, 'm', tm) })
+                .chain({ |pos| parse_char(s, pos, '-') })
+                .chain({ |pos| parse_type(s, pos, 'd', tm) })
           }
           'H' {
             // FIXME (#2350): range check.
@@ -398,17 +398,17 @@ fn strptime(s: str, format: str) -> result<tm, str> {
           }
           'R' {
             parse_type(s, pos, 'H', tm)
-                .chain { |pos| parse_char(s, pos, ':') }
-                .chain { |pos| parse_type(s, pos, 'M', tm) }
+                .chain({ |pos| parse_char(s, pos, ':') })
+                .chain({ |pos| parse_type(s, pos, 'M', tm) })
           }
           'r' {
             parse_type(s, pos, 'I', tm)
-                .chain { |pos| parse_char(s, pos, ':') }
-                .chain { |pos| parse_type(s, pos, 'M', tm) }
-                .chain { |pos| parse_char(s, pos, ':') }
-                .chain { |pos| parse_type(s, pos, 'S', tm) }
-                .chain { |pos| parse_char(s, pos, ' ') }
-                .chain { |pos| parse_type(s, pos, 'p', tm) }
+                .chain({ |pos| parse_char(s, pos, ':') })
+                .chain({ |pos| parse_type(s, pos, 'M', tm) })
+                .chain({ |pos| parse_char(s, pos, ':') })
+                .chain({ |pos| parse_type(s, pos, 'S', tm) })
+                .chain({ |pos| parse_char(s, pos, ' ') })
+                .chain({ |pos| parse_type(s, pos, 'p', tm) })
           }
           'S' {
             // FIXME (#2350): range check.
@@ -424,10 +424,10 @@ fn strptime(s: str, format: str) -> result<tm, str> {
           //'s' {}
           'T' | 'X' {
             parse_type(s, pos, 'H', tm)
-                .chain { |pos| parse_char(s, pos, ':') }
-                .chain { |pos| parse_type(s, pos, 'M', tm) }
-                .chain { |pos| parse_char(s, pos, ':') }
-                .chain { |pos| parse_type(s, pos, 'S', tm) }
+                .chain({ |pos| parse_char(s, pos, ':') })
+                .chain({ |pos| parse_type(s, pos, 'M', tm) })
+                .chain({ |pos| parse_char(s, pos, ':') })
+                .chain({ |pos| parse_type(s, pos, 'S', tm) })
           }
           't' { parse_char(s, pos, '\t') }
           'u' {
@@ -443,10 +443,10 @@ fn strptime(s: str, format: str) -> result<tm, str> {
           }
           'v' {
             parse_type(s, pos, 'e', tm)
-                .chain { |pos| parse_char(s, pos, '-') }
-                .chain { |pos| parse_type(s, pos, 'b', tm) }
-                .chain { |pos| parse_char(s, pos, '-') }
-                .chain { |pos| parse_type(s, pos, 'Y', tm) }
+                .chain({ |pos| parse_char(s, pos, '-') })
+                .chain({ |pos| parse_type(s, pos, 'b', tm) })
+                .chain({ |pos| parse_char(s, pos, '-') })
+                .chain({ |pos| parse_type(s, pos, 'Y', tm) })
           }
           //'W' {}
           'w' {
@@ -526,7 +526,7 @@ fn strptime(s: str, format: str) -> result<tm, str> {
         }
     }
 
-    io::with_str_reader(format) { |rdr|
+    do io::with_str_reader(format) { |rdr|
         let tm = {
             mut tm_sec: 0_i32,
             mut tm_min: 0_i32,
@@ -738,7 +738,7 @@ fn strftime(format: str, tm: tm) -> str {
 
     let mut buf = "";
 
-    io::with_str_reader(format) { |rdr|
+    do io::with_str_reader(format) { |rdr|
         while !rdr.eof() {
             alt rdr.read_char() {
                 '%' { buf += parse_type(rdr.read_char(), tm); }
@@ -1002,7 +1002,7 @@ mod tests {
             }
         }
 
-        [
+        do [
             "Sunday",
             "Monday",
             "Tuesday",
@@ -1012,7 +1012,7 @@ mod tests {
             "Saturday"
         ]/_.iter { |day| assert test(day, "%A"); }
 
-        [
+        do [
             "Sun",
             "Mon",
             "Tue",
@@ -1022,7 +1022,7 @@ mod tests {
             "Sat"
         ]/_.iter { |day| assert test(day, "%a"); }
 
-        [
+        do [
             "January",
             "February",
             "March",
@@ -1037,7 +1037,7 @@ mod tests {
             "December"
         ]/_.iter { |day| assert test(day, "%B"); }
 
-        [
+        do [
             "Jan",
             "Feb",
             "Mar",
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index 7d7e01bb892..b907944e51a 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -31,7 +31,7 @@ fn delayed_send<T: copy send>(iotask: iotask,
             let timer_done_ch_ptr = ptr::addr_of(timer_done_ch);
             let timer = uv::ll::timer_t();
             let timer_ptr = ptr::addr_of(timer);
-            iotask::interact(iotask) {|loop_ptr|
+            do iotask::interact(iotask) {|loop_ptr|
                 let init_result = uv::ll::timer_init(loop_ptr, timer_ptr);
                 if (init_result == 0i32) {
                     let start_result = uv::ll::timer_start(
@@ -151,7 +151,7 @@ mod test {
     #[test]
     fn test_gl_timer_sleep_stress1() {
         let hl_loop = uv::global_loop::get();
-        iter::repeat(200u) {||
+        do iter::repeat(200u) {||
             sleep(hl_loop, 1u);
         }
     }
@@ -171,14 +171,14 @@ mod test {
 
         };
 
-        iter::repeat(repeat) {||
+        do iter::repeat(repeat) {||
 
             for spec.each {|spec|
                 let (times, maxms) = spec;
-                task::spawn {||
+                do task::spawn {||
                     import rand::*;
                     let rng = rng();
-                    iter::repeat(times) {||
+                    do iter::repeat(times) {||
                         sleep(hl_loop, rng.next() as uint % maxms);
                     }
                     comm::send(ch, ());
@@ -186,7 +186,7 @@ mod test {
             }
         }
 
-        iter::repeat(repeat * spec.len()) {||
+        do iter::repeat(repeat * spec.len()) {||
             comm::recv(po)
         }
     }
@@ -204,14 +204,14 @@ mod test {
         let mut failures = 0;
         let hl_loop = uv::global_loop::get();
 
-        iter::repeat(times as uint) {||
+        do iter::repeat(times as uint) {||
             task::yield();
 
             let expected = rand::rng().gen_str(16u);
             let test_po = comm::port::<str>();
             let test_ch = comm::chan(test_po);
 
-            task::spawn() {||
+            do task::spawn() {||
                 delayed_send(hl_loop, 1u, test_ch, expected);
             };
 
@@ -231,12 +231,12 @@ mod test {
         let mut failures = 0;
         let hl_loop = uv::global_loop::get();
 
-        iter::repeat(times as uint) {||
+        do iter::repeat(times as uint) {||
             let expected = rand::rng().gen_str(16u);
             let test_po = comm::port::<str>();
             let test_ch = comm::chan(test_po);
 
-            task::spawn() {||
+            do task::spawn() {||
                 delayed_send(hl_loop, 1000u, test_ch, expected);
             };
 
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index ec2ce9b684c..6ea7b48ad97 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -56,12 +56,12 @@ fn get_monitor_task_gl() -> iotask unsafe {
     #debug("before priv::chan_from_global_ptr");
     type monchan = chan<iotask>;
 
-    let monitor_ch = chan_from_global_ptr::<monchan>(monitor_loop_chan_ptr,
+    let monitor_ch = do chan_from_global_ptr::<monchan>(monitor_loop_chan_ptr,
                                                      builder_fn) {|msg_po|
         #debug("global monitor task starting");
 
         // As a weak task the runtime will notify us when to exit
-        weaken_task() {|weak_exit_po|
+        do weaken_task() {|weak_exit_po|
             #debug("global monitor task is now weak");
             let hl_loop = spawn_loop();
             loop {
@@ -87,7 +87,7 @@ fn get_monitor_task_gl() -> iotask unsafe {
 
     // once we have a chan to the monitor loop, we ask it for
     // the libuv loop's async handle
-    listen { |fetch_ch|
+    do listen { |fetch_ch|
         monitor_ch.send(fetch_ch);
         fetch_ch.recv()
     }
@@ -95,11 +95,11 @@ fn get_monitor_task_gl() -> iotask unsafe {
 
 fn spawn_loop() -> iotask unsafe {
     let builder = task::builder();
-    task::add_wrapper(builder) {|task_body|
+    do task::add_wrapper(builder) {|task_body|
         fn~(move task_body) {
             // The I/O loop task also needs to be weak so it doesn't keep
             // the runtime alive
-            weaken_task {|weak_exit_po|
+            do weaken_task {|weak_exit_po|
                 #debug("global libuv task is now weak %?", weak_exit_po);
                 task_body();
 
@@ -129,7 +129,7 @@ mod test {
         log(debug, "in simple timer cb");
         ll::timer_stop(timer_ptr);
         let hl_loop = get_gl();
-        iotask::interact(hl_loop) {|_loop_ptr|
+        do iotask::interact(hl_loop) {|_loop_ptr|
             log(debug, "closing timer");
             ll::close(timer_ptr, simple_timer_close_cb);
             log(debug, "about to deref exit_ch_ptr");
@@ -146,7 +146,7 @@ mod test {
                        exit_ch_ptr));
         let timer_handle = ll::timer_t();
         let timer_ptr = ptr::addr_of(timer_handle);
-        iotask::interact(iotask) {|loop_ptr|
+        do iotask::interact(iotask) {|loop_ptr|
             log(debug, "user code inside interact loop!!!");
             let init_status = ll::timer_init(loop_ptr, timer_ptr);
             if(init_status == 0i32) {
@@ -191,13 +191,13 @@ mod test {
         let exit_po = comm::port::<()>();
         let exit_ch = comm::chan(exit_po);
         let cycles = 5000u;
-        iter::repeat(cycles) {||
+        do iter::repeat(cycles) {||
             task::spawn_sched(task::manual_threads(1u), {||
                 impl_uv_hl_simple_timer(hl_loop);
                 comm::send(exit_ch, ());
             });
         };
-        iter::repeat(cycles) {||
+        do iter::repeat(cycles) {||
             comm::recv(exit_po);
         };
         log(debug, "test_stress_gl_uv_global_loop_high_level_global_timer"+
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index 3833cafe15e..625a261b6f5 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -39,9 +39,9 @@ fn spawn_iotask(-builder: task::builder) -> iotask {
         with get_opts(builder)
     });
 
-    listen {|iotask_ch|
+    do listen {|iotask_ch|
 
-        run(copy(builder)) {||
+        do run(copy(builder)) {||
             #debug("entering libuv task");
             run_loop(iotask_ch);
             #debug("libuv task exiting");
@@ -211,7 +211,7 @@ mod test {
             exit_ch: exit_ch
         };
         let ah_data_ptr = ptr::addr_of(ah_data);
-        interact(iotask) {|loop_ptr|
+        do interact(iotask) {|loop_ptr|
             ll::async_init(loop_ptr, ah_ptr, async_handle_cb);
             ll::set_data_for_uv_handle(ah_ptr, ah_data_ptr as *libc::c_void);
             ll::async_send(ah_ptr);
@@ -224,7 +224,7 @@ mod test {
     unsafe fn spawn_test_loop(exit_ch: comm::chan<()>) -> iotask {
         let iotask_port = comm::port::<iotask>();
         let iotask_ch = comm::chan(iotask_port);
-        task::spawn_sched(task::manual_threads(1u)) {||
+        do task::spawn_sched(task::manual_threads(1u)) {||
             run_loop(iotask_ch);
             exit_ch.send(());
         };
@@ -255,13 +255,13 @@ mod test {
         // called, at least.
         let work_exit_po = comm::port::<()>();
         let work_exit_ch = comm::chan(work_exit_po);
-        iter::repeat(7u) {||
-            task::spawn_sched(task::manual_threads(1u), {||
+        do iter::repeat(7u) {||
+            do task::spawn_sched(task::manual_threads(1u)) {||
                 impl_uv_iotask_async(iotask);
                 comm::send(work_exit_ch, ());
-            });
+            };
         };
-        iter::repeat(7u) {||
+        do iter::repeat(7u) {||
             comm::recv(work_exit_po);
         };
         log(debug, "sending teardown_loop msg..");
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index 043c4e2204a..bb8eac6d528 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -1262,7 +1262,7 @@ mod test {
         let continue_chan = comm::chan::<bool>(continue_port);
         let continue_chan_ptr = ptr::addr_of(continue_chan);
 
-        task::spawn_sched(task::manual_threads(1u)) {||
+        do task::spawn_sched(task::manual_threads(1u)) {||
             impl_uv_tcp_server(bind_ip, port,
                                kill_server_msg,
                                server_resp_msg,
@@ -1275,7 +1275,7 @@ mod test {
         comm::recv(continue_port);
         log(debug, "received on continue port, set up tcp client");
 
-        task::spawn_sched(task::manual_threads(1u)) {||
+        do task::spawn_sched(task::manual_threads(1u)) {||
             impl_uv_tcp_request(request_ip, port,
                                kill_server_msg,
                                ptr::addr_of(client_chan));