Convert to new closure syntax

25 files changed, 217 insertions, 219 deletions

diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index 972bae82b8b..adc3a7969d6 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -45,7 +45,7 @@ fn process(v0: bitv, v1: bitv, op: fn(uint, uint) -> uint) -> bool {
     assert (vec::len(v0.storage) == len);
     assert (v0.nbits == v1.nbits);
     let mut changed = false;
-    for uint::range(0u, len) {|i|
+    for uint::range(0u, len) |i| {
         let w0 = v0.storage[i];
         let w1 = v1.storage[i];
         let w = op(w0, w1);
@@ -89,7 +89,7 @@ fn assign(v0: bitv, v1: bitv) -> bool {
 fn clone(v: bitv) -> bitv {
     let storage = vec::to_mut(vec::from_elem(v.nbits / uint_bits + 1u, 0u));
     let len = vec::len(v.storage);
-    for uint::range(0u, len) {|i| storage[i] = v.storage[i]; };
+    for uint::range(0u, len) |i| { storage[i] = v.storage[i]; };
     ret @{storage: storage, nbits: v.nbits};
 }
 
@@ -113,22 +113,22 @@ contain identical elements.
 fn equal(v0: bitv, v1: bitv) -> bool {
     if v0.nbits != v1.nbits { ret false; }
     let len = vec::len(v1.storage);
-    for uint::iterate(0u, len) {|i|
+    for uint::iterate(0u, len) |i| {
         if v0.storage[i] != v1.storage[i] { ret false; }
     }
 }
 
 #[doc = "Set all bits to 0"]
 #[inline(always)]
-fn clear(v: bitv) { for each_storage(v) {|w| w = 0u } }
+fn clear(v: bitv) { for each_storage(v) |w| { w = 0u } }
 
 #[doc = "Set all bits to 1"]
 #[inline(always)]
-fn set_all(v: bitv) { for each_storage(v) {|w| w = !0u } }
+fn set_all(v: bitv) { for each_storage(v) |w| { w = !0u } }
 
 #[doc = "Invert all bits"]
 #[inline(always)]
-fn invert(v: bitv) { for each_storage(v) {|w| w = !w } }
+fn invert(v: bitv) { for each_storage(v) |w| { w = !w } }
 
 #[doc = "
 Calculate the difference between two bitvectors
@@ -163,14 +163,14 @@ fn set(v: bitv, i: uint, x: bool) {
 
 #[doc = "Returns true if all bits are 1"]
 fn is_true(v: bitv) -> bool {
-    for each(v) {|i| if !i { ret false; } }
+    for each(v) |i| { if !i { ret false; } }
     ret true;
 }
 
 
 #[doc = "Returns true if all bits are 0"]
 fn is_false(v: bitv) -> bool {
-    for each(v) {|i| if i { ret false; } }
+    for each(v) |i| { if i { ret false; } }
     ret true;
 }
 
@@ -184,7 +184,7 @@ Converts the bitvector to a vector of uint with the same length.
 Each uint in the resulting vector has either value 0u or 1u.
 "]
 fn to_vec(v: bitv) -> ~[uint] {
-    let sub = {|x|init_to_vec(v, x)};
+    let sub = |x| init_to_vec(v, x);
     ret vec::from_fn::<uint>(v.nbits, sub);
 }
 
@@ -199,7 +199,7 @@ fn each(v: bitv, f: fn(bool) -> bool) {
 
 #[inline(always)]
 fn each_storage(v: bitv, op: fn(&uint) -> bool) {
-    for uint::range(0u, vec::len(v.storage)) {|i|
+    for uint::range(0u, vec::len(v.storage)) |i| {
         let mut w = v.storage[i];
         let b = !op(w);
         v.storage[i] = w;
@@ -215,7 +215,7 @@ is either '0' or '1'.
 "]
 fn to_str(v: bitv) -> str {
     let mut rs = "";
-    for each(v) {|i| if i { rs += "1"; } else { rs += "0"; } }
+    for each(v) |i| { if i { rs += "1"; } else { rs += "0"; } }
     ret rs;
 }
 
diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index 3c89adfb1aa..02ed63981b9 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -140,7 +140,7 @@ mod tests {
         assert mem as int != 0;
 
         ret unsafe { c_vec_with_dtor(mem as *mut u8, n as uint,
-                                     {||free(mem)}) };
+                                     ||free(mem)) };
     }
 
     #[test]
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index c03f09f1ce0..501a9dabc5a 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -57,7 +57,7 @@ fn create<T: copy>() -> t<T> {
                 self.lo = self.elts.len() - 1u;
             } else { self.lo -= 1u; }
             if self.lo == self.hi {
-                self.elts.swap({ |v| grow(self.nelts, oldlo, v) });
+                self.elts.swap(|v| grow(self.nelts, oldlo, v));
                 self.lo = self.elts.len() - 1u;
                 self.hi = self.nelts;
             }
@@ -66,7 +66,7 @@ fn create<T: copy>() -> t<T> {
         }
         fn add_back(t: T) {
             if self.lo == self.hi && self.nelts != 0u {
-                self.elts.swap({ |v| grow(self.nelts, self.lo, v) });
+                self.elts.swap(|v| grow(self.nelts, self.lo, v));
                 self.lo = 0u;
                 self.hi = self.nelts;
             }
@@ -292,7 +292,7 @@ mod tests {
                                     two(17, 42));
 
         #debug("*** test parameterized: taggypar<int>");
-        let eq4: eqfn<taggypar<int>> = {|x,y|taggypareq::<int>(x, y)};
+        let eq4: eqfn<taggypar<int>> = |x,y| taggypareq::<int>(x, y);
         test_parameterized::<taggypar<int>>(eq4, onepar::<int>(1),
                                             twopar::<int>(1, 2),
                                             threepar::<int>(1, 2, 3),
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index e3152839793..70d974f255f 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) {
-        do 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) {
-        do 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) {
-        do 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) {
-        do 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) {
-        do 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) {
-        do 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()) {
-        do 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];
-        do 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()"];
-        do 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>) {
-        do 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) {
-                do 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> {
-        do s.read_enum("core::option::t") {||
-            do 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 = do 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/getopts.rs b/src/libstd/getopts.rs
index 6b1e7c38a48..a82d131f516 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -145,7 +145,7 @@ fn name_str(nm: name) -> str {
 }
 
 fn find_opt(opts: ~[opt], nm: name) -> option<uint> {
-    vec::position(opts, { |opt| opt.name == nm })
+    vec::position(opts, |opt| opt.name == nm)
 }
 
 #[doc = "
@@ -228,7 +228,7 @@ fn getopts(args: ~[str], opts: ~[opt]) -> result unsafe {
                 }
             }
             let mut name_pos = 0u;
-            for vec::each(names) {|nm|
+            for vec::each(names) |nm| {
                 name_pos += 1u;
                 let optid = alt find_opt(opts, nm) {
                   some(id) { id }
@@ -297,7 +297,7 @@ fn opt_present(m: match, nm: str) -> bool {
 
 #[doc = "Returns true if any of several options were matched"]
 fn opts_present(m: match, names: ~[str]) -> bool {
-    for vec::each(names) {|nm|
+    for vec::each(names) |nm| {
         alt find_opt(m.opts, mkname(nm)) {
           some(_) { ret true; }
           _ { }
@@ -323,7 +323,7 @@ Fails if the no option was provided from the given list, or if the no such
 option took an argument
 "]
 fn opts_str(m: match, names: ~[str]) -> str {
-    for vec::each(names) {|nm|
+    for vec::each(names) |nm| {
         alt opt_val(m, nm) {
           val(s) { ret s }
           _ {  }
@@ -340,7 +340,7 @@ Used when an option accepts multiple values.
 "]
 fn opt_strs(m: match, nm: str) -> ~[str] {
     let mut acc: ~[str] = ~[];
-    for vec::each(opt_vals(m, nm)) {|v|
+    for vec::each(opt_vals(m, nm)) |v| {
         alt v { val(s) { vec::push(acc, s); } _ { } }
     }
     ret acc;
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 51f59f59d13..859349d4170 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -54,7 +54,7 @@ fn to_writer(wr: io::writer, j: json) {
       list(v) {
         wr.write_char('[');
         let mut first = true;
-        for (*v).each { |item|
+        for (*v).each |item| {
             if !first {
                 wr.write_str(", ");
             }
@@ -71,7 +71,7 @@ fn to_writer(wr: io::writer, j: json) {
 
         wr.write_str("{ ");
         let mut first = true;
-        for d.each { |key, value|
+        for d.each |key, value| {
             if !first {
                 wr.write_str(", ");
             }
@@ -90,7 +90,7 @@ fn to_writer(wr: io::writer, j: json) {
 
 fn escape_str(s: str) -> str {
     let mut escaped = "\"";
-    do 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 = {
@@ -186,7 +186,7 @@ impl parser for parser {
     }
 
     fn parse_ident(ident: str, value: json) -> result<json, error> {
-        if str::all(ident, { |c| c == self.next_char() }) {
+        if str::all(ident, |c| c == self.next_char()) {
             self.bump();
             ok(value)
         } else {
@@ -487,7 +487,7 @@ fn eq(value0: json, value1: json) -> bool {
       (dict(d0), dict(d1)) {
           if d0.size() == d1.size() {
               let mut equal = true;
-              for d0.each { |k, v0|
+              for d0.each |k, v0| {
                   alt d1.find(k) {
                     some(v1) {
                         if !eq(v0, v1) { equal = false; } }
@@ -598,13 +598,13 @@ 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> {
     fn to_json() -> json {
         let d = map::str_hash();
-        for self.each() { |key, value|
+        for self.each() |key, value| {
             d.insert(copy key, value.to_json());
         }
         dict(d)
@@ -635,7 +635,7 @@ mod tests {
     fn mk_dict(items: ~[(str, json)]) -> json {
         let d = map::str_hash();
 
-        do 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 5018f9860ce..30df6432d05 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -11,7 +11,7 @@ enum list<T> {
 
 #[doc = "Create a list from a vector"]
 fn from_vec<T: copy>(v: ~[T]) -> @list<T> {
-    vec::foldr(v, @nil::<T>, { |h, t| @cons(h, t) })
+    vec::foldr(v, @nil::<T>, |h, t| @cons(h, t))
 }
 
 #[doc = "
@@ -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;
-    do iter(ls) {|elt| accum = f(accum, elt);}
+    do iter(ls) |elt| { accum = f(accum, elt);}
     accum
 }
 
@@ -55,7 +55,7 @@ fn find<T: copy>(ls: @list<T>, f: fn(T) -> bool) -> option<T> {
 
 #[doc = "Returns true if a list contains an element with the given value"]
 fn has<T: copy>(ls: @list<T>, elt: T) -> bool {
-    for each(ls) { |e|
+    for each(ls) |e| {
         if e == elt { ret true; }
     }
     ret false;
@@ -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 331bc6dcced..6163f6154a1 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -151,7 +151,7 @@ mod chained {
             let n_old_chains = vec::len(self.chains);
             let n_new_chains: uint = uint::next_power_of_two(n_old_chains+1u);
             let new_chains = chains(n_new_chains);
-            for self.each_entry {|entry|
+            for self.each_entry |entry| {
                 let idx = entry.hash % n_new_chains;
                 entry.next = new_chains[idx];
                 new_chains[idx] = present(entry);
@@ -256,14 +256,14 @@ mod chained {
         }
 
         fn each(blk: fn(K,V) -> bool) {
-            for self.each_entry { |entry|
+            for self.each_entry |entry| {
                 if !blk(entry.key, copy entry.value) { break; }
             }
         }
 
-        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>] {
@@ -302,7 +302,7 @@ fn str_hash<V: copy>() -> hashmap<str, V> {
 
 #[doc = "Construct a hashmap for boxed string keys"]
 fn box_str_hash<V: copy>() -> hashmap<@str, V> {
-    ret hashmap({|x: @str|str::hash(*x)}, {|x,y|str::eq(*x,*y)});
+    ret hashmap(|x: @str| str::hash(*x), |x,y| str::eq(*x,*y));
 }
 
 #[doc = "Construct a hashmap for byte string keys"]
@@ -332,7 +332,7 @@ Convert a set into a vector.
 "]
 fn vec_from_set<T: copy>(s: set<T>) -> ~[T] {
     let mut v = ~[];
-    do 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);
-    do 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 f923b6fedea..d7bd7ed811a 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 = "";
-    do 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_ip.rs b/src/libstd/net_ip.rs
index 64cded848d1..f1e15dec6de 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -66,7 +66,7 @@ j    Fails if the string is not a valid IPv4 address
         }
     }
     fn try_parse_addr(ip: str) -> result::result<ip_addr,parse_addr_err> {
-        let parts = vec::map(str::split_char(ip, '.'), {|s|
+        let parts = vec::map(str::split_char(ip, '.'), |s| {
             alt uint::from_str(s) {
               some(n) if n <= 255u { n }
               _ { 256u }
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index f1e28ed0290..c995e021f5f 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;
-       do 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;
-    do 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));
-    do 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));
-    do 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));
-    do 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);
-    do 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);
-    do 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);
-    do 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);
-        do 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);
-    do 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");
-    do 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);
-    do 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);
-    do comm::listen {|cont_ch|
-        do 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
-        do task::spawn_sched(task::manual_threads(1u)) {||
-            let actual_req = do 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 = do 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
-        do task::spawn_sched(task::manual_threads(1u)) {||
-            let actual_req = do 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 = do comm::listen {|client_ch|
+        let actual_resp = do comm::listen |client_ch| {
             run_tcp_test_client(
                 server_ip,
                 server_port,
@@ -1413,23 +1413,21 @@ mod test {
                           cont_ch: comm::chan<()>,
                           iotask: iotask) -> str {
 
-        do 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,
-                iotask,
-                // on_establish_cb -- called when listener is set up
-                {|kill_ch|
+                iotask, |kill_ch| {
+                    // on_establish_cb -- called when listener is set up
                     log(debug, #fmt("establish_cb %?",
                         kill_ch));
                     comm::send(cont_ch, ());
-                },
+                }, |new_conn, kill_ch| {
                 // risky to run this on the loop, but some users
                 // will want the POWER
-                {|new_conn, kill_ch|
                 log(debug, "SERVER: new connection!");
-                do comm::listen {|cont_ch|
-                    do 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 +1490,7 @@ mod test {
                                     cont_ch: comm::chan<()>,
                                     iotask: iotask) -> str {
 
-        do 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 eab0fa6980f..3447d55827a 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)
-            do vec::unpack_slice::<A, ()>(xs) {|p, _len|
+            do vec::unpack_slice::<A, ()>(xs) |p, _len| {
                 let f = f();
-                let f = do 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 = do futures.map() {|ys|
+        let r = do futures.map() |ys| {
             ys.get()
         };
         assert(r.len() == futures.len());
@@ -76,7 +76,7 @@ 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)
         }
@@ -86,9 +86,9 @@ fn map<A: copy send, B: copy send>(xs: ~[A], f: fn~(A) -> B) -> ~[B] {
 #[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)
             })
         }
@@ -105,10 +105,10 @@ 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)
             })
         }
@@ -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 {
-    do 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 {
-    do 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 374add74404..a7d54daba9a 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -158,13 +158,13 @@ fn concat(v: ~[rope]) -> rope {
     let mut len = vec::len(v);
     if len == 0u { ret node::empty; }
     let ropes = vec::to_mut(vec::from_elem(len, v[0]));
-    for uint::range(1u, len) {|i|
+    for uint::range(1u, len) |i| {
        ropes[i] = v[i];
     }
 
     //Merge progresively
     while len > 1u {
-        for uint::range(0u, len/2u) {|i|
+        for uint::range(0u, len/2u) |i| {
             ropes[i] = append_rope(ropes[2u*i], ropes[2u*i+1u]);
         }
         if len%2u != 0u {
@@ -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)) {
-    do loop_chars(rope) {|x|
+    do loop_chars(rope) |x| {
         it(x);
         true
     };
@@ -1038,11 +1038,11 @@ mod node {
     }
 
     fn loop_chars(node: @node, it: fn(char) -> bool) -> bool {
-        ret loop_leaves(node, {|leaf|
+        ret loop_leaves(node,|leaf| {
             str::all_between(*leaf.content,
                              leaf.byte_offset,
                              leaf.byte_len, it)
-        })
+        });
     }
 
     #[doc ="
@@ -1350,19 +1350,19 @@ mod tests {
     fn char_at1() {
         //Generate a large rope
         let mut r = of_str(@ "123456789");
-        for uint::range(0u, 10u){|_i|
+        for uint::range(0u, 10u) |_i| {
             r = append_rope(r, r);
         }
 
         //Copy it in the slowest possible way
         let mut r2 = empty();
-        for uint::range(0u, char_len(r)){|i|
+        for uint::range(0u, char_len(r)) |i| {
             r2 = append_char(r2, char_at(r, i));
         }
         assert eq(r, r2);
 
         let mut r3 = empty();
-        for uint::range(0u, char_len(r)){|i|
+        for uint::range(0u, char_len(r)) |i| {
             r3 = prepend_char(r3, char_at(r, char_len(r) - i - 1u));
         }
         assert eq(r, r3);
@@ -1383,7 +1383,7 @@ mod tests {
         //Generate a reasonable rope
         let chunk = of_str(@ "123456789");
         let mut r = empty();
-        for uint::range(0u, 10u){|_i|
+        for uint::range(0u, 10u) |_i| {
             r = append_rope(r, chunk);
         }
 
diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs
index 6819711aad6..a5d56bda0ef 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)) {
-    do s.emit_vec(vec::len(v)) {||
-        do vec::iteri(v) {|i,e|
-            do 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] {
-    do d.read_vec {|len|
-        do vec::from_fn(len) {|i|
-            do d.read_vec_elt(i) {|| f() }
+    do d.read_vec |len| {
+        do vec::from_fn(len) |i| {
+            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)) {
-    do s.emit_enum("option") {||
+    do s.emit_enum("option") || {
         alt v {
           none {
-            do s.emit_enum_variant("none", 0u, 0u) {||
+            do s.emit_enum_variant("none", 0u, 0u) || {
             }
           }
 
           some(v) {
-            do s.emit_enum_variant("some", 1u, 1u) {||
-                do s.emit_enum_variant_arg(0u) {||
+            do s.emit_enum_variant("some", 1u, 1u) || {
+                do s.emit_enum_variant_arg(0u) || {
                     st(v)
                 }
             }
@@ -254,14 +254,14 @@ 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> {
-    do d.read_enum("option") {||
-        do 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/sha1.rs b/src/libstd/sha1.rs
index d7c373046fd..6aed645283d 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -63,7 +63,7 @@ fn sha1() -> sha1 {
     fn add_input(st: sha1state, msg: ~[u8]) {
         /* FIXME: Should be typestate precondition (#2345) */
         assert (!st.computed);
-        for vec::each(msg) {|element|
+        for vec::each(msg) |element| {
             st.msg_block[st.msg_block_idx] = element;
             st.msg_block_idx += 1u;
             st.len_low += 8u32;
@@ -160,7 +160,7 @@ fn sha1() -> sha1 {
     fn mk_result(st: sha1state) -> ~[u8] {
         if !st.computed { pad_msg(st); st.computed = true; }
         let mut rs: ~[u8] = ~[];
-        for vec::each(st.h) {|hpart|
+        for vec::each(st.h) |hpart| {
             let a = (hpart >> 24u32 & 0xFFu32) as u8;
             let b = (hpart >> 16u32 & 0xFFu32) as u8;
             let c = (hpart >> 8u32 & 0xFFu32) as u8;
@@ -237,7 +237,7 @@ fn sha1() -> sha1 {
         fn result_str() -> str {
             let r = mk_result(self);
             let mut s = "";
-            for vec::each(r) {|b| s += uint::to_str(b as uint, 16u); }
+            for vec::each(r) |b| { s += uint::to_str(b as uint, 16u); }
             ret s;
         }
     }
@@ -326,7 +326,7 @@ mod tests {
         // Test that it works when accepting the message all at once
 
         let sh = sha1::sha1();
-        for vec::each(tests) {|t|
+        for vec::each(tests) |t| {
             sh.input_str(t.input);
             let out = sh.result();
             check_vec_eq(t.output, out);
@@ -335,7 +335,7 @@ mod tests {
 
 
         // Test that it works when accepting the message in pieces
-        for vec::each(tests) {|t|
+        for vec::each(tests) |t| {
             let len = str::len(t.input);
             let mut left = len;
             while left > 0u {
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index a7df6df281a..6583d97908d 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -58,7 +58,7 @@ fn contains_key<T: copy>(self: smallintmap<T>, key: uint) -> bool {
 impl <V: copy> of map::map<uint, V> for smallintmap<V> {
     fn size() -> uint {
         let mut sz = 0u;
-        for self.v.each {|item|
+        for self.v.each |item| {
             alt item { some(_) { sz += 1u; } _ {} }
         }
         sz
@@ -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/sort.rs b/src/libstd/sort.rs
index fafd5bfa73d..7de8f0cfab8 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -155,7 +155,7 @@ This is an unstable sort.
 "]
 fn quick_sort3<T: copy ord eq>(arr: ~[mut T]) {
     if len::<T>(arr) == 0u { ret; }
-    qsort3::<T>({ |x, y| x.lt(y) }, { |x, y| x.eq(y) }, arr, 0,
+    qsort3::<T>(|x, y| x.lt(y), |x, y| x.eq(y), arr, 0,
                 (len::<T>(arr) as int) - 1);
 }
 
@@ -251,7 +251,7 @@ mod test_qsort {
         let immut_names = vec::from_mut(names);
 
         let pairs = vec::zip(expected, immut_names);
-        for vec::each(pairs) {|p|
+        for vec::each(pairs) |p| {
             let (a, b) = p;
             #debug("%d %d", a, b);
             assert (a == b);
diff --git a/src/libstd/term.rs b/src/libstd/term.rs
index b6c00762d4f..43e1765f50b 100644
--- a/src/libstd/term.rs
+++ b/src/libstd/term.rs
@@ -37,7 +37,7 @@ fn color_supported() -> bool {
                            "screen-bce", "xterm-256color"];
     ret alt os::getenv("TERM") {
           option::some(env) {
-            for vec::each(supported_terms) {|term|
+            for vec::each(supported_terms) |term| {
                 if str::eq(term, env) { ret true; }
             }
             false
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 6c18afb6474..42ff9f6366a 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -162,7 +162,7 @@ fn run_tests_console(opts: test_opts,
           mut ignored: 0u,
           mut failures: ~[]};
 
-    run_tests(opts, tests, {|x|callback(x, st)});
+    run_tests(opts, tests, |x| callback(x, st));
 
     assert (st.passed + st.failed + st.ignored == st.total);
     let success = st.failed == 0u;
@@ -216,9 +216,9 @@ 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|
+    for vec::each(failures) |name| {
         st.out.write_line(#fmt["    %s", name]);
     }
 }
@@ -349,7 +349,7 @@ fn filter_tests(opts: test_opts,
             } else { ret option::none; }
         }
 
-        let filter = {|x|filter_fn(x, filter_str)};
+        let filter = |x| filter_fn(x, filter_str);
 
         vec::filter_map(filtered, filter)
     };
@@ -367,7 +367,7 @@ fn filter_tests(opts: test_opts,
             } else { ret option::none; }
         };
 
-        vec::filter_map(filtered, {|x|filter(x)})
+        vec::filter_map(filtered, |x| filter(x))
     };
 
     // Sort the tests alphabetically
@@ -376,7 +376,7 @@ fn filter_tests(opts: test_opts,
             fn lteq(t1: test_desc, t2: test_desc) -> bool {
                 str::le(t1.name, t2.name)
             }
-        sort::merge_sort({|x,y|lteq(x, y)}, filtered)
+        sort::merge_sort(|x,y| lteq(x, y), filtered)
         };
 
     ret filtered;
@@ -390,7 +390,7 @@ fn run_test(+test: test_desc, monitor_ch: comm::chan<monitor_msg>) {
         ret;
     }
 
-    do task::spawn {||
+    do task::spawn || {
         let testfn = copy test.fn;
         let mut builder = task::builder();
         let result_future = task::future_result(builder);
@@ -529,7 +529,7 @@ mod tests {
         {
         let testfn = fn~() { };
         let mut tests = ~[];
-        for vec::each(names) {|name|
+            for vec::each(names) |name| {
             let test = {name: name, fn: copy testfn, ignore: false,
                         should_fail: false};
             tests += ~[test];
@@ -547,7 +547,7 @@ mod tests {
 
     let pairs = vec::zip(expected, filtered);
 
-    for vec::each(pairs) {|p| let (a, b) = copy p; assert (a == b.name); }
+    for vec::each(pairs) |p| { let (a, b) = copy p; assert (a == b.name); }
 }
 }
 
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index e38f72ab189..fa1597925bd 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -142,7 +142,7 @@ fn strptime(s: str, format: str) -> result<tm, str> {
 
     fn match_str(s: str, pos: uint, needle: str) -> bool {
         let mut i = pos;
-        for str::each(needle) {|ch|
+        for str::each(needle) |ch| {
             if s[i] != ch {
                 ret false;
             }
@@ -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> {
         }
     }
 
-    do 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 = "";
 
-    do 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",
@@ -1010,9 +1010,9 @@ mod tests {
             "Thursday",
             "Friday",
             "Saturday"
-        ]/_.iter { |day| assert test(day, "%A"); }
+        ]/_.iter(|day| assert test(day, "%A"));
 
-        do [
+        [
             "Sun",
             "Mon",
             "Tue",
@@ -1020,9 +1020,9 @@ mod tests {
             "Thu",
             "Fri",
             "Sat"
-        ]/_.iter { |day| assert test(day, "%a"); }
+        ]/_.iter(|day| assert test(day, "%a"));
 
-        do [
+        [
             "January",
             "February",
             "March",
@@ -1035,9 +1035,9 @@ mod tests {
             "October",
             "November",
             "December"
-        ]/_.iter { |day| assert test(day, "%B"); }
+        ]/_.iter(|day| assert test(day, "%B"));
 
-        do [
+        [
             "Jan",
             "Feb",
             "Mar",
@@ -1050,7 +1050,7 @@ mod tests {
             "Oct",
             "Nov",
             "Dec"
-        ]/_.iter { |day| assert test(day, "%b"); }
+        ]/_.iter(|day| assert test(day, "%b"));
 
         assert test("19", "%C");
         assert test("Fri Feb 13 23:31:30 2009", "%c");
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index b907944e51a..6365c9bd953 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);
-            do 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(
@@ -105,11 +105,11 @@ fn recv_timeout<T: copy send>(iotask: iotask,
     delayed_send(iotask, msecs, timeout_ch, ());
     // FIXME: This could be written clearer (#2618)
     either::either(
-        {|left_val|
+        |left_val| {
             log(debug, #fmt("recv_time .. left_val %?",
                            left_val));
             none
-        }, {|right_val|
+        }, |right_val| {
             some(right_val)
         }, comm::select2(timeout_po, wait_po)
     )
@@ -151,7 +151,7 @@ mod test {
     #[test]
     fn test_gl_timer_sleep_stress1() {
         let hl_loop = uv::global_loop::get();
-        do iter::repeat(200u) {||
+        do iter::repeat(200u) || {
             sleep(hl_loop, 1u);
         }
     }
@@ -171,14 +171,14 @@ mod test {
 
         };
 
-        do iter::repeat(repeat) {||
+        do iter::repeat(repeat) || {
 
-            for spec.each {|spec|
+            for spec.each |spec| {
                 let (times, maxms) = spec;
-                do task::spawn {||
+                do task::spawn || {
                     import rand::*;
                     let rng = rng();
-                    do iter::repeat(times) {||
+                    do iter::repeat(times) || {
                         sleep(hl_loop, rng.next() as uint % maxms);
                     }
                     comm::send(ch, ());
@@ -186,7 +186,7 @@ mod test {
             }
         }
 
-        do 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();
 
-        do 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);
 
-            do 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();
 
-        do 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);
 
-            do task::spawn() {||
+            do task::spawn() || {
                 delayed_send(hl_loop, 1000u, test_ch, expected);
             };
 
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index 6cf98f93fe3..066d2a6501f 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -125,7 +125,7 @@ mod tests {
         fn t(n: @mut int, &&k: int, &&_v: ()) {
             assert (*n == k); *n += 1;
         }
-        traverse(m, {|x,y|t(n, x, y)});
+        traverse(m, |x,y| t(n, x, y));
     }
 
     #[test]
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index 6ea7b48ad97..aab8040c0a4 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -40,7 +40,7 @@ fn get_monitor_task_gl() -> iotask unsafe {
     #debug("ENTERING global_loop::get() loop chan: %?",
            monitor_loop_chan_ptr);
 
-    let builder_fn = {||
+    let builder_fn = || {
         let builder = task::builder();
         task::set_opts(builder, {
             supervise: false,
@@ -57,11 +57,11 @@ fn get_monitor_task_gl() -> iotask unsafe {
     type monchan = chan<iotask>;
 
     let monitor_ch = do chan_from_global_ptr::<monchan>(monitor_loop_chan_ptr,
-                                                     builder_fn) {|msg_po|
+                                                        builder_fn) |msg_po| {
         #debug("global monitor task starting");
 
         // As a weak task the runtime will notify us when to exit
-        do 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
-    do 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();
-    do 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
-            do 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();
-        do 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);
-        do 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) {
@@ -174,7 +174,7 @@ mod test {
         let hl_loop = get_gl();
         let exit_po = comm::port::<()>();
         let exit_ch = comm::chan(exit_po);
-        task::spawn_sched(task::manual_threads(1u), {||
+        task::spawn_sched(task::manual_threads(1u), || {
             impl_uv_hl_simple_timer(hl_loop);
             comm::send(exit_ch, ());
         });
@@ -191,13 +191,13 @@ mod test {
         let exit_po = comm::port::<()>();
         let exit_ch = comm::chan(exit_po);
         let cycles = 5000u;
-        do iter::repeat(cycles) {||
-            task::spawn_sched(task::manual_threads(1u), {||
+        do iter::repeat(cycles) || {
+            task::spawn_sched(task::manual_threads(1u), || {
                 impl_uv_hl_simple_timer(hl_loop);
                 comm::send(exit_ch, ());
             });
         };
-        do 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 625a261b6f5..c24a3bf8170 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)
     });
 
-    do listen {|iotask_ch|
+    do listen |iotask_ch| {
 
-        do 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);
-        do 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);
-        do 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);
-        do iter::repeat(7u) {||
-            do 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, ());
             };
         };
-        do 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 bb8eac6d528..6004b0cf62e 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);
 
-        do 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");
 
-        do 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));