Convert to new closure syntax

26 files changed, 221 insertions, 225 deletions

diff --git a/src/rustdoc/astsrv.rs b/src/rustdoc/astsrv.rs
index 7f82e690e33..255d49b6f74 100644
--- a/src/rustdoc/astsrv.rs
+++ b/src/rustdoc/astsrv.rs
@@ -60,7 +60,7 @@ fn from_file<T>(file: str, owner: srv_owner<T>) -> T {
 fn run<T>(owner: srv_owner<T>, source: str, +parse: parser) -> T {
 
     let srv_ = srv({
-        ch: do task::spawn_listener {|po|
+        ch: do task::spawn_listener |po| {
             act(po, source, parse);
         }
     });
@@ -199,8 +199,8 @@ fn build_error_handlers(
 #[test]
 fn should_prune_unconfigured_items() {
     let source = "#[cfg(shut_up_and_leave_me_alone)]fn a() { }";
-    do from_str(source) {|srv|
-        do exec(srv) {|ctxt|
+    do from_str(source) |srv| {
+        do exec(srv) |ctxt| {
             assert vec::is_empty(ctxt.ast.node.module.items);
         }
     }
@@ -209,8 +209,8 @@ fn should_prune_unconfigured_items() {
 #[test]
 fn srv_should_build_ast_map() {
     let source = "fn a() { }";
-    do from_str(source) {|srv|
-        do exec(srv) {|ctxt|
+    do from_str(source) |srv| {
+        do exec(srv) |ctxt| {
             assert ctxt.ast_map.size() != 0u
         };
     }
@@ -219,8 +219,8 @@ fn srv_should_build_ast_map() {
 #[test]
 fn srv_should_build_reexport_map() {
     let source = "import a::b; export b; mod a { mod b { } }";
-    do from_str(source) {|srv|
-        do exec(srv) {|ctxt|
+    do from_str(source) |srv| {
+        do exec(srv) |ctxt| {
             assert ctxt.exp_map.size() != 0u
         };
     }
@@ -232,14 +232,14 @@ fn srv_should_resolve_external_crates() {
                   fn f() -> std::sha1::sha1 {\
                   std::sha1::mk_sha1() }";
     // Just testing that resolve doesn't crash
-    from_str(source, {|_srv| })
+    from_str(source, |_srv| { } )
 }
 
 #[test]
 fn srv_should_resolve_core_crate() {
     let source = "fn a() -> option { fail }";
     // Just testing that resolve doesn't crash
-    from_str(source, {|_srv| })
+    from_str(source, |_srv| { } )
 }
 
 #[test]
@@ -247,26 +247,26 @@ fn srv_should_resolve_non_existant_imports() {
     // We want to ignore things we can't resolve. Shouldn't
     // need to be able to find external crates to create docs.
     let source = "import wooboo; fn a() { }";
-    from_str(source, {|_srv| })
+    from_str(source, |_srv| { } )
 }
 
 #[test]
 fn srv_should_resolve_non_existant_uses() {
     let source = "use forble; fn a() { }";
-    from_str(source, {|_srv| })
+    from_str(source, |_srv| { } )
 }
 
 #[test]
 fn should_ignore_external_import_paths_that_dont_exist() {
     let source = "use forble; import forble::bippy;";
-    from_str(source, {|_srv| })
+    from_str(source, |_srv| { } )
 }
 
 #[test]
 fn srv_should_return_request_result() {
     let source = "fn a() { }";
-    do from_str(source) {|srv|
-        let result = exec(srv, {|_ctxt| 1000});
+    do from_str(source) |srv| {
+        let result = exec(srv, |_ctxt| 1000 );
         assert result == 1000;
     }
 }
diff --git a/src/rustdoc/attr_parser.rs b/src/rustdoc/attr_parser.rs
index dcb8a9e7661..9046496b9e5 100644
--- a/src/rustdoc/attr_parser.rs
+++ b/src/rustdoc/attr_parser.rs
@@ -60,7 +60,7 @@ fn parse_crate(attrs: ~[ast::attribute]) -> crate_attrs {
 
     {
         name: attr::last_meta_item_value_str_by_name(
-            link_metas, "name").map({|x|*x})
+            link_metas, "name").map(|x| *x )
     }
 }
 
@@ -91,7 +91,7 @@ fn should_not_extract_crate_name_if_no_name_value_in_link_attribute() {
 fn parse_desc(attrs: ~[ast::attribute]) -> option<str> {
     alt doc_meta(attrs) {
       some(meta) {
-        attr::get_meta_item_value_str(meta).map({|x|*x})
+        attr::get_meta_item_value_str(meta).map(|x| *x )
       }
       none { none }
     }
diff --git a/src/rustdoc/attr_pass.rs b/src/rustdoc/attr_pass.rs
index 21e8d002d0d..0a00a5ef58c 100644
--- a/src/rustdoc/attr_pass.rs
+++ b/src/rustdoc/attr_pass.rs
@@ -42,7 +42,7 @@ fn fold_crate(
     let srv = fold.ctxt;
     let doc = fold::default_seq_fold_crate(fold, doc);
 
-    let attrs = do astsrv::exec(srv) {|ctxt|
+    let attrs = do astsrv::exec(srv) |ctxt| {
         let attrs = ctxt.ast.node.attrs;
         attr_parser::parse_crate(attrs)
     };
@@ -74,7 +74,7 @@ fn fold_item(
 
     let desc = if doc.id == ast::crate_node_id {
         // This is the top-level mod, use the crate attributes
-        do astsrv::exec(srv) {|ctxt|
+        do astsrv::exec(srv) |ctxt| {
             attr_parser::parse_desc(ctxt.ast.node.attrs)
         }
     } else {
@@ -91,7 +91,7 @@ fn parse_item_attrs<T:send>(
     srv: astsrv::srv,
     id: doc::ast_id,
     +parse_attrs: fn~(~[ast::attribute]) -> T) -> T {
-    do astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) |ctxt| {
         let attrs = alt ctxt.ast_map.get(id) {
           ast_map::node_item(item, _) { item.attrs }
           ast_map::node_foreign_item(item, _, _) { item.attrs }
@@ -143,14 +143,14 @@ fn fold_enum(
     let doc = fold::default_seq_fold_enum(fold, doc);
 
     {
-        variants: do par::anymap(doc.variants) {|variant|
-            let desc = do astsrv::exec(srv) {|ctxt|
+        variants: do par::anymap(doc.variants) |variant| {
+            let desc = do astsrv::exec(srv) |ctxt| {
                 alt check ctxt.ast_map.get(doc_id) {
                   ast_map::node_item(@{
                     node: ast::item_enum(ast_variants, _, _), _
                   }, _) {
                     let ast_variant = option::get(
-                        vec::find(ast_variants, {|v|
+                        vec::find(ast_variants, |v| {
                             *v.node.name == variant.name
                         }));
 
@@ -201,19 +201,19 @@ fn merge_method_attrs(
 ) -> ~[doc::methoddoc] {
 
     // Create an assoc list from method name to attributes
-    let attrs: ~[(str, option<str>)] = do astsrv::exec(srv) {|ctxt|
+    let attrs: ~[(str, option<str>)] = do astsrv::exec(srv) |ctxt| {
         alt ctxt.ast_map.get(item_id) {
           ast_map::node_item(@{
             node: ast::item_iface(_, _, methods), _
           }, _) {
-            par::seqmap(methods, {|method|
+            par::seqmap(methods, |method| {
                 (*method.ident, attr_parser::parse_desc(method.attrs))
             })
           }
           ast_map::node_item(@{
             node: ast::item_impl(_, _, _, _, methods), _
           }, _) {
-            par::seqmap(methods, {|method|
+            par::seqmap(methods, |method| {
                 (*method.ident, attr_parser::parse_desc(method.attrs))
             })
           }
@@ -221,7 +221,7 @@ fn merge_method_attrs(
         }
     };
 
-    do vec::map2(docs, attrs) {|doc, attrs|
+    do vec::map2(docs, attrs) |doc, attrs| {
         assert doc.name == tuple::first(attrs);
         let desc = tuple::second(attrs);
 
@@ -282,7 +282,7 @@ fn should_extract_impl_method_docs() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             run(srv, doc)
         }
diff --git a/src/rustdoc/config.rs b/src/rustdoc/config.rs
index e3332cfe54b..c316b175e66 100644
--- a/src/rustdoc/config.rs
+++ b/src/rustdoc/config.rs
@@ -59,7 +59,7 @@ fn usage() {
 
     println("Usage: rustdoc ~[options] <cratefile>\n");
     println("Options:\n");
-    for opts().each {|opt|
+    for opts().each |opt| {
         println(#fmt("    %s", tuple::second(opt)));
     }
     println("");
@@ -122,20 +122,20 @@ fn config_from_opts(
 
     let config = default_config(input_crate);
     let result = result::ok(config);
-    let result = do result::chain(result) {|config|
+    let result = do result::chain(result) |config| {
         let output_dir = getopts::opt_maybe_str(match, opt_output_dir());
         result::ok({
             output_dir: option::get_default(output_dir, config.output_dir)
             with config
         })
     };
-    let result = do result::chain(result) {|config|
+    let result = do result::chain(result) |config| {
         let output_format = getopts::opt_maybe_str(
             match, opt_output_format());
         do option::map_default(output_format, result::ok(config))
-           {|output_format|
+            |output_format| {
             do result::chain(parse_output_format(output_format))
-                {|output_format|
+                |output_format| {
 
                 result::ok({
                     output_format: output_format
@@ -144,11 +144,12 @@ fn config_from_opts(
             }
         }
     };
-    let result = do result::chain(result) {|config|
+    let result = do result::chain(result) |config| {
         let output_style = getopts::opt_maybe_str(match, opt_output_style());
         do option::map_default(output_style, result::ok(config))
-          {|output_style|
-            do result::chain(parse_output_style(output_style)) {|output_style|
+            |output_style| {
+            do result::chain(parse_output_style(output_style))
+                |output_style| {
                 result::ok({
                     output_style: output_style
                     with config
@@ -156,11 +157,11 @@ fn config_from_opts(
             }
         }
     };
-    let result = do result::chain(result) {|config|
+    let result = do result::chain(result) |config| {
         let pandoc_cmd = getopts::opt_maybe_str(match, opt_pandoc_cmd());
         let pandoc_cmd = maybe_find_pandoc(
             config, pandoc_cmd, program_output);
-        do result::chain(pandoc_cmd) {|pandoc_cmd|
+        do result::chain(pandoc_cmd) |pandoc_cmd| {
             result::ok({
                 pandoc_cmd: pandoc_cmd
                 with config
@@ -207,7 +208,7 @@ fn maybe_find_pandoc(
       }
     };
 
-    let pandoc = do vec::find(possible_pandocs) {|pandoc|
+    let pandoc = do vec::find(possible_pandocs) |pandoc| {
         let output = program_output(pandoc, ~["--version"]);
         #debug("testing pandoc cmd %s: %?", pandoc, output);
         output.status == 0
diff --git a/src/rustdoc/desc_to_brief_pass.rs b/src/rustdoc/desc_to_brief_pass.rs
index 3738b443ffe..f4b0a52a268 100644
--- a/src/rustdoc/desc_to_brief_pass.rs
+++ b/src/rustdoc/desc_to_brief_pass.rs
@@ -42,11 +42,9 @@ fn fold_iface(fold: fold::fold<()>, doc: doc::ifacedoc) -> doc::ifacedoc {
     let doc =fold::default_seq_fold_iface(fold, doc);
 
     {
-        methods: par::anymap(doc.methods, {|doc|
-            {
-                brief: extract(doc.desc)
-                with doc
-            }
+        methods: par::anymap(doc.methods, |doc| {
+            brief: extract(doc.desc)
+            with doc
         })
         with doc
     }
@@ -56,11 +54,9 @@ fn fold_impl(fold: fold::fold<()>, doc: doc::impldoc) -> doc::impldoc {
     let doc =fold::default_seq_fold_impl(fold, doc);
 
     {
-        methods: par::anymap(doc.methods, {|doc|
-            {
-                brief: extract(doc.desc)
-                with doc
-            }
+        methods: par::anymap(doc.methods, |doc| {
+            brief: extract(doc.desc)
+            with doc
         })
         with doc
     }
@@ -88,7 +84,7 @@ fn should_promote_impl_method_desc() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             let doc = attr_pass::mk_pass().f(srv, doc);
             run(srv, doc)
@@ -134,7 +130,7 @@ fn first_sentence_(s: str) -> str {
     let mut dotcount = 0;
     // The index of the character following a single dot. This allows
     // Things like [0..1) to appear in the brief description
-    let idx = do str::find(s) {|ch|
+    let idx = do str::find(s) |ch| {
         if ch == '.' {
             dotcount += 1;
             false
@@ -165,7 +161,7 @@ fn paragraphs(s: str) -> ~[str] {
     let lines = str::lines_any(s);
     let mut whitespace_lines = 0;
     let mut accum = "";
-    let paras = do vec::foldl(~[], lines) {|paras, line|
+    let paras = do vec::foldl(~[], lines) |paras, line| {
         let mut res = paras;
 
         if str::is_whitespace(line) {
diff --git a/src/rustdoc/doc.rs b/src/rustdoc/doc.rs
index b0369620daf..cd83b70bbea 100644
--- a/src/rustdoc/doc.rs
+++ b/src/rustdoc/doc.rs
@@ -128,7 +128,7 @@ type index_entry = {
 
 impl util for doc {
     fn cratedoc() -> cratedoc {
-        option::get(vec::foldl(none, self.pages, {|_m, page|
+        option::get(vec::foldl(none, self.pages, |_m, page| {
             alt page {
               doc::cratepage(doc) { some(doc) }
               _ { none }
@@ -145,7 +145,7 @@ impl util for doc {
 impl util for moddoc {
 
     fn mods() -> ~[moddoc] {
-        do vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) |itemtag| {
             alt itemtag {
               modtag(moddoc) { some(moddoc) }
               _ { none }
@@ -154,7 +154,7 @@ impl util for moddoc {
     }
 
     fn nmods() -> ~[nmoddoc] {
-        do vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) |itemtag| {
             alt itemtag {
               nmodtag(nmoddoc) { some(nmoddoc) }
               _ { none }
@@ -163,7 +163,7 @@ impl util for moddoc {
     }
 
     fn fns() -> ~[fndoc] {
-        do vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) |itemtag| {
             alt itemtag {
               fntag(fndoc) { some(fndoc) }
               _ { none }
@@ -172,7 +172,7 @@ impl util for moddoc {
     }
 
     fn consts() -> ~[constdoc] {
-        do vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) |itemtag| {
             alt itemtag {
               consttag(constdoc) { some(constdoc) }
               _ { none }
@@ -181,7 +181,7 @@ impl util for moddoc {
     }
 
     fn enums() -> ~[enumdoc] {
-        do vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) |itemtag| {
             alt itemtag {
               enumtag(enumdoc) { some(enumdoc) }
               _ { none }
@@ -190,7 +190,7 @@ impl util for moddoc {
     }
 
     fn ifaces() -> ~[ifacedoc] {
-        do vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) |itemtag| {
             alt itemtag {
               ifacetag(ifacedoc) { some(ifacedoc) }
               _ { none }
@@ -199,7 +199,7 @@ impl util for moddoc {
     }
 
     fn impls() -> ~[impldoc] {
-        do vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) |itemtag| {
             alt itemtag {
               impltag(impldoc) { some(impldoc) }
               _ { none }
@@ -208,7 +208,7 @@ impl util for moddoc {
     }
 
     fn types() -> ~[tydoc] {
-        do vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) |itemtag| {
             alt itemtag {
               tytag(tydoc) { some(tydoc) }
               _ { none }
@@ -220,7 +220,7 @@ impl util for moddoc {
 impl util for ~[page] {
 
     fn mods() -> ~[moddoc] {
-        do vec::filter_map(self) {|page|
+        do vec::filter_map(self) |page| {
             alt page {
               itempage(modtag(moddoc)) { some(moddoc) }
               _ { none }
@@ -229,7 +229,7 @@ impl util for ~[page] {
     }
 
     fn nmods() -> ~[nmoddoc] {
-        do vec::filter_map(self) {|page|
+        do vec::filter_map(self) |page| {
             alt page {
               itempage(nmodtag(nmoddoc)) { some(nmoddoc) }
               _ { none }
@@ -238,7 +238,7 @@ impl util for ~[page] {
     }
 
     fn fns() -> ~[fndoc] {
-        do vec::filter_map(self) {|page|
+        do vec::filter_map(self) |page| {
             alt page {
               itempage(fntag(fndoc)) { some(fndoc) }
               _ { none }
@@ -247,7 +247,7 @@ impl util for ~[page] {
     }
 
     fn consts() -> ~[constdoc] {
-        do vec::filter_map(self) {|page|
+        do vec::filter_map(self) |page| {
             alt page {
               itempage(consttag(constdoc)) { some(constdoc) }
               _ { none }
@@ -256,7 +256,7 @@ impl util for ~[page] {
     }
 
     fn enums() -> ~[enumdoc] {
-        do vec::filter_map(self) {|page|
+        do vec::filter_map(self) |page| {
             alt page {
               itempage(enumtag(enumdoc)) { some(enumdoc) }
               _ { none }
@@ -265,7 +265,7 @@ impl util for ~[page] {
     }
 
     fn ifaces() -> ~[ifacedoc] {
-        do vec::filter_map(self) {|page|
+        do vec::filter_map(self) |page| {
             alt page {
               itempage(ifacetag(ifacedoc)) { some(ifacedoc) }
               _ { none }
@@ -274,7 +274,7 @@ impl util for ~[page] {
     }
 
     fn impls() -> ~[impldoc] {
-        do vec::filter_map(self) {|page|
+        do vec::filter_map(self) |page| {
             alt page {
               itempage(impltag(impldoc)) { some(impldoc) }
               _ { none }
@@ -283,7 +283,7 @@ impl util for ~[page] {
     }
 
     fn types() -> ~[tydoc] {
-        do vec::filter_map(self) {|page|
+        do vec::filter_map(self) |page| {
             alt page {
               itempage(tytag(tydoc)) { some(tydoc) }
               _ { none }
diff --git a/src/rustdoc/extract.rs b/src/rustdoc/extract.rs
index 17ce84f266d..66585d5683e 100644
--- a/src/rustdoc/extract.rs
+++ b/src/rustdoc/extract.rs
@@ -11,7 +11,7 @@ fn from_srv(
 
     #[doc = "Use the AST service to create a document tree"];
 
-    do astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) |ctxt| {
         extract(ctxt.ast, default_name)
     }
 }
@@ -55,7 +55,7 @@ fn moddoc_from_mod(
 ) -> doc::moddoc {
     {
         item: itemdoc,
-        items: do vec::filter_map(module.items) {|item|
+        items: do vec::filter_map(module.items) |item| {
             let itemdoc = mk_itemdoc(item.id, item.ident);
             alt item.node {
               ast::item_mod(m) {
@@ -113,7 +113,7 @@ fn nmoddoc_from_mod(
 ) -> doc::nmoddoc {
     {
         item: itemdoc,
-        fns: do par::seqmap(module.items) {|item|
+        fns: do par::seqmap(module.items) |item| {
             let itemdoc = mk_itemdoc(item.id, item.ident);
             alt item.node {
               ast::foreign_item_fn(_, _) {
@@ -189,7 +189,7 @@ fn ifacedoc_from_iface(
 ) -> doc::ifacedoc {
     {
         item: itemdoc,
-        methods: do par::seqmap(methods) {|method|
+        methods: do par::seqmap(methods) |method| {
             {
                 name: *method.ident,
                 brief: none,
@@ -221,7 +221,7 @@ fn impldoc_from_impl(
         item: itemdoc,
         iface_ty: none,
         self_ty: none,
-        methods: do par::seqmap(methods) {|method|
+        methods: do par::seqmap(methods) |method| {
             {
                 name: *method.ident,
                 brief: none,
@@ -339,7 +339,7 @@ mod test {
     #[test]
     fn extract_from_seq_srv() {
         let source = "";
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = from_srv(srv, "name");
             assert doc.cratemod().name() == "name";
         }
diff --git a/src/rustdoc/fold.rs b/src/rustdoc/fold.rs
index 7e5cafcb91e..9d560c7486d 100644
--- a/src/rustdoc/fold.rs
+++ b/src/rustdoc/fold.rs
@@ -83,57 +83,57 @@ fn mk_fold<T:copy>(
 fn default_any_fold<T:send copy>(ctxt: T) -> fold<T> {
     mk_fold(
         ctxt,
-        {|f, d| default_seq_fold_doc(f, d)},
-        {|f, d| default_seq_fold_crate(f, d)},
-        {|f, d| default_seq_fold_item(f, d)},
-        {|f, d| default_any_fold_mod(f, d)},
-        {|f, d| default_any_fold_nmod(f, d)},
-        {|f, d| default_seq_fold_fn(f, d)},
-        {|f, d| default_seq_fold_const(f, d)},
-        {|f, d| default_seq_fold_enum(f, d)},
-        {|f, d| default_seq_fold_iface(f, d)},
-        {|f, d| default_seq_fold_impl(f, d)},
-        {|f, d| default_seq_fold_type(f, d)}
+        |f, d| default_seq_fold_doc(f, d),
+        |f, d| default_seq_fold_crate(f, d),
+        |f, d| default_seq_fold_item(f, d),
+        |f, d| default_any_fold_mod(f, d),
+        |f, d| default_any_fold_nmod(f, d),
+        |f, d| default_seq_fold_fn(f, d),
+        |f, d| default_seq_fold_const(f, d),
+        |f, d| default_seq_fold_enum(f, d),
+        |f, d| default_seq_fold_iface(f, d),
+        |f, d| default_seq_fold_impl(f, d),
+        |f, d| default_seq_fold_type(f, d)
     )
 }
 
 fn default_seq_fold<T:copy>(ctxt: T) -> fold<T> {
     mk_fold(
         ctxt,
-        {|f, d| default_seq_fold_doc(f, d)},
-        {|f, d| default_seq_fold_crate(f, d)},
-        {|f, d| default_seq_fold_item(f, d)},
-        {|f, d| default_seq_fold_mod(f, d)},
-        {|f, d| default_seq_fold_nmod(f, d)},
-        {|f, d| default_seq_fold_fn(f, d)},
-        {|f, d| default_seq_fold_const(f, d)},
-        {|f, d| default_seq_fold_enum(f, d)},
-        {|f, d| default_seq_fold_iface(f, d)},
-        {|f, d| default_seq_fold_impl(f, d)},
-        {|f, d| default_seq_fold_type(f, d)}
+        |f, d| default_seq_fold_doc(f, d),
+        |f, d| default_seq_fold_crate(f, d),
+        |f, d| default_seq_fold_item(f, d),
+        |f, d| default_seq_fold_mod(f, d),
+        |f, d| default_seq_fold_nmod(f, d),
+        |f, d| default_seq_fold_fn(f, d),
+        |f, d| default_seq_fold_const(f, d),
+        |f, d| default_seq_fold_enum(f, d),
+        |f, d| default_seq_fold_iface(f, d),
+        |f, d| default_seq_fold_impl(f, d),
+        |f, d| default_seq_fold_type(f, d)
     )
 }
 
 fn default_par_fold<T:send copy>(ctxt: T) -> fold<T> {
     mk_fold(
         ctxt,
-        {|f, d| default_seq_fold_doc(f, d)},
-        {|f, d| default_seq_fold_crate(f, d)},
-        {|f, d| default_seq_fold_item(f, d)},
-        {|f, d| default_par_fold_mod(f, d)},
-        {|f, d| default_par_fold_nmod(f, d)},
-        {|f, d| default_seq_fold_fn(f, d)},
-        {|f, d| default_seq_fold_const(f, d)},
-        {|f, d| default_seq_fold_enum(f, d)},
-        {|f, d| default_seq_fold_iface(f, d)},
-        {|f, d| default_seq_fold_impl(f, d)},
-        {|f, d| default_seq_fold_type(f, d)}
+        |f, d| default_seq_fold_doc(f, d),
+        |f, d| default_seq_fold_crate(f, d),
+        |f, d| default_seq_fold_item(f, d),
+        |f, d| default_par_fold_mod(f, d),
+        |f, d| default_par_fold_nmod(f, d),
+        |f, d| default_seq_fold_fn(f, d),
+        |f, d| default_seq_fold_const(f, d),
+        |f, d| default_seq_fold_enum(f, d),
+        |f, d| default_seq_fold_iface(f, d),
+        |f, d| default_seq_fold_impl(f, d),
+        |f, d| default_seq_fold_type(f, d)
     )
 }
 
 fn default_seq_fold_doc<T>(fold: fold<T>, doc: doc::doc) -> doc::doc {
     {
-        pages: do par::seqmap(doc.pages) {|page|
+        pages: do par::seqmap(doc.pages) |page| {
             alt page {
               doc::cratepage(doc) {
                 doc::cratepage(fold.fold_crate(fold, doc))
@@ -169,7 +169,7 @@ fn default_any_fold_mod<T:send copy>(
 ) -> doc::moddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        items: par::anymap(doc.items, {|itemtag, copy fold|
+        items: par::anymap(doc.items, |itemtag, copy fold| {
             fold_itemtag(fold, itemtag)
         })
         with doc
@@ -182,7 +182,7 @@ fn default_seq_fold_mod<T>(
 ) -> doc::moddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        items: par::seqmap(doc.items, {|itemtag|
+        items: par::seqmap(doc.items, |itemtag| {
             fold_itemtag(fold, itemtag)
         })
         with doc
@@ -195,7 +195,7 @@ fn default_par_fold_mod<T:send copy>(
 ) -> doc::moddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        items: par::parmap(doc.items, {|itemtag, copy fold|
+        items: par::parmap(doc.items, |itemtag, copy fold| {
             fold_itemtag(fold, itemtag)
         })
         with doc
@@ -208,7 +208,7 @@ fn default_any_fold_nmod<T:send copy>(
 ) -> doc::nmoddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        fns: par::anymap(doc.fns, {|fndoc, copy fold|
+        fns: par::anymap(doc.fns, |fndoc, copy fold| {
             fold.fold_fn(fold, fndoc)
         })
         with doc
@@ -221,7 +221,7 @@ fn default_seq_fold_nmod<T>(
 ) -> doc::nmoddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        fns: par::seqmap(doc.fns, {|fndoc|
+        fns: par::seqmap(doc.fns, |fndoc| {
             fold.fold_fn(fold, fndoc)
         })
         with doc
@@ -234,7 +234,7 @@ fn default_par_fold_nmod<T:send copy>(
 ) -> doc::nmoddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        fns: par::parmap(doc.fns, {|fndoc, copy fold|
+        fns: par::parmap(doc.fns, |fndoc, copy fold| {
             fold.fold_fn(fold, fndoc)
         })
         with doc
diff --git a/src/rustdoc/markdown_index_pass.rs b/src/rustdoc/markdown_index_pass.rs
index 83d2180e1e7..25691cb79d9 100644
--- a/src/rustdoc/markdown_index_pass.rs
+++ b/src/rustdoc/markdown_index_pass.rs
@@ -55,7 +55,7 @@ fn build_mod_index(
     config: config::config
 ) -> doc::index {
     {
-        entries: par::anymap(doc.items, {|doc|
+        entries: par::anymap(doc.items, |doc| {
             item_to_entry(doc, config)
         })
     }
@@ -66,7 +66,7 @@ fn build_nmod_index(
     config: config::config
 ) -> doc::index {
     {
-        entries: par::anymap(doc.fns, {|doc|
+        entries: par::anymap(doc.fns, |doc| {
             item_to_entry(doc::fntag(doc), config)
         })
     }
@@ -215,7 +215,7 @@ fn should_index_foreign_mod_contents() {
 #[cfg(test)]
 mod test {
     fn mk_doc(output_style: config::output_style, source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let config = {
                 output_style: output_style
                 with config::default_config("whatever")
diff --git a/src/rustdoc/markdown_pass.rs b/src/rustdoc/markdown_pass.rs
index 9fe29dafd05..a616897f3b2 100644
--- a/src/rustdoc/markdown_pass.rs
+++ b/src/rustdoc/markdown_pass.rs
@@ -82,7 +82,7 @@ fn write_markdown(
     doc: doc::doc,
     +writer_factory: writer_factory
 ) {
-    do par::anymap(doc.pages) {|page|
+    do par::anymap(doc.pages) |page| {
         let ctxt = {
             w: writer_factory(page)
         };
@@ -115,7 +115,7 @@ fn should_request_new_writer_for_each_page() {
     let doc = page_pass::mk_pass(config::doc_per_mod).f(srv, doc);
     write_markdown(doc, writer_factory);
     // We expect two pages to have been written
-    do iter::repeat(2u) {||
+    do iter::repeat(2u) || {
         comm::recv(po);
     }
 }
@@ -146,7 +146,7 @@ fn should_write_title_for_each_page() {
         "#[link(name = \"core\")]; mod a { }");
     let doc = page_pass::mk_pass(config::doc_per_mod).f(srv, doc);
     write_markdown(doc, writer_factory);
-    do iter::repeat(2u) {||
+    do iter::repeat(2u) || {
         let (page, markdown) = comm::recv(po);
         alt page {
           doc::cratepage(_) {
@@ -295,7 +295,7 @@ fn write_desc(
 }
 
 fn write_sections(ctxt: ctxt, sections: ~[doc::section]) {
-    do vec::iter(sections) {|section|
+    do vec::iter(sections) |section| {
         write_section(ctxt, section);
     }
 }
@@ -325,7 +325,7 @@ fn write_mod_contents(
         write_index(ctxt, option::get(doc.index));
     }
 
-    for doc.items.each {|itemtag|
+    for doc.items.each |itemtag| {
         write_item(ctxt, itemtag);
     }
 }
@@ -377,7 +377,7 @@ fn write_index(ctxt: ctxt, index: doc::index) {
         ret;
     }
 
-    for index.entries.each {|entry|
+    for index.entries.each |entry| {
         let header = header_text_(entry.kind, entry.name);
         let id = entry.link;
         if option::is_some(entry.brief) {
@@ -427,7 +427,7 @@ fn write_nmod(ctxt: ctxt, doc: doc::nmoddoc) {
         write_index(ctxt, option::get(doc.index));
     }
 
-    for doc.fns.each {|fndoc|
+    for doc.fns.each |fndoc| {
         write_item_header(ctxt, doc::fntag(fndoc));
         write_fn(ctxt, fndoc);
     }
@@ -486,7 +486,7 @@ fn write_sig(ctxt: ctxt, sig: option<str>) {
 
 fn code_block_indent(s: str) -> str {
     let lines = str::lines_any(s);
-    let indented = par::seqmap(lines, { |line| #fmt("    %s", line) });
+    let indented = par::seqmap(lines, |line| #fmt("    %s", line) );
     str::connect(indented, "\n")
 }
 
@@ -588,7 +588,7 @@ fn write_variants(
 
     write_header_(ctxt, h4, "Variants");
 
-    vec::iter(docs, {|variant| write_variant(ctxt, variant) });
+    vec::iter(docs, |variant| write_variant(ctxt, variant) );
 
     ctxt.w.write_line("");
 }
@@ -645,7 +645,7 @@ fn write_iface(ctxt: ctxt, doc: doc::ifacedoc) {
 }
 
 fn write_methods(ctxt: ctxt, docs: ~[doc::methoddoc]) {
-    do vec::iter(docs) {|doc| write_method(ctxt, doc) }
+    do vec::iter(docs) |doc| { write_method(ctxt, doc) }
 }
 
 fn write_method(ctxt: ctxt, doc: doc::methoddoc) {
@@ -760,7 +760,7 @@ mod test {
     }
 
     fn create_doc_srv(source: str) -> (astsrv::srv, doc::doc) {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
 
             let config = {
                 output_style: config::doc_per_crate
diff --git a/src/rustdoc/markdown_writer.rs b/src/rustdoc/markdown_writer.rs
index 6d8a4d9632c..ee968174aa2 100644
--- a/src/rustdoc/markdown_writer.rs
+++ b/src/rustdoc/markdown_writer.rs
@@ -56,7 +56,7 @@ fn markdown_writer(
     page: doc::page
 ) -> writer {
     let filename = make_local_filename(config, page);
-    do generic_writer {|markdown|
+    do generic_writer |markdown| {
         write_file(filename, markdown);
     }
 }
@@ -78,7 +78,7 @@ fn pandoc_writer(
         "--output=" + filename
     ];
 
-    do generic_writer {|markdown|
+    do generic_writer |markdown| {
         import io::writer_util;
 
         #debug("pandoc cmd: %s", pandoc_cmd);
@@ -101,14 +101,14 @@ fn pandoc_writer(
 
         let stdout_po = comm::port();
         let stdout_ch = comm::chan(stdout_po);
-        do task::spawn_sched(task::single_threaded) {||
+        do task::spawn_sched(task::single_threaded) || {
             comm::send(stdout_ch, readclose(pipe_out.in));
         }
         let stdout = comm::recv(stdout_po);
 
         let stderr_po = comm::port();
         let stderr_ch = comm::chan(stderr_po);
-        do task::spawn_sched(task::single_threaded) {||
+        do task::spawn_sched(task::single_threaded) || {
             comm::send(stderr_ch, readclose(pipe_err.in));
         }
         let stderr = comm::recv(stderr_po);
@@ -137,7 +137,7 @@ fn readclose(fd: libc::c_int) -> str {
 }
 
 fn generic_writer(+process: fn~(markdown: str)) -> writer {
-    let ch = do task::spawn_listener {|po: comm::port<writeinstr>|
+    let ch = do task::spawn_listener |po: comm::port<writeinstr>| {
         let mut markdown = "";
         let mut keep_going = true;
         while keep_going {
@@ -236,7 +236,7 @@ fn should_name_mod_file_names_by_path() {
 #[cfg(test)]
 mod test {
     fn mk_doc(name: str, source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, name);
             let doc = path_pass::mk_pass().f(srv, doc);
             doc
@@ -262,7 +262,7 @@ fn future_writer_factory(
     let writer_factory = fn~(page: doc::page) -> writer {
         let writer_po = comm::port();
         let writer_ch = comm::chan(writer_po);
-        do task::spawn {||
+        do task::spawn || {
             let (writer, future) = future_writer();
             comm::send(writer_ch, writer);
             let s = future::get(future);
@@ -280,7 +280,7 @@ fn future_writer() -> (writer, future::future<str>) {
     let writer = fn~(+instr: writeinstr) {
         comm::send(chan, copy instr);
     };
-    let future = do future::from_fn {||
+    let future = do future::from_fn || {
         let mut res = "";
         loop {
             alt comm::recv(port) {
diff --git a/src/rustdoc/page_pass.rs b/src/rustdoc/page_pass.rs
index 753ce879b61..80af8f2553f 100644
--- a/src/rustdoc/page_pass.rs
+++ b/src/rustdoc/page_pass.rs
@@ -32,7 +32,7 @@ fn run(
 
     let result_port = comm::port();
     let result_chan = comm::chan(result_port);
-    let page_chan = do task::spawn_listener {|page_port|
+    let page_chan = do task::spawn_listener |page_port| {
         comm::send(result_chan, make_doc_from_pages(page_port));
     };
 
@@ -106,7 +106,7 @@ fn fold_mod(
 
 fn strip_mod(doc: doc::moddoc) -> doc::moddoc {
     {
-        items: do vec::filter(doc.items) {|item|
+        items: do vec::filter(doc.items) |item| {
             alt item {
               doc::modtag(_) { false }
               doc::nmodtag(_) { false }
@@ -166,7 +166,7 @@ mod test {
         output_style: config::output_style,
         source: str
     ) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             run(srv, doc, output_style)
         }
diff --git a/src/rustdoc/par.rs b/src/rustdoc/par.rs
index 6275e47d26c..d64a89714ce 100644
--- a/src/rustdoc/par.rs
+++ b/src/rustdoc/par.rs
@@ -9,16 +9,16 @@ fn seqmap<T, U>(v: ~[T], f: fn(T) -> U) -> ~[U] {
 }
 
 fn parmap<T:send, U:send>(v: ~[T], f: fn~(T) -> U) -> ~[U] unsafe {
-    let futures = do vec::map(v) {|elt|
+    let futures = do vec::map(v) |elt| {
         let po = comm::port();
         let ch = comm::chan(po);
         let addr = ptr::addr_of(elt);
-        do task::spawn {|copy f|
+        do task::spawn |copy f| {
             comm::send(ch, f(*addr));
         }
         po
     };
-    do vec::map(futures) {|future|
+    do vec::map(futures) |future| {
         comm::recv(future)
     }
 }
@@ -26,6 +26,6 @@ fn parmap<T:send, U:send>(v: ~[T], f: fn~(T) -> U) -> ~[U] unsafe {
 #[test]
 fn test_parallel_map() {
     let i = ~[1, 2, 3, 4];
-    let j = parmap(i, {|e| e + 1 });
+    let j = parmap(i, |e| e + 1 );
     assert j == ~[2, 3, 4, 5];
 }
diff --git a/src/rustdoc/path_pass.rs b/src/rustdoc/path_pass.rs
index 081cd9fe293..99be48c0362 100644
--- a/src/rustdoc/path_pass.rs
+++ b/src/rustdoc/path_pass.rs
@@ -66,7 +66,7 @@ fn fold_nmod(fold: fold::fold<ctxt>, doc: doc::nmoddoc) -> doc::nmoddoc {
 #[test]
 fn should_record_mod_paths() {
     let source = "mod a { mod b { mod c { } } mod d { mod e { } } }";
-    do astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv, "");
         let doc = run(srv, doc);
         assert doc.cratemod().mods()[0].mods()[0].mods()[0].path()
@@ -79,7 +79,7 @@ fn should_record_mod_paths() {
 #[test]
 fn should_record_fn_paths() {
     let source = "mod a { fn b() { } }";
-    do astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv, "");
         let doc = run(srv, doc);
         assert doc.cratemod().mods()[0].fns()[0].path() == ~["a"];
@@ -89,7 +89,7 @@ fn should_record_fn_paths() {
 #[test]
 fn should_record_foreign_mod_paths() {
     let source = "mod a { native mod b { } }";
-    do astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv, "");
         let doc = run(srv, doc);
         assert doc.cratemod().mods()[0].nmods()[0].path() == ~["a"];
@@ -99,7 +99,7 @@ fn should_record_foreign_mod_paths() {
 #[test]
 fn should_record_foreign_fn_paths() {
     let source = "native mod a { fn b(); }";
-    do astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv, "");
         let doc = run(srv, doc);
         assert doc.cratemod().nmods()[0].fns[0].path() == ~["a"];
diff --git a/src/rustdoc/prune_hidden_pass.rs b/src/rustdoc/prune_hidden_pass.rs
index 24c0c019ee6..783ca6d3f14 100644
--- a/src/rustdoc/prune_hidden_pass.rs
+++ b/src/rustdoc/prune_hidden_pass.rs
@@ -25,7 +25,7 @@ fn fold_mod(
     let doc = fold::default_any_fold_mod(fold, doc);
 
     {
-        items: vec::filter(doc.items, {|itemtag|
+        items: vec::filter(doc.items, |itemtag| {
             !is_hidden(fold.ctxt, itemtag.item())
         })
         with doc
@@ -36,7 +36,7 @@ fn is_hidden(srv: astsrv::srv, doc: doc::itemdoc) -> bool {
     import syntax::ast_map;
 
     let id = doc.id;
-    do astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) |ctxt| {
         let attrs = alt ctxt.ast_map.get(id) {
           ast_map::node_item(item, _) { item.attrs }
           _ { ~[] }
@@ -54,7 +54,7 @@ fn should_prune_hidden_items() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             run(srv, doc)
         }
diff --git a/src/rustdoc/prune_unexported_pass.rs b/src/rustdoc/prune_unexported_pass.rs
index 8e9d15e25ec..753100c1f09 100644
--- a/src/rustdoc/prune_unexported_pass.rs
+++ b/src/rustdoc/prune_unexported_pass.rs
@@ -62,7 +62,7 @@ fn exported_items_from_mod(
     srv: astsrv::srv,
     doc: doc::moddoc
 ) -> ~[doc::itemtag] {
-    exported_items_from(srv, doc, {|a,b|
+    exported_items_from(srv, doc, |a,b| {
         is_exported_from_mod(a, doc.id(), b)
     })
 }
@@ -72,7 +72,7 @@ fn exported_items_from(
     doc: doc::moddoc,
     is_exported: fn(astsrv::srv, str) -> bool
 ) -> ~[doc::itemtag] {
-    do vec::filter_map(doc.items) { |itemtag|
+    do vec::filter_map(doc.items) |itemtag| {
         let itemtag = alt itemtag {
           doc::enumtag(enumdoc) {
             // Also need to check variant exportedness
@@ -97,7 +97,7 @@ fn exported_variants_from(
     doc: doc::enumdoc,
     is_exported: fn(astsrv::srv, str) -> bool
 ) -> ~[doc::variantdoc] {
-    do vec::filter_map(doc.variants) { |doc|
+    do vec::filter_map(doc.variants) |doc| {
         if is_exported(srv, doc.name) {
             some(doc)
         } else {
@@ -111,7 +111,7 @@ fn is_exported_from_mod(
     mod_id: doc::ast_id,
     item_name: str
 ) -> bool {
-    do astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) |ctxt| {
         alt ctxt.ast_map.get(mod_id) {
           ast_map::node_item(item, _) {
             alt item.node {
@@ -132,7 +132,7 @@ fn is_exported_from_crate(
     srv: astsrv::srv,
     item_name: str
 ) -> bool {
-    do astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) |ctxt| {
         ast_util::is_exported(@item_name, ctxt.ast.node.module)
     }
 }
@@ -223,7 +223,7 @@ fn should_prune_unexported_types() {
 #[test]
 fn should_not_prune_reexports() {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             let doc = reexport_pass::mk_pass().f(srv, doc);
             run(srv, doc)
@@ -238,7 +238,7 @@ fn should_not_prune_reexports() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             run(srv, doc)
         }
diff --git a/src/rustdoc/reexport_pass.rs b/src/rustdoc/reexport_pass.rs
index 3232a724745..a998faeac31 100644
--- a/src/rustdoc/reexport_pass.rs
+++ b/src/rustdoc/reexport_pass.rs
@@ -46,7 +46,7 @@ fn to_assoc_list<K:copy, V:copy>(
 ) -> ~[(K, V)] {
 
     let mut vec = ~[];
-    for map.each {|k, v|
+    for map.each |k, v| {
         vec += ~[(k, v)];
     }
     ret vec;
@@ -58,7 +58,7 @@ fn from_assoc_list<K:copy, V:copy>(
 ) -> map::hashmap<K, V> {
 
     let map = new_hash();
-    do vec::iter(list) {|elt|
+    do vec::iter(list) |elt| {
         let (k, v) = elt;
         map.insert(k, v);
     }
@@ -78,16 +78,16 @@ fn from_str_assoc_list<V:copy>(
 }
 
 fn build_reexport_def_set(srv: astsrv::srv) -> def_set {
-    let assoc_list = do astsrv::exec(srv) {|ctxt|
+    let assoc_list = do astsrv::exec(srv) |ctxt| {
         let def_set = ast_util::new_def_hash();
-        for ctxt.exp_map.each {|_id, defs|
-            for defs.each {|def|
+        for ctxt.exp_map.each |_id, defs| {
+            for defs.each |def| {
                 if def.reexp {
                     def_set.insert(def.id, ());
                 }
             }
         }
-        for find_reexport_impls(ctxt).each {|def|
+        for find_reexport_impls(ctxt).each |def| {
             def_set.insert(def, ());
         }
         to_assoc_list(def_set)
@@ -98,7 +98,7 @@ fn build_reexport_def_set(srv: astsrv::srv) -> def_set {
 
 fn find_reexport_impls(ctxt: astsrv::ctxt) -> ~[ast::def_id] {
     let defs = @mut ~[];
-    do for_each_reexported_impl(ctxt) {|_mod_id, i|
+    do for_each_reexported_impl(ctxt) |_mod_id, i| {
         *defs += ~[i.did]
     }
     ret *defs;
@@ -136,7 +136,7 @@ fn build_reexport_def_map(
     fn fold_mod(fold: fold::fold<ctxt>, doc: doc::moddoc) -> doc::moddoc {
         let doc = fold::default_seq_fold_mod(fold, doc);
 
-        for doc.items.each {|item|
+        for doc.items.each |item| {
             let def_id = ast_util::local_def(item.id());
             if fold.ctxt.def_set.contains_key(def_id) {
                 fold.ctxt.def_map.insert(def_id, item);
@@ -149,7 +149,7 @@ fn build_reexport_def_map(
     fn fold_nmod(fold: fold::fold<ctxt>, doc: doc::nmoddoc) -> doc::nmoddoc {
         let doc = fold::default_seq_fold_nmod(fold, doc);
 
-        for doc.fns.each {|fndoc|
+        for doc.fns.each |fndoc| {
             let def_id = ast_util::local_def(fndoc.id());
             if fold.ctxt.def_set.contains_key(def_id) {
                 fold.ctxt.def_map.insert(def_id, doc::fntag(fndoc));
@@ -166,12 +166,12 @@ fn build_reexport_path_map(srv: astsrv::srv, -def_map: def_map) -> path_map {
     let def_assoc_list = to_assoc_list(def_map);
     #debug("def_map: %?", def_assoc_list);
 
-    let assoc_list = do astsrv::exec(srv) {|ctxt|
+    let assoc_list = do astsrv::exec(srv) |ctxt| {
 
         let def_map = from_def_assoc_list(def_assoc_list);
         let path_map = map::str_hash::<~[(str,doc::itemtag)]>();
 
-        for ctxt.exp_map.each {|exp_id, defs|
+        for ctxt.exp_map.each |exp_id, defs| {
             let path = alt check ctxt.ast_map.get(exp_id) {
               ast_map::node_export(_, path) { path }
             };
@@ -183,7 +183,7 @@ fn build_reexport_path_map(srv: astsrv::srv, -def_map: def_map) -> path_map {
             let modpath = ast_map::path_to_str(vec::init(*path));
 
             let mut reexportdocs = ~[];
-            for defs.each {|def|
+            for defs.each |def| {
                 if !def.reexp { cont; }
                 alt def_map.find(def.id) {
                   some(itemtag) {
@@ -194,8 +194,8 @@ fn build_reexport_path_map(srv: astsrv::srv, -def_map: def_map) -> path_map {
             }
 
             if reexportdocs.len() > 0u {
-                do option::iter(path_map.find(modpath)) {|docs|
-                    reexportdocs = docs + vec::filter(reexportdocs, {|x|
+                do option::iter(path_map.find(modpath)) |docs| {
+                    reexportdocs = docs + vec::filter(reexportdocs, |x| {
                         !vec::contains(docs, x)
                     });
                 }
@@ -205,7 +205,7 @@ fn build_reexport_path_map(srv: astsrv::srv, -def_map: def_map) -> path_map {
             }
         }
 
-        for find_reexport_impl_docs(ctxt, def_map).each {|elt|
+        for find_reexport_impl_docs(ctxt, def_map).each |elt| {
             let (path, doc) = elt;
             let docs = alt path_map.find(path) {
               some(docs) { docs + ~[(doc)] }
@@ -226,7 +226,7 @@ fn find_reexport_impl_docs(
 ) -> ~[(str, (str, doc::itemtag))] {
     let docs = @mut ~[];
 
-    do for_each_reexported_impl(ctxt) {|mod_id, i|
+    do for_each_reexported_impl(ctxt) |mod_id, i| {
         let path = alt ctxt.ast_map.find(mod_id) {
           some(ast_map::node_item(item, path)) {
             let path = ast_map::path_to_str(*path);
@@ -256,7 +256,7 @@ fn for_each_reexported_impl(
     f: fn@(ast::node_id, resolve::_impl)
 ) {
     let visitor = @{
-        visit_mod: {|a,b,c|visit_mod(ctxt, f, a, b, c)}
+        visit_mod: |a,b,c| visit_mod(ctxt, f, a, b, c)
         with *visit::default_simple_visitor()
     };
     let visitor = visit::mk_simple_visitor(visitor);
@@ -272,7 +272,7 @@ fn for_each_reexported_impl(
         let all_impls = all_impls(m);
         alt check *ctxt.impl_map.get(mod_id) {
           list::cons(impls, @list::nil) {
-            for vec::each(*impls) {|i|
+            for vec::each(*impls) |i| {
                 // This impl is not an item in the current mod
                 if !all_impls.contains_key(i.did) {
                     // Ignore external impls because I don't
@@ -289,7 +289,7 @@ fn for_each_reexported_impl(
 
 fn all_impls(m: ast::_mod) -> map::set<ast::def_id> {
     let all_impls = ast_util::new_def_hash();
-    for m.items.each {|item|
+    for m.items.each |item| {
         alt item.node {
           ast::item_impl(_, _, _, _, _) {
             all_impls.insert(ast_util::local_def(item.id), ());
@@ -338,7 +338,7 @@ fn merge_reexports(
         #debug("looking for reexports in path %?", path);
         alt path_map.find(str::connect(path, "::")) {
           some(name_docs) {
-            do vec::foldl(~[], name_docs) {|v, name_doc|
+            do vec::foldl(~[], name_docs) |v, name_doc| {
                 let (name, doc) = name_doc;
                 v + ~[reexport_doc(doc, name)]
             }
@@ -462,7 +462,7 @@ fn should_duplicate_multiple_reexported_items() {
                   import a::b; import a::c; \
                   export b; export c; \
                   }";
-    do astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv, "");
         let doc = path_pass::mk_pass().f(srv, doc);
         let doc = run(srv, doc);
@@ -484,7 +484,7 @@ fn should_rename_items_reexported_with_different_names() {
 #[test]
 fn should_reexport_in_topmod() {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "core");
             let doc = path_pass::mk_pass().f(srv, doc);
             run(srv, doc)
@@ -515,7 +515,7 @@ fn should_not_reexport_multiple_times() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             let doc = path_pass::mk_pass().f(srv, doc);
             run(srv, doc)
diff --git a/src/rustdoc/rustdoc.rs b/src/rustdoc/rustdoc.rs
index c9d08567596..0d7f59e6b6d 100755
--- a/src/rustdoc/rustdoc.rs
+++ b/src/rustdoc/rustdoc.rs
@@ -31,11 +31,11 @@ fn run_passes(
     )];
 
     let mut passno = 0;
-    do vec::foldl(doc, passes) {|doc, pass|
+    do vec::foldl(doc, passes) |doc, pass| {
         log(debug, #fmt("pass #%d", passno));
         passno += 1;
         log(debug, doc);
-        do time(pass.name) {||
+        do time(pass.name) || {
             pass.f(srv, doc)
         }
     }
@@ -82,7 +82,7 @@ fn test_run_passes() {
         }
     }
     let source = "";
-    do astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) |srv| {
         let passes = ~[
             {
                 name: "",
@@ -129,11 +129,11 @@ fn time<T>(what: str, f: fn() -> T) -> T {
 fn run(config: config::config) {
 
     let source_file = config.input_crate;
-    do astsrv::from_file(source_file) {|srv|
-        do time("wait_ast") {||
-            do astsrv::exec(srv) {|_ctxt| () }
+    do astsrv::from_file(source_file) |srv| {
+        do time("wait_ast") || {
+            do astsrv::exec(srv) |_ctxt| { }
         };
-        let doc = time("extract", {||
+        let doc = time("extract", || {
             let default_name = source_file;
             extract::from_srv(srv, default_name)
         });
diff --git a/src/rustdoc/sectionalize_pass.rs b/src/rustdoc/sectionalize_pass.rs
index d4a453acb83..85879c94ba9 100644
--- a/src/rustdoc/sectionalize_pass.rs
+++ b/src/rustdoc/sectionalize_pass.rs
@@ -34,7 +34,7 @@ fn fold_iface(fold: fold::fold<()>, doc: doc::ifacedoc) -> doc::ifacedoc {
     let doc = fold::default_seq_fold_iface(fold, doc);
 
     {
-        methods: do par::anymap(doc.methods) {|method|
+        methods: do par::anymap(doc.methods) |method| {
             let (desc, sections) = sectionalize(method.desc);
 
             {
@@ -51,7 +51,7 @@ fn fold_impl(fold: fold::fold<()>, doc: doc::impldoc) -> doc::impldoc {
     let doc = fold::default_seq_fold_impl(fold, doc);
 
     {
-        methods: do par::anymap(doc.methods) {|method|
+        methods: do par::anymap(doc.methods) |method| {
             let (desc, sections) = sectionalize(method.desc);
 
             {
@@ -94,7 +94,7 @@ fn sectionalize(desc: option<str>) -> (option<str>, ~[doc::section]) {
     let mut current_section = none;
     let mut sections = ~[];
 
-    for lines.each {|line|
+    for lines.each |line| {
         alt parse_header(line) {
           some(header) {
             if option::is_some(current_section) {
@@ -228,7 +228,7 @@ fn should_sectionalize_impl_methods() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             let doc = attr_pass::mk_pass().f(srv, doc);
             run(srv, doc)
diff --git a/src/rustdoc/sort_item_name_pass.rs b/src/rustdoc/sort_item_name_pass.rs
index 580286922ff..c791c099b43 100644
--- a/src/rustdoc/sort_item_name_pass.rs
+++ b/src/rustdoc/sort_item_name_pass.rs
@@ -3,7 +3,7 @@
 export mk_pass;
 
 fn mk_pass() -> pass {
-    sort_pass::mk_pass("sort_item_name", { |item1, item2|
+    sort_pass::mk_pass("sort_item_name", |item1, item2| {
         str::le(item1.name(), item2.name())
     })
 }
@@ -11,7 +11,7 @@ fn mk_pass() -> pass {
 #[test]
 fn test() {
     let source = "mod z { } fn y() { }";
-    do astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv, "");
         let doc = mk_pass().f(srv, doc);
         assert doc.cratemod().items[0].name() == "y";
diff --git a/src/rustdoc/sort_item_type_pass.rs b/src/rustdoc/sort_item_type_pass.rs
index 4509a1e996d..7536da57150 100644
--- a/src/rustdoc/sort_item_type_pass.rs
+++ b/src/rustdoc/sort_item_type_pass.rs
@@ -3,7 +3,7 @@
 export mk_pass;
 
 fn mk_pass() -> pass {
-    do sort_pass::mk_pass("sort_item_type") { |item1, item2|
+    do sort_pass::mk_pass("sort_item_type") |item1, item2| {
         fn score(item: doc::itemtag) -> int {
             alt item {
               doc::consttag(_) { 0 }
@@ -32,7 +32,7 @@ fn test() {
          iface iiface { fn a(); } \
          impl iimpl for int { fn a() { } } \
          type itype = int;";
-    do astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv, "");
         let doc = mk_pass().f(srv, doc);
         assert doc.cratemod().items[0].name() == "iconst";
diff --git a/src/rustdoc/sort_pass.rs b/src/rustdoc/sort_pass.rs
index 838348dd99b..7cc537851dc 100644
--- a/src/rustdoc/sort_pass.rs
+++ b/src/rustdoc/sort_pass.rs
@@ -47,7 +47,7 @@ fn test() {
     }
 
     let source = "mod z { mod y { } fn x() { } } mod w { }";
-    do astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv, "");
         let doc = mk_pass("", name_lteq).f(srv, doc);
         assert doc.cratemod().mods()[0].name() == "w";
@@ -64,7 +64,7 @@ fn should_be_stable() {
     }
 
     let source = "mod a { mod b { } } mod c { mod d { } }";
-    do astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv, "");
         let doc = mk_pass("", always_eq).f(srv, doc);
         assert doc.cratemod().mods()[0].items[0].name() == "b";
diff --git a/src/rustdoc/text_pass.rs b/src/rustdoc/text_pass.rs
index bb750491947..6d3ef691f64 100644
--- a/src/rustdoc/text_pass.rs
+++ b/src/rustdoc/text_pass.rs
@@ -30,7 +30,7 @@ fn run(
 }
 
 fn maybe_apply_op(op: op, s: option<str>) -> option<str> {
-    option::map(s, {|s| op(s) })
+    option::map(s, |s| op(s) )
 }
 
 fn fold_item(fold: fold::fold<op>, doc: doc::itemdoc) -> doc::itemdoc {
@@ -45,11 +45,9 @@ fn fold_item(fold: fold::fold<op>, doc: doc::itemdoc) -> doc::itemdoc {
 }
 
 fn apply_to_sections(op: op, sections: ~[doc::section]) -> ~[doc::section] {
-    par::anymap(sections, {|section, copy op|
-        {
-            header: op(section.header),
-            body: op(section.body)
-        }
+    par::anymap(sections, |section, copy op| {
+        header: op(section.header),
+        body: op(section.body)
     })
 }
 
@@ -57,7 +55,7 @@ fn fold_enum(fold: fold::fold<op>, doc: doc::enumdoc) -> doc::enumdoc {
     let doc = fold::default_seq_fold_enum(fold, doc);
 
     {
-        variants: do par::anymap(doc.variants) {|variant, copy fold|
+        variants: do par::anymap(doc.variants) |variant, copy fold| {
             {
                 desc: maybe_apply_op(fold.ctxt, variant.desc)
                 with variant
@@ -77,7 +75,7 @@ fn fold_iface(fold: fold::fold<op>, doc: doc::ifacedoc) -> doc::ifacedoc {
 }
 
 fn apply_to_methods(op: op, docs: ~[doc::methoddoc]) -> ~[doc::methoddoc] {
-    do par::anymap(docs) {|doc, copy op|
+    do par::anymap(docs) |doc, copy op| {
         {
             brief: maybe_apply_op(op, doc.brief),
             desc: maybe_apply_op(op, doc.desc),
@@ -253,12 +251,12 @@ fn should_execute_on_impl_method_section_bodies() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             let doc = attr_pass::mk_pass().f(srv, doc);
             let doc = desc_to_brief_pass::mk_pass().f(srv, doc);
             let doc = sectionalize_pass::mk_pass().f(srv, doc);
-            mk_pass("", {|s| str::trim(s)}).f(srv, doc)
+            mk_pass("", |s| str::trim(s) ).f(srv, doc)
         }
     }
 }
diff --git a/src/rustdoc/trim_pass.rs b/src/rustdoc/trim_pass.rs
index d9076516209..4f7a90743ac 100644
--- a/src/rustdoc/trim_pass.rs
+++ b/src/rustdoc/trim_pass.rs
@@ -10,7 +10,7 @@ is interpreted as the brief description.
 export mk_pass;
 
 fn mk_pass() -> pass {
-    text_pass::mk_pass("trim", {|s| str::trim(s)})
+    text_pass::mk_pass("trim", |s| str::trim(s) )
 }
 
 #[test]
@@ -23,7 +23,7 @@ fn should_trim_text() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             let doc = attr_pass::mk_pass().f(srv, doc);
             mk_pass().f(srv, doc)
diff --git a/src/rustdoc/tystr_pass.rs b/src/rustdoc/tystr_pass.rs
index 33410cca299..69b86bff19b 100644
--- a/src/rustdoc/tystr_pass.rs
+++ b/src/rustdoc/tystr_pass.rs
@@ -45,7 +45,7 @@ fn fold_fn(
 }
 
 fn get_fn_sig(srv: astsrv::srv, fn_id: doc::ast_id) -> option<str> {
-    do astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) |ctxt| {
         alt check ctxt.ast_map.get(fn_id) {
           ast_map::node_item(@{
             ident: ident,
@@ -80,7 +80,7 @@ fn fold_const(
     let srv = fold.ctxt;
 
     {
-        sig: some(do astsrv::exec(srv) {|ctxt|
+        sig: some(do astsrv::exec(srv) |ctxt| {
             alt check ctxt.ast_map.get(doc.id()) {
               ast_map::node_item(@{
                 node: ast::item_const(ty, _), _
@@ -107,14 +107,14 @@ fn fold_enum(
     let srv = fold.ctxt;
 
     {
-        variants: do par::anymap(doc.variants) {|variant|
-            let sig = do astsrv::exec(srv) {|ctxt|
+        variants: do par::anymap(doc.variants) |variant| {
+            let sig = do astsrv::exec(srv) |ctxt| {
                 alt check ctxt.ast_map.get(doc_id) {
                   ast_map::node_item(@{
                     node: ast::item_enum(ast_variants, _, _), _
                   }, _) {
                     let ast_variant = option::get(
-                        do vec::find(ast_variants) {|v|
+                        do vec::find(ast_variants) |v| {
                             *v.node.name == variant.name
                         });
 
@@ -153,7 +153,7 @@ fn merge_methods(
     item_id: doc::ast_id,
     docs: ~[doc::methoddoc]
 ) -> ~[doc::methoddoc] {
-    do par::anymap(docs) {|doc|
+    do par::anymap(docs) |doc| {
         {
             sig: get_method_sig(srv, item_id, doc.name)
             with doc
@@ -166,12 +166,12 @@ fn get_method_sig(
     item_id: doc::ast_id,
     method_name: str
 ) -> option<str> {
-    do astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) |ctxt| {
         alt check ctxt.ast_map.get(item_id) {
           ast_map::node_item(@{
             node: ast::item_iface(_, _, methods), _
           }, _) {
-            alt check vec::find(methods, {|method|
+            alt check vec::find(methods, |method| {
                 *method.ident == method_name
             }) {
                 some(method) {
@@ -186,7 +186,7 @@ fn get_method_sig(
           ast_map::node_item(@{
             node: ast::item_impl(_, _, _, _, methods), _
           }, _) {
-            alt check vec::find(methods, {|method|
+            alt check vec::find(methods, |method| {
                 *method.ident == method_name
             }) {
                 some(method) {
@@ -216,12 +216,12 @@ fn fold_impl(
 
     let srv = fold.ctxt;
 
-    let (iface_ty, self_ty) = do astsrv::exec(srv) {|ctxt|
+    let (iface_ty, self_ty) = do astsrv::exec(srv) |ctxt| {
         alt ctxt.ast_map.get(doc.id()) {
           ast_map::node_item(@{
             node: ast::item_impl(_, _, iface_ty, self_ty, _), _
           }, _) {
-            let iface_ty = option::map(iface_ty, {|p|
+            let iface_ty = option::map(iface_ty, |p| {
                 pprust::path_to_str(p.path)
             });
             (iface_ty, some(pprust::ty_to_str(self_ty)))
@@ -271,7 +271,7 @@ fn fold_type(
     let srv = fold.ctxt;
 
     {
-        sig: do astsrv::exec(srv) {|ctxt|
+        sig: do astsrv::exec(srv) |ctxt| {
             alt ctxt.ast_map.get(doc.id()) {
               ast_map::node_item(@{
                 ident: ident,
@@ -300,7 +300,7 @@ fn should_add_type_signatures() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        do astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, "");
             run(srv, doc)
         }
diff --git a/src/rustdoc/unindent_pass.rs b/src/rustdoc/unindent_pass.rs
index 9e10637e8f2..b5e11b0dfd9 100644
--- a/src/rustdoc/unindent_pass.rs
+++ b/src/rustdoc/unindent_pass.rs
@@ -21,7 +21,8 @@ fn unindent(s: str) -> str {
     let lines = str::lines_any(s);
     let mut saw_first_line = false;
     let mut saw_second_line = false;
-    let min_indent = do vec::foldl(uint::max_value, lines) {|min_indent, line|
+    let min_indent = do vec::foldl(uint::max_value, lines)
+        |min_indent, line| {
 
         // After we see the first non-whitespace line, look at
         // the line we have. If it is not whitespace, and therefore
@@ -47,7 +48,7 @@ fn unindent(s: str) -> str {
         } else {
             saw_first_line = true;
             let mut spaces = 0u;
-            do str::all(line) {|char|
+            do str::all(line) |char| {
                 // Only comparing against space because I wouldn't
                 // know what to do with mixed whitespace chars
                 if char == ' ' {
@@ -63,7 +64,7 @@ fn unindent(s: str) -> str {
 
     if check vec::is_not_empty(lines) {
         let unindented = ~[str::trim(vec::head(lines))]
-            + do par::anymap(vec::tail(lines)) {|line|
+            + do par::anymap(vec::tail(lines)) |line| {
             if str::is_whitespace(line) {
                 line
             } else {