about summary refs log tree commit diff
path: root/src/libstd/vec.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/vec.rs')
-rw-r--r--src/libstd/vec.rs59
1 files changed, 30 insertions, 29 deletions
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index db57d7bac68..534dc27196c 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -295,7 +295,7 @@ pub fn append_one<T>(lhs: ~[T], x: T) -> ~[T] {
  */
 pub fn flat_map<T, U>(v: &[T], f: &fn(t: &T) -> ~[U]) -> ~[U] {
     let mut result = ~[];
-    for v.iter().advance |elem| { result.push_all_move(f(elem)); }
+    foreach elem in v.iter() { result.push_all_move(f(elem)); }
     result
 }
 
@@ -329,7 +329,7 @@ impl<'self, T:Clone> VectorVector<T> for &'self [~[T]] {
     pub fn connect_vec(&self, sep: &T) -> ~[T] {
         let mut r = ~[];
         let mut first = true;
-        for self.iter().advance |inner| {
+        foreach inner in self.iter() {
             if first { first = false; } else { r.push((*sep).clone()); }
             r.push_all((*inner).clone());
         }
@@ -347,7 +347,7 @@ impl<'self,T:Clone> VectorVector<T> for &'self [&'self [T]] {
     pub fn connect_vec(&self, sep: &T) -> ~[T] {
         let mut r = ~[];
         let mut first = true;
-        for self.iter().advance |&inner| {
+        foreach &inner in self.iter() {
             if first { first = false; } else { r.push((*sep).clone()); }
             r.push_all(inner);
         }
@@ -365,7 +365,7 @@ impl<'self,T:Clone> VectorVector<T> for &'self [&'self [T]] {
 pub fn unzip_slice<T:Clone,U:Clone>(v: &[(T, U)]) -> (~[T], ~[U]) {
     let mut ts = ~[];
     let mut us = ~[];
-    for v.iter().advance |p| {
+    foreach p in v.iter() {
         let (t, u) = (*p).clone();
         ts.push(t);
         us.push(u);
@@ -384,7 +384,7 @@ pub fn unzip_slice<T:Clone,U:Clone>(v: &[(T, U)]) -> (~[T], ~[U]) {
 pub fn unzip<T,U>(v: ~[(T, U)]) -> (~[T], ~[U]) {
     let mut ts = ~[];
     let mut us = ~[];
-    for v.consume_iter().advance |p| {
+    foreach p in v.consume_iter() {
         let (t, u) = p;
         ts.push(t);
         us.push(u);
@@ -530,6 +530,7 @@ pub mod traits {
     use clone::Clone;
     use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Equal, Equiv};
     use ops::Add;
+    use option::{Some, None};
 
     impl<'self,T:Eq> Eq for &'self [T] {
         fn eq(&self, other: & &'self [T]) -> bool {
@@ -588,7 +589,7 @@ pub mod traits {
 
     impl<'self,T:TotalOrd> TotalOrd for &'self [T] {
         fn cmp(&self, other: & &'self [T]) -> Ordering {
-            for self.iter().zip(other.iter()).advance |(s,o)| {
+            foreach (s,o) in self.iter().zip(other.iter()) {
                 match s.cmp(o) {
                     Equal => {},
                     non_eq => { return non_eq; }
@@ -610,7 +611,7 @@ pub mod traits {
 
     impl<'self,T:Ord> Ord for &'self [T] {
         fn lt(&self, other: & &'self [T]) -> bool {
-            for self.iter().zip(other.iter()).advance |(s,o)| {
+            foreach (s,o) in self.iter().zip(other.iter()) {
                 if *s < *o { return true; }
                 if *s > *o { return false; }
             }
@@ -724,7 +725,7 @@ impl<'self,T:Clone> CopyableVector<T> for &'self [T] {
     #[inline]
     fn to_owned(&self) -> ~[T] {
         let mut result = with_capacity(self.len());
-        for self.iter().advance |e| {
+        foreach e in self.iter() {
             result.push((*e).clone());
         }
         result
@@ -879,7 +880,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
      *
      * ~~~ {.rust}
      * let v = &[1,2,3,4];
-     * for v.window_iter().advance |win| {
+     * foreach win in v.window_iter() {
      *     printfln!(win);
      * }
      * ~~~
@@ -908,7 +909,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
      *
      * ~~~ {.rust}
      * let v = &[1,2,3,4,5];
-     * for v.chunk_iter().advance |win| {
+     * foreach win in v.chunk_iter() {
      *     printfln!(win);
      * }
      * ~~~
@@ -974,7 +975,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
      */
     #[inline]
     fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
-        for self.rev_iter().enumerate().advance |(i, t)| {
+        foreach (i, t) in self.rev_iter().enumerate() {
             if f(t) { return Some(self.len() - i - 1); }
         }
         None
@@ -1074,7 +1075,7 @@ impl<'self,T:Eq> ImmutableEqVector<T> for &'self [T] {
 
     /// Return true if a vector contains an element with the given value
     fn contains(&self, x: &T) -> bool {
-        for self.iter().advance |elt| { if *x == *elt { return true; } }
+        foreach elt in self.iter() { if *x == *elt { return true; } }
         false
     }
 }
@@ -1112,7 +1113,7 @@ impl<'self,T:Clone> ImmutableCopyableVector<T> for &'self [T] {
         let mut lefts  = ~[];
         let mut rights = ~[];
 
-        for self.iter().advance |elt| {
+        foreach elt in self.iter() {
             if f(elt) {
                 lefts.push((*elt).clone());
             } else {
@@ -1169,7 +1170,7 @@ impl<T> OwnedVector<T> for ~[T] {
     ///
     /// ~~~ {.rust}
     /// let v = ~[~"a", ~"b"];
-    /// for v.consume_iter().advance |s| {
+    /// foreach s in v.consume_iter() {
     ///   // s has type ~str, not &~str
     ///   println(s);
     /// }
@@ -1498,7 +1499,7 @@ impl<T> OwnedVector<T> for ~[T] {
         let mut lefts  = ~[];
         let mut rights = ~[];
 
-        for self.consume_iter().advance |elt| {
+        foreach elt in self.consume_iter() {
             if f(&elt) {
                 lefts.push(elt);
             } else {
@@ -1831,7 +1832,7 @@ impl<'self,T> MutableVector<'self, T> for &'self mut [T] {
 
     #[inline]
     fn move_from(self, mut src: ~[T], start: uint, end: uint) -> uint {
-        for self.mut_iter().zip(src.mut_slice(start, end).mut_iter()).advance |(a, b)| {
+        foreach (a, b) in self.mut_iter().zip(src.mut_slice(start, end).mut_iter()) {
             util::swap(a, b);
         }
         cmp::min(self.len(), end-start)
@@ -1866,7 +1867,7 @@ pub trait MutableCloneableVector<T> {
 impl<'self, T:Clone> MutableCloneableVector<T> for &'self mut [T] {
     #[inline]
     fn copy_from(self, src: &[T]) -> uint {
-        for self.mut_iter().zip(src.iter()).advance |(a, b)| {
+        foreach (a, b) in self.mut_iter().zip(src.iter()) {
             *a = b.clone();
         }
         cmp::min(self.len(), src.len())
@@ -2268,7 +2269,7 @@ impl<A, T: Iterator<A>> FromIterator<A, T> for ~[A] {
     fn from_iterator(iterator: &mut T) -> ~[A] {
         let (lower, _) = iterator.size_hint();
         let mut xs = with_capacity(lower);
-        for iterator.advance |x| {
+        foreach x in *iterator {
             xs.push(x);
         }
         xs
@@ -2280,7 +2281,7 @@ impl<A, T: Iterator<A>> Extendable<A, T> for ~[A] {
         let (lower, _) = iterator.size_hint();
         let len = self.len();
         self.reserve(len + lower);
-        for iterator.advance |x| {
+        foreach x in *iterator {
             self.push(x);
         }
     }
@@ -3237,7 +3238,7 @@ mod tests {
     fn test_mut_iterator() {
         use iterator::*;
         let mut xs = [1, 2, 3, 4, 5];
-        for xs.mut_iter().advance |x| {
+        foreach x in xs.mut_iter() {
             *x += 1;
         }
         assert_eq!(xs, [2, 3, 4, 5, 6])
@@ -3250,7 +3251,7 @@ mod tests {
         let xs = [1, 2, 5, 10, 11];
         let ys = [11, 10, 5, 2, 1];
         let mut i = 0;
-        for xs.rev_iter().advance |&x| {
+        foreach &x in xs.rev_iter() {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -3261,7 +3262,7 @@ mod tests {
     fn test_mut_rev_iterator() {
         use iterator::*;
         let mut xs = [1u, 2, 3, 4, 5];
-        for xs.mut_rev_iter().enumerate().advance |(i,x)| {
+        foreach (i,x) in xs.mut_rev_iter().enumerate() {
             *x += i;
         }
         assert_eq!(xs, [5, 5, 5, 5, 5])
@@ -3501,12 +3502,12 @@ mod tests {
         {
             let (left, right) = values.mut_split(2);
             assert_eq!(left.slice(0, left.len()), [1, 2]);
-            for left.mut_iter().advance |p| {
+            foreach p in left.mut_iter() {
                 *p += 1;
             }
 
             assert_eq!(right.slice(0, right.len()), [3, 4, 5]);
-            for right.mut_iter().advance |p| {
+            foreach p in right.mut_iter() {
                 *p += 2;
             }
         }
@@ -3523,25 +3524,25 @@ mod tests {
         assert_eq!(v.len(), 3);
         let mut cnt = 0;
 
-        for v.iter().advance |f| {
+        foreach f in v.iter() {
             assert!(*f == Foo);
             cnt += 1;
         }
         assert_eq!(cnt, 3);
 
-        for v.slice(1, 3).iter().advance |f| {
+        foreach f in v.slice(1, 3).iter() {
             assert!(*f == Foo);
             cnt += 1;
         }
         assert_eq!(cnt, 5);
 
-        for v.mut_iter().advance |f| {
+        foreach f in v.mut_iter() {
             assert!(*f == Foo);
             cnt += 1;
         }
         assert_eq!(cnt, 8);
 
-        for v.consume_iter().advance |f| {
+        foreach f in v.consume_iter() {
             assert!(f == Foo);
             cnt += 1;
         }
@@ -3553,7 +3554,7 @@ mod tests {
         let xs: [Foo, ..3] = [Foo, Foo, Foo];
         assert_eq!(fmt!("%?", xs.slice(0, 2).to_owned()), ~"~[{}, {}]");
         cnt = 0;
-        for xs.iter().advance |f| {
+        foreach f in xs.iter() {
             assert!(*f == Foo);
             cnt += 1;
         }