std: remove vec::each2 and vec::each2_mut in favour of iterators

Author: huonw

src/librustc/middle/kind.rs

@@ -17,6 +17,7 @@ use middle::typeck;
 use util::ppaux::{Repr, ty_to_str};
 use util::ppaux::UserString;
 
+use core::iterator::IteratorUtil;
 use core::vec;
 use syntax::ast::*;
 use syntax::attr::attrs_contains_name;
@@ -268,7 +269,7 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt<Context>) {
                   ts.repr(cx.tcx),
                   type_param_defs.repr(cx.tcx));
         }
-        for vec::each2(**ts, *type_param_defs) |&ty, type_param_def| {
+        for ts.iter().zip(type_param_defs.iter()).advance |(&ty, type_param_def)| {
             check_bounds(cx, type_parameter_id, e.span, ty, type_param_def)
         }
     }
@@ -309,7 +310,7 @@ fn check_ty(aty: @Ty, cx: Context, v: visit::vt<Context>) {
             let did = ast_util::def_id_of_def(cx.tcx.def_map.get_copy(&id));
             let type_param_defs =
                 ty::lookup_item_type(cx.tcx, did).generics.type_param_defs;
-            for vec::each2(**ts, *type_param_defs) |&ty, type_param_def| {
+            for ts.iter().zip(type_param_defs.iter()).advance |(&ty, type_param_def)| {
                 check_bounds(cx, aty.id, aty.span, ty, type_param_def)
             }
         }

src/librustc/middle/trans/inline.rs

@@ -19,6 +19,7 @@ use middle::trans::common::*;
 use middle::ty;
 use util::ppaux::ty_to_str;
 
+use core::iterator::IteratorUtil;
 use core::vec;
 use syntax::ast;
 use syntax::ast_map::path_name;
@@ -75,7 +76,7 @@ pub fn maybe_instantiate_inline(ccx: @CrateContext, fn_id: ast::def_id,
             ast::item_enum(_, _) => {
               let vs_here = ty::enum_variants(ccx.tcx, local_def(item.id));
               let vs_there = ty::enum_variants(ccx.tcx, parent_id);
-              for vec::each2(*vs_here, *vs_there) |here, there| {
+              for vs_here.iter().zip(vs_there.iter()).advance |(here, there)| {
                   if there.id == fn_id { my_id = here.id.node; }
                   ccx.external.insert(there.id, Some(here.id.node));
               }

src/librustc/middle/trans/type_use.rs

@@ -33,6 +33,7 @@ use middle::trans::inline;
 use middle::ty;
 use middle::typeck;
 
+use core::iterator::IteratorUtil;
 use core::option::{Some, None};
 use core::uint;
 use core::vec;
@@ -264,7 +265,7 @@ pub fn mark_for_method_call(cx: Context, e_id: node_id, callee_id: node_id) {
     for opt_static_did.each |&did| {
         for cx.ccx.tcx.node_type_substs.find_copy(&callee_id).each |ts| {
             let type_uses = type_uses_for(cx.ccx, did, ts.len());
-            for vec::each2(*type_uses, *ts) |uses, subst| {
+            for type_uses.iter().zip(ts.iter()).advance |(uses, subst)| {
                 type_needs(cx, *uses, *subst)
             }
         }
@@ -302,7 +303,7 @@ pub fn mark_for_expr(cx: Context, e: @expr) {
         for opt_ts.each |ts| {
             let id = ast_util::def_id_of_def(cx.ccx.tcx.def_map.get_copy(&e.id));
             let uses_for_ts = type_uses_for(cx.ccx, id, ts.len());
-            for vec::each2(*uses_for_ts, *ts) |uses, subst| {
+            for uses_for_ts.iter().zip(ts.iter()).advance |(uses, subst)| {
                 type_needs(cx, *uses, *subst)
             }
         }

src/librustc/middle/typeck/check/_match.rs

@@ -18,8 +18,8 @@ use middle::typeck::check::{instantiate_path, lookup_def};
 use middle::typeck::check::{structure_of, valid_range_bounds};
 use middle::typeck::require_same_types;
 
+use core::iterator::IteratorUtil;
 use core::hashmap::{HashMap, HashSet};
-use core::vec;
 use syntax::ast;
 use syntax::ast_util;
 use syntax::codemap::span;
@@ -232,7 +232,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: @ast::Path,
 
         if !error_happened {
             for subpats.each |pats| {
-                for vec::each2(*pats, arg_types) |subpat, arg_ty| {
+                for pats.iter().zip(arg_types.iter()).advance |(subpat, arg_ty)| {
                     check_pat(pcx, *subpat, *arg_ty);
                 }
             }

src/librustc/middle/typeck/check/mod.rs

@@ -110,6 +110,8 @@ use util::common::{block_query, indenter, loop_query};
 use util::ppaux::{bound_region_to_str};
 use util::ppaux;
 
+
+use core::iterator::IteratorUtil;
 use core::cast::transmute;
 use core::hashmap::HashMap;
 use core::result;
@@ -412,7 +414,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
     for opt_self_info.each |self_info| {
         fcx.write_ty(self_info.self_id, self_info.self_ty);
     }
-    for vec::each2(decl.inputs, arg_tys) |input, arg| {
+    for decl.inputs.iter().zip(arg_tys.iter()).advance |(input, arg)| {
         fcx.write_ty(input.id, *arg);
     }
 
@@ -449,7 +451,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
         }
 
         // Add formal parameters.
-        for vec::each2(arg_tys, decl.inputs) |arg_ty, input| {
+        for arg_tys.iter().zip(decl.inputs.iter()).advance |(arg_ty, input)| {
             // Create type variables for each argument.
             do pat_util::pat_bindings(tcx.def_map, input.pat)
                     |_bm, pat_id, _sp, _path| {

src/librustc/middle/typeck/coherence.rs

@@ -54,6 +54,7 @@ use syntax::visit::{Visitor, SimpleVisitor};
 use syntax::visit::{visit_mod};
 use util::ppaux::ty_to_str;
 
+use core::iterator::IteratorUtil;
 use core::hashmap::{HashMap, HashSet};
 use core::old_iter;
 use core::result::Ok;
@@ -617,9 +618,9 @@ impl CoherenceChecker {
                 // Check to ensure that each parameter binding respected its
                 // kind bounds.
                 for [ a, b ].each |result| {
-                    for vec::each2(result.type_variables,
-                                   *result.type_param_defs)
-                        |ty_var, type_param_def|
+                    for result.type_variables.iter()
+                        .zip(result.type_param_defs.iter())
+                        .advance |(ty_var, type_param_def)|
                     {
                         if type_param_def.bounds.builtin_bounds.contains_elem(
                             ty::BoundCopy)

src/libstd/vec.rs

@@ -1666,44 +1666,6 @@ pub fn eachi_reverse<'r,T>(v: &'r [T],
     return true;
 }
 
-/**
- * Iterates over two vectors simultaneously
- *
- * # Failure
- *
- * Both vectors must have the same length
- */
-#[inline]
-pub fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) -> bool {
-    assert_eq!(v1.len(), v2.len());
-    for uint::range(0u, v1.len()) |i| {
-        if !f(&v1[i], &v2[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-
-/**
- *
- * Iterates over two vector with mutable.
- *
- * # Failure
- *
- * Both vectors must have the same length
- */
-#[inline]
-pub fn each2_mut<U, T>(v1: &mut [U], v2: &mut [T],
-                       f: &fn(u: &mut U, t: &mut T) -> bool) -> bool {
-    assert_eq!(v1.len(), v2.len());
-    for uint::range(0u, v1.len()) |i| {
-        if !f(&mut v1[i], &mut v2[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-
 /**
  * Iterate over all permutations of vector `v`.
  *

src/libsyntax/ext/deriving/generic.rs

@@ -174,6 +174,7 @@ use opt_vec;
 
 use core::uint;
 use core::vec;
+use core::iterator::IteratorUtil;
 
 pub use self::ty::*;
 mod ty;
@@ -616,7 +617,7 @@ impl<'self> MethodDef<'self> {
         // make a series of nested matches, to destructure the
         // structs. This is actually right-to-left, but it shoudn't
         // matter.
-        for vec::each2(self_args, patterns) |&arg_expr, &pat| {
+        for self_args.iter().zip(patterns.iter()).advance |(&arg_expr, &pat)| {
             body = cx.expr_match(span, arg_expr,
                                  ~[ cx.arm(span, ~[pat], body) ])
         }
@@ -951,7 +952,7 @@ fn create_struct_pattern(cx: @ExtCtxt,
     // must be nonempty to reach here
     let pattern = if struct_type == Record {
         let field_pats = do vec::build |push| {
-            for vec::each2(subpats, ident_expr) |&pat, &(id, _)| {
+            for subpats.iter().zip(ident_expr.iter()).advance |(&pat, &(id, _))| {
                 // id is guaranteed to be Some
                 push(ast::field_pat { ident: id.get(), pat: pat })
             }

src/test/bench/shootout-fannkuch-redux.rs

@@ -1,3 +1,4 @@
+use std::iterator::*;
 use std::from_str::FromStr;
 use std::i32::range;
 use std::os;
@@ -29,9 +30,8 @@ fn fannkuch_redux(n: i32) -> i32 {
                 r -= 1;
             }
 
-            // XXX: Need each2_mut.
-            for vec::eachi_mut(perm) |i, perm_i| {
-                *perm_i = perm1.unsafe_get(i);
+            for perm.mut_iter().zip(perm1.iter()).advance |(perm_i, perm1_i)| {
+                *perm_i = *perm1_i;
             }
 
             let mut flips_count: i32 = 0;