Remove vec::{map, mapi, zip_map} and the methods, except for .map, since this

is very common, and the replacement (.iter().transform().collect()) is very
ugly.

Author: huonw

src/compiletest/runtest.rs

@@ -345,9 +345,9 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
         fatal(~"process did not return an error status");
     }
 
-    let prefixes = vec::map(expected_errors, |ee| {
+    let prefixes = expected_errors.iter().transform(|ee| {
         fmt!("%s:%u:", testfile.to_str(), ee.line)
-    });
+    }).collect::<~[~str]>();
 
     // Scan and extract our error/warning messages,
     // which look like:

src/libextra/fileinput.rs

@@ -100,7 +100,6 @@ total line count).
 use std::io::ReaderUtil;
 use std::io;
 use std::os;
-use std::vec;
 
 /**
 A summary of the internal state of a `FileInput` object. `line_num`
@@ -353,13 +352,13 @@ a literal `-`.
 */
 // XXX: stupid, unclear name
 pub fn pathify(vec: &[~str], stdin_hyphen : bool) -> ~[Option<Path>] {
-    vec::map(vec, |&str : & ~str| {
-        if stdin_hyphen && str == ~"-" {
+    vec.iter().transform(|str| {
+        if stdin_hyphen && "-" == *str {
             None
         } else {
-            Some(Path(str))
+            Some(Path(*str))
         }
-    })
+    }).collect()
 }
 
 /**

src/libextra/getopts.rs

@@ -592,9 +592,9 @@ pub mod groups {
      */
     pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str {
 
-        let desc_sep = ~"\n" + " ".repeat(24);
+        let desc_sep = "\n" + " ".repeat(24);
 
-        let rows = vec::map(opts, |optref| {
+        let mut rows = opts.iter().transform(|optref| {
             let OptGroup{short_name: short_name,
                          long_name: long_name,
                          hint: hint,
@@ -669,7 +669,7 @@ pub mod groups {
 
         return str::to_owned(brief) +
                "\n\nOptions:\n" +
-               rows.connect("\n") +
+               rows.collect::<~[~str]>().connect("\n") +
                "\n\n";
     }
 } // end groups module

src/libextra/num/bigint.rs

@@ -283,13 +283,13 @@ impl Mul<BigUint, BigUint> for BigUint {
             if n == 1 { return copy *a; }
 
             let mut carry = 0;
-            let prod = do vec::map(a.data) |ai| {
+            let prod = do a.data.iter().transform |ai| {
                 let (hi, lo) = BigDigit::from_uint(
                     (*ai as uint) * (n as uint) + (carry as uint)
                 );
                 carry = hi;
                 lo
-            };
+            }.collect::<~[BigDigit]>();
             if carry == 0 { return BigUint::new(prod) };
             return BigUint::new(prod + [carry]);
         }
@@ -618,13 +618,13 @@ impl BigUint {
         if n_bits == 0 || self.is_zero() { return copy *self; }
 
         let mut carry = 0;
-        let shifted = do vec::map(self.data) |elem| {
+        let shifted = do self.data.iter().transform |elem| {
             let (hi, lo) = BigDigit::from_uint(
                 (*elem as uint) << n_bits | (carry as uint)
             );
             carry = hi;
             lo
-        };
+        }.collect::<~[BigDigit]>();
         if carry == 0 { return BigUint::new(shifted); }
         return BigUint::new(shifted + [carry]);
     }
@@ -1172,7 +1172,7 @@ mod biguint_tests {
 
     #[test]
     fn test_cmp() {
-        let data = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1]  ]
+        let data: ~[BigUint] = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1]  ]
             .map(|v| BigUint::from_slice(*v));
         for data.iter().enumerate().advance |(i, ni)| {
             for data.slice(i, data.len()).iter().enumerate().advance |(j0, nj)| {

src/libextra/par.rs

@@ -92,7 +92,7 @@ pub fn map<A:Copy + Send,B:Copy + Send>(
     vec::concat(map_slices(xs, || {
         let f = fn_factory();
         let result: ~fn(uint, &[A]) -> ~[B] =
-            |_, slice| vec::map(slice, |x| f(x));
+            |_, slice| slice.iter().transform(|x| f(x)).collect();
         result
     }))
 }
@@ -104,9 +104,9 @@ pub fn mapi<A:Copy + Send,B:Copy + Send>(
     let slices = map_slices(xs, || {
         let f = fn_factory();
         let result: ~fn(uint, &[A]) -> ~[B] = |base, slice| {
-            vec::mapi(slice, |i, x| {
+            slice.iter().enumerate().transform(|(i, x)| {
                 f(i + base, x)
-            })
+            }).collect()
         };
         result
     });

src/libextra/semver.rs

@@ -78,12 +78,12 @@ impl ToStr for Version {
         let s = if self.pre.is_empty() {
             s
         } else {
-            s + "-" + self.pre.map(|i| i.to_str()).connect(".")
+            fmt!("%s-%s", s, self.pre.map(|i| i.to_str()).connect("."))
         };
         if self.build.is_empty() {
             s
         } else {
-            s + "+" + self.build.map(|i| i.to_str()).connect(".")
+            fmt!("%s+%s", s, self.build.map(|i| i.to_str()).connect("."))
         }
     }
 }

src/librustc/back/rpath.rs

@@ -52,7 +52,7 @@ fn get_sysroot_absolute_rt_lib(sess: session::Session) -> Path {
 }
 
 pub fn rpaths_to_flags(rpaths: &[Path]) -> ~[~str] {
-    vec::map(rpaths, |rpath| fmt!("-Wl,-rpath,%s",rpath.to_str()))
+    rpaths.iter().transform(|rpath| fmt!("-Wl,-rpath,%s",rpath.to_str())).collect()
 }
 
 fn get_rpaths(os: session::os,
@@ -103,9 +103,7 @@ fn get_rpaths(os: session::os,
 fn get_rpaths_relative_to_output(os: session::os,
                                  output: &Path,
                                  libs: &[Path]) -> ~[Path] {
-    vec::map(libs, |a| {
-        get_rpath_relative_to_output(os, output, a)
-    })
+    libs.iter().transform(|a| get_rpath_relative_to_output(os, output, a)).collect()
 }
 
 pub fn get_rpath_relative_to_output(os: session::os,
@@ -163,7 +161,7 @@ pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
 }
 
 fn get_absolute_rpaths(libs: &[Path]) -> ~[Path] {
-    vec::map(libs, |a| get_absolute_rpath(a) )
+    libs.iter().transform(|a| get_absolute_rpath(a)).collect()
 }
 
 pub fn get_absolute_rpath(lib: &Path) -> Path {

src/librustc/front/config.rs

@@ -90,7 +90,7 @@ fn fold_foreign_mod(
     ast::foreign_mod {
         sort: nm.sort,
         abis: nm.abis,
-        view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)),
+        view_items: filtered_view_items.iter().transform(|x| fld.fold_view_item(*x)).collect(),
         items: filtered_items
     }
 }

src/librustc/front/test.rs

@@ -117,7 +117,7 @@ fn fold_mod(cx: @mut TestCtxt,
 
     let mod_nomain = ast::_mod {
         view_items: /*bad*/copy m.view_items,
-        items: vec::map(m.items, |i| nomain(cx, *i)),
+        items: m.items.iter().transform(|i| nomain(cx, *i)).collect(),
     };
 
     fold::noop_fold_mod(&mod_nomain, fld)

src/librustc/metadata/encoder.rs

@@ -1441,8 +1441,7 @@ fn encode_crate_deps(ecx: &EncodeContext,
             expected_cnum += 1;
         }
 
-        // mut -> immutable hack for vec::map
-        deps.slice(0, deps.len()).to_owned()
+        deps
     }
 
     // We're just going to write a list of crate 'name-hash-version's, with

src/librustc/middle/check_match.rs

@@ -642,13 +642,13 @@ pub fn specialize(cx: &MatchCheckCtxt,
                                          ty_to_str(cx.tcx, left_ty)));
                             }
                         }
-                        let args = vec::map(class_fields, |class_field| {
+                        let args = class_fields.iter().transform(|class_field| {
                             match flds.iter().find_(|f|
                                             f.ident == class_field.ident) {
                                 Some(f) => f.pat,
                                 _ => wild()
                             }
-                        });
+                        }).collect();
                         Some(vec::append(args, vec::to_owned(r.tail())))
                     }
                 }

src/librustc/middle/const_eval.rs

@@ -19,7 +19,6 @@ use syntax::ast::*;
 
 use std::float;
 use std::hashmap::{HashMap, HashSet};
-use std::vec;
 
 //
 // This pass classifies expressions by their constant-ness.
@@ -70,8 +69,8 @@ pub fn join(a: constness, b: constness) -> constness {
     }
 }
 
-pub fn join_all(cs: &[constness]) -> constness {
-    cs.iter().fold(integral_const, |a, b| join(a, *b))
+pub fn join_all<It: Iterator<constness>>(mut cs: It) -> constness {
+    cs.fold(integral_const, |a, b| join(a, b))
 }
 
 pub fn classify(e: &expr,
@@ -104,7 +103,7 @@ pub fn classify(e: &expr,
 
               ast::expr_tup(ref es) |
               ast::expr_vec(ref es, ast::m_imm) => {
-                join_all(vec::map(*es, |e| classify(*e, tcx)))
+                join_all(es.iter().transform(|e| classify(*e, tcx)))
               }
 
               ast::expr_vstore(e, vstore) => {
@@ -118,7 +117,7 @@ pub fn classify(e: &expr,
               }
 
               ast::expr_struct(_, ref fs, None) => {
-                let cs = do vec::map((*fs)) |f| {
+                let cs = do fs.iter().transform |f| {
                     classify(f.node.expr, tcx)
                 };
                 join_all(cs)

src/librustc/middle/lint.rs

@@ -740,11 +740,10 @@ fn check_item_ctypes(cx: &Context, it: &ast::item) {
     }
 
     fn check_foreign_fn(cx: &Context, decl: &ast::fn_decl) {
-        let tys = vec::map(decl.inputs, |a| a.ty );
-        let r = vec::append_one(tys, decl.output);
-        for r.iter().advance |ty| {
-            check_ty(cx, *ty);
+        for decl.inputs.iter().advance |in| {
+            check_ty(cx, in.ty);
         }
+        check_ty(cx, decl.output)
     }
 
     match it.node {

src/librustc/middle/trans/adt.rs

@@ -519,10 +519,10 @@ pub fn trans_const(ccx: &mut CrateContext, r: &Repr, discr: int,
                 C_struct(build_const_struct(ccx, nonnull, vals))
             } else {
                 assert_eq!(vals.len(), 0);
-                let vals = do nonnull.fields.mapi |i, &ty| {
+                let vals = do nonnull.fields.iter().enumerate().transform |(i, &ty)| {
                     let llty = type_of::sizing_type_of(ccx, ty);
                     if i == ptrfield { C_null(llty) } else { C_undef(llty) }
-                };
+                }.collect::<~[ValueRef]>();
                 C_struct(build_const_struct(ccx, nonnull, vals))
             }
         }

src/librustc/middle/trans/build.rs

@@ -615,12 +615,12 @@ pub fn GEPi(cx: block, base: ValueRef, ixs: &[uint]) -> ValueRef {
     // we care about.
     if ixs.len() < 16 {
         let mut small_vec = [ C_i32(0), ..16 ];
-        for ixs.iter().enumerate().advance |(i, &ix)| {
-            small_vec[i] = C_i32(ix as i32)
+        for small_vec.mut_iter().zip(ixs.iter()).advance |(small_vec_e, &ix)| {
+            *small_vec_e = C_i32(ix as i32);
         }
         InBoundsGEP(cx, base, small_vec.slice(0, ixs.len()))
     } else {
-        let v = do vec::map(ixs) |i| { C_i32(*i as i32) };
+        let v = do ixs.iter().transform |i| { C_i32(*i as i32) }.collect::<~[ValueRef]>();
         count_insn(cx, "gepi");
         InBoundsGEP(cx, base, v)
     }

src/librustc/middle/trans/cabi.rs

@@ -17,7 +17,6 @@ use middle::trans::type_::Type;
 
 use std::libc::c_uint;
 use std::option;
-use std::vec;
 
 pub trait ABIInfo {
     fn compute_info(&self, atys: &[Type], rty: Type, ret_def: bool) -> FnType;
@@ -37,7 +36,7 @@ pub struct FnType {
 
 impl FnType {
     pub fn decl_fn(&self, decl: &fn(fnty: Type) -> ValueRef) -> ValueRef {
-        let atys = vec::map(self.arg_tys, |t| t.ty);
+        let atys = self.arg_tys.iter().transform(|t| t.ty).collect::<~[Type]>();
         let rty = self.ret_ty.ty;
         let fnty = Type::func(atys, &rty);
         let llfn = decl(fnty);

src/librustc/middle/trans/common.rs

@@ -980,9 +980,9 @@ pub fn node_id_type_params(bcx: block, id: ast::node_id) -> ~[ty::t] {
 
     match bcx.fcx.param_substs {
       Some(substs) => {
-        do vec::map(params) |t| {
+        do params.iter().transform |t| {
             ty::subst_tps(tcx, substs.tys, substs.self_ty, *t)
-        }
+        }.collect()
       }
       _ => params
     }
@@ -1006,9 +1006,11 @@ pub fn resolve_vtables_under_param_substs(tcx: ty::ctxt,
                                           param_substs: Option<@param_substs>,
                                           vts: typeck::vtable_res)
     -> typeck::vtable_res {
-    @vec::map(*vts, |ds|
-      @vec::map(**ds, |d|
-                resolve_vtable_under_param_substs(tcx, param_substs, copy *d)))
+    @vts.iter().transform(|ds|
+      @ds.iter().transform(
+          |d| resolve_vtable_under_param_substs(tcx, param_substs, copy *d))
+                          .collect::<~[typeck::vtable_origin]>())
+        .collect::<~[typeck::vtable_param_res]>()
 }
 
 
@@ -1029,9 +1031,9 @@ pub fn resolve_vtable_under_param_substs(tcx: ty::ctxt,
         typeck::vtable_static(trait_id, tys, sub) => {
             let tys = match param_substs {
                 Some(substs) => {
-                    do vec::map(tys) |t| {
+                    do tys.iter().transform |t| {
                         ty::subst_tps(tcx, substs.tys, substs.self_ty, *t)
-                    }
+                    }.collect()
                 }
                 _ => tys
             };

src/librustc/middle/trans/expr.rs

@@ -588,8 +588,9 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr,
         }
         ast::expr_tup(ref args) => {
             let repr = adt::represent_type(bcx.ccx(), expr_ty(bcx, expr));
-            return trans_adt(bcx, repr, 0, args.mapi(|i, arg| (i, *arg)),
-                             None, dest);
+            let numbered_fields: ~[(uint, @ast::expr)] =
+                args.iter().enumerate().transform(|(i, arg)| (i, *arg)).collect();
+            return trans_adt(bcx, repr, 0, numbered_fields, None, dest);
         }
         ast::expr_lit(@codemap::spanned {node: ast::lit_str(s), _}) => {
             return tvec::trans_lit_str(bcx, expr, s, dest);