---

yaml
---
r: 63331
b: refs/heads/snap-stage3
c: 824a627
h: refs/heads/master
i:
  63329: b2ea4f6
  63327: 677df6d
v: v3

Author: thestinger

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: d68be89e6912a394beb12c2731bdc6240a81655b
+refs/heads/snap-stage3: 824a6277af9e614767e0570ecc282065256ac32a
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libstd/old_iter.rs

@@ -59,13 +59,6 @@ pub trait CopyableOrderedIter<A:Copy + Ord> {
     fn max(&self) -> A;
 }
 
-pub trait CopyableNonstrictIter<A:Copy> {
-    // Like "each", but copies out the value. If the receiver is mutated while
-    // iterating over it, the semantics must not be memory-unsafe but are
-    // otherwise undefined.
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool;
-}
-
 // A trait for sequences that can be built by imperatively pushing elements
 // onto them.
 pub trait Buildable<A> {

branches/snap-stage3/src/libstd/prelude.rs

@@ -47,7 +47,7 @@ pub use char::Char;
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;
 pub use old_iter::{BaseIter, ReverseIter, ExtendedIter, EqIter};
-pub use old_iter::{CopyableIter, CopyableOrderedIter, CopyableNonstrictIter};
+pub use old_iter::{CopyableIter, CopyableOrderedIter};
 pub use iter::{Times, FromIter};
 pub use iterator::{Iterator, IteratorUtil};
 pub use num::{Num, NumCast};

branches/snap-stage3/src/libstd/vec.rs

@@ -2630,41 +2630,6 @@ impl<A:Copy + Ord> old_iter::CopyableOrderedIter<A> for @[A] {
     fn max(&self) -> A { old_iter::max(self) }
 }
 
-impl<'self,A:Copy> old_iter::CopyableNonstrictIter<A> for &'self [A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
-        let mut i = 0;
-        while i < self.len() {
-            if !f(copy self[i]) { return false; }
-            i += 1;
-        }
-        return true;
-    }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A:Copy> old_iter::CopyableNonstrictIter<A> for ~[A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
-        let mut i = 0;
-        while i < uniq_len(self) {
-            if !f(copy self[i]) { return false; }
-            i += 1;
-        }
-        return true;
-    }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A:Copy> old_iter::CopyableNonstrictIter<A> for @[A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
-        let mut i = 0;
-        while i < self.len() {
-            if !f(copy self[i]) { return false; }
-            i += 1;
-        }
-        return true;
-    }
-}
-
 impl<A:Clone> Clone for ~[A] {
     #[inline]
     fn clone(&self) -> ~[A] {
@@ -4326,14 +4291,4 @@ mod tests {
         }
         assert_eq!(v, ~[~[1,2,3],~[1,3,2],~[2,1,3],~[2,3,1],~[3,1,2],~[3,2,1]]);
     }
-
-    #[test]
-    fn test_each_val() {
-        use old_iter::CopyableNonstrictIter;
-        let mut i = 0;
-        for [1, 2, 3].each_val |v| {
-            i += v;
-        }
-        assert_eq!(i, 6);
-    }
 }