OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove bind. Issue #2189

Browse Source
This commit is contained in:
Brian Anderson 2012-06-19 19:34:01 -07:00
parent bcd3942f41
commit 4dcf84e4f4
116 changed files with 384 additions and 806 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
doc/rust.md
View File

@ -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*.

13
doc/tutorial.md
View File

@ -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

4
src/cargo/cargo.rs
View File

@ -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_item: bind goto_item(e, _),
visit_view_item: {|a|goto_view_item(e, a)},
visit_item: {|a|goto_item(e, a)},
with *visit::default_simple_visitor()
});

2
src/compiletest/runtest.rs
View File

@ -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 {

32
src/fuzzer/fuzzer.rs
View File

@ -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_ty: bind stash_ty_if(safe_to_steal_ty, tys, _, tm)
visit_expr: {|a|stash_expr_if(safe_to_steal_expr, exprs, a, 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,
newexpr.node, _, _, tm))
@{fold_expr: fold::wrap({|a,b|
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(""), _,
pprust::no_ann()));
io::str_reader(""), a,
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, _,
pprust::no_ann()))
rdr, a,
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, _,
pprust::no_ann())));
rdr, a,
pprust::no_ann())}));
}
check_variants_of_ast(*crate, sess.cm, file, cx);
}

4
src/libcore/comm.rs
View File

@ -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"]

2
src/libcore/extfmt.rs
View File

@ -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)

2
src/libstd/bitv.rs
View File

@ -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);
}

2
src/libstd/c_vec.rs
View File

@ -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]

2
src/libstd/deque.rs
View File

@ -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),

8
src/libstd/test.rs
View File

@ -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;

2
src/libstd/treemap.rs
View File

@ -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]

1
src/libsyntax/ast.rs
View File

@ -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),

10
src/libsyntax/ext/auto_serialize.rs
View File

@ -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_deser_fn(cx, span, name, tps, deser_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, {|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)})
]
}

8
src/libsyntax/ext/expand.rs
View File

@ -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_mod: bind expand_mod_items(exts, cx, _, _, afp.fold_mod),
fold_item: bind expand_item(cx, _, _, afp.fold_item),
new_span: bind new_span(cx, _)
@{fold_expr: {|a,b,c|expand_expr(exts, cx, a, b, c, afp.fold_expr)},
fold_mod: {|a,b|expand_mod_items(exts, cx, a, b, afp.fold_mod)},
fold_item: {|a,b|expand_item(cx, a, b, afp.fold_item)},
new_span: {|a|new_span(cx, a)}
with *afp};
let f = make_fold(f_pre);
let cm = parse_expr_from_source_str("<core-macros>",

4
src/libsyntax/ext/fmt.rs
View File

@ -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);
}

8
src/libsyntax/ext/qquote.rs
View File

@ -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, _, _, _,
aft.fold_expr),
fold_ty: bind replace_ty(repls, _, _, _,
aft.fold_ty)
let f_pre = @{fold_expr: {|a,b,c|replace_expr(repls, a, b, c,
aft.fold_expr)},
fold_ty: {|a,b,c|replace_ty(repls, a, b, c,
aft.fold_ty)}
with *aft};
ret ff(make_fold(f_pre), node);
}

50
src/libsyntax/ext/simplext.rs
View File

@ -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_path: bind transcribe_path(cx, b, idx_path, _, _),
fold_expr:
bind transcribe_expr(cx, b, idx_path, _, _, _, afp.fold_expr),
fold_ty: bind transcribe_type(cx, b, idx_path,
_, _, _, afp.fold_ty),
fold_block:
bind transcribe_block(cx, b, idx_path, _, _, _, afp.fold_block),
map_exprs: bind transcribe_exprs(cx, b, idx_path, _, _),
new_id: bind new_id(_, cx)
@{fold_ident: {|x,y|transcribe_ident(cx, b, idx_path, x, y)},
fold_path: {|x,y|transcribe_path(cx, b, idx_path, x, y)},
fold_expr: {|x,y,z|
transcribe_expr(cx, b, idx_path, x, y, z, afp.fold_expr)
},
fold_ty: {|x,y,z|
transcribe_type(cx, b, idx_path,
x, y, z, afp.fold_ty)
},
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 {

32
src/libsyntax/fold.rs
View File

@ -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_attribute = bind fold_attribute_(_, fld);
let fold_meta_item = {|x|fold_meta_item_(x, 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_attribute = bind fold_attribute_(_, fld);
let fold_arg = {|x|fold_arg_(x, 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 {

5
src/libsyntax/parse.rs
View File

@ -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,
reader, string_reader, tt_reader};
// FIXME: resolve badness
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 = @{

27
src/libsyntax/parse/parser.rs
View File

@ -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 =
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)
};
let nd = 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;

1
src/libsyntax/parse/token.rs
View File

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

24
src/libsyntax/print/pprust.rs
View File

@ -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);
}

81
src/libsyntax/visit.rs
View File

@ -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>(_, _, _, _, _),
visit_view_item: bind visit_view_item::<E>(_, _, _),
visit_native_item: bind visit_native_item::<E>(_, _, _),
visit_item: bind visit_item::<E>(_, _, _),
visit_local: bind visit_local::<E>(_, _, _),
visit_block: bind visit_block::<E>(_, _, _),
visit_stmt: bind visit_stmt::<E>(_, _, _),
visit_arm: bind visit_arm::<E>(_, _, _),
visit_pat: bind visit_pat::<E>(_, _, _),
visit_decl: bind visit_decl::<E>(_, _, _),
visit_expr: bind visit_expr::<E>(_, _, _),
visit_ty: bind skip_ty::<E>(_, _, _),
visit_ty_params: bind visit_ty_params::<E>(_, _, _),
visit_constr: bind visit_constr::<E>(_, _, _, _, _),
visit_fn: bind visit_fn::<E>(_, _, _, _, _, _, _),
visit_class_item: bind visit_class_item::<E>(_,_,_)};
ret @{visit_mod: {|a,b,c,d,e|visit_mod::<E>(a, b, c, d, e)},
visit_view_item: {|a,b,c|visit_view_item::<E>(a, b, c)},
visit_native_item: {|a,b,c|visit_native_item::<E>(a, b, c)},
visit_item: {|a,b,c|visit_item::<E>(a, b, c)},
visit_local: {|a,b,c|visit_local::<E>(a, b, c)},
visit_block: {|a,b,c|visit_block::<E>(a, b, c)},
visit_stmt: {|a,b,c|visit_stmt::<E>(a, b, c)},
visit_arm: {|a,b,c|visit_arm::<E>(a, b, c)},
visit_pat: {|a,b,c|visit_pat::<E>(a, b, c)},
visit_decl: {|a,b,c|visit_decl::<E>(a, b, c)},
visit_expr: {|a,b,c|visit_expr::<E>(a, b, c)},
visit_ty: {|a,b,c|skip_ty::<E>(a, b, c)},
visit_ty_params: {|a,b,c|visit_ty_params::<E>(a, b, c)},
visit_constr: {|a,b,c,d,e|visit_constr::<E>(a, b, c, d, e)},
visit_fn: {|a,b,c,d,e,f,g|visit_fn::<E>(a, b, c, d, e, f, g)},
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, _, _, _, _, _),
visit_view_item: bind v_view_item(v.visit_view_item, _, _, _),
ret mk_vt(@{visit_mod: {|a,b,c,d,e|v_mod(v.visit_mod, a, b, c, d, e)},
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, _, _, _),
visit_item: bind v_item(v.visit_item, _, _, _),
visit_local: bind v_local(v.visit_local, _, _, _),
visit_block: bind v_block(v.visit_block, _, _, _),
visit_stmt: bind v_stmt(v.visit_stmt, _, _, _),
visit_arm: bind v_arm(v.visit_arm, _, _, _),
visit_pat: bind v_pat(v.visit_pat, _, _, _),
visit_decl: bind v_decl(v.visit_decl, _, _, _),
visit_expr: bind v_expr(v.visit_expr, _, _, _),
{|a,b,c|v_native_item(v.visit_native_item, a, b, c)},
visit_item: {|a,b,c|v_item(v.visit_item, a, b, c)},
visit_local: {|a,b,c|v_local(v.visit_local, a, b, c)},
visit_block: {|a,b,c|v_block(v.visit_block, a, b, c)},
visit_stmt: {|a,b,c|v_stmt(v.visit_stmt, a, b, c)},
visit_arm: {|a,b,c|v_arm(v.visit_arm, a, b, c)},
visit_pat: {|a,b,c|v_pat(v.visit_pat, a, b, c)},
visit_decl: {|a,b,c|v_decl(v.visit_decl, a, b, c)},
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_constr: bind v_constr(v.visit_constr, _, _, _, _, _),
visit_fn: bind v_fn(v.visit_fn, _, _, _, _, _, _, _),
visit_class_item: bind v_class_item(v.visit_class_item, _, _,
_)
visit_ty_params: {|a,b,c|
v_ty_params(v.visit_ty_params, a, b, c)
},
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)
}
});
}

7
src/rustc/back/rpath.rs
View File

@ -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 {

4
src/rustc/back/upcall.rs
View File

@ -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 dv = bind decl(llmod, "upcall_", _, _, T_void());
let d = {|a,b,c|decl(llmod, "upcall_", a, b, c)};
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);

106
src/rustc/driver/driver.rs
View File

@ -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(
sess.parse_sess, sess.opts.cfg, crate));
{|copy crate|syntax::ext::expand::expand_crate(
sess.parse_sess, sess.opts.cfg, crate)});
if upto == cu_expand { ret {crate: crate, tcx: none}; }
crate =
time(time_passes, "intrinsic injection",
bind front::intrinsic_inject::inject_intrinsic(sess, crate));
time(time_passes, "intrinsic injection", {|copy crate|
front::intrinsic_inject::inject_intrinsic(sess, crate)
});
crate =
time(time_passes, "core injection",
bind front::core_inject::maybe_inject_libcore_ref(sess, crate));
time(time_passes, "core injection", {|copy crate|
front::core_inject::maybe_inject_libcore_ref(sess, crate)
});
time(time_passes, "building warning settings table",
bind lint::build_settings_crate(sess, crate));
time(time_passes, "building warning settings table", {|copy crate|
lint::build_settings_crate(sess, crate)
});
let ast_map =
time(time_passes, "ast indexing",
bind syntax::ast_map::map_crate(sess.diagnostic(), *crate));
time(time_passes, "external crate/lib resolution",
bind creader::read_crates(
sess.diagnostic(), *crate, sess.cstore,
sess.filesearch,
session::sess_os_to_meta_os(sess.targ_cfg.os),
sess.opts.static));
time(time_passes, "ast indexing", {|copy crate|
syntax::ast_map::map_crate(sess.diagnostic(), *crate)
});
time(time_passes, "external crate/lib resolution", {|copy crate|
creader::read_crates(
sess.diagnostic(), *crate, sess.cstore,
sess.filesearch,
session::sess_os_to_meta_os(sess.targ_cfg.os),
sess.opts.static)
});
let {def_map, exp_map, impl_map} =
time(time_passes, "resolution",
bind resolve::resolve_crate(sess, ast_map, crate));
time(time_passes, "resolution", {|copy crate|
resolve::resolve_crate(sess, ast_map, crate)
});
let freevars =
time(time_passes, "freevar finding",
bind freevars::annotate_freevars(def_map, crate));
time(time_passes, "freevar finding", {|copy crate|
freevars::annotate_freevars(def_map, crate)
});
let region_map =
time(time_passes, "region resolution",
bind middle::region::resolve_crate(sess, def_map, crate));
time(time_passes, "region resolution", {|copy 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",
bind 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,
method_map, ty_cx));
time(time_passes, "typechecking", {|copy crate|
typeck::check_crate(ty_cx, impl_map, crate)
});
time(time_passes, "const checking", {|copy crate|
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",
bind middle::liveness::check_crate(ty_cx, method_map, crate));
time(time_passes, "liveness checking", {|copy 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,
last_use_map, crate));
time(time_passes, "kind checking",
bind kind::check_crate(ty_cx, method_map, last_use_map, crate));
{|copy crate|middle::borrowck::check_crate(ty_cx, method_map,
last_use_map, crate)});
time(time_passes, "kind checking", {|copy 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,
outputs.out_filename, link_meta));
{||link::link_binary(sess, outputs.obj_filename,
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};

2
src/rustc/driver/rustc.rs
View File

@ -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 */ }

12
src/rustc/front/config.rs
View File

@ -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_block: fold::wrap(bind fold_block(ctxt, _, _)),
fold_native_mod: bind fold_native_mod(ctxt, _, _)
@{fold_mod: {|a,b|fold_mod(ctxt, a, b)},
fold_block: fold::wrap({|a,b|fold_block(ctxt, a, b)}),
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),

6
src/rustc/front/test.rs
View File

@ -44,9 +44,9 @@ fn generate_test_harness(sess: session::session,
testfns: dvec()};
let precursor =
@{fold_crate: fold::wrap(bind fold_crate(cx, _, _)),
fold_item: bind fold_item(cx, _, _),
fold_mod: bind fold_mod(cx, _, _) with *fold::default_ast_fold()};
@{fold_crate: fold::wrap({|a,b|fold_crate(cx, a, b)}),
fold_item: {|a,b|fold_item(cx, a, b)},
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);

4
src/rustc/metadata/creader.rs
View File

@ -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, _),
visit_item: bind visit_item(e, _)
{|a|visit_view_item(e, a)},
visit_item: {|a|visit_item(e, a)}
with *visit::default_simple_visitor()});
visit::visit_crate(crate, (), v);
dump_crates(e.crate_cache);

4
src/rustc/metadata/decoder.rs
View File

@ -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|

6
src/rustc/metadata/encoder.rs
View File

@ -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(_, _) {

2
src/rustc/metadata/tydecode.rs
View File

@ -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) ->

10
src/rustc/middle/astencode.rs
View File

@ -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_span: xcx.tr_span(_)
new_id: {|a|xcx.tr_id(a)},
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)

2
src/rustc/middle/borrowck/categorization.rs
View File

@ -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(*) |

4
src/rustc/middle/check_alt.rs
View File

@ -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_local: bind check_local(tcx, _, _, _)
visit_expr: {|a,b,c|check_expr(tcx, a, b, c)},
visit_local: {|a,b,c|check_local(tcx, a, b, c)}
with *visit::default_visitor::<()>()
}));
tcx.sess.abort_if_errors();

6
src/rustc/middle/check_const.rs
View File

@ -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();

3
src/rustc/middle/kind.rs
View File

@ -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|

14
src/rustc/middle/liveness.rs
View File

@ -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(*) |

43
src/rustc/middle/resolve.rs
View File

@ -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_item: bind index_i(e, _, _, _),
@{visit_view_item: {|a,b,c|index_vi(e, a, b, c)},
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_pat: bind walk_pat(e, _, _, _),
visit_expr: bind walk_expr(e, _, _, _),
visit_ty: bind walk_ty(e, _, _, _),
visit_ty_params: bind walk_tps(e, _, _, _),
visit_constr: bind walk_constr(e, _, _, _, _, _),
visit_fn: bind visit_fn_with_scope(e, _, _, _, _, _, _, _)
visit_local: {|a,b,c|visit_local_with_scope(e, a, b, c)},
visit_pat: {|a,b,c|walk_pat(e, a, b, c)},
visit_expr: {|a,b,c|walk_expr(e, a, b ,c)},
visit_ty: {|a,b,c|walk_ty(e, a, b, c)},
visit_ty_params: {|a,b,c|walk_tps(e, a, b, c)},
visit_constr: {|a,b,c,d,f|walk_constr(e, a, b, c, d, f)},
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_block: bind check_block(e, _, _, _),
visit_arm: bind check_arm(e, _, _, _),
visit_expr: bind check_expr(e, _, _, _),
visit_ty: bind check_ty(e, _, _, _) with *visit::default_visitor()};
@{visit_item: {|a,b,c|check_item(e, a, b, c)},
visit_block: {|a,b,c|check_block(e, a, b, c)},
visit_arm: {|a,b,c|check_arm(e, a, b, c)},
visit_expr: {|a,b,c|check_expr(e, a, b, c)},
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_mod: bind visit_mod_with_impl_scope(e, _, _, _, _, _),
visit_expr: bind resolve_impl_in_expr(e, _, _, _)
visit_block: {|a,b,c|visit_block_with_impl_scope(e, a, b, c)},
visit_mod: {|a,b,c,d,f|visit_mod_with_impl_scope(e, a, b, c, d, f)},
visit_expr: {|a,b,c|resolve_impl_in_expr(e, a, b, c)}
with *visit::default_visitor()
}));
}

2
src/rustc/middle/trans/alt.rs
View File

@ -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 }
};

21
src/rustc/middle/trans/base.rs
View File

@ -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,

8
src/rustc/middle/trans/closure.rs
View File

@ -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,

10
src/rustc/middle/trans/common.rs
View File

@ -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) }
else { bind base::trans_free(_, ptr) };
let free_fn = if shared { {|a|base::trans_unique_free(a, ptr)} }
else { {|a|base::trans_free(a, ptr)} };
in_scope_cx(cx) {|info|
info.cleanups += [clean_temp(ptr, free_fn,
normal_exit_and_unwind)];

2
src/rustc/middle/trans/type_use.rs
View File

@ -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(_) {}
}
}

12
src/rustc/middle/tstate/annotate.rs
View File

@ -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_block: bind collect_ids_block(_, rs),
visit_stmt: bind collect_ids_stmt(_, rs),
visit_local:
bind collect_ids_local(tcx, _, rs)
visit::mk_simple_visitor(@{visit_expr: {|a|collect_ids_expr(a, rs)},
visit_block: {|a|collect_ids_block(a, rs)},
visit_stmt: {|a|collect_ids_stmt(a, rs)},
visit_local: {|a|
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);
}

2
src/rustc/middle/tstate/auxiliary.rs
View File

@ -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

2
src/rustc/middle/tstate/bitvectors.rs
View File

@ -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);

4
src/rustc/middle/tstate/ck.rs
View File

@ -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);
}

10
src/rustc/middle/tstate/collect_locals.rs
View File

@ -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:
bind mk_fn_info(ccx, _, _, _, _, _)
with *visit::default_simple_visitor()});
visit::mk_simple_visitor(@{
visit_fn: {|a,b,c,d,e|
mk_fn_info(ccx, a, b, c, d, e)
}
with *visit::default_simple_visitor()});
visit::visit_crate(*c, (), visitor);
}
//

22
src/rustc/middle/tstate/pre_post_conditions.rs
View File

@ -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] = [];

15
src/rustc/middle/tstate/states.rs
View File

@ -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);

59
src/rustc/middle/typeck/check.rs
View File

@ -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);
}

2
src/rustc/middle/typeck/check/alt.rs
View File

@ -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);
}

4
src/rustc/middle/typeck/collect.rs
View File

@ -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_native_item: bind convert_native(ccx, _)
visit_item: {|a|convert(ccx, a)},
visit_native_item: {|a|convert_native(ccx, a)}
with *visit::default_simple_visitor()
}));
}

2
src/rustc/util/common.rs
View File

@ -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;

4
src/rustdoc/prune_unexported_pass.rs
View File

@ -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(

6
src/rustdoc/reexport_pass.rs
View File

@ -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);

2
src/test/bench/sudoku.rs
View File

@ -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 */

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

@ -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 is_done = false;
let mut ref_count = 0;
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>(

4
src/test/bench/task-perf-word-count.rs
View File

@ -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]) {

4
src/test/compile-fail/auto-deref-bind.rs
View File

@ -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); }

10
src/test/compile-fail/bind-stack-closure.rs
View File

@ -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() {
}

7
src/test/compile-fail/crust-no-bind.rs
View File

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

8
src/test/compile-fail/fn-bare-bind.rs
View File

@ -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@()`
}

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

@ -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`
}

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

@ -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
}

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

@ -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);
}

3
src/test/run-fail/unwind-closure.rs
View File

@ -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();
}

54
src/test/run-pass/auto_serialize.rs
View File

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

5
src/test/run-pass/bind-exterior.rs
View File

@ -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); }

16
src/test/run-pass/bind-generic.rs
View File

@ -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);
}

11
src/test/run-pass/bind-interior.rs
View File

@ -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);
}

20
src/test/run-pass/bind-methods.rs
View File

@ -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;
}

21
src/test/run-pass/bind-native-fn.rs
View File

@ -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);
}

10
src/test/run-pass/bind-native.rs
View File

@ -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(); }

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

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

7
src/test/run-pass/bind-parameterized-args.rs
View File

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

11
src/test/run-pass/bind-thunk.rs
View File

@ -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);
}

11
src/test/run-pass/bind-trivial.rs
View File

@ -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);
}

2
src/test/run-pass/block-fn-coerce.rs
View File

@ -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);
}

4
src/test/run-pass/cycle-collection2.rs
View File

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

4
src/test/run-pass/cycle-collection4.rs
View File

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

4
src/test/run-pass/cycle-collection5.rs
View File

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

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

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

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

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

2
src/test/run-pass/empty-tag.rs
View File

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

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

@ -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, eq);
test_generic::<bool>(@true, compare_box);
}
fn main() { test_box(); }

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

@ -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, eq);
test_generic::<@int>(@1, compare_box);
}
fn main() { test_vec(); }

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

@ -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, eq);
test_generic::<bool>(~true, compare_box);
}
fn main() { test_box(); }

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

@ -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, eq);
test_generic::<~int>(~1, compare_box);
}
fn main() { test_vec(); }

6
src/test/run-pass/expr-alt-generic.rs
View File

@ -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, eq);
test_generic::<bool>(true, compare_bool);
}
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}, eq);
test_generic::<t>({a: 1, b: 2}, compare_rec);
}
fn main() { test_bool(); test_rec(); }

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

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

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

@ -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, eq);
test_generic::<@int>(@1, compare_vec);
}
fn main() { test_vec(); }

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

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

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

@ -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, eq);
test_generic::<~int>(~1, compare_vec);
}
fn main() { test_vec(); }

6
src/test/run-pass/expr-block-generic.rs
View File

@ -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, eq);
test_generic::<bool>(true, compare_bool);
}
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}, eq);
test_generic::<t>({a: 1, b: 2}, compare_rec);
}
fn main() { test_bool(); test_rec(); }

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

@ -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, eq);
test_generic::<bool>(@true, @false, compare_box);
}
fn main() { test_box(); }

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

@ -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, eq);
test_generic::<@int>(@1, @2, compare_box);
}
fn main() { test_vec(); }

Some files were not shown because too many files have changed in this diff Show More