---

yaml
---
r: 6742
b: refs/heads/master
c: 2833ca4
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 0a3626161d5ebb1d2c6839773b0e533d3ec4589c
+refs/heads/master: 2833ca478c19d2f8f150570a6d60b93488debdcc

trunk/src/cargo/cargo.rs

@@ -155,13 +155,13 @@ fn install_one_crate(c: cargo, _path: str, cf: str, _p: pkg) {
         name = str::slice(name, 0u, ri as uint);
     }
     log #fmt["Installing: %s", name];
-    let old = vec::map({|x| str::slice(x, 2u, str::byte_len(x))},
-                       fs::list_dir("."));
+    let old = vec::map(fs::list_dir("."),
+                       {|x| str::slice(x, 2u, str::byte_len(x))});
     run::run_program("rustc", [name + ".rc"]);
-    let new = vec::map({|x| str::slice(x, 2u, str::byte_len(x))},
-                       fs::list_dir("."));
+    let new = vec::map(fs::list_dir("."),
+                       {|x| str::slice(x, 2u, str::byte_len(x))});
     let created =
-        vec::filter::<str>({ |n| !vec::member::<str>(n, old) }, new);
+        vec::filter::<str>(new, { |n| !vec::member::<str>(n, old) });
     let exec_suffix = os::exec_suffix();
     for ct: str in created {
         if (exec_suffix != "" && str::ends_with(ct, exec_suffix)) ||
@@ -184,7 +184,7 @@ fn install_source(c: cargo, path: str) {
     log #fmt["contents: %s", str::connect(contents, ", ")];
 
     let cratefiles =
-        vec::filter::<str>({ |n| str::ends_with(n, ".rc") }, contents);
+        vec::filter::<str>(contents, { |n| str::ends_with(n, ".rc") });
 
     if vec::is_empty(cratefiles) {
         fail "This doesn't look like a rust package (no .rc files).";

trunk/src/comp/back/rpath.rs

@@ -47,7 +47,7 @@ fn get_sysroot_absolute_rt_lib(sess: session::session) -> fs::path {
 }
 
 fn rpaths_to_flags(rpaths: [str]) -> [str] {
-    vec::map({ |rpath| #fmt("-Wl,-rpath,%s",rpath)}, rpaths)
+    vec::map(rpaths, { |rpath| #fmt("-Wl,-rpath,%s",rpath)})
 }
 
 fn get_rpaths(os: session::os, cwd: fs::path, sysroot: fs::path,
@@ -96,7 +96,7 @@ fn get_rpaths_relative_to_output(os: session::os,
                                  cwd: fs::path,
                                  output: fs::path,
                                  libs: [fs::path]) -> [str] {
-    vec::map(bind get_rpath_relative_to_output(os, cwd, output, _), libs)
+    vec::map(libs, bind get_rpath_relative_to_output(os, cwd, output, _))
 }
 
 fn get_rpath_relative_to_output(os: session::os,
@@ -150,7 +150,7 @@ fn get_relative_to(abs1: fs::path, abs2: fs::path) -> fs::path {
 }
 
 fn get_absolute_rpaths(cwd: fs::path, libs: [fs::path]) -> [str] {
-    vec::map(bind get_absolute_rpath(cwd, _), libs)
+    vec::map(libs, bind get_absolute_rpath(cwd, _))
 }
 
 fn get_absolute_rpath(cwd: fs::path, &&lib: fs::path) -> str {

trunk/src/comp/driver/rustc.rs

@@ -650,10 +650,9 @@ fn main(args: [str]) {
     let ofile = getopts::opt_maybe_str(match, "o");
     let cfg = build_configuration(sess, binary, ifile);
     let pretty =
-        option::map::<str,
-                      pp_mode>(bind parse_pretty(sess, _),
-                               getopts::opt_default(match, "pretty",
-                                                    "normal"));
+        option::map(getopts::opt_default(match, "pretty",
+                                         "normal"),
+                    bind parse_pretty(sess, _));
     alt pretty {
       some::<pp_mode>(ppm) { pretty_print_input(sess, cfg, ifile, ppm); ret; }
       none::<pp_mode>. {/* continue */ }

trunk/src/comp/front/attr.rs

@@ -50,7 +50,7 @@ fn find_attrs_by_name(attrs: [ast::attribute], name: ast::ident) ->
                      option::some(a)
                  } else { option::none }
              }(_, name);
-    ret vec::filter_map(filter, attrs);
+    ret vec::filter_map(attrs, filter);
 }
 
 fn get_attr_name(attr: ast::attribute) -> ast::ident {
@@ -66,7 +66,7 @@ fn find_meta_items_by_name(metas: [@ast::meta_item], name: ast::ident) ->
                      option::some(m)
                  } else { option::none }
              }(_, name);
-    ret vec::filter_map(filter, metas);
+    ret vec::filter_map(metas, filter);
 }
 
 fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident {
@@ -186,7 +186,7 @@ fn remove_meta_items_by_name(items: [@ast::meta_item], name: str) ->
                  } else { option::none }
              }(_, name);
 
-    ret vec::filter_map(filter, items);
+    ret vec::filter_map(items, filter);
 }
 
 fn require_unique_names(sess: session::session, metas: [@ast::meta_item]) {

trunk/src/comp/front/config.rs

@@ -29,9 +29,9 @@ fn filter_item(cfg: ast::crate_cfg, &&item: @ast::item) ->
 fn fold_mod(cfg: ast::crate_cfg, m: ast::_mod, fld: fold::ast_fold) ->
    ast::_mod {
     let filter = bind filter_item(cfg, _);
-    let filtered_items = vec::filter_map(filter, m.items);
-    ret {view_items: vec::map(fld.fold_view_item, m.view_items),
-         items: vec::map(fld.fold_item, filtered_items)};
+    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)};
 }
 
 fn filter_native_item(cfg: ast::crate_cfg, &&item: @ast::native_item) ->
@@ -44,8 +44,8 @@ fn filter_native_item(cfg: ast::crate_cfg, &&item: @ast::native_item) ->
 fn fold_native_mod(cfg: ast::crate_cfg, nm: ast::native_mod,
                    fld: fold::ast_fold) -> ast::native_mod {
     let filter = bind filter_native_item(cfg, _);
-    let filtered_items = vec::filter_map(filter, nm.items);
-    ret {view_items: vec::map(fld.fold_view_item, nm.view_items),
+    let filtered_items = vec::filter_map(nm.items, filter);
+    ret {view_items: vec::map(nm.view_items, fld.fold_view_item),
          items: filtered_items};
 }
 
@@ -69,10 +69,10 @@ fn filter_stmt(cfg: ast::crate_cfg, &&stmt: @ast::stmt) ->
 fn fold_block(cfg: ast::crate_cfg, b: ast::blk_, fld: fold::ast_fold) ->
    ast::blk_ {
     let filter = bind filter_stmt(cfg, _);
-    let filtered_stmts = vec::filter_map(filter, b.stmts);
+    let filtered_stmts = vec::filter_map(b.stmts, filter);
     ret {view_items: b.view_items,
-         stmts: vec::map(fld.fold_stmt, filtered_stmts),
-         expr: option::map(fld.fold_expr, b.expr),
+         stmts: vec::map(filtered_stmts, fld.fold_stmt),
+         expr: option::map(b.expr, fld.fold_expr),
          id: b.id,
          rules: b.rules};
 }
@@ -99,8 +99,8 @@ fn metas_in_cfg(cfg: ast::crate_cfg, metas: [@ast::meta_item]) -> bool {
     // Pull the inner meta_items from the #[cfg(meta_item, ...)]  attributes,
     // so we can match against them. This is the list of configurations for
     // which the item is valid
-    let cfg_metas = vec::concat(vec::filter_map(
-        {|&&i| attr::get_meta_item_list(i)}, cfg_metas));
+    let cfg_metas = vec::concat(vec::filter_map(cfg_metas,
+        {|&&i| attr::get_meta_item_list(i)}));
 
     let has_cfg_metas = vec::len(cfg_metas) > 0u;
     if !has_cfg_metas { ret true; }

trunk/src/comp/front/test.rs

@@ -61,7 +61,7 @@ fn fold_mod(_cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
     }
 
     let mod_nomain =
-        {view_items: m.view_items, items: vec::filter_map(nomain, m.items)};
+        {view_items: m.view_items, items: vec::filter_map(m.items, nomain)};
     ret fold::noop_fold_mod(mod_nomain, fld);
 }
 
@@ -126,8 +126,8 @@ fn is_test_fn(i: @ast::item) -> bool {
 fn is_ignored(cx: test_ctxt, i: @ast::item) -> bool {
     let ignoreattrs = attr::find_attrs_by_name(i.attrs, "ignore");
     let ignoreitems = attr::attr_metas(ignoreattrs);
-    let cfg_metas = vec::concat(vec::filter_map(
-        {|&&i| attr::get_meta_item_list(i)}, ignoreitems));
+    let cfg_metas = vec::concat(vec::filter_map(ignoreitems,
+        {|&&i| attr::get_meta_item_list(i)}));
     ret if vec::is_not_empty(ignoreitems) {
         config::metas_in_cfg(cx.crate.node.config, cfg_metas)
     } else {

trunk/src/comp/metadata/cstore.rs

@@ -140,7 +140,7 @@ fn get_dep_hashes(cstore: cstore) -> [str] {
         log #fmt("  hash[%s]: %s", x.name, x.hash);
     }
     fn mapper(ch: crate_hash) -> str { ret ch.hash; }
-    ret vec::map(mapper, sorted);
+    ret vec::map(sorted, mapper);
 }
 // Local Variables:
 // mode: rust

trunk/src/comp/metadata/decoder.rs

@@ -159,7 +159,6 @@ fn resolve_path(path: [ast::ident], data: @[u8]) -> [ast::def_id] {
     ret result;
 }
 
-
 // FIXME doesn't yet handle renamed re-exported externals
 fn lookup_def(cnum: ast::crate_num, data: @[u8], did_: ast::def_id) ->
    ast::def {

trunk/src/comp/metadata/encoder.rs

@@ -610,7 +610,7 @@ fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) {
         fn name(kv: numname) -> str { kv.ident }
         // mutable -> immutable hack for vec::map
         let immpairs = vec::slice(pairs, 0u, vec::len(pairs));
-        ret vec::map(name, immpairs);
+        ret vec::map(immpairs, name);
     }
 
     // We're just going to write a list of crate names, with the assumption

trunk/src/comp/middle/alias.rs

@@ -325,7 +325,7 @@ fn check_alt(cx: ctx, input: @ast::expr, arms: [ast::arm], sc: scope,
         for pat in a.pats {
             for proot in pattern_roots(cx.tcx, root.mut, pat) {
                 let canon_id = pat_id_map.get(proot.name);
-                alt vec::find({|x| x.id == canon_id}, binding_info) {
+                alt vec::find(binding_info, {|x| x.id == canon_id}) {
                   some(s) { s.unsafe_tys += unsafe_set(proot.mut); }
                   none. {
                       binding_info += [
@@ -683,7 +683,7 @@ fn filter_invalid(src: list<@invalid>, bs: [binding]) -> list<@invalid> {
     while cur != list::nil {
         alt cur {
           list::cons(head, tail) {
-            let p = vec::position_pred({|b| b.node_id == head.node_id}, bs);
+            let p = vec::position_pred(bs, {|b| b.node_id == head.node_id});
             if !is_none(p) { out = list::cons(head, @out); }
             cur = *tail;
           }

trunk/src/comp/middle/kind.rs

@@ -78,7 +78,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
             let t = ty::expr_ty(cx.tcx, ex);
             let ty_fields = alt ty::struct(cx.tcx, t) { ty::ty_rec(f) { f } };
             for tf in ty_fields {
-                if !vec::any({|f| f.node.ident == tf.ident}, fields) &&
+                if !vec::any(fields, {|f| f.node.ident == tf.ident}) &&
                     !kind_can_be_copied(ty::type_kind(cx.tcx, tf.mt.ty)) {
                     cx.tcx.sess.span_err(ex.span,
                                          "copying a noncopyable value");

trunk/src/comp/middle/last_use.rs

@@ -197,7 +197,7 @@ fn join_branches(branches: [set]) -> set {
     for set in branches {
         i += 1u;
         for {def, exprs} in set {
-            if !vec::any({|v| v.def == def}, found) {
+            if !vec::any(found, {|v| v.def == def}) {
                 let j = i, ne = exprs;
                 while j < l {
                     for {def: d2, exprs} in branches[j] {
@@ -234,8 +234,8 @@ fn clear_in_current(cx: ctx, my_def: node_id, to: bool) {
                      cx.last_uses.insert(expr, to);
                 }
             }
-            cx.current = vec::filter({|x| x.def != my_def},
-                                     copy cx.current);
+            cx.current = vec::filter(copy cx.current,
+                                     {|x| x.def != my_def});
             break;
         }
     }

trunk/src/comp/middle/resolve.rs

@@ -1152,8 +1152,8 @@ fn lookup_in_globs(e: env, globs: [glob_imp_def], sp: span, id: ident,
           none. { none }
         }
     }
-    let matches = vec::filter_map(bind lookup_in_mod_(e, _, sp, id, ns, dr),
-                                  copy globs);
+    let matches = vec::filter_map(copy globs,
+                                  bind lookup_in_mod_(e, _, sp, id, ns, dr));
     if vec::len(matches) == 0u {
         ret none;
     } else if vec::len(matches) == 1u {
@@ -1448,7 +1448,7 @@ fn check_arm(e: @env, a: ast::arm, &&x: (), v: vt<()>) {
                             "inconsistent number of bindings");
         } else {
             for name: ident in ch.seen {
-                if is_none(vec::find(bind str::eq(name, _), seen0)) {
+                if is_none(vec::find(seen0, bind str::eq(name, _))) {
                     // Fight the alias checker
                     let name_ = name;
                     e.sess.span_err(a.pats[i].span,

trunk/src/comp/middle/trans.rs

@@ -3428,9 +3428,9 @@ fn trans_rec(bcx: @block_ctxt, fields: [ast::field],
     let ty_fields = alt ty::struct(bcx_tcx(bcx), t) { ty::ty_rec(f) { f } };
     let temp_cleanups = [];
     for fld in fields {
-        let ix = option::get(vec::position_pred({|ft|
+        let ix = option::get(vec::position_pred(ty_fields, {|ft|
             str::eq(fld.node.ident, ft.ident)
-        }, ty_fields));
+        }));
         let dst = GEP_tup_like_1(bcx, t, addr, [0, ix as int]);
         bcx = trans_expr_save_in(dst.bcx, fld.node.expr, dst.val);
         add_clean_temp_mem(bcx, dst.val, ty_fields[ix].mt.ty);
@@ -3442,7 +3442,7 @@ fn trans_rec(bcx: @block_ctxt, fields: [ast::field],
         bcx = cx;
         // Copy over inherited fields
         for tf in ty_fields {
-            if !vec::any({|f| str::eq(f.node.ident, tf.ident)}, fields) {
+            if !vec::any(fields, {|f| str::eq(f.node.ident, tf.ident)}) {
                 let dst = GEP_tup_like_1(bcx, t, addr, [0, i]);
                 let base = GEP_tup_like_1(bcx, t, base_val, [0, i]);
                 let val = load_if_immediate(base.bcx, base.val, tf.mt.ty);

trunk/src/comp/middle/trans_alt.rs

@@ -291,7 +291,7 @@ fn collect_record_fields(m: match, col: uint) -> [ast::ident] {
         alt br.pats[col].node {
           ast::pat_rec(fs, _) {
             for f: ast::field_pat in fs {
-                if !vec::any(bind str::eq(f.ident, _), fields) {
+                if !vec::any(fields, bind str::eq(f.ident, _)) {
                     fields += [f.ident];
                 }
             }

trunk/src/comp/middle/trans_closure.rs

@@ -426,7 +426,7 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t,
     // Actually construct the closure
     let {llbox, box_ty, bcx} = store_environment(
         bcx, lltydescs,
-        env_vals + vec::map({|x| env_expr(x)}, bound),
+        env_vals + vec::map(bound, {|x| env_expr(x)}),
         ty::closure_shared);
 
     // Make thunk

trunk/src/comp/middle/trans_objects.rs

@@ -244,8 +244,8 @@ fn trans_anon_obj(bcx: @block_ctxt, sp: span, anon_obj: ast::anon_obj,
     // methods, not inner ones.
     let wrapper_obj: ast::_obj =
         {fields:
-             vec::map(ast_util::obj_field_from_anon_obj_field,
-                           additional_fields),
+             vec::map(additional_fields,
+                      ast_util::obj_field_from_anon_obj_field),
          methods: anon_obj.methods};
 
     let inner_obj_ty: ty::t;
@@ -481,7 +481,7 @@ fn create_vtbl(cx: @local_ctxt, sp: span, outer_obj_ty: ty::t, ob: ast::_obj,
         // Filter out any methods that we don't need forwarding slots for
         // because they're being overridden.
         let f = bind filtering_fn(cx, _, ob.methods);
-        meths = vec::filter_map(f, meths);
+        meths = vec::filter_map(meths, f);
 
         // And now add the additional ones, both overriding ones and entirely
         // new ones.  These will just be normal methods.

trunk/src/comp/middle/tstate/auxiliary.rs

@@ -1083,7 +1083,7 @@ fn callee_arg_init_ops(fcx: fn_ctxt, callee: node_id) -> [init_op] {
     fn mode_to_op(m: ty::mode) -> init_op {
         alt m { by_move. { init_move } _ { init_assign } }
     }
-    vec::map(mode_to_op, callee_modes(fcx, callee))
+    vec::map(callee_modes(fcx, callee), mode_to_op)
 }
 
 fn anon_bindings(ops: [init_op], es: [@expr]) -> [binding] {

trunk/src/comp/middle/tstate/pre_post_conditions.rs

@@ -95,10 +95,10 @@ 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(bind get_pp(fcx.ccx, _), args);
+    let pps = vec::map(args, bind get_pp(fcx.ccx, _));
 
     set_pre_and_post(fcx.ccx, id, seq_preconds(fcx, pps),
-                     seq_postconds(fcx, vec::map(get_post, pps)));
+                     seq_postconds(fcx, vec::map(pps, get_post)));
 }
 
 fn find_pre_post_loop(fcx: fn_ctxt, l: @local, index: @expr, body: blk,
@@ -472,7 +472,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
               postcondition: false_postcond(num_local_vars)};
         let g = bind combine_pp(antec_pp, fcx, _, _);
         let alts_overall_pp =
-            vec::foldl::<pre_and_post, pre_and_post>(g, e_pp, alt_pps);
+            vec::foldl(e_pp, alt_pps, g);
         set_pre_and_post(fcx.ccx, e.id, alts_overall_pp.precondition,
                          alts_overall_pp.postcondition);
       }
@@ -669,7 +669,7 @@ fn find_pre_post_block(fcx: fn_ctxt, b: blk) {
     for s: @stmt in b.node.stmts { 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, _);
-    option::map::<@expr, ()>(do_inner, b.node.expr);
+    option::map::<@expr, ()>(b.node.expr, do_inner);
 
     let pps: [pre_and_post] = [];
     for s: @stmt in b.node.stmts { pps += [stmt_pp(fcx.ccx, *s)]; }

trunk/src/comp/middle/ty.rs

@@ -1708,7 +1708,7 @@ fn field_idx(sess: session::session, sp: span, id: ast::ident,
 fn get_field(tcx: ctxt, rec_ty: t, id: ast::ident) -> field {
     alt struct(tcx, rec_ty) {
       ty_rec(fields) {
-        alt vec::find({|f| str::eq(f.ident, id) }, fields) {
+        alt vec::find(fields, {|f| str::eq(f.ident, id) }) {
             some(f) { ret f; }
         }
       }