---

yaml
---
r: 57195
b: refs/heads/try
c: d53e686
h: refs/heads/master
i:
  57193: 0f9eb15
  57191: 45edb94
v: v3

Author: emberian

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
-refs/heads/try: 91fb7b282de4877e72f22f42b4535e3c76732264
+refs/heads/try: d53e686f4f940ff87cc8bff3a2ebe81cc4022208
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/result.rs

@@ -358,7 +358,7 @@ pub fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
 
 /**
  * Applies op to the pairwise elements from `ss` and `ts`, aborting on
- * error.  This could be implemented using `map2()` but it is more efficient
+ * error.  This could be implemented using `map_zip()` but it is more efficient
  * on its own as no result vector is built.
  */
 #[inline(always)]

branches/try/src/libcore/tuple.rs

@@ -123,7 +123,7 @@ impl<'self,A:Copy,B:Copy> ExtendedTupleOps<A,B> for (&'self [A], &'self [B]) {
     fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] {
         match *self {
             (ref a, ref b) => {
-                vec::map2(*a, *b, f)
+                vec::map_zip(*a, *b, f)
             }
         }
     }
@@ -144,7 +144,7 @@ impl<A:Copy,B:Copy> ExtendedTupleOps<A,B> for (~[A], ~[B]) {
     fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] {
         match *self {
             (ref a, ref b) => {
-                vec::map2(*a, *b, f)
+                vec::map_zip(*a, *b, f)
             }
         }
     }

branches/try/src/libcore/vec.rs

@@ -173,7 +173,6 @@ pub fn from_slice<T:Copy>(t: &[T]) -> ~[T] {
     from_fn(t.len(), |i| t[i])
 }
 
-/// Creates a new vector with a capacity of `capacity`
 pub fn with_capacity<T>(capacity: uint) -> ~[T] {
     let mut vec = ~[];
     reserve(&mut vec, capacity);
@@ -848,8 +847,11 @@ pub fn flat_map<T, U>(v: &[T], f: &fn(t: &T) -> ~[U]) -> ~[U] {
     result
 }
 
-/// Apply a function to each pair of elements and return the results
-pub fn map2<T:Copy,U:Copy,V>(v0: &[T], v1: &[U],
+/**
+ * Apply a function to each pair of elements and return the results.
+ * Equivalent to `map(zip(v0, v1), f)`.
+ */
+pub fn map_zip<T:Copy,U:Copy,V>(v0: &[T], v1: &[U],
                                   f: &fn(t: &T, v: &U) -> V) -> ~[V] {
     let v0_len = len(v0);
     if v0_len != len(v1) { fail!(); }
@@ -1566,16 +1568,6 @@ pub fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) {
     }
 }
 
-// see doc below
-#[cfg(stage0)] // XXX: lifetimes!
-pub fn windowed<T>(n: uint, v: &[T], it: &fn(&[T]) -> bool) {
-    assert!(1u <= n);
-    if n > v.len() { return; }
-    for uint::range(0, v.len() - n + 1) |i| {
-        if !it(v.slice(i, i+n)) { return }
-    }
-}
-
 /**
  * Iterate over all contiguous windows of length `n` of the vector `v`.
  *
@@ -1590,6 +1582,14 @@ pub fn windowed<T>(n: uint, v: &[T], it: &fn(&[T]) -> bool) {
  * ~~~
  *
  */
+#[cfg(stage0)] // XXX: lifetimes!
+pub fn windowed<T>(n: uint, v: &[T], it: &fn(&[T]) -> bool) {
+    assert!(1u <= n);
+    if n > v.len() { return; }
+    for uint::range(0, v.len() - n + 1) |i| {
+        if !it(v.slice(i, i+n)) { return }
+    }
+}
 #[cfg(stage1)]
 #[cfg(stage2)]
 #[cfg(stage3)]
@@ -3399,12 +3399,12 @@ mod tests {
     }
 
     #[test]
-    fn test_map2() {
+    fn test_map_zip() {
         fn times(x: &int, y: &int) -> int { *x * *y }
         let f = times;
         let v0 = ~[1, 2, 3, 4, 5];
         let v1 = ~[5, 4, 3, 2, 1];
-        let u = map2::<int, int, int>(v0, v1, f);
+        let u = map_zip::<int, int, int>(v0, v1, f);
         let mut i = 0;
         while i < 5 { assert!(v0[i] * v1[i] == u[i]); i += 1; }
     }
@@ -4338,10 +4338,10 @@ mod tests {
     #[ignore(windows)]
     #[should_fail]
     #[allow(non_implicitly_copyable_typarams)]
-    fn test_map2_fail() {
+    fn test_map_zip_fail() {
         let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
         let mut i = 0;
-        do map2(v, v) |_elt1, _elt2| {
+        do map_zip(v, v) |_elt1, _elt2| {
             if i == 2 {
                 fail!()
             }

branches/try/src/librustc/middle/trans/monomorphize.rs

@@ -356,7 +356,7 @@ pub fn make_mono_id(ccx: @CrateContext,
       Some(vts) => {
         let item_ty = ty::lookup_item_type(ccx.tcx, item);
         let mut i = 0;
-        vec::map2(*item_ty.generics.type_param_defs, substs, |type_param_def, subst| {
+        vec::map_zip(*item_ty.generics.type_param_defs, substs, |type_param_def, subst| {
             let mut v = ~[];
             for type_param_def.bounds.each |bound| {
                 match *bound {
@@ -376,7 +376,7 @@ pub fn make_mono_id(ccx: @CrateContext,
     };
     let param_ids = match param_uses {
       Some(ref uses) => {
-        vec::map2(precise_param_ids, **uses, |id, uses| {
+        vec::map_zip(precise_param_ids, **uses, |id, uses| {
             if ccx.sess.no_monomorphic_collapse() {
                 match copy *id {
                     (a, b) => mono_precise(a, b)

branches/try/src/librustdoc/attr_pass.rs

@@ -209,7 +209,7 @@ fn merge_method_attrs(
         }
     };
 
-    do vec::map2(docs, attrs) |doc, attrs| {
+    do vec::map_zip(docs, attrs) |doc, attrs| {
         assert!(doc.name == attrs.first());
         let desc = attrs.second();
 

branches/try/src/libsyntax/ext/deriving/generic.rs

@@ -629,7 +629,7 @@ impl<'self> MethodDef<'self> {
                                 }
                             }
                             let field_tuples =
-                                do vec::map2(*self_vec,
+                                do vec::map_zip(*self_vec,
                                              enum_matching_fields) |&(id, self_f), &other| {
                                 (id, self_f, other)
                             };

branches/try/src/libsyntax/ext/pipes/pipec.rs

@@ -57,7 +57,7 @@ impl gen_send for message {
             assert!(next_state.tys.len() ==
                 next.generics.ty_params.len());
             let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str()));
-            let args_ast = vec::map2(arg_names, *tys, |n, t| cx.arg(*n, *t));
+            let args_ast = vec::map_zip(arg_names, *tys, |n, t| cx.arg(*n, *t));
 
             let pipe_ty = cx.ty_path_ast_builder(
                 path(~[this.data_name()], span)
@@ -135,7 +135,7 @@ impl gen_send for message {
                 debug!("pipec: no next state");
                 let arg_names = tys.mapi(|i, _ty| (~"x_" + i.to_str()));
 
-                let args_ast = do vec::map2(arg_names, *tys) |n, t| {
+                let args_ast = do vec::map_zip(arg_names, *tys) |n, t| {
                     cx.arg(cx.ident_of(*n), *t)
                 };
 

branches/try/src/test/run-pass/block-vec-map2.rs renamed to branches/try/src/test/run-pass/block-vec-map_zip.rs

@@ -12,7 +12,7 @@ extern mod std;
 
 pub fn main() {
     let v =
-        vec::map2(~[1, 2, 3, 4, 5],
+        vec::map_zip(~[1, 2, 3, 4, 5],
                   ~[true, false, false, true, true],
                   |i, b| if *b { -(*i) } else { *i } );
     error!(v.clone());