Remove bind. Issue #2189

doc/rust.md

@@ -980,7 +980,7 @@ fn pure_foldl<T, U: copy>(ls: list<T>, u: U, f: fn(&&T, &&U) -> U) -> U {
 pure fn pure_length<T>(ls: list<T>) -> uint {
     fn count<T>(_t: T, &&u: uint) -> uint { u + 1u }
     unchecked {
-        pure_foldl(ls, 0u, count(_, _))
+        pure_foldl(ls, 0u, count)
     }
 }
 ~~~~
@@ -1941,49 +1941,6 @@ An example of a call expression:
 let x: int = add(1, 2);
 ~~~~
 
-
-### Bind expressions
-
-A _bind expression_ constructs a new function from an existing function.^[The
-`bind` expression is analogous to the `bind` expression in the Sather
-language.] The new function has zero or more of its arguments *bound* into a
-new, hidden boxed tuple that holds the bindings. For each concrete argument
-passed in the `bind` expression, the corresponding parameter in the existing
-function is *omitted* as a parameter of the new function. For each argument
-passed the placeholder symbol `_` in the `bind` expression, the corresponding
-parameter of the existing function is *retained* as a parameter of the new
-function.
-
-Any subsequent invocation of the new function with residual arguments causes
-invocation of the existing function with the combination of bound arguments
-and residual arguments that was specified during the binding.
-
-An example of a `bind` expression:
-
-~~~~{.xfail-test}
-fn add(x: int, y: int) -> int {
-    ret x + y;
-}
-type single_param_fn = fn(int) -> int;
-
-let add4: single_param_fn = bind add(4, _);
-
-let add5: single_param_fn = bind add(_, 5);
-
-assert (add(4,5) == add4(5));
-assert (add(4,5) == add5(4));
-
-~~~~
-
-A `bind` expression generally stores a copy of the bound arguments in a
-hidden, boxed tuple, owned by the resulting first-class function. For each
-bound slot in the bound function's signature, space is allocated in the hidden
-tuple and populated with a copy of the bound value.
-
-A `bind` expression is an alternative way of constructing a shared function
-closure; the [`fn@` expression](#shared-function-expressions) form is another
-way.
-
 ### Shared function expressions
 
 *TODO*.

doc/tutorial.md

@@ -903,19 +903,6 @@ argument to every element of a vector, producing a new vector.
 Even when a closure takes no parameters, you must still write the bars
 for the parameter list, as in `{|| ...}`.
 
-## Binding
-
-Partial application is done using the `bind` keyword in Rust.
-
-~~~~
-let findx = bind str::find_char(_, 'x');
-~~~~
-
-Binding a function produces a boxed closure (`fn@` type) in which some
-of the arguments to the bound function have already been provided.
-`findx` will be a function taking a single string argument, and
-returning the position where the letter `x` occurs.
-
 ## Iteration
 
 Functions taking closures provide a good way to define non-trivial

src/cargo/cargo.rs

@@ -328,8 +328,8 @@ fn load_crate(filename: str) -> option<crate> {
         mut deps: []
     };
     let v = visit::mk_simple_visitor(@{
-        visit_view_item: bind goto_view_item(e, _),
+        visit_view_item: {|a|goto_view_item(e, a)},
-        visit_item: bind goto_item(e, _),
+        visit_item: {|a|goto_item(e, a)},
         with *visit::default_simple_visitor()
     });
 

src/compiletest/runtest.rs

@@ -325,7 +325,7 @@ fn compose_and_run_compiler(
         let abs_ab = path::connect(config.aux_base, rel_ab);
         let aux_args =
             make_compile_args(config, props, ["--lib"] + extra_link_args,
-                              bind make_lib_name(_, _, testfile), abs_ab);
+                              {|a,b|make_lib_name(a, b, testfile)}, abs_ab);
         let auxres = compose_and_run(config, abs_ab, aux_args, [],
                                      config.compile_lib_path, option::none);
         if auxres.status != 0 {

src/fuzzer/fuzzer.rs

@@ -139,8 +139,8 @@ fn steal(crate: ast::crate, tm: test_mode) -> stolen_stuff {
     let exprs = @mut [];
     let tys = @mut [];
     let v = visit::mk_simple_visitor(@{
-        visit_expr: bind stash_expr_if(safe_to_steal_expr, exprs, _, tm),
+        visit_expr: {|a|stash_expr_if(safe_to_steal_expr, exprs, a, tm)},
-        visit_ty: bind stash_ty_if(safe_to_steal_ty, tys, _, tm)
+        visit_ty: {|a|stash_ty_if(safe_to_steal_ty, tys, a, tm)}
         with *visit::default_simple_visitor()
     });
     visit::visit_crate(crate, (), v);
@@ -188,8 +188,8 @@ fn replace_expr_in_crate(crate: ast::crate, i: uint,
         }
     }
     let afp =
-        @{fold_expr: fold::wrap(bind fold_expr_rep(j, i,
+        @{fold_expr: fold::wrap({|a,b|
-                                                   newexpr.node, _, _, tm))
+        fold_expr_rep(j, i, newexpr.node, a, b, tm)})
           with *fold::default_ast_fold()};
     let af = fold::make_fold(afp);
     let crate2: @ast::crate = @af.fold_crate(crate);
@@ -211,7 +211,7 @@ fn replace_ty_in_crate(crate: ast::crate, i: uint, newty: ast::ty,
         } else { fold::noop_fold_ty(original, fld) }
     }
     let afp =
-        @{fold_ty: fold::wrap(bind fold_ty_rep(j, i, newty.node, _, _, tm))
+        @{fold_ty: fold::wrap({|a,b|fold_ty_rep(j, i, newty.node, a, b, tm)})
          with *fold::default_ast_fold()};
     let af = fold::make_fold(afp);
     let crate2: @ast::crate = @af.fold_crate(crate);
@@ -235,7 +235,7 @@ fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap,
                          filename: str, cx: context) {
     let stolen = steal(crate, cx.mode);
     let extra_exprs = vec::filter(common_exprs(),
-                                  bind safe_to_use_expr(_, cx.mode));
+                                  {|a|safe_to_use_expr(a, cx.mode)});
     check_variants_T(crate, codemap, filename, "expr",
                      extra_exprs + stolen.exprs, pprust::expr_to_str,
                      replace_expr_in_crate, cx);
@@ -268,13 +268,13 @@ fn check_variants_T<T: copy>(
                 // testing the string for stability is easier and ok for now.
                 let handler = diagnostic::mk_handler(none);
                 let str3 =
-                    @as_str(bind pprust::print_crate(
+                    @as_str({|a|pprust::print_crate(
                         codemap,
                         diagnostic::mk_span_handler(handler, codemap),
                         crate2,
                         filename,
-                        io::str_reader(""), _,
+                        io::str_reader(""), a,
-                        pprust::no_ann()));
+                        pprust::no_ann())});
                 alt cx.mode {
                   tm_converge {
                     check_roundtrip_convergence(str3, 1u);
@@ -421,12 +421,12 @@ fn parse_and_print(code: @str) -> str {
     let crate = parse::parse_crate_from_source_str(
         filename, code, [], sess);
     io::with_str_reader(*code) { |rdr|
-        as_str(bind pprust::print_crate(sess.cm,
+        as_str({|a|pprust::print_crate(sess.cm,
                                         sess.span_diagnostic,
                                         crate,
                                         filename,
-                                        rdr, _,
+                                        rdr, a,
-                                        pprust::no_ann()))
+                                       pprust::no_ann())})
     }
 }
 
@@ -439,7 +439,7 @@ fn has_raw_pointers(c: ast::crate) -> bool {
         }
     }
     let v =
-        visit::mk_simple_visitor(@{visit_ty: bind visit_ty(has_rp, _)
+        visit::mk_simple_visitor(@{visit_ty: {|a|visit_ty(has_rp, a)}
                                       with *visit::default_simple_visitor()});
     visit::visit_crate(c, (), v);
     ret *has_rp;
@@ -565,12 +565,12 @@ fn check_variants(files: [str], cx: context) {
                 s, [], sess);
         io::with_str_reader(*s) { |rdr|
             #error("%s",
-                   as_str(bind pprust::print_crate(sess.cm,
+                   as_str({|a|pprust::print_crate(sess.cm,
                                                    sess.span_diagnostic,
                                                    crate,
                                                    file,
-                                                   rdr, _,
+                                                   rdr, a,
-                                                   pprust::no_ann())));
+                                                  pprust::no_ann())}));
         }
         check_variants_of_ast(*crate, sess.cm, file, cx);
     }

src/libcore/comm.rs

@@ -177,11 +177,11 @@ fn peek<T: send>(p: port<T>) -> bool { peek_(***p) }
 
 #[doc(hidden)]
 fn recv_chan<T: send>(ch: comm::chan<T>) -> T {
-    as_raw_port(ch, recv_(_))
+    as_raw_port(ch, {|x|recv_(x)})
 }
 
 fn peek_chan<T: send>(ch: comm::chan<T>) -> bool {
-    as_raw_port(ch, peek_(_))
+    as_raw_port(ch, {|x|peek_(x)})
 }
 
 #[doc = "Receive on a raw port pointer"]

src/libcore/extfmt.rs

@@ -174,7 +174,7 @@ mod ct {
             let curr: [flag] = [f];
             ret {flags: curr + rest, next: j};
         }
-        let more = bind more_(_, s, i, lim);
+        let more = {|x|more_(x, s, i, lim)};
         let f = s[i];
         ret if f == '-' as u8 {
                 more(flag_left_justify)

src/libstd/bitv.rs

@@ -185,7 +185,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 = bind init_to_vec(v, _);
+    let sub = {|x|init_to_vec(v, x)};
     ret vec::from_fn::<uint>(v.nbits, sub);
 }
 

src/libstd/c_vec.rs

@@ -136,7 +136,7 @@ mod tests {
         assert mem as int != 0;
 
         ret unsafe { c_vec_with_dtor(mem as *mut u8, n as uint,
-                                     bind free(mem)) };
+                                     {||free(mem)}) };
     }
 
     #[test]

src/libstd/deque.rs

@@ -292,7 +292,7 @@ mod tests {
                                     two(17, 42));
 
         #debug("*** test parameterized: taggypar<int>");
-        let eq4: eqfn<taggypar<int>> = bind taggypareq::<int>(_, _);
+        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),

src/libstd/test.rs

@@ -162,7 +162,7 @@ fn run_tests_console(opts: test_opts,
           mut ignored: 0u,
           mut failures: []};
 
-    run_tests(opts, tests, bind callback(_, st));
+    run_tests(opts, tests, {|x|callback(x, st)});
 
     assert (st.passed + st.failed + st.ignored == st.total);
     let success = st.failed == 0u;
@@ -349,7 +349,7 @@ fn filter_tests(opts: test_opts,
             } else { ret option::none; }
         }
 
-        let filter = bind filter_fn(_, 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, bind filter(_))
+        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(bind lteq(_, _), filtered)
+        sort::merge_sort({|x,y|lteq(x, y)}, filtered)
         };
 
     ret filtered;

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, bind t(n, _, _));
+        traverse(m, {|x,y|t(n, x, y)});
     }
 
     #[test]

src/libsyntax/ast.rs

@@ -300,7 +300,6 @@ enum expr_ {
     expr_rec([field], option<@expr>),
     expr_call(@expr, [@expr], bool), // True iff last argument is a block
     expr_tup([@expr]),
-    expr_bind(@expr, [option<@expr>]),
     expr_binary(binop, @expr, @expr),
     expr_unary(unop, @expr),
     expr_lit(@lit),

src/libsyntax/ext/auto_serialize.rs

@@ -267,7 +267,7 @@ impl helpers for ext_ctxt {
         }
 
         let fld = fold::make_fold(@{
-            new_span: repl_sp(_, ast_util::dummy_sp(), span)
+            new_span: {|a|repl_sp(a, ast_util::dummy_sp(), span)}
             with *fold::default_ast_fold()
         });
 
@@ -757,8 +757,8 @@ fn ty_fns(cx: ext_ctxt, name: ast::ident, ty: @ast::ty, tps: [ast::ty_param])
 
     let span = ty.span;
     [
-        mk_ser_fn(cx, span, name, tps, ser_ty(_, _, ty, _, _)),
+        mk_ser_fn(cx, span, name, tps, {|a,b,c,d|ser_ty(a, b, ty, c, d)}),
-        mk_deser_fn(cx, span, name, tps, deser_ty(_, _, ty, _))
+        mk_deser_fn(cx, span, name, tps, {|a,b,c|deser_ty(a, b, ty, c)})
     ]
 }
 
@@ -860,8 +860,8 @@ fn enum_fns(cx: ext_ctxt, e_name: ast::ident, e_span: span,
     -> [@ast::item] {
     [
         mk_ser_fn(cx, e_span, e_name, tps,
-                  ser_enum(_, _, e_name, e_span, variants, _, _)),
+                  {|a,b,c,d|ser_enum(a, b, e_name, e_span, variants, c, d)}),
         mk_deser_fn(cx, e_span, e_name, tps,
-                    deser_enum(_, _, e_name, e_span, variants, _))
+                    {|a,b,c|deser_enum(a, b, e_name, e_span, variants, c)})
     ]
 }

src/libsyntax/ext/expand.rs

@@ -130,10 +130,10 @@ fn expand_crate(parse_sess: parse::parse_sess,
     let afp = default_ast_fold();
     let cx: ext_ctxt = mk_ctxt(parse_sess, cfg);
     let f_pre =
-        @{fold_expr: bind expand_expr(exts, cx, _, _, _, afp.fold_expr),
+        @{fold_expr: {|a,b,c|expand_expr(exts, cx, a, b, c, afp.fold_expr)},
-          fold_mod: bind expand_mod_items(exts, cx, _, _, afp.fold_mod),
+          fold_mod: {|a,b|expand_mod_items(exts, cx, a, b, afp.fold_mod)},
-          fold_item: bind expand_item(cx, _, _, afp.fold_item),
+          fold_item: {|a,b|expand_item(cx, a, b, afp.fold_item)},
-          new_span: bind new_span(cx, _)
+          new_span: {|a|new_span(cx, a)}
           with *afp};
     let f = make_fold(f_pre);
     let cm = parse_expr_from_source_str("<core-macros>",

src/libsyntax/ext/fmt.rs

@@ -23,7 +23,9 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
     fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: str) -> ! {
         cx.span_fatal(sp, msg);
     }
-    let parse_fmt_err = bind parse_fmt_err_(cx, fmtspan, _);
+    let parse_fmt_err = fn@(s: str) -> ! {
+        parse_fmt_err_(cx, fmtspan, s)
+    };
     let pieces = parse_fmt_string(fmt, parse_fmt_err);
     ret pieces_to_expr(cx, sp, pieces, args);
 }

src/libsyntax/ext/qquote.rs

@@ -274,10 +274,10 @@ fn replace<T>(node: T, repls: [fragment], ff: fn (ast_fold, T) -> T)
     -> T
 {
     let aft = default_ast_fold();
-    let f_pre = @{fold_expr: bind replace_expr(repls, _, _, _,
+    let f_pre = @{fold_expr: {|a,b,c|replace_expr(repls, a, b, c,
-                                               aft.fold_expr),
+                                                  aft.fold_expr)},
-                  fold_ty: bind replace_ty(repls, _, _, _,
+                  fold_ty: {|a,b,c|replace_ty(repls, a, b, c,
-                                           aft.fold_ty)
+                                              aft.fold_ty)}
                   with *aft};
     ret ff(make_fold(f_pre), node);
 }

src/libsyntax/ext/simplext.rs

@@ -113,7 +113,7 @@ fn a_d_map(ad: arb_depth<matchable>, f: selector) -> match_result {
     alt ad {
       leaf(x) { ret f(x); }
       seq(ads, span) {
-        alt option_flatten_map(bind a_d_map(_, f), *ads) {
+        alt option_flatten_map({|x| a_d_map(x, f)}, *ads) {
           none { ret none; }
           some(ts) { ret some(seq(@ts, span)); }
         }
@@ -128,7 +128,7 @@ fn compose_sels(s1: selector, s2: selector) -> selector {
               some(matches) { a_d_map(matches, s2) }
             }
     }
-    ret bind scomp(s1, s2, _);
+    ret {|x|scomp(s1, s2, x)};
 }
 
 
@@ -190,16 +190,22 @@ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr {
     }
     let afp = default_ast_fold();
     let f_pre =
-        @{fold_ident: bind transcribe_ident(cx, b, idx_path, _, _),
+        @{fold_ident: {|x,y|transcribe_ident(cx, b, idx_path, x, y)},
-          fold_path: bind transcribe_path(cx, b, idx_path, _, _),
+          fold_path: {|x,y|transcribe_path(cx, b, idx_path, x, y)},
-          fold_expr:
+          fold_expr: {|x,y,z|
-              bind transcribe_expr(cx, b, idx_path, _, _, _, afp.fold_expr),
+              transcribe_expr(cx, b, idx_path, x, y, z, afp.fold_expr)
-          fold_ty: bind transcribe_type(cx, b, idx_path,
+          },
-                                        _, _, _, afp.fold_ty),
+          fold_ty: {|x,y,z|
-          fold_block:
+              transcribe_type(cx, b, idx_path,
-              bind transcribe_block(cx, b, idx_path, _, _, _, afp.fold_block),
+                              x, y, z, afp.fold_ty)
-          map_exprs: bind transcribe_exprs(cx, b, idx_path, _, _),
+          },
-          new_id: bind new_id(_, cx)
+          fold_block: {|x,y,z|
+              transcribe_block(cx, b, idx_path, x, y, z, afp.fold_block)
+          },
+          map_exprs: {|x,y|
+              transcribe_exprs(cx, b, idx_path, x, y)
+          },
+          new_id: {|x|new_id(x, cx)}
           with *afp};
     let f = make_fold(f_pre);
     let result = f.fold_expr(body);
@@ -249,7 +255,7 @@ fn free_vars(b: bindings, e: @expr, it: fn(ident)) {
     // using fold is a hack: we want visit, but it doesn't hit idents ) :
     // solve this with macros
     let f_pre =
-        @{fold_ident: bind mark_ident(_, _, b, idents)
+        @{fold_ident: {|x,y|mark_ident(x, y, b, idents)}
           with *default_ast_fold()};
     let f = make_fold(f_pre);
     f.fold_expr(e); // ignore result
@@ -475,7 +481,7 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) {
                       _ { cx.bug("broken traversal in p_t_s_r") }
                     }
             }
-            b.literal_ast_matchers.push(bind select(cx, _, e));
+            b.literal_ast_matchers.push({|x|select(cx, x, e)});
           }
         }
       }
@@ -517,7 +523,7 @@ fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) {
         if b.real_binders.contains_key(p_id) {
             cx.span_fatal(p.span, "duplicate binding identifier");
         }
-        b.real_binders.insert(p_id, compose_sels(s, bind select(cx, _)));
+        b.real_binders.insert(p_id, compose_sels(s, {|x|select(cx, x)}));
       }
       none { }
     }
@@ -562,7 +568,7 @@ fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, s: selector, b: binders) {
                           _ { none }
                         }
                 }
-                let final_step = bind select_pt_1(cx, _, select_pt_2);
+                let final_step = {|x|select_pt_1(cx, x, select_pt_2)};
                 b.real_binders.insert(id, compose_sels(s, final_step));
               }
               none { no_des(cx, pth.span, "under `#<>`"); }
@@ -582,7 +588,7 @@ fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, s: selector, b: binders) {
                       _ { none }
                     }
             }
-            let final_step = bind select_pt_1(cx, _, select_pt_2);
+            let final_step = {|x|select_pt_1(cx, x, select_pt_2)};
             b.real_binders.insert(id, compose_sels(s, final_step));
           }
           none { no_des(cx, blk.span, "under `#{}`"); }
@@ -619,7 +625,7 @@ fn p_t_s_r_ellipses(cx: ext_ctxt, repeat_me: @expr, offset: uint, s: selector,
             }
     }
     p_t_s_rec(cx, match_expr(repeat_me),
-              compose_sels(s, bind select(cx, repeat_me, offset, _)), b);
+              compose_sels(s, {|x|select(cx, repeat_me, offset, x)}), b);
 }
 
 
@@ -643,7 +649,7 @@ fn p_t_s_r_length(cx: ext_ctxt, len: uint, at_least: bool, s: selector,
             }
     }
     b.literal_ast_matchers.push(
-        compose_sels(s, bind len_select(cx, _, at_least, len)));
+        compose_sels(s, {|x|len_select(cx, x, at_least, len)}));
 }
 
 fn p_t_s_r_actual_vector(cx: ext_ctxt, elts: [@expr], _repeat_after: bool,
@@ -664,7 +670,7 @@ fn p_t_s_r_actual_vector(cx: ext_ctxt, elts: [@expr], _repeat_after: bool,
                 }
         }
         p_t_s_rec(cx, match_expr(elts[idx]),
-                  compose_sels(s, bind select(cx, _, idx)), b);
+                  compose_sels(s, {|x, copy idx|select(cx, x, idx)}), b);
         idx += 1u;
     }
 }
@@ -739,7 +745,9 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
         }
     }
 
-    let ext = bind generic_extension(_, _, _, _, clauses);
+    let ext = {|a,b,c,d, move clauses|
+        generic_extension(a,b,c,d,clauses)
+    };
 
     ret {ident:
              alt macro_name {

src/libsyntax/fold.rs

@@ -87,7 +87,7 @@ fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item {
               alt mi.node {
                 meta_word(id) { meta_word(fld.fold_ident(id)) }
                 meta_list(id, mis) {
-                  let fold_meta_item = bind fold_meta_item_(_, fld);
+                  let fold_meta_item = {|x|fold_meta_item_(x, fld)};
                   meta_list(/* FIXME: bad */ copy id,
                             vec::map(mis, fold_meta_item))
                 }
@@ -130,7 +130,7 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
 }
 
 fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
-    ret {inputs: vec::map(decl.inputs, bind fold_arg_(_, fld)),
+    ret {inputs: vec::map(decl.inputs, {|x| fold_arg_(x, fld)}),
          output: fld.fold_ty(decl.output),
          purity: decl.purity,
          cf: decl.cf,
@@ -147,16 +147,16 @@ fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
 fn fold_ty_param(tp: ty_param, fld: ast_fold) -> ty_param {
     {ident: /* FIXME: bad */ copy tp.ident,
      id: fld.new_id(tp.id),
-     bounds: @vec::map(*tp.bounds, fold_ty_param_bound(_, fld))}
+     bounds: @vec::map(*tp.bounds, {|x|fold_ty_param_bound(x, fld)})}
 }
 
 fn fold_ty_params(tps: [ty_param], fld: ast_fold) -> [ty_param] {
-    vec::map(tps, fold_ty_param(_, fld))
+    vec::map(tps, {|x|fold_ty_param(x, fld)})
 }
 
 fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
-    let fold_meta_item = bind fold_meta_item_(_, fld);
+    let fold_meta_item = {|x|fold_meta_item_(x, fld)};
-    let fold_attribute = bind fold_attribute_(_, fld);
+    let fold_attribute = {|x|fold_attribute_(x, fld)};
 
     ret {directives: vec::map(c.directives, fld.fold_crate_directive),
          module: fld.fold_mod(c.module),
@@ -186,8 +186,8 @@ fn noop_fold_view_item(vi: view_item_, _fld: ast_fold) -> view_item_ {
 
 
 fn noop_fold_native_item(&&ni: @native_item, fld: ast_fold) -> @native_item {
-    let fold_arg = bind fold_arg_(_, fld);
+    let fold_arg = {|x|fold_arg_(x, fld)};
-    let fold_attribute = bind fold_attribute_(_, fld);
+    let fold_attribute = {|x|fold_attribute_(x, fld)};
 
     ret @{ident: fld.fold_ident(ni.ident),
           attrs: vec::map(ni.attrs, fold_attribute),
@@ -209,7 +209,7 @@ fn noop_fold_native_item(&&ni: @native_item, fld: ast_fold) -> @native_item {
 }
 
 fn noop_fold_item(&&i: @item, fld: ast_fold) -> @item {
-    let fold_attribute = bind fold_attribute_(_, fld);
+    let fold_attribute = {|x|fold_attribute_(x, fld)};
 
     ret @{ident: fld.fold_ident(i.ident),
           attrs: vec::map(i.attrs, fold_attribute),
@@ -381,9 +381,9 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
                   expr: fld.fold_expr(field.node.expr)},
              span: fld.new_span(field.span)};
     }
-    let fold_field = bind fold_field_(_, fld);
+    let fold_field = {|x|fold_field_(x, fld)};
 
-    let fold_mac = bind fold_mac_(_, fld);
+    let fold_mac = {|x|fold_mac_(x, fld)};
 
     ret alt e {
           expr_new(p, i, v) {
@@ -406,10 +406,6 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
             expr_call(fld.fold_expr(f), fld.map_exprs(fld.fold_expr, args),
                       blk)
           }
-          expr_bind(f, args) {
-            let opt_map_se = bind option::map(_, fld.fold_expr);
-            expr_bind(fld.fold_expr(f), vec::map(args, opt_map_se))
-          }
           expr_binary(binop, lhs, rhs) {
             expr_binary(binop, fld.fold_expr(lhs), fld.fold_expr(rhs))
           }
@@ -483,7 +479,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
 }
 
 fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
-    let fold_mac = bind fold_mac_(_, fld);
+    let fold_mac = {|x|fold_mac_(x, fld)};
     fn fold_mt(mt: mt, fld: ast_fold) -> mt {
         {ty: fld.fold_ty(mt.ty), mutbl: mt.mutbl}
     }
@@ -536,10 +532,10 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
     fn fold_variant_arg_(va: variant_arg, fld: ast_fold) -> variant_arg {
         ret {ty: fld.fold_ty(va.ty), id: fld.new_id(va.id)};
     }
-    let fold_variant_arg = bind fold_variant_arg_(_, fld);
+    let fold_variant_arg = {|x|fold_variant_arg_(x, fld)};
     let args = vec::map(v.args, fold_variant_arg);
 
-    let fold_attribute = bind fold_attribute_(_, fld);
+    let fold_attribute = {|x|fold_attribute_(x, fld)};
     let attrs = vec::map(v.attrs, fold_attribute);
 
     let de = alt v.disr_expr {

src/libsyntax/parse.rs

@@ -17,8 +17,9 @@ import attr::parser_attr;
 import common::parser_common;
 import ast::node_id;
 import util::interner;
-import lexer::{string_reader_as_reader, tt_reader_as_reader,
+// FIXME: resolve badness
-               reader, string_reader, tt_reader};
+import lexer::*;//{string_reader_as_reader, tt_reader_as_reader,
+               //reader, string_reader, tt_reader};
 import diagnostic::{span_handler, mk_span_handler, mk_handler, emitter};
 
 type parse_sess = @{

src/libsyntax/parse/parser.rs

@@ -829,14 +829,6 @@ class parser {
             let ex_ext = self.parse_syntax_ext();
             hi = ex_ext.span.hi;
             ex = ex_ext.node;
-        } else if self.eat_keyword("bind") {
-            let e = self.parse_expr_res(RESTRICT_NO_CALL_EXPRS);
-            let es = self.parse_unspanned_seq(
-                token::LPAREN, token::RPAREN,
-                seq_sep_trailing_disallowed(token::COMMA),
-                {|p| p.parse_expr_or_hole()});
-            hi = self.span.hi;
-            ex = expr_bind(e, es);
         } else if self.eat_keyword("fail") {
             if can_begin_expr(self.token) {
                 let e = self.parse_expr();
@@ -1008,19 +1000,13 @@ class parser {
             alt copy self.token {
               // expr(...)
               token::LPAREN if self.permits_call() {
-                let es_opt = self.parse_unspanned_seq(
+                let es = self.parse_unspanned_seq(
                     token::LPAREN, token::RPAREN,
                     seq_sep_trailing_disallowed(token::COMMA),
-                    {|p| p.parse_expr_or_hole()});
+                    {|p| p.parse_expr()});
                 hi = self.span.hi;
 
-                let nd =
+                let nd = expr_call(self.to_expr(e), es, false);
-                    if vec::any(es_opt, {|e| option::is_none(e) }) {
-                    expr_bind(self.to_expr(e), es_opt)
-                } else {
-                    let es = vec::map(es_opt) {|e| option::get(e) };
-                    expr_call(self.to_expr(e), es, false)
-                };
                 e = self.mk_pexpr(lo, hi, nd);
               }
 
@@ -1370,13 +1356,6 @@ class parser {
         ret self.parse_expr_res(UNRESTRICTED);
     }
 
-    fn parse_expr_or_hole() -> option<@expr> {
-        alt self.token {
-          token::UNDERSCORE { self.bump(); ret none; }
-          _ { ret some(self.parse_expr()); }
-        }
-    }
-
     fn parse_expr_res(r: restriction) -> @expr {
         let old = self.restriction;
         self.restriction = r;

src/libsyntax/parse/token.rs

@@ -250,7 +250,6 @@ fn contextual_keyword_table() -> hashmap<str, ()> {
     let words = str_hash();
     let keys = [
         "as",
-        "bind",
         "else",
         "implements",
         "move",

src/libsyntax/print/pprust.rs

@@ -102,7 +102,7 @@ fn typarams_to_str(tps: [ast::ty_param]) -> str {
 }
 
 fn path_to_str(&&p: @ast::path) -> str {
-    ret to_str(p, bind print_path(_, _, false));
+    ret to_str(p, {|a,b|print_path(a, b, false)});
 }
 
 fn fun_to_str(decl: ast::fn_decl, name: ast::ident,
@@ -840,7 +840,7 @@ fn print_mac(s: ps, m: ast::mac) {
           some(@{node: ast::expr_vec(_, _), _}) { }
           _ { word(s.s, " "); }
         }
-        option::iter(arg, bind print_expr(s, _));
+        option::iter(arg, {|a|print_expr(s, a)});
         // FIXME: extension 'body' (#2339)
       }
       ast::mac_embed_type(ty) {
@@ -938,24 +938,6 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
             print_expr(s, option::get(blk));
         }
       }
-      ast::expr_bind(func, args) {
-        fn print_opt(s: ps, expr: option<@ast::expr>) {
-            alt expr {
-              some(expr) { print_expr(s, expr); }
-              _ { word(s.s, "_"); }
-            }
-        }
-
-        // "bind" keyword is only needed if there are no "_" arguments.
-        if !vec::any(args) {|arg| option::is_none(arg) } {
-            word_nbsp(s, "bind");
-        }
-
-        print_expr(s, func);
-        popen(s);
-        commasep(s, inconsistent, args, print_opt);
-        pclose(s);
-      }
       ast::expr_binary(op, lhs, rhs) {
         let prec = operator_prec(op);
         print_op_maybe_parens(s, lhs, prec);
@@ -1780,7 +1762,7 @@ fn ast_ty_fn_constr_to_str(&&c: @ast::constr) -> str {
 }
 
 fn ast_fn_constr_to_str(decl: ast::fn_decl, &&c: @ast::constr) -> str {
-    let arg_to_str = bind fn_arg_idx_to_str(decl, _);
+    let arg_to_str = {|a|fn_arg_idx_to_str(decl, a)};
     ret path_to_str(c.node.path) +
             constr_args_to_str(arg_to_str, c.node.args);
 }

src/libsyntax/visit.rs

@@ -65,22 +65,22 @@ type visitor<E> =
       visit_class_item: fn@(@class_member, E, vt<E>)};
 
 fn default_visitor<E>() -> visitor<E> {
-    ret @{visit_mod: bind visit_mod::<E>(_, _, _, _, _),
+    ret @{visit_mod: {|a,b,c,d,e|visit_mod::<E>(a, b, c, d, e)},
-          visit_view_item: bind visit_view_item::<E>(_, _, _),
+          visit_view_item: {|a,b,c|visit_view_item::<E>(a, b, c)},
-          visit_native_item: bind visit_native_item::<E>(_, _, _),
+          visit_native_item: {|a,b,c|visit_native_item::<E>(a, b, c)},
-          visit_item: bind visit_item::<E>(_, _, _),
+          visit_item: {|a,b,c|visit_item::<E>(a, b, c)},
-          visit_local: bind visit_local::<E>(_, _, _),
+          visit_local: {|a,b,c|visit_local::<E>(a, b, c)},
-          visit_block: bind visit_block::<E>(_, _, _),
+          visit_block: {|a,b,c|visit_block::<E>(a, b, c)},
-          visit_stmt: bind visit_stmt::<E>(_, _, _),
+          visit_stmt: {|a,b,c|visit_stmt::<E>(a, b, c)},
-          visit_arm: bind visit_arm::<E>(_, _, _),
+          visit_arm: {|a,b,c|visit_arm::<E>(a, b, c)},
-          visit_pat: bind visit_pat::<E>(_, _, _),
+          visit_pat: {|a,b,c|visit_pat::<E>(a, b, c)},
-          visit_decl: bind visit_decl::<E>(_, _, _),
+          visit_decl: {|a,b,c|visit_decl::<E>(a, b, c)},
-          visit_expr: bind visit_expr::<E>(_, _, _),
+          visit_expr: {|a,b,c|visit_expr::<E>(a, b, c)},
-          visit_ty: bind skip_ty::<E>(_, _, _),
+          visit_ty: {|a,b,c|skip_ty::<E>(a, b, c)},
-          visit_ty_params: bind visit_ty_params::<E>(_, _, _),
+          visit_ty_params: {|a,b,c|visit_ty_params::<E>(a, b, c)},
-          visit_constr: bind visit_constr::<E>(_, _, _, _, _),
+          visit_constr: {|a,b,c,d,e|visit_constr::<E>(a, b, c, d, e)},
-          visit_fn: bind visit_fn::<E>(_, _, _, _, _, _, _),
+          visit_fn: {|a,b,c,d,e,f,g|visit_fn::<E>(a, b, c, d, e, f, g)},
-          visit_class_item: bind visit_class_item::<E>(_,_,_)};
+          visit_class_item: {|a,b,c|visit_class_item::<E>(a, b, c)}};
 }
 
 fn visit_crate<E>(c: crate, e: E, v: vt<E>) {
@@ -377,10 +377,6 @@ fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
         visit_exprs(args, e, v);
         v.visit_expr(callee, e, v);
       }
-      expr_bind(callee, args) {
-        v.visit_expr(callee, e, v);
-        for args.each {|eo| visit_expr_opt(eo, e, v); }
-      }
       expr_binary(_, a, b) { v.visit_expr(a, e, v); v.visit_expr(b, e, v); }
       expr_addr_of(_, x) | expr_unary(_, x) |
       expr_loop_body(x) | expr_do_body(x) |
@@ -559,9 +555,9 @@ fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
         visit_fn(fk, decl, body, sp, id, e, v);
     }
     let visit_ty = if v.visit_ty == simple_ignore_ty {
-        bind skip_ty(_, _, _)
+        {|a,b,c| skip_ty(a, b, c)}
     } else {
-        bind v_ty(v.visit_ty, _, _, _)
+        {|a,b,c| v_ty(v.visit_ty, a, b, c)}
     };
     fn v_class_item(f: fn@(@class_member),
                     cm: @class_member, &&e: (),
@@ -569,24 +565,33 @@ fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
         f(cm);
         visit_class_item(cm, e, v);
     }
-    ret mk_vt(@{visit_mod: bind v_mod(v.visit_mod, _, _, _, _, _),
+    ret mk_vt(@{visit_mod: {|a,b,c,d,e|v_mod(v.visit_mod, a, b, c, d, e)},
-                visit_view_item: bind v_view_item(v.visit_view_item, _, _, _),
+                visit_view_item: {|a,b,c|
+                    v_view_item(v.visit_view_item, a, b, c)
+                },
                 visit_native_item:
-                    bind v_native_item(v.visit_native_item, _, _, _),
+                    {|a,b,c|v_native_item(v.visit_native_item, a, b, c)},
-                visit_item: bind v_item(v.visit_item, _, _, _),
+                visit_item: {|a,b,c|v_item(v.visit_item, a, b, c)},
-                visit_local: bind v_local(v.visit_local, _, _, _),
+                visit_local: {|a,b,c|v_local(v.visit_local, a, b, c)},
-                visit_block: bind v_block(v.visit_block, _, _, _),
+                visit_block: {|a,b,c|v_block(v.visit_block, a, b, c)},
-                visit_stmt: bind v_stmt(v.visit_stmt, _, _, _),
+                visit_stmt: {|a,b,c|v_stmt(v.visit_stmt, a, b, c)},
-                visit_arm: bind v_arm(v.visit_arm, _, _, _),
+                visit_arm: {|a,b,c|v_arm(v.visit_arm, a, b, c)},
-                visit_pat: bind v_pat(v.visit_pat, _, _, _),
+                visit_pat: {|a,b,c|v_pat(v.visit_pat, a, b, c)},
-                visit_decl: bind v_decl(v.visit_decl, _, _, _),
+                visit_decl: {|a,b,c|v_decl(v.visit_decl, a, b, c)},
-                visit_expr: bind v_expr(v.visit_expr, _, _, _),
+                visit_expr: {|a,b,c|v_expr(v.visit_expr, a, b, c)},
                 visit_ty: visit_ty,
-                visit_ty_params: bind v_ty_params(v.visit_ty_params, _, _, _),
+                visit_ty_params: {|a,b,c|
-                visit_constr: bind v_constr(v.visit_constr, _, _, _, _, _),
+                    v_ty_params(v.visit_ty_params, a, b, c)
-                visit_fn: bind v_fn(v.visit_fn, _, _, _, _, _, _, _),
+                },
-                visit_class_item: bind v_class_item(v.visit_class_item, _, _,
+                visit_constr: {|a,b,c,d,e|
-                                                    _)
+                    v_constr(v.visit_constr, a, b, c, d, e)
+                },
+                visit_fn: {|a,b,c,d,e,f,g|
+                    v_fn(v.visit_fn, a, b, c, d, e, f, g)
+                },
+                visit_class_item: {|a,b,c|
+                    v_class_item(v.visit_class_item, a, b, c)
+                }
                });
 }
 

src/rustc/back/rpath.rs

@@ -94,7 +94,10 @@ fn get_rpaths_relative_to_output(os: session::os,
                                  cwd: path::path,
                                  output: path::path,
                                  libs: [path::path]) -> [str] {
-    vec::map(libs, bind get_rpath_relative_to_output(os, cwd, output, _))
+    vec::map(libs, {|a|
+        check not_win32(os);
+        get_rpath_relative_to_output(os, cwd, output, a)
+    })
 }
 
 fn get_rpath_relative_to_output(os: session::os,
@@ -149,7 +152,7 @@ fn get_relative_to(abs1: path::path, abs2: path::path) -> path::path {
 }
 
 fn get_absolute_rpaths(cwd: path::path, libs: [path::path]) -> [str] {
-    vec::map(libs, bind get_absolute_rpath(cwd, _))
+    vec::map(libs, {|a|get_absolute_rpath(cwd, a)})
 }
 
 fn get_absolute_rpath(cwd: path::path, &&lib: path::path) -> str {

src/rustc/back/upcall.rs

@@ -43,8 +43,8 @@ fn declare_upcalls(targ_cfg: @session::config,
     fn nothrow(f: ValueRef) -> ValueRef {
         base::set_no_unwind(f); f
     }
-    let d = bind decl(llmod, "upcall_", _, _, _);
+    let d = {|a,b,c|decl(llmod, "upcall_", a, b, c)};
-    let dv = bind decl(llmod, "upcall_", _, _, T_void());
+    let dv = {|a,b|decl(llmod, "upcall_", a, b, T_void())};
 
     let int_t = T_int(targ_cfg);
     let size_t = T_size_t(targ_cfg);

src/rustc/driver/driver.rs

@@ -132,7 +132,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
     -> {crate: @ast::crate, tcx: option<ty::ctxt>} {
     let time_passes = sess.time_passes();
     let mut crate = time(time_passes, "parsing",
-                         bind parse_input(sess, cfg, input));
+                         {||parse_input(sess, cfg, input)});
     if upto == cu_parse { ret {crate: crate, tcx: none}; }
 
     sess.building_library = session::building_library(
@@ -140,75 +140,87 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
 
     crate =
         time(time_passes, "configuration",
-             bind front::config::strip_unconfigured_items(crate));
+             {|copy crate|front::config::strip_unconfigured_items(crate)});
     crate =
         time(time_passes, "maybe building test harness",
-             bind front::test::modify_for_testing(sess, crate));
+             {|copy crate|front::test::modify_for_testing(sess, crate)});
     crate =
         time(time_passes, "expansion",
-             bind syntax::ext::expand::expand_crate(
+             {|copy crate|syntax::ext::expand::expand_crate(
-                 sess.parse_sess, sess.opts.cfg, crate));
+                 sess.parse_sess, sess.opts.cfg, crate)});
 
     if upto == cu_expand { ret {crate: crate, tcx: none}; }
 
     crate =
-        time(time_passes, "intrinsic injection",
+        time(time_passes, "intrinsic injection", {|copy crate|
-             bind front::intrinsic_inject::inject_intrinsic(sess, crate));
+            front::intrinsic_inject::inject_intrinsic(sess, crate)
+        });
 
     crate =
-        time(time_passes, "core injection",
+        time(time_passes, "core injection", {|copy crate|
-             bind front::core_inject::maybe_inject_libcore_ref(sess, crate));
+            front::core_inject::maybe_inject_libcore_ref(sess, crate)
+        });
 
-    time(time_passes, "building warning settings table",
+    time(time_passes, "building warning settings table", {|copy crate|
-         bind lint::build_settings_crate(sess, crate));
+        lint::build_settings_crate(sess, crate)
+    });
 
     let ast_map =
-        time(time_passes, "ast indexing",
+        time(time_passes, "ast indexing", {|copy crate|
-             bind syntax::ast_map::map_crate(sess.diagnostic(), *crate));
+            syntax::ast_map::map_crate(sess.diagnostic(), *crate)
-    time(time_passes, "external crate/lib resolution",
+        });
-         bind creader::read_crates(
+    time(time_passes, "external crate/lib resolution", {|copy crate|
-             sess.diagnostic(), *crate, sess.cstore,
+        creader::read_crates(
-             sess.filesearch,
+            sess.diagnostic(), *crate, sess.cstore,
-             session::sess_os_to_meta_os(sess.targ_cfg.os),
+            sess.filesearch,
-             sess.opts.static));
+            session::sess_os_to_meta_os(sess.targ_cfg.os),
+            sess.opts.static)
+    });
     let {def_map, exp_map, impl_map} =
-        time(time_passes, "resolution",
+        time(time_passes, "resolution", {|copy crate|
-             bind resolve::resolve_crate(sess, ast_map, crate));
+            resolve::resolve_crate(sess, ast_map, crate)
+        });
     let freevars =
-        time(time_passes, "freevar finding",
+        time(time_passes, "freevar finding", {|copy crate|
-             bind freevars::annotate_freevars(def_map, crate));
+            freevars::annotate_freevars(def_map, crate)
+        });
     let region_map =
-        time(time_passes, "region resolution",
+        time(time_passes, "region resolution", {|copy crate|
-             bind middle::region::resolve_crate(sess, def_map, crate));
+            middle::region::resolve_crate(sess, def_map, crate)
+        });
     let ty_cx = ty::mk_ctxt(sess, def_map, ast_map, freevars, region_map);
     let (method_map, vtable_map) =
-        time(time_passes, "typechecking",
+        time(time_passes, "typechecking", {|copy crate|
-             bind typeck::check_crate(ty_cx, impl_map, crate));
+            typeck::check_crate(ty_cx, impl_map, crate)
-    time(time_passes, "const checking",
+        });
-         bind middle::check_const::check_crate(sess, crate, ast_map, def_map,
+    time(time_passes, "const checking", {|copy crate|
-                                               method_map, ty_cx));
+        middle::check_const::check_crate(
+            sess, crate, ast_map, def_map, method_map, ty_cx)
+    });
 
     if upto == cu_typeck { ret {crate: crate, tcx: some(ty_cx)}; }
 
     time(time_passes, "block-use checking",
-         bind middle::block_use::check_crate(ty_cx, crate));
+         {|copy crate|middle::block_use::check_crate(ty_cx, crate)});
     time(time_passes, "loop checking",
-         bind middle::check_loop::check_crate(ty_cx, crate));
+         {|copy crate|middle::check_loop::check_crate(ty_cx, crate)});
     time(time_passes, "alt checking",
-         bind middle::check_alt::check_crate(ty_cx, crate));
+         {|copy crate|middle::check_alt::check_crate(ty_cx, crate)});
     let last_use_map =
-        time(time_passes, "liveness checking",
+        time(time_passes, "liveness checking", {|copy crate|
-             bind middle::liveness::check_crate(ty_cx, method_map, crate));
+            middle::liveness::check_crate(ty_cx, method_map, crate)
+        });
     time(time_passes, "typestate checking",
-         bind middle::tstate::ck::check_crate(ty_cx, crate));
+         {|copy crate|middle::tstate::ck::check_crate(ty_cx, crate)});
     let (root_map, mutbl_map) = time(
         time_passes, "borrow checking",
-        bind middle::borrowck::check_crate(ty_cx, method_map,
+        {|copy crate|middle::borrowck::check_crate(ty_cx, method_map,
-                                           last_use_map, crate));
+                                         last_use_map, crate)});
-    time(time_passes, "kind checking",
+    time(time_passes, "kind checking", {|copy crate|
-         bind kind::check_crate(ty_cx, method_map, last_use_map, crate));
+        kind::check_crate(ty_cx, method_map, last_use_map, crate)
+    });
     time(time_passes, "lint checking",
-         bind lint::check_crate(ty_cx, crate));
+         {|copy crate|lint::check_crate(ty_cx, crate)});
 
     if upto == cu_no_trans { ret {crate: crate, tcx: some(ty_cx)}; }
     let outputs = option::get(outputs);
@@ -220,11 +232,11 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
 
     let (llmod, link_meta) =
         time(time_passes, "translation",
-             bind trans::base::trans_crate(
+             {|copy crate|trans::base::trans_crate(
                  sess, crate, ty_cx, outputs.obj_filename,
-                 exp_map, maps));
+                 exp_map, maps)});
     time(time_passes, "LLVM passes",
-         bind link::write::run_passes(sess, llmod, outputs.obj_filename));
+         {||link::write::run_passes(sess, llmod, outputs.obj_filename)});
 
     let stop_after_codegen =
         sess.opts.output_type != link::output_type_exe ||
@@ -233,8 +245,8 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
     if stop_after_codegen { ret {crate: crate, tcx: some(ty_cx)}; }
 
     time(time_passes, "linking",
-         bind link::link_binary(sess, outputs.obj_filename,
+         {||link::link_binary(sess, outputs.obj_filename,
-                                outputs.out_filename, link_meta));
+                              outputs.out_filename, link_meta)});
     ret {crate: crate, tcx: some(ty_cx)};
 }
 
@@ -303,7 +315,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input,
     alt ppm {
       ppm_typed {
         ann = {pre: ann_paren_for_expr,
-               post: bind ann_typed_post(option::get(tcx), _)};
+               post: {|a|ann_typed_post(option::get(tcx), a)}};
       }
       ppm_identified | ppm_expanded_identified {
         ann = {pre: ann_paren_for_expr, post: ann_identified_post};

src/rustc/driver/rustc.rs

@@ -169,7 +169,7 @@ fn run_compiler(args: [str], demitter: diagnostic::emitter) {
     let pretty =
         option::map(getopts::opt_default(match, "pretty",
                                          "normal"),
-                    bind parse_pretty(sess, _));
+                    {|a|parse_pretty(sess, a)});
     alt pretty {
       some::<pp_mode>(ppm) { pretty_print_input(sess, cfg, input, ppm); ret; }
       none::<pp_mode> {/* continue */ }

src/rustc/front/config.rs

@@ -24,9 +24,9 @@ fn strip_items(crate: @ast::crate, in_cfg: in_cfg_pred)
     let ctxt = @{in_cfg: in_cfg};
 
     let precursor =
-        @{fold_mod: bind fold_mod(ctxt, _, _),
+        @{fold_mod: {|a,b|fold_mod(ctxt, a, b)},
-          fold_block: fold::wrap(bind fold_block(ctxt, _, _)),
+          fold_block: fold::wrap({|a,b|fold_block(ctxt, a, b)}),
-          fold_native_mod: bind fold_native_mod(ctxt, _, _)
+          fold_native_mod: {|a,b|fold_native_mod(ctxt, a, b)}
           with *fold::default_ast_fold()};
 
     let fold = fold::make_fold(precursor);
@@ -41,7 +41,7 @@ fn filter_item(cx: ctxt, &&item: @ast::item) ->
 
 fn fold_mod(cx: ctxt, m: ast::_mod, fld: fold::ast_fold) ->
    ast::_mod {
-    let filter = bind filter_item(cx, _);
+    let filter = {|a|filter_item(cx, a)};
     let filtered_items = vec::filter_map(m.items, filter);
     ret {view_items: vec::map(m.view_items, fld.fold_view_item),
          items: vec::map(filtered_items, fld.fold_item)};
@@ -56,7 +56,7 @@ fn filter_native_item(cx: ctxt, &&item: @ast::native_item) ->
 
 fn fold_native_mod(cx: ctxt, nm: ast::native_mod,
                    fld: fold::ast_fold) -> ast::native_mod {
-    let filter = bind filter_native_item(cx, _);
+    let filter = {|a|filter_native_item(cx, a)};
     let filtered_items = vec::filter_map(nm.items, filter);
     ret {view_items: vec::map(nm.view_items, fld.fold_view_item),
          items: filtered_items};
@@ -81,7 +81,7 @@ fn filter_stmt(cx: ctxt, &&stmt: @ast::stmt) ->
 
 fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) ->
    ast::blk_ {
-    let filter = bind filter_stmt(cx, _);
+    let filter = {|a|filter_stmt(cx, a)};
     let filtered_stmts = vec::filter_map(b.stmts, filter);
     ret {view_items: b.view_items,
          stmts: vec::map(filtered_stmts, fld.fold_stmt),

src/rustc/front/test.rs

@@ -44,9 +44,9 @@ fn generate_test_harness(sess: session::session,
           testfns: dvec()};
 
     let precursor =
-        @{fold_crate: fold::wrap(bind fold_crate(cx, _, _)),
+        @{fold_crate: fold::wrap({|a,b|fold_crate(cx, a, b)}),
-          fold_item: bind fold_item(cx, _, _),
+          fold_item: {|a,b|fold_item(cx, a, b)},
-          fold_mod: bind fold_mod(cx, _, _) with *fold::default_ast_fold()};
+          fold_mod: {|a,b|fold_mod(cx, a, b)} with *fold::default_ast_fold()};
 
     let fold = fold::make_fold(precursor);
     let res = @fold.fold_crate(*crate);

src/rustc/metadata/creader.rs

@@ -31,8 +31,8 @@ fn read_crates(diag: span_handler, crate: ast::crate,
               mut next_crate_num: 1};
     let v =
         visit::mk_simple_visitor(@{visit_view_item:
-                                       bind visit_view_item(e, _),
+                                       {|a|visit_view_item(e, a)},
-                                   visit_item: bind visit_item(e, _)
+                                   visit_item: {|a|visit_item(e, a)}
                                       with *visit::default_simple_visitor()});
     visit::visit_crate(crate, (), v);
     dump_crates(e.crate_cache);

src/rustc/metadata/decoder.rs

@@ -77,7 +77,7 @@ fn maybe_find_item(item_id: int, items: ebml::doc) -> option<ebml::doc> {
     fn eq_item(bytes: [u8], item_id: int) -> bool {
         ret io::u64_from_be_bytes(bytes, 0u, 4u) as int == item_id;
     }
-    let eqer = bind eq_item(_, item_id);
+    let eqer = {|a|eq_item(a, item_id)};
     let found = lookup_hash(items, eqer, hash_node_id(item_id));
     if vec::len(found) == 0u {
         ret option::none::<ebml::doc>;
@@ -213,7 +213,7 @@ fn resolve_path(path: [ast::ident], data: @[u8]) -> [ast::def_id] {
     let s = ast_util::path_name_i(path);
     let md = ebml::doc(data);
     let paths = ebml::get_doc(md, tag_paths);
-    let eqer = bind eq_item(_, s);
+    let eqer = {|a|eq_item(a, s)};
     let mut result: [ast::def_id] = [];
     #debug("resolve_path: looking up %s", s);
     for lookup_hash(paths, eqer, hash_path(s)).each {|doc|

src/rustc/metadata/encoder.rs

@@ -271,7 +271,7 @@ fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt,
     let ty_str_ctxt = @{diag: ecx.diag,
                         ds: def_to_str,
                         tcx: ecx.tcx,
-                        reachable: reachable(ecx, _),
+                        reachable: {|a|reachable(ecx, a)},
                         abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     for params.each {|param|
         ebml_w.start_tag(tag_items_data_item_ty_param_bounds);
@@ -292,7 +292,7 @@ fn write_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
         @{diag: ecx.diag,
           ds: def_to_str,
           tcx: ecx.tcx,
-          reachable: reachable(ecx, _),
+          reachable: {|a|reachable(ecx, a)},
           abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ);
 }
@@ -551,7 +551,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
                      index: @mut [entry<int>]) {
         *index += [{val: item.id, pos: ebml_w.writer.tell()}];
     }
-    let add_to_index = bind add_to_index_(item, copy ebml_w, index);
+    let add_to_index = {|copy ebml_w|add_to_index_(item, ebml_w, index)};
 
     alt item.node {
       item_const(_, _) {

src/rustc/metadata/tydecode.rs

@@ -37,7 +37,7 @@ fn next_byte(st: @pstate) -> u8 {
 
 fn parse_ident(st: @pstate, last: char) -> ast::ident {
     fn is_last(b: char, c: char) -> bool { ret c == b; }
-    ret parse_ident_(st, bind is_last(last, _));
+    ret parse_ident_(st, {|a|is_last(last, a)});
 }
 
 fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) ->

src/rustc/middle/astencode.rs

@@ -445,8 +445,8 @@ fn decode_ast(par_doc: ebml::doc) -> ast::inlined_item {
 fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
     -> ast::inlined_item {
     let fld = fold::make_fold(@{
-        new_id: xcx.tr_id(_),
+        new_id: {|a|xcx.tr_id(a)},
-        new_span: xcx.tr_span(_)
+        new_span: {|a|xcx.tr_span(a)}
         with *fold::default_ast_fold()
     });
 
@@ -697,7 +697,7 @@ impl helpers for @e::encode_ctxt {
         @{diag: self.tcx.sess.diagnostic(),
           ds: e::def_to_str,
           tcx: self.tcx,
-          reachable: encoder::reachable(self, _),
+          reachable: {|a|encoder::reachable(self, a)},
           abbrevs: tyencode::ac_use_abbrevs(self.type_abbrevs)}
     }
 }
@@ -903,7 +903,7 @@ impl decoder for ebml::ebml_deserializer {
 
         tydecode::parse_ty_data(
             self.parent.data, xcx.dcx.cdata.cnum, self.pos, xcx.dcx.tcx,
-            xcx.tr_def_id(_))
+            {|a|xcx.tr_def_id(a)})
     }
 
     fn read_tys(xcx: extended_decode_ctxt) -> [ty::t] {
@@ -913,7 +913,7 @@ impl decoder for ebml::ebml_deserializer {
     fn read_bounds(xcx: extended_decode_ctxt) -> @[ty::param_bound] {
         tydecode::parse_bounds_data(
             self.parent.data, self.pos, xcx.dcx.cdata.cnum, xcx.dcx.tcx,
-            xcx.tr_def_id(_))
+            {|a|xcx.tr_def_id(a)})
     }
 
     fn read_ty_param_bounds_and_ty(xcx: extended_decode_ctxt)

src/rustc/middle/borrowck/categorization.rs

@@ -170,7 +170,7 @@ impl public_methods for borrowck_ctxt {
             self.cat_def(expr.id, expr.span, expr_ty, def)
           }
 
-          ast::expr_addr_of(*) | ast::expr_call(*) | ast::expr_bind(*) |
+          ast::expr_addr_of(*) | ast::expr_call(*) |
           ast::expr_swap(*) | ast::expr_move(*) | ast::expr_assign(*) |
           ast::expr_assign_op(*) | ast::expr_fn(*) | ast::expr_fn_block(*) |
           ast::expr_assert(*) | ast::expr_check(*) | ast::expr_ret(*) |

src/rustc/middle/check_alt.rs

@@ -13,8 +13,8 @@ import std::map::hashmap;
 
 fn check_crate(tcx: ty::ctxt, crate: @crate) {
     visit::visit_crate(*crate, (), visit::mk_vt(@{
-        visit_expr: bind check_expr(tcx, _, _, _),
+        visit_expr: {|a,b,c|check_expr(tcx, a, b, c)},
-        visit_local: bind check_local(tcx, _, _, _)
+        visit_local: {|a,b,c|check_local(tcx, a, b, c)}
         with *visit::default_visitor::<()>()
     }));
     tcx.sess.abort_if_errors();

src/rustc/middle/check_const.rs

@@ -8,9 +8,11 @@ fn check_crate(sess: session, crate: @crate, ast_map: ast_map::map,
                def_map: resolve::def_map,
                 method_map: typeck::method_map, tcx: ty::ctxt) {
     visit::visit_crate(*crate, false, visit::mk_vt(@{
-        visit_item: check_item(sess, ast_map, def_map, _, _, _),
+        visit_item: {|a,b,c|check_item(sess, ast_map, def_map, a, b, c)},
         visit_pat: check_pat,
-        visit_expr: bind check_expr(sess, def_map, method_map, tcx, _, _, _)
+        visit_expr: {|a,b,c|
+            check_expr(sess, def_map, method_map, tcx, a, b, c)
+        }
         with *visit::default_visitor()
     }));
     sess.abort_if_errors();

src/rustc/middle/kind.rs

@@ -240,9 +240,6 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
       expr_tup(exprs) | expr_vec(exprs, _) {
         for exprs.each {|expr| maybe_copy(cx, expr); }
       }
-      expr_bind(_, args) {
-        for args.each {|a| alt a { some(ex) { maybe_copy(cx, ex); } _ {} } }
-      }
       expr_call(f, args, _) {
         let mut i = 0u;
         for ty::ty_fn_args(ty::expr_ty(cx.tcx, f)).each {|arg_t|

src/rustc/middle/liveness.rs

@@ -468,7 +468,7 @@ fn visit_expr(expr: @expr, &&self: @ir_maps, vt: vt<@ir_maps>) {
       // otherwise, live nodes are not required:
       expr_index(*) | expr_field(*) | expr_vstore(*) |
       expr_vec(*) | expr_rec(*) | expr_call(*) | expr_tup(*) |
-      expr_bind(*) | expr_new(*) | expr_log(*) | expr_binary(*) |
+      expr_new(*) | expr_log(*) | expr_binary(*) |
       expr_assert(*) | expr_check(*) | expr_addr_of(*) | expr_copy(*) |
       expr_loop_body(*) | expr_do_body(*) | expr_cast(*) |
       expr_unary(*) | expr_fail(*) |
@@ -1081,16 +1081,6 @@ class liveness {
             self.propagate_through_exprs(exprs, succ)
           }
 
-          expr_bind(f, args) {
-            let succ = args.foldr(succ) { |arg, succ|
-                alt arg {
-                  none {succ}
-                  some(e) {self.propagate_through_expr(e, succ)}
-                }
-            };
-            self.propagate_through_expr(f, succ)
-          }
-
           expr_binary(op, l, r) if ast_util::lazy_binop(op) {
             let r_succ = self.propagate_through_expr(r, succ);
 
@@ -1464,7 +1454,7 @@ fn check_expr(expr: @expr, &&self: @liveness, vt: vt<@liveness>) {
       expr_while(*) | expr_loop(*) |
       expr_index(*) | expr_field(*) | expr_vstore(*) |
       expr_vec(*) | expr_rec(*) | expr_tup(*) |
-      expr_bind(*) | expr_new(*) | expr_log(*) | expr_binary(*) |
+      expr_new(*) | expr_log(*) | expr_binary(*) |
       expr_assert(*) | expr_check(*) | expr_copy(*) |
       expr_loop_body(*) | expr_do_body(*) |
       expr_cast(*) | expr_unary(*) | expr_fail(*) |

src/rustc/middle/resolve.rs

@@ -328,8 +328,8 @@ fn map_crate(e: @env, c: @ast::crate) {
 
     // First, find all the modules, and index the names that they contain
     let v_map_mod =
-        @{visit_view_item: bind index_vi(e, _, _, _),
+        @{visit_view_item: {|a,b,c|index_vi(e, a, b, c)},
-          visit_item: bind index_i(e, _, _, _),
+          visit_item: {|a,b,c|index_i(e, a, b, c)},
           visit_block: visit_block_with_scope
           with *visit::default_visitor::<scopes>()};
     visit::visit_crate(*c, top_scope(), visit::mk_vt(v_map_mod));
@@ -345,9 +345,9 @@ fn map_crate(e: @env, c: @ast::crate) {
 
     // Next, assemble the links for globbed imports and exports.
     let v_link_glob =
-        @{visit_view_item: bind link_glob(e, _, _, _),
+        @{visit_view_item: {|a,b,c|link_glob(e, a, b, c)},
           visit_block: visit_block_with_scope,
-          visit_item: bind visit_item_with_scope(e, _, _, _)
+          visit_item: {|a,b,c|visit_item_with_scope(e, a, b, c)}
           with *visit::default_visitor::<scopes>()};
     visit::visit_crate(*c, top_scope(), visit::mk_vt(v_link_glob));
 
@@ -414,17 +414,19 @@ fn resolve_names(e: @env, c: @ast::crate) {
     e.used_imports.track = true;
     let v =
         @{visit_native_item: visit_native_item_with_scope,
-          visit_item: bind walk_item(e, _, _, _),
+          visit_item: {|a,b,c|walk_item(e, a, b, c)},
           visit_block: visit_block_with_scope,
           visit_decl: visit_decl_with_scope,
           visit_arm: visit_arm_with_scope,
-          visit_local: bind visit_local_with_scope(e, _, _, _),
+          visit_local: {|a,b,c|visit_local_with_scope(e, a, b, c)},
-          visit_pat: bind walk_pat(e, _, _, _),
+          visit_pat: {|a,b,c|walk_pat(e, a, b, c)},
-          visit_expr: bind walk_expr(e, _, _, _),
+          visit_expr: {|a,b,c|walk_expr(e, a, b ,c)},
-          visit_ty: bind walk_ty(e, _, _, _),
+          visit_ty: {|a,b,c|walk_ty(e, a, b, c)},
-          visit_ty_params: bind walk_tps(e, _, _, _),
+          visit_ty_params: {|a,b,c|walk_tps(e, a, b, c)},
-          visit_constr: bind walk_constr(e, _, _, _, _, _),
+          visit_constr: {|a,b,c,d,f|walk_constr(e, a, b, c, d, f)},
-          visit_fn: bind visit_fn_with_scope(e, _, _, _, _, _, _, _)
+          visit_fn: {|a,b,c,d,f,g,h|
+              visit_fn_with_scope(e, a, b, c, d, f, g, h)
+          }
           with *visit::default_visitor()};
     visit::visit_crate(*c, top_scope(), visit::mk_vt(v));
     e.used_imports.track = false;
@@ -1713,11 +1715,12 @@ fn check_for_collisions(e: @env, c: ast::crate) {
     };
     // Other scopes have to be checked the hard way.
     let v =
-        @{visit_item: bind check_item(e, _, _, _),
+        @{visit_item: {|a,b,c|check_item(e, a, b, c)},
-          visit_block: bind check_block(e, _, _, _),
+          visit_block: {|a,b,c|check_block(e, a, b, c)},
-          visit_arm: bind check_arm(e, _, _, _),
+          visit_arm: {|a,b,c|check_arm(e, a, b, c)},
-          visit_expr: bind check_expr(e, _, _, _),
+          visit_expr: {|a,b,c|check_expr(e, a, b, c)},
-          visit_ty: bind check_ty(e, _, _, _) with *visit::default_visitor()};
+          visit_ty: {|a,b,c|check_ty(e, a, b, c)}
+          with *visit::default_visitor()};
     visit::visit_crate(c, (), visit::mk_vt(v));
 }
 
@@ -2157,9 +2160,9 @@ type iscopes = @list<@[@_impl]>;
 
 fn resolve_impls(e: @env, c: @ast::crate) {
     visit::visit_crate(*c, @nil, visit::mk_vt(@{
-        visit_block: bind visit_block_with_impl_scope(e, _, _, _),
+        visit_block: {|a,b,c|visit_block_with_impl_scope(e, a, b, c)},
-        visit_mod: bind visit_mod_with_impl_scope(e, _, _, _, _, _),
+        visit_mod: {|a,b,c,d,f|visit_mod_with_impl_scope(e, a, b, c, d, f)},
-        visit_expr: bind resolve_impl_in_expr(e, _, _, _)
+        visit_expr: {|a,b,c|resolve_impl_in_expr(e, a, b, c)}
         with *visit::default_visitor()
     }));
 }

src/rustc/middle/trans/alt.rs

@@ -663,7 +663,7 @@ fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: [ast::arm],
             *done = some(fail_cx.llbb);
             ret fail_cx.llbb;
         }
-        some(bind mk_fail(scope_cx, expr.span, fail_cx))
+        some({||mk_fail(scope_cx, expr.span, fail_cx)})
       }
       ast::alt_exhaustive { none }
     };

src/rustc/middle/trans/base.rs

@@ -920,7 +920,7 @@ enum scalar_type { nil_type, signed_int, unsigned_int, floating_point, }
 
 fn compare_scalar_types(cx: block, lhs: ValueRef, rhs: ValueRef,
                         t: ty::t, op: ast::binop) -> result {
-    let f = bind compare_scalar_values(cx, lhs, rhs, _, op);
+    let f = {|a|compare_scalar_values(cx, lhs, rhs, a, op)};
 
     alt ty::get(t).struct {
       ty::ty_nil { ret rslt(cx, f(nil_type)); }
@@ -950,7 +950,7 @@ fn compare_scalar_values(cx: block, lhs: ValueRef, rhs: ValueRef,
         cx.tcx().sess.bug("compare_scalar_values: must be a\
           comparison operator");
     }
-    let die = bind die_(cx);
+    let die = fn@() -> ! { die_(cx) };
     alt nt {
       nil_type {
         // We don't need to do actual comparisons for nil.
@@ -1609,7 +1609,8 @@ fn trans_compare(cx: block, op: ast::binop, lhs: ValueRef,
 fn cast_shift_expr_rhs(cx: block, op: ast::binop,
                        lhs: ValueRef, rhs: ValueRef) -> ValueRef {
     cast_shift_rhs(op, lhs, rhs,
-                   bind Trunc(cx, _, _), bind ZExt(cx, _, _))
+                   {|a,b|Trunc(cx, a, b)},
+                   {|a,b|ZExt(cx, a, b)})
 }
 
 fn cast_shift_const_rhs(op: ast::binop,
@@ -2343,7 +2344,9 @@ fn maybe_instantiate_inline(ccx: @crate_ctxt, fn_id: ast::def_id)
       none { // Not seen yet
         alt csearch::maybe_get_item_ast(
             ccx.tcx, fn_id,
-            bind astencode::decode_inlined_item(_, _, ccx.maps, _, _)) {
+            {|a,b,c,d|
+                astencode::decode_inlined_item(a, b, ccx.maps, c, d)
+            }) {
 
           csearch::not_found {
             ccx.external.insert(fn_id, none);
@@ -3664,10 +3667,6 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
           ast::expr_do_body(blk) {
             ret trans_expr(bcx, blk, dest);
           }
-          ast::expr_bind(f, args) {
-            ret closure::trans_bind(
-                bcx, f, args, e.id, dest);
-          }
           ast::expr_copy(a) {
             if !expr_is_lval(bcx, a) {
                 ret trans_expr(bcx, a, dest);
@@ -5351,7 +5350,7 @@ fn trans_constant(ccx: @crate_ctxt, it: @ast::item) {
 
 fn trans_constants(ccx: @crate_ctxt, crate: @ast::crate) {
     visit::visit_crate(*crate, (), visit::mk_simple_visitor(@{
-        visit_item: bind trans_constant(ccx, _)
+        visit_item: {|a|trans_constant(ccx, a)}
         with *visit::default_simple_visitor()
     }));
 }
@@ -5495,14 +5494,14 @@ fn crate_ctxt_to_encode_parms(cx: @crate_ctxt)
     -> encoder::encode_parms {
 
     let encode_inlined_item =
-        bind astencode::encode_inlined_item(_, _, _, _, cx.maps);
+        {|a,b,c,d|astencode::encode_inlined_item(a, b, c, d, cx.maps)};
 
     ret {
         diag: cx.sess.diagnostic(),
         tcx: cx.tcx,
         reachable: cx.reachable,
         reexports: reexports(cx),
-        impl_map: impl_map(cx, _),
+        impl_map: {|a|impl_map(cx, a)},
         item_symbols: cx.item_symbols,
         discrim_symbols: cx.discrim_symbols,
         link_meta: cx.link_meta,

src/rustc/middle/trans/closure.rs

@@ -426,14 +426,6 @@ fn trans_expr_fn(bcx: block,
     ret bcx;
 }
 
-fn trans_bind(cx: block, f: @ast::expr, args: [option<@ast::expr>],
-              id: ast::node_id, dest: dest) -> block {
-    let _icx = cx.insn_ctxt("closure::trans_bind");
-    let f_res = trans_callee(cx, f);
-    ret trans_bind_1(cx, expr_ty(cx, f), f_res, args,
-                     node_id_type(cx, id), dest);
-}
-
 fn trans_bind_1(cx: block, outgoing_fty: ty::t,
                 f_res: lval_maybe_callee,
                 args: [option<@ast::expr>], pair_ty: ty::t,

src/rustc/middle/trans/common.rs

@@ -232,7 +232,7 @@ fn add_clean(cx: block, val: ValueRef, ty: ty::t) {
            ty_to_str(cx.ccx().tcx, ty)];
     let cleanup_type = cleanup_type(cx.tcx(), ty);
     in_scope_cx(cx) {|info|
-        info.cleanups += [clean(bind base::drop_ty(_, val, ty),
+        info.cleanups += [clean({|a|base::drop_ty(a, val, ty)},
                                 cleanup_type)];
         scope_clean_changed(info);
     }
@@ -252,7 +252,7 @@ fn add_clean_temp(cx: block, val: ValueRef, ty: ty::t) {
         }
     }
     in_scope_cx(cx) {|info|
-        info.cleanups += [clean_temp(val, bind do_drop(_, val, ty),
+        info.cleanups += [clean_temp(val, {|a|do_drop(a, val, ty)},
                                      cleanup_type)];
         scope_clean_changed(info);
     }
@@ -264,14 +264,14 @@ fn add_clean_temp_mem(cx: block, val: ValueRef, ty: ty::t) {
            ty_to_str(cx.ccx().tcx, ty)];
     let cleanup_type = cleanup_type(cx.tcx(), ty);
     in_scope_cx(cx) {|info|
-        info.cleanups += [clean_temp(val, bind base::drop_ty(_, val, ty),
+        info.cleanups += [clean_temp(val, {|a|base::drop_ty(a, val, ty)},
                                      cleanup_type)];
         scope_clean_changed(info);
     }
 }
 fn add_clean_free(cx: block, ptr: ValueRef, shared: bool) {
-    let free_fn = if shared { bind base::trans_unique_free(_, ptr) }
+    let free_fn = if shared { {|a|base::trans_unique_free(a, ptr)} }
-                  else { bind base::trans_free(_, ptr) };
+    else { {|a|base::trans_free(a, ptr)} };
     in_scope_cx(cx) {|info|
         info.cleanups += [clean_temp(ptr, free_fn,
                                      normal_exit_and_unwind)];

src/rustc/middle/trans/type_use.rs

@@ -223,7 +223,7 @@ fn mark_for_expr(cx: ctx, e: @expr) {
       expr_while(_, _) | expr_fail(_) | expr_break | expr_cont |
       expr_unary(_, _) | expr_lit(_) | expr_assert(_) | expr_check(_, _) |
       expr_if_check(_, _, _) | expr_mac(_) | expr_addr_of(_, _) |
-      expr_ret(_) | expr_loop(_) | expr_bind(_, _) |
+      expr_ret(_) | expr_loop(_) |
       expr_loop_body(_) | expr_do_body(_) {}
     }
 }

src/rustc/middle/tstate/annotate.rs

@@ -27,11 +27,11 @@ fn collect_ids_local(tcx: ty::ctxt, l: @local, rs: @mut [node_id]) {
 
 fn node_ids_in_fn(tcx: ty::ctxt, body: blk, rs: @mut [node_id]) {
     let collect_ids =
-        visit::mk_simple_visitor(@{visit_expr: bind collect_ids_expr(_, rs),
+        visit::mk_simple_visitor(@{visit_expr: {|a|collect_ids_expr(a, rs)},
-                                   visit_block: bind collect_ids_block(_, rs),
+                                   visit_block: {|a|collect_ids_block(a, rs)},
-                                   visit_stmt: bind collect_ids_stmt(_, rs),
+                                   visit_stmt: {|a|collect_ids_stmt(a, rs)},
-                                   visit_local:
+                                   visit_local: {|a|
-                                       bind collect_ids_local(tcx, _, rs)
+                                       collect_ids_local(tcx, a, rs)}
                                    with *visit::default_simple_visitor()});
     collect_ids.visit_block(body, (), collect_ids);
 }
@@ -59,7 +59,7 @@ fn annotate_in_fn(ccx: crate_ctxt, _fk: visit::fn_kind, _decl: fn_decl,
 fn annotate_crate(ccx: crate_ctxt, crate: crate) {
     let do_ann =
         visit::mk_simple_visitor(
-            @{visit_fn: bind annotate_in_fn(ccx, _, _, _, _, _)
+            @{visit_fn: {|a,b,c,d,e|annotate_in_fn(ccx, a, b, c, d, e)}
               with *visit::default_simple_visitor()});
     visit::visit_crate(crate, (), do_ann);
 }

src/rustc/middle/tstate/auxiliary.rs

@@ -551,7 +551,7 @@ fn expr_to_constr_arg(tcx: ty::ctxt, e: @expr) -> @constr_arg_use {
 }
 
 fn exprs_to_constr_args(tcx: ty::ctxt, args: [@expr]) -> [@constr_arg_use] {
-    let f = bind expr_to_constr_arg(tcx, _);
+    let f = {|a|expr_to_constr_arg(tcx, a)};
     let mut rslt: [@constr_arg_use] = [];
     for args.each {|e| rslt += [f(e)]; }
     rslt

src/rustc/middle/tstate/bitvectors.rs

@@ -138,7 +138,7 @@ fn relax_precond_block(fcx: fn_ctxt, i: node_id, b: blk) {
           visit_stmt: relax_precond_stmt,
           visit_item:
               fn@(_i: @item, _cx: relax_ctxt, _vt: visit::vt<relax_ctxt>) { },
-          visit_fn: bind do_nothing(_, _, _, _, _, _, _)
+          visit_fn: do_nothing
              with *visitor};
     let v1 = visit::mk_vt(visitor);
     v1.visit_block(b, cx, v1);

src/rustc/middle/tstate/ck.rs

@@ -80,7 +80,9 @@ fn check_states_against_conditions(fcx: fn_ctxt,
     let visitor = visit::mk_vt(
         @{visit_stmt: check_states_stmt,
           visit_expr: check_states_expr,
-          visit_fn: bind do_nothing::<fn_ctxt>(_, _, _, _, _, _, _)
+          visit_fn: {|a,b,c,d,e,f,g|
+              do_nothing::<fn_ctxt>(a, b, c, d, e, f, g)
+          }
           with *visit::default_visitor::<fn_ctxt>()});
     visit::visit_fn(fk, f_decl, f_body, sp, id, fcx, visitor);
 }

src/rustc/middle/tstate/collect_locals.rs

@@ -43,7 +43,7 @@ fn find_locals(tcx: ty::ctxt,
     let visitor = visit::default_visitor::<ctxt>();
     let visitor =
         @{visit_expr: collect_pred,
-          visit_fn: bind do_nothing(_, _, _, _, _, _, _)
+          visit_fn: do_nothing
           with *visitor};
     visit::visit_fn(fk, f_decl, f_body, sp,
                     id, cx, visit::mk_vt(visitor));
@@ -147,9 +147,11 @@ fn mk_fn_info(ccx: crate_ctxt,
    to bit number) */
 fn mk_f_to_fn_info(ccx: crate_ctxt, c: @crate) {
     let visitor =
-        visit::mk_simple_visitor(@{visit_fn:
+        visit::mk_simple_visitor(@{
-                                       bind mk_fn_info(ccx, _, _, _, _, _)
+            visit_fn: {|a,b,c,d,e|
-                                   with *visit::default_simple_visitor()});
+                mk_fn_info(ccx, a, b, c, d, e)
+            }
+            with *visit::default_simple_visitor()});
     visit::visit_crate(*c, (), visitor);
 }
 //

src/rustc/middle/tstate/pre_post_conditions.rs

@@ -81,7 +81,7 @@ fn find_pre_post_exprs(fcx: fn_ctxt, args: [@expr], id: node_id) {
     fn get_pp(ccx: crate_ctxt, &&e: @expr) -> pre_and_post {
         ret expr_pp(ccx, e);
     }
-    let pps = vec::map(args, bind get_pp(fcx.ccx, _));
+    let pps = vec::map(args, {|a|get_pp(fcx.ccx, a)});
 
     set_pre_and_post(fcx.ccx, id, seq_preconds(fcx, pps),
                      seq_postconds(fcx, vec::map(pps, get_post)));
@@ -414,7 +414,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
         let e_pp =
             {precondition: empty_prestate(num_local_vars),
              postcondition: false_postcond(num_local_vars)};
-        let g = bind combine_pp(antec_pp, fcx, _, _);
+        let g = {|a,b|combine_pp(antec_pp, fcx, a, b)};
         let alts_overall_pp =
             vec::foldl(e_pp, alt_pps, g);
         set_pre_and_post(fcx.ccx, e.id, alts_overall_pp.precondition,
@@ -449,22 +449,6 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
       expr_if_check(p, conseq, maybe_alt) {
         join_then_else(fcx, p, conseq, maybe_alt, e.id, if_check);
       }
-      expr_bind(operator, maybe_args) {
-        let mut args = [];
-        let mut cmodes = callee_modes(fcx, operator.id);
-        let mut modes = [];
-        let mut i = 0;
-        for maybe_args.each {|expr_opt|
-            alt expr_opt {
-              none {/* no-op */ }
-              some(expr) { modes += [cmodes[i]]; args += [expr]; }
-            }
-            i += 1;
-        }
-        args += [operator]; /* ??? order of eval? */
-        forget_args_moved_in(fcx, e, modes, args);
-        find_pre_post_exprs(fcx, args, e.id);
-      }
       expr_break { clear_pp(expr_pp(fcx.ccx, e)); }
       expr_cont { clear_pp(expr_pp(fcx.ccx, e)); }
       expr_mac(_) { fcx.ccx.tcx.sess.bug("unexpanded macro"); }
@@ -572,7 +556,7 @@ fn find_pre_post_block(fcx: fn_ctxt, b: blk) {
     }
     for b.node.stmts.each {|s| do_one_(fcx, s); }
     fn do_inner_(fcx: fn_ctxt, &&e: @expr) { find_pre_post_expr(fcx, e); }
-    let do_inner = bind do_inner_(fcx, _);
+    let do_inner = {|a|do_inner_(fcx, a)};
     option::map::<@expr, ()>(b.node.expr, do_inner);
 
     let mut pps: [pre_and_post] = [];

src/rustc/middle/tstate/states.rs

@@ -305,21 +305,6 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
                                      operands,
                                      controlflow_expr(fcx.ccx, operator));
       }
-      expr_bind(operator, maybe_args) {
-        let mut args = [];
-        let callee_ops = callee_arg_init_ops(fcx, operator.id);
-        let mut ops = [];
-        let mut i = 0;
-        for maybe_args.each {|a_opt|
-            alt a_opt {
-              none {/* no-op */ }
-              some(a) { ops += [callee_ops[i]]; args += [a]; }
-            }
-            i += 1;
-        }
-        ret find_pre_post_state_call(fcx, pres, operator, e.id, ops, args,
-                                     return_val);
-      }
       expr_path(_) { ret pure_exp(fcx.ccx, e.id, pres); }
       expr_log(_, lvl, ex) {
         ret find_pre_post_state_two(fcx, pres, lvl, ex, e.id, oper_pure);

src/rustc/middle/typeck/check.rs

@@ -134,7 +134,7 @@ impl methods for isr_alist {
 
 fn check_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
     let visit = visit::mk_simple_visitor(@{
-        visit_item: bind check_item(ccx, _)
+        visit_item: {|a|check_item(ccx, a)}
         with *visit::default_simple_visitor()
     });
     visit::visit_crate(*crate, (), visit);
@@ -1396,63 +1396,6 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
             };
         fcx.write_ty(id, typ);
       }
-      ast::expr_bind(f, args) {
-        // Call the generic checker.
-        bot = check_expr(fcx, f, none);
-
-        let {fty, bot: ccob_bot} = {
-            let fn_ty = fcx.expr_ty(f);
-            check_call_or_bind(fcx, expr.span, expr.id, fn_ty, args)
-        };
-        bot |= ccob_bot;
-
-        // TODO: Perform substitutions on the return type.
-
-        // Pull the argument and return types out.
-        let mut proto, arg_tys, rt, cf, constrs;
-        alt structure_of(fcx, expr.span, fty) {
-          // FIXME:
-          // probably need to munge the constrs to drop constraints
-          // for any bound args (contingent on #2588 not getting accepted)
-          ty::ty_fn(f) {
-            proto = f.proto;
-            arg_tys = f.inputs;
-            rt = f.output;
-            cf = f.ret_style;
-            constrs = f.constraints;
-          }
-          _ { fail "LHS of bind expr didn't have a function type?!"; }
-        }
-
-        let proto = alt proto {
-          ast::proto_bare | ast::proto_box | ast::proto_uniq {
-            ast::proto_box
-          }
-          ast::proto_any | ast::proto_block {
-            tcx.sess.span_err(expr.span,
-                              #fmt["cannot bind %s closures",
-                                   proto_to_str(proto)]);
-            proto // dummy value so compilation can proceed
-          }
-        };
-
-        // For each blank argument, add the type of that argument
-        // to the resulting function type.
-        let mut out_args = [];
-        let mut i = 0u;
-        while i < vec::len(args) {
-            alt args[i] {
-              some(_) {/* no-op */ }
-              none { out_args += [arg_tys[i]]; }
-            }
-            i += 1u;
-        }
-
-        let ft = ty::mk_fn(tcx, {purity: ast::impure_fn, proto: proto,
-                                 inputs: out_args, output: rt,
-                                 ret_style: cf, constraints: constrs});
-        fcx.write_ty(id, ft);
-      }
       ast::expr_call(f, args, _) {
         bot = check_call(fcx, expr.span, expr.id, f, args);
       }

src/rustc/middle/typeck/check/alt.rs

@@ -198,7 +198,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
             ret str::eq(*name, *f.ident);
         }
         for fields.each {|f|
-            alt vec::find(ex_fields, bind matches(f.ident, _)) {
+            alt vec::find(ex_fields, {|a|matches(f.ident, a)}) {
               some(field) {
                 check_pat(pcx, f.pat, field.mt.ty);
               }

src/rustc/middle/typeck/collect.rs

@@ -53,8 +53,8 @@ fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
     }
 
     visit::visit_crate(*crate, (), visit::mk_simple_visitor(@{
-        visit_item: bind convert(ccx, _),
+        visit_item: {|a|convert(ccx, a)},
-        visit_native_item: bind convert_native(ccx, _)
+        visit_native_item: {|a|convert_native(ccx, a)}
         with *visit::default_simple_visitor()
     }));
 }

src/rustc/util/common.rs

@@ -39,7 +39,7 @@ fn block_expr_query(b: ast::blk, p: fn@(ast::expr_) -> bool) -> bool {
     let rs = @mut false;
     let visit_expr = {|flag: @mut bool, e: @ast::expr| *flag |= p(e.node)};
     let v =
-        visit::mk_simple_visitor(@{visit_expr: bind visit_expr(rs, _)
+        visit::mk_simple_visitor(@{visit_expr: {|a|visit_expr(rs, a)}
                                       with *visit::default_simple_visitor()});
     visit::visit_block(b, (), v);
     ret *rs;

src/rustdoc/prune_unexported_pass.rs

@@ -62,7 +62,9 @@ fn exported_items_from_mod(
     srv: astsrv::srv,
     doc: doc::moddoc
 ) -> [doc::itemtag] {
-    exported_items_from(srv, doc, bind is_exported_from_mod(_, doc.id(), _))
+    exported_items_from(srv, doc, {|a,b|
+        is_exported_from_mod(a, doc.id(), b)
+    })
 }
 
 fn exported_items_from(

src/rustdoc/reexport_pass.rs

@@ -68,13 +68,13 @@ fn from_assoc_list<K:copy, V:copy>(
 fn from_def_assoc_list<V:copy>(
     list: [(ast::def_id, V)]
 ) -> map::hashmap<ast::def_id, V> {
-    from_assoc_list(list, bind ast_util::new_def_hash())
+    from_assoc_list(list, ast_util::new_def_hash)
 }
 
 fn from_str_assoc_list<V:copy>(
     list: [(str, V)]
 ) -> map::hashmap<str, V> {
-    from_assoc_list(list, bind map::str_hash())
+    from_assoc_list(list, map::str_hash)
 }
 
 fn build_reexport_def_set(srv: astsrv::srv) -> def_set {
@@ -256,7 +256,7 @@ fn for_each_reexported_impl(
     f: fn@(ast::node_id, resolve::_impl)
 ) {
     let visitor = @{
-        visit_mod: bind visit_mod(ctxt, f, _, _, _)
+        visit_mod: {|a,b,c|visit_mod(ctxt, f, a, b, c)}
         with *visit::default_simple_visitor()
     };
     let visitor = visit::mk_simple_visitor(visitor);

src/test/bench/sudoku.rs

@@ -77,7 +77,7 @@ fn solve_grid(g: grid_t) {
             if color != 0u8 { bitv::set(colors, color as uint, false); }
         }
 
-        let it = bind drop_color(g, avail, _, _);
+        let it = {|a,b|drop_color(g, avail, a, b)};
 
         for u8::range(0u8, 9u8) { |idx|
             it(idx, col); /* check same column fields */

src/test/bench/task-perf-word-count-generic.rs

@@ -129,7 +129,7 @@ mod map_reduce {
             send(c, emit_val(val));
         }
 
-        map(input, bind emit(intermediates, ctrl, _, _));
+        map(input, {|a,b|emit(intermediates, ctrl, a, b)});
 
         fn finish<K: copy send, V: copy send>(_k: K, v: chan<reduce_proto<V>>)
         {
@@ -148,8 +148,8 @@ mod map_reduce {
 
         send(out, chan(p));
 
-        let ref_count = 0;
+        let mut ref_count = 0;
-        let is_done = false;
+        let mut is_done = false;
 
         fn get<V: copy send>(p: port<reduce_proto<V>>,
                              &ref_count: int, &is_done: bool)
@@ -171,7 +171,7 @@ mod map_reduce {
             ret none;
         }
 
-        reduce(key, bind get(p, ref_count, is_done));
+        reduce(key, {||get(p, ref_count, is_done)});
     }
 
     fn map_reduce<K1: copy send, K2: copy send, V: copy send>(

src/test/bench/task-perf-word-count.rs

@@ -91,7 +91,7 @@ mod map_reduce {
             send(c, emit_val(val));
         }
 
-        map(input, bind emit(intermediates, ctrl, _, _));
+        map(input, {|a,b|emit(intermediates, ctrl, a, b)});
 
         for intermediates.each_value {|v| send(v, release); }
 
@@ -125,7 +125,7 @@ mod map_reduce {
             ret none;
         }
 
-        reduce(key, bind get(p, state));
+        reduce(key, {||get(p, state)});
     }
 
     fn map_reduce(-inputs: [str]) {

src/test/compile-fail/auto-deref-bind.rs

@@ -1,4 +0,0 @@
-// error-pattern: mismatched types
-
-fn add1(i: int) -> int { ret i + 1; }
-fn main() { let f = @add1; let g = bind f(5); }

src/test/compile-fail/bind-stack-closure.rs

@@ -1,10 +0,0 @@
-fn foo(x: fn()) {
-    bind x(); //! ERROR cannot bind fn closures
-}
-
-fn bar(x: fn&()) {
-    bind x(); //! ERROR cannot bind fn& closures
-}
-
-fn main() {
-}

src/test/compile-fail/crust-no-bind.rs

@@ -1,7 +0,0 @@
-// error-pattern:expected function or native function but found *u8
-crust fn f() {
-}
-
-fn main() {
-    let x = bind f();
-}

src/test/compile-fail/fn-bare-bind.rs

@@ -1,8 +0,0 @@
-fn f() {
-}
-
-fn main() {
-    // Can't produce a bare function by binding
-    let g: native fn() = bind f();
-    //!^ ERROR mismatched types: expected `native fn()` but found `fn@()`
-}

src/test/compile-fail/liveness-uninit-after-item.rs

@@ -1,6 +1,6 @@
 fn main() {
     let bar;
     fn baz(_x: int) { }
-    bind baz(bar); //! ERROR use of possibly uninitialized variable: `bar`
+    baz(bar); //! ERROR use of possibly uninitialized variable: `bar`
 }
 

src/test/compile-fail/tstate-unsat-after-item.rs

@@ -4,6 +4,6 @@ fn even(i: int) : is_even(i) -> int { i }
 fn main() {
     let x = 4;
     fn baz(_x: int) { }
-    bind baz(even(x)); //! ERROR unsatisfied precondition
+    baz(even(x)); //! ERROR unsatisfied precondition
 }
 

src/test/compile-fail/unsafe-fn-used-in-bind.rs

@@ -1,9 +0,0 @@
-// -*- rust -*-
-
-unsafe fn f(x: int, y: int) -> int { ret x + y; }
-
-fn main() {
-    let x = bind f(3, _);
-    //!^ ERROR access to unsafe function requires unsafe function or block
-    let y = x(4);
-}

src/test/run-fail/unwind-closure.rs

@@ -5,6 +5,7 @@ fn f(a: @int) {
 }
 
 fn main() {
-    let g = bind f(@0);
+    let b = @0;
+    let g = {|move b|f(b)};
     g();
 }

src/test/run-pass/auto_serialize.rs

@@ -81,55 +81,55 @@ fn main() {
                             @plus(@val(22u), @val(5u))),
                        "plus(@minus(@val(3u), @val(10u)), \
                         @plus(@val(22u), @val(5u)))",
-                       serialize_expr(_, _),
+                       serialize_expr,
-                       deserialize_expr(_),
+                       deserialize_expr,
-                       serialize_expr(_, _));
+                       serialize_expr);
 
     test_ser_and_deser({lo: 0u, hi: 5u, node: 22u},
                        "{lo: 0u, hi: 5u, node: 22u}",
-                       serialize_spanned_uint(_, _),
+                       serialize_spanned_uint,
-                       deserialize_spanned_uint(_),
+                       deserialize_spanned_uint,
-                       serialize_spanned_uint(_, _));
+                       serialize_spanned_uint);
 
     test_ser_and_deser(an_enum({v: [1u, 2u, 3u]}),
                        "an_enum({v: [1u, 2u, 3u]})",
-                       serialize_an_enum(_, _),
+                       serialize_an_enum,
-                       deserialize_an_enum(_),
+                       deserialize_an_enum,
-                       serialize_an_enum(_, _));
+                       serialize_an_enum);
 
     test_ser_and_deser({x: 3u, y: 5u},
                        "{x: 3u, y: 5u}",
-                       serialize_point(_, _),
+                       serialize_point,
-                       deserialize_point(_),
+                       deserialize_point,
-                       serialize_point(_, _));
+                       serialize_point);
 
     test_ser_and_deser([1u, 2u, 3u],
                        "[1u, 2u, 3u]",
-                       serialize_uint_vec(_, _),
+                       serialize_uint_vec,
-                       deserialize_uint_vec(_),
+                       deserialize_uint_vec,
-                       serialize_uint_vec(_, _));
+                       serialize_uint_vec);
 
     test_ser_and_deser(top(22u),
                        "top(22u)",
-                       serialize_uint_quark(_, _),
+                       serialize_uint_quark,
-                       deserialize_uint_quark(_),
+                       deserialize_uint_quark,
-                       serialize_uint_quark(_, _));
+                       serialize_uint_quark);
 
     test_ser_and_deser(bottom(222u),
                        "bottom(222u)",
-                       serialize_uint_quark(_, _),
+                       serialize_uint_quark,
-                       deserialize_uint_quark(_),
+                       deserialize_uint_quark,
-                       serialize_uint_quark(_, _));
+                       serialize_uint_quark);
 
     test_ser_and_deser(a,
                        "a",
-                       serialize_c_like(_, _),
+                       serialize_c_like,
-                       deserialize_c_like(_),
+                       deserialize_c_like,
-                       serialize_c_like(_, _));
+                       serialize_c_like);
 
     test_ser_and_deser(b,
                        "b",
-                       serialize_c_like(_, _),
+                       serialize_c_like,
-                       deserialize_c_like(_),
+                       deserialize_c_like,
-                       serialize_c_like(_, _));
+                       serialize_c_like);
 }

src/test/run-pass/bind-exterior.rs

@@ -1,5 +0,0 @@
-
-
-fn foo(a: @int, b: @int) -> int { ret *a + *b; }
-
-fn main() { let f1 = bind foo(@10, @12); assert (f1() == 22); }

src/test/run-pass/bind-generic.rs

@@ -1,16 +0,0 @@
-fn wrapper3<T: copy>(i: T, j: int) {
-    log(debug, i);
-    log(debug, j);
-    // This is a regression test that the spawn3 thunk to wrapper3
-    // correctly finds the value of j
-    assert j == 123456789;
-}
-
-fn spawn3<T: copy>(i: T, j: int) {
-    let wrapped = bind wrapper3(i, j);
-    wrapped();
-}
-
-fn main() {
-    spawn3(127u8, 123456789);
-}

src/test/run-pass/bind-interior.rs

@@ -1,11 +0,0 @@
-
-
-
-// -*- rust -*-
-fn f(n: int) -> int { ret n; }
-
-fn main() {
-    let g: fn@() -> int = bind f(10);
-    let i: int = g();
-    assert (i == 10);
-}

src/test/run-pass/bind-methods.rs

@@ -1,20 +0,0 @@
-iface foo {
-    fn foo() -> int;
-    fn bar(p: int) -> int;
-}
-impl of foo for int {
-    fn foo() -> int { self }
-    fn bar(p: int) -> int { p * self.foo() }
-}
-impl <T: foo> of foo for [T] {
-    fn foo() -> int { vec::foldl(0, self, {|a, b| a + b.foo()}) }
-    fn bar(p: int) -> int { p + self.len() as int }
-}
-
-fn main() {
-    let x = [1, 2, 3];
-    let y = x.foo, z = [4, 5, 6].foo;
-    assert y() + z() == 21;
-    let a = x.bar, b = bind [4, 5, 6].bar(_);
-    assert a(1) + b(2) + z() == 24;
-}

src/test/run-pass/bind-native-fn.rs

@@ -1,21 +0,0 @@
-// From #1174:
-// xfail-fast
-
-use std;
-import str;
-import libc::*;
-
-#[nolink]
-native mod libc {
-    fn write(fd: core::libc::c_int, buf: *u8, nbyte: core::libc::size_t);
-}
-
-fn main() {
-    let s = "hello world\n";
-    let b = str::bytes(s);
-    let l = str::len(s) as core::libc::size_t;
-    let b8 = unsafe { vec::unsafe::to_ptr(b) };
-    libc::write(0i32, b8, l);
-    let a = bind libc::write(0i32, _, _);
-    a(b8, l);
-}

src/test/run-pass/bind-native.rs

@@ -1,10 +0,0 @@
-/*
-Can we bind native things?
-*/
-
-#[abi = "cdecl"]
-native mod rustrt {
-    fn rand_new() -> *libc::c_void;
-}
-
-fn main() { bind rustrt::rand_new(); }

src/test/run-pass/bind-parameterized-args-2.rs

@@ -1,7 +0,0 @@
-fn main() {
-    fn echo<T>(c: int, x: fn@(T)) { #error("wee"); }
-
-    let y = echo(42, _);
-
-    y(fn@(&&i: str) { });
-}

src/test/run-pass/bind-parameterized-args.rs

@@ -1,7 +0,0 @@
-fn main() {
-    fn echo<T>(c: int, x: [T]) { }
-
-    let y: fn@([int]) = echo(42, _);
-
-    y([1]);
-}

src/test/run-pass/bind-thunk.rs

@@ -1,11 +0,0 @@
-
-
-
-// -*- rust -*-
-fn f() -> int { ret 42; }
-
-fn main() {
-    let g: fn@() -> int = bind f();
-    let i: int = g();
-    assert (i == 42);
-}

src/test/run-pass/bind-trivial.rs

@@ -1,11 +0,0 @@
-
-
-
-// -*- rust -*-
-fn f(n: int) -> int { ret n; }
-
-fn main() {
-    let g: fn@(int) -> int = f(_);
-    let i: int = g(42);
-    assert (i == 42);
-}

src/test/run-pass/block-fn-coerce.rs

@@ -2,6 +2,6 @@ fn force(f: fn() -> int) -> int { ret f(); }
 fn main() {
     fn f() -> int { ret 7; }
     assert (force(f) == 7);
-    let g = bind force(f);
+    let g = {||force(f)};
     assert (g() == 7);
 }

src/test/run-pass/cycle-collection2.rs

@@ -4,7 +4,7 @@ fn nop() { }
 fn nop_foo(_x : @foo) { }
 
 fn main() {
-    let w = @{ mut z: bind nop() };
+    let w = @{ mut z: {||nop()} };
-    let x = bind nop_foo(w);
+    let x = {||nop_foo(w)};
     w.z = x;
 }

src/test/run-pass/cycle-collection4.rs

@@ -4,7 +4,7 @@ fn nop() { }
 fn nop_foo(_y: [int], _x : @foo) { }
 
 fn main() {
-    let w = @{ mut z: bind nop() };
+    let w = @{ mut z: {||nop()} };
-    let x = bind nop_foo([], w);
+    let x = {||nop_foo([], w)};
     w.z = x;
 }

src/test/run-pass/cycle-collection5.rs

@@ -6,7 +6,7 @@ fn nop_foo(_y: @int, _x : @foo) { }
 fn o() -> @int { @10 }
 
 fn main() {
-    let w = @{ mut z: bind nop() };
+    let w = @{ mut z: {||nop()} };
-    let x = bind nop_foo(o(), w);
+    let x = {||nop_foo(o(), w)};
     w.z = x;
 }

src/test/run-pass/drop-bind-thunk-args.rs

@@ -1,5 +0,0 @@
-
-
-fn f(x: @int) { }
-
-fn main() { let x = @10; let ff = f(_); ff(x); ff(x); }

src/test/run-pass/drop-parametric-closure-with-bound-box.rs

@@ -1,5 +0,0 @@
-
-
-fn f<T>(i: @uint, t: T) { }
-
-fn main() { let x = f::<char>(@0xdeafbeefu, _); }

src/test/run-pass/empty-tag.rs

@@ -5,6 +5,6 @@ fn wrapper3(i: chan) {
 }
 
 fn main() {
-    let wrapped = bind wrapper3(chan_t);
+    let wrapped = {||wrapper3(chan_t)};
     wrapped();
 }

src/test/run-pass/expr-alt-generic-box1.rs

@@ -11,8 +11,7 @@ fn test_generic<T>(expected: @T, eq: compare<T>) {
 
 fn test_box() {
     fn compare_box(b1: @bool, b2: @bool) -> bool { ret *b1 == *b2; }
-    let eq = compare_box(_, _);
+    test_generic::<bool>(@true, compare_box);
-    test_generic::<bool>(@true, eq);
 }
 
 fn main() { test_box(); }

src/test/run-pass/expr-alt-generic-box2.rs

@@ -11,8 +11,7 @@ fn test_generic<T: copy>(expected: T, eq: compare<T>) {
 
 fn test_vec() {
     fn compare_box(&&v1: @int, &&v2: @int) -> bool { ret v1 == v2; }
-    let eq = compare_box(_, _);
+    test_generic::<@int>(@1, compare_box);
-    test_generic::<@int>(@1, eq);
 }
 
 fn main() { test_vec(); }

src/test/run-pass/expr-alt-generic-unique1.rs

@@ -10,8 +10,7 @@ fn test_generic<T: copy>(expected: ~T, eq: compare<T>) {
 
 fn test_box() {
     fn compare_box(b1: ~bool, b2: ~bool) -> bool { ret *b1 == *b2; }
-    let eq = compare_box(_, _);
+    test_generic::<bool>(~true, compare_box);
-    test_generic::<bool>(~true, eq);
 }
 
 fn main() { test_box(); }

src/test/run-pass/expr-alt-generic-unique2.rs

@@ -11,8 +11,7 @@ fn test_generic<T: copy>(expected: T, eq: compare<T>) {
 
 fn test_vec() {
     fn compare_box(&&v1: ~int, &&v2: ~int) -> bool { ret v1 == v2; }
-    let eq = compare_box(_, _);
+    test_generic::<~int>(~1, compare_box);
-    test_generic::<~int>(~1, eq);
 }
 
 fn main() { test_vec(); }

src/test/run-pass/expr-alt-generic.rs

@@ -11,16 +11,14 @@ fn test_generic<T: copy>(expected: T, eq: compare<T>) {
 
 fn test_bool() {
     fn compare_bool(&&b1: bool, &&b2: bool) -> bool { ret b1 == b2; }
-    let eq = compare_bool(_, _);
+    test_generic::<bool>(true, compare_bool);
-    test_generic::<bool>(true, eq);
 }
 
 fn test_rec() {
     type t = {a: int, b: int};
 
     fn compare_rec(t1: t, t2: t) -> bool { ret t1 == t2; }
-    let eq = compare_rec(_, _);
+    test_generic::<t>({a: 1, b: 2}, compare_rec);
-    test_generic::<t>({a: 1, b: 2}, eq);
 }
 
 fn main() { test_bool(); test_rec(); }

src/test/run-pass/expr-block-generic-box1.rs

@@ -15,8 +15,7 @@ fn test_box() {
         log(debug, *b2);
         ret *b1 == *b2;
     }
-    let eq = compare_box(_, _);
+    test_generic::<bool>(@true, compare_box);
-    test_generic::<bool>(@true, eq);
 }
 
 fn main() { test_box(); }

src/test/run-pass/expr-block-generic-box2.rs

@@ -11,8 +11,7 @@ fn test_generic<T: copy>(expected: T, eq: compare<T>) {
 
 fn test_vec() {
     fn compare_vec(&&v1: @int, &&v2: @int) -> bool { ret v1 == v2; }
-    let eq = compare_vec(_, _);
+    test_generic::<@int>(@1, compare_vec);
-    test_generic::<@int>(@1, eq);
 }
 
 fn main() { test_vec(); }

src/test/run-pass/expr-block-generic-unique1.rs

@@ -14,8 +14,7 @@ fn test_box() {
         log(debug, *b2);
         ret *b1 == *b2;
     }
-    let eq = compare_box(_, _);
+    test_generic::<bool>(~true, compare_box);
-    test_generic::<bool>(~true, eq);
 }
 
 fn main() { test_box(); }

src/test/run-pass/expr-block-generic-unique2.rs

@@ -11,8 +11,7 @@ fn test_generic<T: copy>(expected: T, eq: compare<T>) {
 
 fn test_vec() {
     fn compare_vec(&&v1: ~int, &&v2: ~int) -> bool { ret v1 == v2; }
-    let eq = compare_vec(_, _);
+    test_generic::<~int>(~1, compare_vec);
-    test_generic::<~int>(~1, eq);
 }
 
 fn main() { test_vec(); }

src/test/run-pass/expr-block-generic.rs

@@ -13,16 +13,14 @@ fn test_generic<T: copy>(expected: T, eq: compare<T>) {
 
 fn test_bool() {
     fn compare_bool(&&b1: bool, &&b2: bool) -> bool { ret b1 == b2; }
-    let eq = compare_bool(_, _);
+    test_generic::<bool>(true, compare_bool);
-    test_generic::<bool>(true, eq);
 }
 
 fn test_rec() {
     type t = {a: int, b: int};
 
     fn compare_rec(t1: t, t2: t) -> bool { ret t1 == t2; }
-    let eq = compare_rec(_, _);
+    test_generic::<t>({a: 1, b: 2}, compare_rec);
-    test_generic::<t>({a: 1, b: 2}, eq);
 }
 
 fn main() { test_bool(); test_rec(); }

src/test/run-pass/expr-if-generic-box1.rs

@@ -11,8 +11,7 @@ fn test_generic<T>(expected: @T, not_expected: @T, eq: compare<T>) {
 
 fn test_box() {
     fn compare_box(b1: @bool, b2: @bool) -> bool { ret *b1 == *b2; }
-    let eq = compare_box(_, _);
+    test_generic::<bool>(@true, @false, compare_box);
-    test_generic::<bool>(@true, @false, eq);
 }
 
 fn main() { test_box(); }

src/test/run-pass/expr-if-generic-box2.rs

@@ -11,8 +11,7 @@ fn test_generic<T: copy>(expected: T, not_expected: T, eq: compare<T>) {
 
 fn test_vec() {
     fn compare_box(&&v1: @int, &&v2: @int) -> bool { ret v1 == v2; }
-    let eq = compare_box(_, _);
+    test_generic::<@int>(@1, @2, compare_box);
-    test_generic::<@int>(@1, @2, eq);
 }
 
 fn main() { test_vec(); }