---

yaml
---
r: 57196
b: refs/heads/try
c: 106fd12
h: refs/heads/master
v: v3

Author: huonw

[refs]

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

branches/try/src/libcore/iterator.rs

@@ -312,19 +312,6 @@ impl<A, T: Iterator<A>> Iterator<A> for TakeIterator<T> {
     }
 }
 
-pub struct ScanIterator<'self, A, B, T, St> {
-    priv iter: T,
-    priv f: &'self fn(&mut St, A) -> Option<B>,
-    state: St
-}
-
-impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B, T, St> {
-    #[inline]
-    fn next(&mut self) -> Option<B> {
-        self.iter.next().chain(|a| (self.f)(&mut self.state, a))
-    }
-}
-
 pub struct UnfoldrIterator<'self, A, St> {
     priv f: &'self fn(&mut St) -> Option<A>,
     state: St
@@ -348,25 +335,16 @@ impl<'self, A, St> Iterator<A> for UnfoldrIterator<'self, A, St> {
     }
 }
 
-/// An infinite iterator starting at `start` and advancing by `step` with each iteration
-pub struct Counter<A> {
-    state: A,
-    step: A
-}
-
-pub impl<A> Counter<A> {
-    #[inline(always)]
-    fn new(start: A, step: A) -> Counter<A> {
-        Counter{state: start, step: step}
-    }
+pub struct ScanIterator<'self, A, B, T, St> {
+    priv iter: T,
+    priv f: &'self fn(&mut St, A) -> Option<B>,
+    state: St
 }
 
-impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
-    #[inline(always)]
-    fn next(&mut self) -> Option<A> {
-        let result = self.state.clone();
-        self.state = self.state.add(&self.step); // FIXME: #6050
-        Some(result)
+impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B, T, St> {
+    #[inline]
+    fn next(&mut self) -> Option<B> {
+        self.iter.next().chain(|a| (self.f)(&mut self.state, a))
     }
 }
 
@@ -375,13 +353,6 @@ mod tests {
     use super::*;
     use prelude::*;
 
-    #[test]
-    fn test_counter_to_vec() {
-        let mut it = Counter::new(0, 5).take(10);
-        let xs = iter::iter_to_vec(|f| it.advance(f));
-        assert_eq!(xs, ~[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
-    }
-
     #[test]
     fn test_iterator_chain() {
         let xs = [0u, 1, 2, 3, 4, 5];

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 `map_zip()` but it is more efficient
+ * error.  This could be implemented using `map2()` 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::map_zip(*a, *b, f)
+                vec::map2(*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::map_zip(*a, *b, f)
+                vec::map2(*a, *b, f)
             }
         }
     }

branches/try/src/libcore/vec.rs

@@ -847,11 +847,8 @@ 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.
- * Equivalent to `map(zip(v0, v1), f)`.
- */
-pub fn map_zip<T:Copy,U:Copy,V>(v0: &[T], v1: &[U],
+/// Apply a function to each pair of elements and return the results
+pub fn map2<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!(); }
@@ -3399,12 +3396,12 @@ mod tests {
     }
 
     #[test]
-    fn test_map_zip() {
+    fn test_map2() {
         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 = map_zip::<int, int, int>(v0, v1, f);
+        let u = map2::<int, int, int>(v0, v1, f);
         let mut i = 0;
         while i < 5 { assert!(v0[i] * v1[i] == u[i]); i += 1; }
     }
@@ -4338,10 +4335,10 @@ mod tests {
     #[ignore(windows)]
     #[should_fail]
     #[allow(non_implicitly_copyable_typarams)]
-    fn test_map_zip_fail() {
+    fn test_map2_fail() {
         let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
         let mut i = 0;
-        do map_zip(v, v) |_elt1, _elt2| {
+        do map2(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::map_zip(*item_ty.generics.type_param_defs, substs, |type_param_def, subst| {
+        vec::map2(*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::map_zip(precise_param_ids, **uses, |id, uses| {
+        vec::map2(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::map_zip(docs, attrs) |doc, attrs| {
+    do vec::map2(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::map_zip(*self_vec,
+                                do vec::map2(*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::map_zip(arg_names, *tys, |n, t| cx.arg(*n, *t));
+            let args_ast = vec::map2(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::map_zip(arg_names, *tys) |n, t| {
+                let args_ast = do vec::map2(arg_names, *tys) |n, t| {
                     cx.arg(cx.ident_of(*n), *t)
                 };
 

branches/try/src/libsyntax/ext/tt/transcribe.rs

@@ -22,6 +22,8 @@ use core::hashmap::HashMap;
 use core::option;
 use core::vec;
 
+/* FIXME #2811: figure out how to have a uniquely linked stack, and change to
+   `~` */
 ///an unzipping of `token_tree`s
 struct TtFrame {
     forest: @mut ~[ast::token_tree],

branches/try/src/rt/isaac/randport.cpp

@@ -6,6 +6,7 @@ rand.c: By Bob Jenkins.  My random number generator, ISAAC.  Public Domain
   970719: use context, not global variables, for internal state
   980324: make a portable version
   010626: Note this is public domain
+  100725: Mask on use of >32 bits, not on assignment: from Paul Eggert
 ------------------------------------------------------------------------------
 */
 #ifndef STANDARD
@@ -27,37 +28,37 @@ rand.c: By Bob Jenkins.  My random number generator, ISAAC.  Public Domain
 
 void     isaac(randctx *ctx)
 {
-   register ub4 a,b,x,y,*m,*mm,*m2,*r,*mend;
+   ub4 a,b,x,y,*m,*mm,*m2,*r,*mend;
    mm=ctx->randmem; r=ctx->randrsl;
-   a = ctx->randa; b = (ctx->randb + (++ctx->randc)) & 0xffffffff;
+   a = ctx->randa; b = ctx->randb + (++ctx->randc);
    for (m = mm, mend = m2 = m+(RANDSIZ/2); m<mend; )
    {
       rngstep( a<<13, a, b, mm, m, m2, r, x);
-      rngstep( a>>6 , a, b, mm, m, m2, r, x);
+      rngstep( (a & 0xffffffff) >>6 , a, b, mm, m, m2, r, x);
       rngstep( a<<2 , a, b, mm, m, m2, r, x);
-      rngstep( a>>16, a, b, mm, m, m2, r, x);
+      rngstep( (a & 0xffffffff) >>16, a, b, mm, m, m2, r, x);
    }
    for (m2 = mm; m2<mend; )
    {
       rngstep( a<<13, a, b, mm, m, m2, r, x);
-      rngstep( a>>6 , a, b, mm, m, m2, r, x);
+      rngstep( (a & 0xffffffff) >>6 , a, b, mm, m, m2, r, x);
       rngstep( a<<2 , a, b, mm, m, m2, r, x);
-      rngstep( a>>16, a, b, mm, m, m2, r, x);
+      rngstep( (a & 0xffffffff) >>16, a, b, mm, m, m2, r, x);
    }
    ctx->randb = b; ctx->randa = a;
 }
 
 
 #define mix(a,b,c,d,e,f,g,h) \
 { \
-   a^=b<<11; d+=a; b+=c; \
-   b^=c>>2;  e+=b; c+=d; \
-   c^=d<<8;  f+=c; d+=e; \
-   d^=e>>16; g+=d; e+=f; \
-   e^=f<<10; h+=e; f+=g; \
-   f^=g>>4;  a+=f; g+=h; \
-   g^=h<<8;  b+=g; h+=a; \
-   h^=a>>9;  c+=h; a+=b; \
+   a^=b<<11;              d+=a; b+=c; \
+   b^=(c&0xffffffff)>>2;  e+=b; c+=d; \
+   c^=d<<8;               f+=c; d+=e; \
+   d^=(e&0xffffffff)>>16; g+=d; e+=f; \
+   e^=f<<10;              h+=e; f+=g; \
+   f^=(g&0xffffffff)>>4;  a+=f; g+=h; \
+   g^=h<<8;               b+=g; h+=a; \
+   h^=(a&0xffffffff)>>9;  c+=h; a+=b; \
 }
 
 /* if (flag==TRUE), then use the contents of randrsl[] to initialize mm[]. */
@@ -81,17 +82,21 @@ void randinit(randctx *ctx, word flag)
      /* initialize using the contents of r[] as the seed */
      for (i=0; i<RANDSIZ; i+=8)
      {
-       a+=r[i  ]; b+=r[i+1]; c+=r[i+2]; d+=r[i+3];
-       e+=r[i+4]; f+=r[i+5]; g+=r[i+6]; h+=r[i+7];
+       a+=r[i  ]; b+=r[i+1];
+       c+=r[i+2]; d+=r[i+3];
+       e+=r[i+4]; f+=r[i+5];
+       g+=r[i+6]; h+=r[i+7];
        mix(a,b,c,d,e,f,g,h);
        m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
        m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
      }
      /* do a second pass to make all of the seed affect all of m */
      for (i=0; i<RANDSIZ; i+=8)
      {
-       a+=m[i  ]; b+=m[i+1]; c+=m[i+2]; d+=m[i+3];
-       e+=m[i+4]; f+=m[i+5]; g+=m[i+6]; h+=m[i+7];
+       a+=m[i  ]; b+=m[i+1];
+       c+=m[i+2]; d+=m[i+3];
+       e+=m[i+4]; f+=m[i+5];
+       g+=m[i+6]; h+=m[i+7];
        mix(a,b,c,d,e,f,g,h);
        m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
        m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;

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

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