migrate many `for` loops to `foreach`

28 files changed, 220 insertions, 215 deletions

diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index 8e5b6b93111..22cbcb0d6d4 100644
--- a/src/libstd/at_vec.rs
+++ b/src/libstd/at_vec.rs
@@ -12,8 +12,8 @@
 
 use clone::Clone;
 use container::Container;
-use iterator::IteratorUtil;
-use option::Option;
+use iterator::Iterator;
+use option::{Option, Some, None};
 use sys;
 use uint;
 use unstable::raw::Repr;
@@ -92,7 +92,7 @@ pub fn build_sized_opt<A>(size: Option<uint>,
 #[inline]
 pub fn append<T:Clone>(lhs: @[T], rhs: &[T]) -> @[T] {
     do build_sized(lhs.len() + rhs.len()) |push| {
-        for lhs.iter().advance |x| {
+        foreach x in lhs.iter() {
             push((*x).clone());
         }
         for uint::range(0, rhs.len()) |i| {
@@ -105,7 +105,7 @@ pub fn append<T:Clone>(lhs: @[T], rhs: &[T]) -> @[T] {
 /// Apply a function to each element of a vector and return the results
 pub fn map<T, U>(v: &[T], f: &fn(x: &T) -> U) -> @[U] {
     do build_sized(v.len()) |push| {
-        for v.iter().advance |elem| {
+        foreach elem in v.iter() {
             push(f(elem));
         }
     }
@@ -148,7 +148,7 @@ pub fn to_managed_consume<T>(v: ~[T]) -> @[T] {
     let mut av = @[];
     unsafe {
         raw::reserve(&mut av, v.len());
-        for v.consume_iter().advance |x| {
+        foreach x in v.consume_iter() {
             raw::push(&mut av, x);
         }
         av
diff --git a/src/libstd/either.rs b/src/libstd/either.rs
index 4fb43e5157b..d0378fa947b 100644
--- a/src/libstd/either.rs
+++ b/src/libstd/either.rs
@@ -12,10 +12,11 @@
 
 #[allow(missing_doc)];
 
+use option::{Some, None};
 use clone::Clone;
 use container::Container;
 use cmp::Eq;
-use iterator::IteratorUtil;
+use iterator::Iterator;
 use result::Result;
 use result;
 use str::StrSlice;
@@ -46,7 +47,7 @@ pub fn either<T, U, V>(f_left: &fn(&T) -> V,
 /// Extracts from a vector of either all the left values
 pub fn lefts<T:Clone,U>(eithers: &[Either<T, U>]) -> ~[T] {
     do vec::build_sized(eithers.len()) |push| {
-        for eithers.iter().advance |elt| {
+        foreach elt in eithers.iter() {
             match *elt {
                 Left(ref l) => { push((*l).clone()); }
                 _ => { /* fallthrough */ }
@@ -58,7 +59,7 @@ pub fn lefts<T:Clone,U>(eithers: &[Either<T, U>]) -> ~[T] {
 /// Extracts from a vector of either all the right values
 pub fn rights<T, U: Clone>(eithers: &[Either<T, U>]) -> ~[U] {
     do vec::build_sized(eithers.len()) |push| {
-        for eithers.iter().advance |elt| {
+        foreach elt in eithers.iter() {
             match *elt {
                 Right(ref r) => { push((*r).clone()); }
                 _ => { /* fallthrough */ }
@@ -74,7 +75,7 @@ pub fn rights<T, U: Clone>(eithers: &[Either<T, U>]) -> ~[U] {
 pub fn partition<T, U>(eithers: ~[Either<T, U>]) -> (~[T], ~[U]) {
     let mut lefts: ~[T] = ~[];
     let mut rights: ~[U] = ~[];
-    for eithers.consume_iter().advance |elt| {
+    foreach elt in eithers.consume_iter() {
         match elt {
             Left(l) => lefts.push(l),
             Right(r) => rights.push(r)
diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs
index 6c3fcd41ed3..16d138d4e1f 100644
--- a/src/libstd/hash.rs
+++ b/src/libstd/hash.rs
@@ -22,7 +22,8 @@
 #[allow(missing_doc)];
 
 use container::Container;
-use iterator::IteratorUtil;
+use iterator::Iterator;
+use option::{Some, None};
 use rt::io::Writer;
 use str::OwnedStr;
 use to_bytes::IterBytes;
@@ -369,7 +370,7 @@ impl Streaming for SipState {
     fn result_str(&mut self) -> ~str {
         let r = self.result_bytes();
         let mut s = ~"";
-        for r.iter().advance |b| {
+        foreach b in r.iter() {
             s.push_str(uint::to_str_radix(*b as uint, 16u));
         }
         s
@@ -471,7 +472,7 @@ mod tests {
 
         fn to_hex_str(r: &[u8, ..8]) -> ~str {
             let mut s = ~"";
-            for r.iter().advance |b| {
+            foreach b in r.iter() {
                 s.push_str(uint::to_str_radix(*b as uint, 16u));
             }
             s
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index e43293f3212..b162869201d 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -177,7 +177,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
 
         self.size = 0;
         // consume_rev_iter is more efficient
-        for old_buckets.consume_rev_iter().advance |bucket| {
+        foreach bucket in old_buckets.consume_rev_iter() {
             self.insert_opt_bucket(bucket);
         }
     }
@@ -518,7 +518,7 @@ impl<K:Hash + Eq,V:Eq> Eq for HashMap<K, V> {
 impl<K:Hash + Eq + Clone,V:Clone> Clone for HashMap<K,V> {
     fn clone(&self) -> HashMap<K,V> {
         let mut new_map = HashMap::with_capacity(self.len());
-        for self.iter().advance |(key, value)| {
+        foreach (key, value) in self.iter() {
             new_map.insert((*key).clone(), (*value).clone());
         }
         new_map
@@ -555,7 +555,7 @@ pub struct HashSetConsumeIterator<K> {
 impl<'self, K, V> Iterator<(&'self K, &'self V)> for HashMapIterator<'self, K, V> {
     #[inline]
     fn next(&mut self) -> Option<(&'self K, &'self V)> {
-        for self.iter.advance |elt| {
+        foreach elt in self.iter {
             match elt {
                 &Some(ref bucket) => return Some((&bucket.key, &bucket.value)),
                 &None => {},
@@ -568,7 +568,7 @@ impl<'self, K, V> Iterator<(&'self K, &'self V)> for HashMapIterator<'self, K, V
 impl<'self, K, V> Iterator<(&'self K, &'self mut V)> for HashMapMutIterator<'self, K, V> {
     #[inline]
     fn next(&mut self) -> Option<(&'self K, &'self mut V)> {
-        for self.iter.advance |elt| {
+        foreach elt in self.iter {
             match elt {
                 &Some(ref mut bucket) => return Some((&bucket.key, &mut bucket.value)),
                 &None => {},
@@ -581,7 +581,7 @@ impl<'self, K, V> Iterator<(&'self K, &'self mut V)> for HashMapMutIterator<'sel
 impl<K, V> Iterator<(K, V)> for HashMapConsumeIterator<K, V> {
     #[inline]
     fn next(&mut self) -> Option<(K, V)> {
-        for self.iter.advance |elt| {
+        foreach elt in self.iter {
             match elt {
                 Some(Bucket {key, value, _}) => return Some((key, value)),
                 None => {},
@@ -594,7 +594,7 @@ impl<K, V> Iterator<(K, V)> for HashMapConsumeIterator<K, V> {
 impl<'self, K> Iterator<&'self K> for HashSetIterator<'self, K> {
     #[inline]
     fn next(&mut self) -> Option<&'self K> {
-        for self.iter.advance |elt| {
+        foreach elt in self.iter {
             match elt {
                 &Some(ref bucket) => return Some(&bucket.key),
                 &None => {},
@@ -607,7 +607,7 @@ impl<'self, K> Iterator<&'self K> for HashSetIterator<'self, K> {
 impl<K> Iterator<K> for HashSetConsumeIterator<K> {
     #[inline]
     fn next(&mut self) -> Option<K> {
-        for self.iter.advance |elt| {
+        foreach elt in self.iter {
             match elt {
                 Some(bucket) => return Some(bucket.key),
                 None => {},
@@ -628,7 +628,7 @@ impl<K: Eq + Hash, V, T: Iterator<(K, V)>> FromIterator<(K, V), T> for HashMap<K
 
 impl<K: Eq + Hash, V, T: Iterator<(K, V)>> Extendable<(K, V), T> for HashMap<K, V> {
     fn extend(&mut self, iter: &mut T) {
-        for iter.advance |(k, v)| {
+        foreach (k, v) in *iter {
             self.insert(k, v);
         }
     }
@@ -785,7 +785,7 @@ impl<K: Eq + Hash, T: Iterator<K>> FromIterator<K, T> for HashSet<K> {
 
 impl<K: Eq + Hash, T: Iterator<K>> Extendable<K, T> for HashSet<K> {
     fn extend(&mut self, iter: &mut T) {
-        for iter.advance |k| {
+        foreach k in *iter {
             self.insert(k);
         }
     }
@@ -959,7 +959,7 @@ mod test_map {
             assert!(m.insert(i, i*2));
         }
         let mut observed = 0;
-        for m.iter().advance |(k, v)| {
+        foreach (k, v) in m.iter() {
             assert_eq!(*v, *k * 2);
             observed |= (1 << *k);
         }
@@ -1036,7 +1036,7 @@ mod test_map {
 
         let map: HashMap<int, int> = xs.iter().transform(|&x| x).collect();
 
-        for xs.iter().advance |&(k, v)| {
+        foreach &(k, v) in xs.iter() {
             assert_eq!(map.find(&k), Some(&v));
         }
     }
@@ -1045,6 +1045,7 @@ mod test_map {
 #[cfg(test)]
 mod test_set {
     use super::*;
+    use prelude::*;
     use container::Container;
     use vec::ImmutableEqVector;
     use uint;
@@ -1107,7 +1108,7 @@ mod test_set {
             assert!(a.insert(i));
         }
         let mut observed = 0;
-        for a.iter().advance |k| {
+        foreach k in a.iter() {
             observed |= (1 << *k);
         }
         assert_eq!(observed, 0xFFFF_FFFF);
@@ -1136,7 +1137,7 @@ mod test_set {
 
         let mut i = 0;
         let expected = [3, 5, 11, 77];
-        for a.intersection_iter(&b).advance |x| {
+        foreach x in a.intersection_iter(&b) {
             assert!(expected.contains(x));
             i += 1
         }
@@ -1159,7 +1160,7 @@ mod test_set {
 
         let mut i = 0;
         let expected = [1, 5, 11];
-        for a.difference_iter(&b).advance |x| {
+        foreach x in a.difference_iter(&b) {
             assert!(expected.contains(x));
             i += 1
         }
@@ -1185,7 +1186,7 @@ mod test_set {
 
         let mut i = 0;
         let expected = [-2, 1, 5, 11, 14, 22];
-        for a.symmetric_difference_iter(&b).advance |x| {
+        foreach x in a.symmetric_difference_iter(&b) {
             assert!(expected.contains(x));
             i += 1
         }
@@ -1215,7 +1216,7 @@ mod test_set {
 
         let mut i = 0;
         let expected = [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24];
-        for a.union_iter(&b).advance |x| {
+        foreach x in a.union_iter(&b) {
             assert!(expected.contains(x));
             i += 1
         }
@@ -1228,7 +1229,7 @@ mod test_set {
 
         let set: HashSet<int> = xs.iter().transform(|&x| x).collect();
 
-        for xs.iter().advance |x: &int| {
+        foreach x in xs.iter() {
             assert!(set.contains(x));
         }
     }
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 1a92e5e07c7..cef183d0429 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -50,12 +50,13 @@ use cast;
 use clone::Clone;
 use container::Container;
 use int;
-use iterator::IteratorUtil;
+use iterator::Iterator;
 use libc::consts::os::posix88::*;
 use libc::{c_int, c_long, c_void, size_t, ssize_t};
 use libc;
 use num;
 use ops::Drop;
+use option::{Some, None};
 use os;
 use path::Path;
 use ptr;
@@ -1279,7 +1280,7 @@ pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
     fn wb() -> c_int { O_WRONLY as c_int }
 
     let mut fflags: c_int = wb();
-    for flags.iter().advance |f| {
+    foreach f in flags.iter() {
         match *f {
           Append => fflags |= O_APPEND as c_int,
           Create => fflags |= O_CREAT as c_int,
@@ -1841,12 +1842,12 @@ pub mod fsync {
 
 #[cfg(test)]
 mod tests {
+    use prelude::*;
     use i32;
     use io::{BytesWriter, SeekCur, SeekEnd, SeekSet};
     use io;
     use path::Path;
     use result::{Ok, Err};
-    use result;
     use u64;
     use vec;
 
@@ -1938,7 +1939,7 @@ mod tests {
                 if len <= ivals.len() {
                     assert_eq!(res.len(), len);
                 }
-                for ivals.iter().zip(res.iter()).advance |(iv, c)| {
+                foreach (iv, c) in ivals.iter().zip(res.iter()) {
                     assert!(*iv == *c as int)
                 }
             }
@@ -2052,7 +2053,7 @@ mod tests {
         // write the ints to the file
         {
             let file = io::file_writer(&path, [io::Create]).unwrap();
-            for uints.iter().advance |i| {
+            foreach i in uints.iter() {
                 file.write_le_u64(*i);
             }
         }
@@ -2060,7 +2061,7 @@ mod tests {
         // then read them back and check that they are the same
         {
             let file = io::file_reader(&path).unwrap();
-            for uints.iter().advance |i| {
+            foreach i in uints.iter() {
                 assert_eq!(file.read_le_u64(), *i);
             }
         }
@@ -2074,7 +2075,7 @@ mod tests {
         // write the ints to the file
         {
             let file = io::file_writer(&path, [io::Create]).unwrap();
-            for uints.iter().advance |i| {
+            foreach i in uints.iter() {
                 file.write_be_u64(*i);
             }
         }
@@ -2082,7 +2083,7 @@ mod tests {
         // then read them back and check that they are the same
         {
             let file = io::file_reader(&path).unwrap();
-            for uints.iter().advance |i| {
+            foreach i in uints.iter() {
                 assert_eq!(file.read_be_u64(), *i);
             }
         }
@@ -2096,7 +2097,7 @@ mod tests {
         // write the ints to the file
         {
             let file = io::file_writer(&path, [io::Create]).unwrap();
-            for ints.iter().advance |i| {
+            foreach i in ints.iter() {
                 file.write_be_i32(*i);
             }
         }
@@ -2104,7 +2105,7 @@ mod tests {
         // then read them back and check that they are the same
         {
             let file = io::file_reader(&path).unwrap();
-            for ints.iter().advance |i| {
+            foreach i in ints.iter() {
                 // this tests that the sign extension is working
                 // (comparing the values as i32 would not test this)
                 assert_eq!(file.read_be_int_n(4), *i as i64);
diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index 9fe865333a2..84923876cbf 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -295,7 +295,7 @@ pub trait IteratorUtil<A> {
     /// let mut it = xs.iter().flat_map_(|&x| Counter::new(0u, 1).take_(x));
     /// // Check that `it` has the same elements as `ys`
     /// let mut i = 0;
-    /// for it.advance |x: uint| {
+    /// foreach x: uint in it {
     ///     assert_eq!(x, ys[i]);
     ///     i += 1;
     /// }
@@ -330,7 +330,7 @@ pub trait IteratorUtil<A> {
     /// ~~~ {.rust}
     /// use std::iterator::Counter;
     ///
-    /// for Counter::new(0, 10).advance |i| {
+    /// foreach i in Counter::new(0, 10) {
     ///     printfln!("%d", i);
     /// }
     /// ~~~
@@ -577,7 +577,7 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
     #[inline]
     fn last_(&mut self) -> Option<A> {
         let mut last = None;
-        for self.advance |x| { last = Some(x); }
+        foreach x in *self { last = Some(x); }
         last
     }
 
@@ -600,20 +600,20 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
 
     #[inline]
     fn all(&mut self, f: &fn(A) -> bool) -> bool {
-        for self.advance |x| { if !f(x) { return false; } }
+        foreach x in *self { if !f(x) { return false; } }
         true
     }
 
     #[inline]
     fn any(&mut self, f: &fn(A) -> bool) -> bool {
-        for self.advance |x| { if f(x) { return true; } }
+        foreach x in *self { if f(x) { return true; } }
         false
     }
 
     /// Return the first element satisfying the specified predicate
     #[inline]
     fn find_(&mut self, predicate: &fn(&A) -> bool) -> Option<A> {
-        for self.advance |x| {
+        foreach x in *self {
             if predicate(&x) { return Some(x) }
         }
         None
@@ -623,7 +623,7 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
     #[inline]
     fn position(&mut self, predicate: &fn(A) -> bool) -> Option<uint> {
         let mut i = 0;
-        for self.advance |x| {
+        foreach x in *self {
             if predicate(x) {
                 return Some(i);
             }
@@ -635,7 +635,7 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
     #[inline]
     fn count(&mut self, predicate: &fn(A) -> bool) -> uint {
         let mut i = 0;
-        for self.advance |x| {
+        foreach x in *self {
             if predicate(x) { i += 1 }
         }
         i
@@ -1024,7 +1024,7 @@ pub struct Filter<'self, A, T> {
 impl<'self, A, T: Iterator<A>> Iterator<A> for Filter<'self, A, T> {
     #[inline]
     fn next(&mut self) -> Option<A> {
-        for self.iter.advance |x| {
+        foreach x in self.iter {
             if (self.predicate)(&x) {
                 return Some(x);
             } else {
@@ -1068,7 +1068,7 @@ pub struct FilterMap<'self, A, B, T> {
 impl<'self, A, B, T: Iterator<A>> Iterator<B> for FilterMap<'self, A, B, T> {
     #[inline]
     fn next(&mut self) -> Option<B> {
-        for self.iter.advance |x| {
+        foreach x in self.iter {
             match (self.f)(x) {
                 Some(y) => return Some(y),
                 None => ()
@@ -1372,8 +1372,8 @@ impl<'self, A, T: Iterator<A>, B, U: Iterator<B>> Iterator<B> for
     #[inline]
     fn next(&mut self) -> Option<B> {
         loop {
-            for self.frontiter.mut_iter().advance |inner| {
-                for inner.advance |x| {
+            foreach inner in self.frontiter.mut_iter() {
+                foreach x in *inner {
                     return Some(x)
                 }
             }
@@ -1402,7 +1402,7 @@ impl<'self,
     #[inline]
     fn next_back(&mut self) -> Option<B> {
         loop {
-            for self.backiter.mut_iter().advance |inner| {
+            foreach inner in self.backiter.mut_iter() {
                 match inner.next_back() {
                     None => (),
                     y => return y
@@ -1549,7 +1549,7 @@ mod tests {
         let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
         let mut it = xs.iter().chain_(ys.iter());
         let mut i = 0;
-        for it.advance |&x| {
+        foreach &x in it {
             assert_eq!(x, expected[i]);
             i += 1;
         }
@@ -1558,7 +1558,7 @@ mod tests {
         let ys = Counter::new(30u, 10).take_(4);
         let mut it = xs.iter().transform(|&x| x).chain_(ys);
         let mut i = 0;
-        for it.advance |x| {
+        foreach x in it {
             assert_eq!(x, expected[i]);
             i += 1;
         }
@@ -1576,7 +1576,7 @@ mod tests {
     fn test_iterator_enumerate() {
         let xs = [0u, 1, 2, 3, 4, 5];
         let mut it = xs.iter().enumerate();
-        for it.advance |(i, &x)| {
+        foreach (i, &x) in it {
             assert_eq!(i, x);
         }
     }
@@ -1587,7 +1587,7 @@ mod tests {
         let ys = [0u, 1, 2, 3, 5, 13];
         let mut it = xs.iter().take_while(|&x| *x < 15u);
         let mut i = 0;
-        for it.advance |&x| {
+        foreach &x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1600,7 +1600,7 @@ mod tests {
         let ys = [15, 16, 17, 19];
         let mut it = xs.iter().skip_while(|&x| *x < 15u);
         let mut i = 0;
-        for it.advance |&x| {
+        foreach &x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1613,7 +1613,7 @@ mod tests {
         let ys = [13, 15, 16, 17, 19, 20, 30];
         let mut it = xs.iter().skip(5);
         let mut i = 0;
-        for it.advance |&x| {
+        foreach &x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1626,7 +1626,7 @@ mod tests {
         let ys = [0u, 1, 2, 3, 5];
         let mut it = xs.iter().take_(5);
         let mut i = 0;
-        for it.advance |&x| {
+        foreach &x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1645,7 +1645,7 @@ mod tests {
 
         let mut it = xs.iter().scan(0, add);
         let mut i = 0;
-        for it.advance |x| {
+        foreach x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1658,7 +1658,7 @@ mod tests {
         let ys = [0u, 1, 2, 3, 4, 5, 6, 7, 8];
         let mut it = xs.iter().flat_map_(|&x| Counter::new(x, 1).take_(3));
         let mut i = 0;
-        for it.advance |x: uint| {
+        foreach x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1693,7 +1693,7 @@ mod tests {
 
         let mut it = Unfoldr::new(0, count);
         let mut i = 0;
-        for it.advance |counted| {
+        foreach counted in it {
             assert_eq!(counted, i);
             i += 1;
         }
@@ -1705,7 +1705,7 @@ mod tests {
         let cycle_len = 3;
         let it = Counter::new(0u,1).take_(cycle_len).cycle();
         assert_eq!(it.size_hint(), (uint::max_value, None));
-        for it.take_(100).enumerate().advance |(i, x)| {
+        foreach (i, x) in it.take_(100).enumerate() {
             assert_eq!(i % cycle_len, x);
         }
 
@@ -1931,7 +1931,7 @@ mod tests {
         let mut b = a.clone();
         assert_eq!(len, b.indexable());
         let mut n = 0;
-        for a.enumerate().advance |(i, elt)| {
+        foreach (i, elt) in a.enumerate() {
             assert_eq!(Some(elt), b.idx(i));
             n += 1;
         }
@@ -2021,7 +2021,7 @@ mod tests {
         // test .transform and .peek_ that don't implement Clone
         let it = xs.iter().peek_(|_| {});
         assert_eq!(xs.len(), it.indexable());
-        for xs.iter().enumerate().advance |(i, elt)| {
+        foreach (i, elt) in xs.iter().enumerate() {
             assert_eq!(Some(elt), it.idx(i));
         }
 
@@ -2034,7 +2034,7 @@ mod tests {
         // test .transform and .peek_ that don't implement Clone
         let it = xs.iter().transform(|x| *x);
         assert_eq!(xs.len(), it.indexable());
-        for xs.iter().enumerate().advance |(i, elt)| {
+        foreach (i, elt) in xs.iter().enumerate() {
             assert_eq!(Some(*elt), it.idx(i));
         }
     }
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index 6e4880550eb..7eca47743d6 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -50,8 +50,6 @@ use iterator::Iterator;
 use str::StrSlice;
 use clone::DeepClone;
 
-#[cfg(test)] use iterator::IteratorUtil;
-
 /// The option type
 #[deriving(Clone, DeepClone, Eq)]
 pub enum Option<T> {
@@ -499,7 +497,7 @@ mod tests {
         let x = Some(());
         let mut y = Some(5);
         let mut y2 = 0;
-        for x.iter().advance |_x| {
+        foreach _x in x.iter() {
             y2 = y.take_unwrap();
         }
         assert_eq!(y2, 5);
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 2802fc30c33..3afd946ee26 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -220,7 +220,7 @@ pub fn env() -> ~[(~str,~str)] {
 
         fn env_convert(input: ~[~str]) -> ~[(~str, ~str)] {
             let mut pairs = ~[];
-            for input.iter().advance |p| {
+            foreach p in input.iter() {
                 let vs: ~[&str] = p.splitn_iter('=', 1).collect();
                 debug!("splitting: len: %u",
                     vs.len());
@@ -1419,7 +1419,7 @@ impl MemoryMap {
         let mut offset: off_t = 0;
         let len = round_up(min_len, page_size()) as size_t;
 
-        for options.iter().advance |&o| {
+        foreach &o in options.iter() {
             match o {
                 MapReadable => { prot |= libc::PROT_READ; },
                 MapWritable => { prot |= libc::PROT_WRITE; },
@@ -1492,7 +1492,7 @@ impl MemoryMap {
         let mut offset: uint = 0;
         let len = round_up(min_len, page_size()) as SIZE_T;
 
-        for options.iter().advance |&o| {
+        foreach &o in options.iter() {
             match o {
                 MapReadable => { readable = true; },
                 MapWritable => { writable = true; },
@@ -1788,7 +1788,7 @@ mod tests {
     fn test_env_getenv() {
         let e = env();
         assert!(e.len() > 0u);
-        for e.iter().advance |p| {
+        foreach p in e.iter() {
             let (n, v) = (*p).clone();
             debug!(n.clone());
             let v2 = getenv(n);
@@ -1832,7 +1832,7 @@ mod tests {
         setenv("HOME", "");
         assert!(os::homedir().is_none());
 
-        for oldhome.iter().advance |s| { setenv("HOME", *s) }
+        foreach s in oldhome.iter() { setenv("HOME", *s) }
     }
 
     #[test]
@@ -1880,7 +1880,7 @@ mod tests {
         // Just assuming that we've got some contents in the current directory
         assert!(dirs.len() > 0u);
 
-        for dirs.iter().advance |dir| {
+        foreach dir in dirs.iter() {
             debug!((*dir).clone());
         }
     }
diff --git a/src/libstd/path.rs b/src/libstd/path.rs
index af6bfc16e54..989a5cbd35b 100644
--- a/src/libstd/path.rs
+++ b/src/libstd/path.rs
@@ -19,7 +19,7 @@ Cross-platform file path handling
 use clone::Clone;
 use container::Container;
 use cmp::Eq;
-use iterator::IteratorUtil;
+use iterator::{Iterator, IteratorUtil};
 use libc;
 use option::{None, Option, Some};
 use str::{OwnedStr, Str, StrSlice, StrVector};
@@ -647,8 +647,8 @@ impl GenericPath for PosixPath {
 
     fn push_many<S: Str>(&self, cs: &[S]) -> PosixPath {
         let mut v = self.components.clone();
-        for cs.iter().advance |e| {
-            for e.as_slice().split_iter(posix::is_sep).advance |s| {
+        foreach e in cs.iter() {
+            foreach s in e.as_slice().split_iter(posix::is_sep) {
                 if !s.is_empty() {
                     v.push(s.to_owned())
                 }
@@ -662,7 +662,7 @@ impl GenericPath for PosixPath {
 
     fn push(&self, s: &str) -> PosixPath {
         let mut v = self.components.clone();
-        for s.split_iter(posix::is_sep).advance |s| {
+        foreach s in s.split_iter(posix::is_sep) {
             if !s.is_empty() {
                 v.push(s.to_owned())
             }
@@ -922,8 +922,8 @@ impl GenericPath for WindowsPath {
 
     fn push_many<S: Str>(&self, cs: &[S]) -> WindowsPath {
         let mut v = self.components.clone();
-        for cs.iter().advance |e| {
-            for e.as_slice().split_iter(windows::is_sep).advance |s| {
+        foreach e in cs.iter() {
+            foreach s in e.as_slice().split_iter(windows::is_sep) {
                 if !s.is_empty() {
                     v.push(s.to_owned())
                 }
@@ -940,7 +940,7 @@ impl GenericPath for WindowsPath {
 
     fn push(&self, s: &str) -> WindowsPath {
         let mut v = self.components.clone();
-        for s.split_iter(windows::is_sep).advance |s| {
+        foreach s in s.split_iter(windows::is_sep) {
             if !s.is_empty() {
                 v.push(s.to_owned())
             }
@@ -989,7 +989,7 @@ impl GenericPath for WindowsPath {
 
 pub fn normalize(components: &[~str]) -> ~[~str] {
     let mut cs = ~[];
-    for components.iter().advance |c| {
+    foreach c in components.iter() {
         if *c == ~"." && components.len() > 1 { loop; }
         if *c == ~"" { loop; }
         if *c == ~".." && cs.len() != 0 {
diff --git a/src/libstd/pipes.rs b/src/libstd/pipes.rs
index 07b435f1b64..a2ad2eb5e76 100644
--- a/src/libstd/pipes.rs
+++ b/src/libstd/pipes.rs
@@ -87,7 +87,7 @@ bounded and unbounded protocols allows for less code duplication.
 use container::Container;
 use cast::{forget, transmute, transmute_copy, transmute_mut};
 use either::{Either, Left, Right};
-use iterator::IteratorUtil;
+use iterator::{Iterator, IteratorUtil};
 use kinds::Send;
 use libc;
 use ops::Drop;
@@ -600,7 +600,7 @@ pub fn wait_many<T: Selectable>(pkts: &mut [T]) -> uint {
 
     let mut data_avail = false;
     let mut ready_packet = pkts.len();
-    for pkts.mut_iter().enumerate().advance |(i, p)| {
+    foreach (i, p) in pkts.mut_iter().enumerate() {
         unsafe {
             let p = &mut *p.header();
             let old = p.mark_blocked(this);
@@ -622,7 +622,7 @@ pub fn wait_many<T: Selectable>(pkts: &mut [T]) -> uint {
         let event = wait_event(this) as *PacketHeader;
 
         let mut pos = None;
-        for pkts.mut_iter().enumerate().advance |(i, p)| {
+        foreach (i, p) in pkts.mut_iter().enumerate() {
             if p.header() == event {
                 pos = Some(i);
                 break;
@@ -640,7 +640,7 @@ pub fn wait_many<T: Selectable>(pkts: &mut [T]) -> uint {
 
     debug!("%?", &mut pkts[ready_packet]);
 
-    for pkts.mut_iter().advance |p| {
+    foreach p in pkts.mut_iter() {
         unsafe {
             (*p.header()).unblock()
         }
@@ -851,7 +851,7 @@ pub fn select<T:Send,Tb:Send>(mut endpoints: ~[RecvPacketBuffered<T, Tb>])
                                     Option<T>,
                                     ~[RecvPacketBuffered<T, Tb>]) {
     let mut endpoint_headers = ~[];
-    for endpoints.mut_iter().advance |endpoint| {
+    foreach endpoint in endpoints.mut_iter() {
         endpoint_headers.push(endpoint.header());
     }
 
diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 6d0613b2e67..aed68f47fdf 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -48,7 +48,6 @@ use clone::Clone;
 use cmp;
 use container::Container;
 use int;
-use iterator::IteratorUtil;
 use local_data;
 use num;
 use prelude::*;
@@ -495,7 +494,7 @@ impl<R: Rng> RngUtil for R {
     fn gen_char_from(&mut self, chars: &str) -> char {
         assert!(!chars.is_empty());
         let mut cs = ~[];
-        for chars.iter().advance |c| { cs.push(c) }
+        foreach c in chars.iter() { cs.push(c) }
         self.choose(cs)
     }
 
@@ -559,7 +558,7 @@ impl<R: Rng> RngUtil for R {
     fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
                                        -> Option<T> {
         let mut total = 0u;
-        for v.iter().advance |item| {
+        foreach item in v.iter() {
             total += item.weight;
         }
         if total == 0u {
@@ -567,7 +566,7 @@ impl<R: Rng> RngUtil for R {
         }
         let chosen = self.gen_uint_range(0u, total);
         let mut so_far = 0u;
-        for v.iter().advance |item| {
+        foreach item in v.iter() {
             so_far += item.weight;
             if so_far > chosen {
                 return Some(item.item.clone());
@@ -582,7 +581,7 @@ impl<R: Rng> RngUtil for R {
      */
     fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T] {
         let mut r = ~[];
-        for v.iter().advance |item| {
+        foreach item in v.iter() {
             for uint::range(0u, item.weight) |_i| {
                 r.push(item.item.clone());
             }
@@ -763,7 +762,7 @@ impl IsaacRng {
         );
 
         let r = [(0, MIDPOINT), (MIDPOINT, 0)];
-        for r.iter().advance |&(mr_offset, m2_offset)| {
+        foreach &(mr_offset, m2_offset) in r.iter() {
             for uint::range_step(0, MIDPOINT, 4) |base| {
                 rngstep!(0, 13);
                 rngstep!(1, -6);
@@ -1142,4 +1141,4 @@ mod bench {
             rng.shuffle_mut(x);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
index 60bd30bbee8..edab639dfbe 100644
--- a/src/libstd/repr.rs
+++ b/src/libstd/repr.rs
@@ -20,8 +20,9 @@ use cast::transmute;
 use char;
 use container::Container;
 use io::{Writer, WriterUtil};
-use iterator::IteratorUtil;
+use iterator::Iterator;
 use libc::c_void;
+use option::{Some, None};
 use ptr;
 use reflect;
 use reflect::{MovePtr, align};
@@ -175,7 +176,7 @@ impl ReprVisitor {
 
     pub fn write_escaped_slice(&self, slice: &str) {
         self.writer.write_char('"');
-        for slice.iter().advance |ch| {
+        foreach ch in slice.iter() {
             self.writer.write_escaped_char(ch);
         }
         self.writer.write_char('"');
diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index c045c191488..89803d022f8 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -15,7 +15,7 @@
 use clone::Clone;
 use cmp::Eq;
 use either;
-use iterator::IteratorUtil;
+use iterator::Iterator;
 use option::{None, Option, Some};
 use vec;
 use vec::{OwnedVector, ImmutableVector};
@@ -263,7 +263,7 @@ impl<T, E: Clone> Result<T, E> {
 pub fn map_vec<T,U,V>(ts: &[T], op: &fn(&T) -> Result<V,U>)
                       -> Result<~[V],U> {
     let mut vs: ~[V] = vec::with_capacity(ts.len());
-    for ts.iter().advance |t| {
+    foreach t in ts.iter() {
         match op(t) {
           Ok(v) => vs.push(v),
           Err(u) => return Err(u)
diff --git a/src/libstd/rt/borrowck.rs b/src/libstd/rt/borrowck.rs
index 2d489e4dbc3..bb66a901234 100644
--- a/src/libstd/rt/borrowck.rs
+++ b/src/libstd/rt/borrowck.rs
@@ -83,7 +83,7 @@ unsafe fn fail_borrowed(box: *mut raw::Box<()>, file: *c_char, line: size_t) {
         Some(borrow_list) => { // recording borrows
             let mut msg = ~"borrowed";
             let mut sep = " at ";
-            for borrow_list.rev_iter().advance |entry| {
+            foreach entry in borrow_list.rev_iter() {
                 if entry.box == box {
                     msg.push_str(sep);
                     let filename = str::raw::from_c_str(entry.file);
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index dc8669b9264..44418001f14 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -64,7 +64,7 @@ use cell::Cell;
 use clone::Clone;
 use container::Container;
 use iter::Times;
-use iterator::IteratorUtil;
+use iterator::{Iterator, IteratorUtil};
 use option::{Some, None};
 use ptr::RawPtr;
 use rt::sched::{Scheduler, Shutdown};
@@ -291,7 +291,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
     let on_exit: ~fn(bool) = |exit_success| {
 
         let mut handles = handles.take();
-        for handles.mut_iter().advance |handle| {
+        foreach handle in handles.mut_iter() {
             handle.send(Shutdown);
         }
 
@@ -346,7 +346,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
     }
 
     // Wait for schedulers
-    for threads.consume_iter().advance() |thread| {
+    foreach thread in threads.consume_iter() {
         thread.join();
     }
 
diff --git a/src/libstd/rt/select.rs b/src/libstd/rt/select.rs
index bc9e265c8d9..6296186aa49 100644
--- a/src/libstd/rt/select.rs
+++ b/src/libstd/rt/select.rs
@@ -37,7 +37,7 @@ pub fn select<A: Select>(ports: &mut [A]) -> uint {
         fail!("can't select on an empty list");
     }
 
-    for ports.mut_iter().enumerate().advance |(index, port)| {
+    foreach (index, port) in ports.mut_iter().enumerate() {
         if port.optimistic_check() {
             return index;
         }
@@ -66,7 +66,7 @@ pub fn select<A: Select>(ports: &mut [A]) -> uint {
     // Task resumes. Now unblock ourselves from all the ports we blocked on.
     // If the success index wasn't reset, 'take' will just take all of them.
     // Iterate in reverse so the 'earliest' index that's ready gets returned.
-    for ports.mut_slice(0, ready_index).mut_rev_iter().enumerate().advance |(index, port)| {
+    foreach (index, port) in ports.mut_slice(0, ready_index).mut_rev_iter().enumerate() {
         if port.unblock_from() {
             ready_index = index;
         }
@@ -127,7 +127,7 @@ mod test {
         let (ports, chans) = unzip(from_fn(num_ports, |_| oneshot::<()>()));
         let mut dead_chans = ~[];
         let mut ports = ports;
-        for chans.consume_iter().enumerate().advance |(i, chan)| {
+        foreach (i, chan) in chans.consume_iter().enumerate() {
             if send_on_chans.contains(&i) {
                 chan.send(());
             } else {
@@ -144,7 +144,7 @@ mod test {
         let (ports, chans) = unzip(from_fn(num_ports, |_| stream::<()>()));
         let mut dead_chans = ~[];
         let mut ports = ports;
-        for chans.consume_iter().enumerate().advance |(i, chan)| {
+        foreach (i, chan) in chans.consume_iter().enumerate() {
             if send_on_chans.contains(&i) {
                 chan.send(());
             } else {
@@ -191,7 +191,7 @@ mod test {
             let mut ports = ports;
             let mut port = Some(port);
             let order = [5u,0,4,3,2,6,9,8,7,1];
-            for order.iter().advance |&index| {
+            foreach &index in order.iter() {
                 // put the port in the vector at any index
                 util::swap(port.get_mut_ref(), &mut ports[index]);
                 assert!(select(ports) == index);
diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs
index 260903cbcbf..ec1094ed4f2 100644
--- a/src/libstd/rt/test.rs
+++ b/src/libstd/rt/test.rs
@@ -14,7 +14,7 @@ use option::{Some, None};
 use cell::Cell;
 use clone::Clone;
 use container::Container;
-use iterator::IteratorUtil;
+use iterator::Iterator;
 use vec::{OwnedVector, MutableVector};
 use super::io::net::ip::{IpAddr, Ipv4, Ipv6};
 use rt::sched::Scheduler;
@@ -100,7 +100,7 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
         let on_exit: ~fn(bool) = |exit_status| {
             let mut handles = handles.take();
             // Tell schedulers to exit
-            for handles.mut_iter().advance |handle| {
+            foreach handle in handles.mut_iter() {
                 handle.send(Shutdown);
             }
 
@@ -125,7 +125,7 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
         }
 
         // Wait for schedulers
-        for threads.consume_iter().advance() |thread| {
+        foreach thread in threads.consume_iter() {
             thread.join();
         }
     }
@@ -380,7 +380,7 @@ fn base_port() -> uint {
 
     let mut final_base = base;
 
-    for bases.iter().advance |&(dir, base)| {
+    foreach &(dir, base) in bases.iter() {
         if path.contains(dir) {
             final_base = base;
             break;
diff --git a/src/libstd/rt/uv/net.rs b/src/libstd/rt/uv/net.rs
index 8ea4a197269..773adb3848a 100644
--- a/src/libstd/rt/uv/net.rs
+++ b/src/libstd/rt/uv/net.rs
@@ -606,6 +606,7 @@ mod test {
     use rt::test::*;
     use rt::uv::{Loop, AllocCallback};
     use rt::uv::{vec_from_uv_buf, vec_to_uv_buf, slice_to_uv_buf};
+    use prelude::*;
 
     #[test]
     fn connect_close_ip4() {
@@ -700,7 +701,7 @@ mod test {
                     if status.is_none() {
                         rtdebug!("got %d bytes", nread);
                         let buf = buf.unwrap();
-                        for buf.slice(0, nread as uint).iter().advance() |byte| {
+                        foreach byte in buf.slice(0, nread as uint).iter() {
                             assert!(*byte == count as u8);
                             rtdebug!("%u", *byte as uint);
                             count += 1;
@@ -776,7 +777,7 @@ mod test {
                         rtdebug!("got %d bytes", nread);
                         let buf = buf.unwrap();
                         let r = buf.slice(0, nread as uint);
-                        for r.iter().advance |byte| {
+                        foreach byte in r.iter() {
                             assert!(*byte == count as u8);
                             rtdebug!("%u", *byte as uint);
                             count += 1;
@@ -847,7 +848,7 @@ mod test {
                 rtdebug!("got %d bytes", nread);
 
                 let buf = buf.unwrap();
-                for buf.slice(0, nread as uint).iter().advance() |&byte| {
+                foreach &byte in buf.slice(0, nread as uint).iter() {
                     assert!(byte == count as u8);
                     rtdebug!("%u", byte as uint);
                     count += 1;
@@ -907,7 +908,7 @@ mod test {
                 rtdebug!("got %d bytes", nread);
 
                 let buf = buf.unwrap();
-                for buf.slice(0, nread as uint).iter().advance() |&byte| {
+                foreach &byte in buf.slice(0, nread as uint).iter() {
                     assert!(byte == count as u8);
                     rtdebug!("%u", byte as uint);
                     count += 1;
diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index 122bc42c4cc..acdc97da58c 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -16,7 +16,6 @@ use cast;
 use clone::Clone;
 use comm::{stream, SharedChan, GenericChan, GenericPort};
 use io;
-use iterator::IteratorUtil;
 use libc::{pid_t, c_void, c_int};
 use libc;
 use option::{Some, None};
@@ -175,9 +174,9 @@ impl Process {
                                    in_fd, out_fd, err_fd);
 
         unsafe {
-            for in_pipe.iter().advance  |pipe| { libc::close(pipe.input); }
-            for out_pipe.iter().advance |pipe| { libc::close(pipe.out); }
-            for err_pipe.iter().advance |pipe| { libc::close(pipe.out); }
+            foreach pipe in in_pipe.iter() { libc::close(pipe.input); }
+            foreach pipe in out_pipe.iter() { libc::close(pipe.out); }
+            foreach pipe in err_pipe.iter() { libc::close(pipe.out); }
         }
 
         Process {
@@ -322,7 +321,7 @@ impl Process {
      * If the child has already been finished then the exit code is returned.
      */
     pub fn finish(&mut self) -> int {
-        for self.exit_code.iter().advance |&code| {
+        foreach &code in self.exit_code.iter() {
             return code;
         }
         self.close_input();
@@ -521,7 +520,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
         CloseHandle(si.hStdOutput);
         CloseHandle(si.hStdError);
 
-        for create_err.iter().advance |msg| {
+        foreach msg in create_err.iter() {
             fail!("failure in CreateProcess: %s", *msg);
         }
 
@@ -580,7 +579,7 @@ pub fn make_command_line(prog: &str, args: &[~str]) -> ~str {
 
     let mut cmd = ~"";
     append_arg(&mut cmd, prog);
-    for args.iter().advance |arg| {
+    foreach arg in args.iter() {
         cmd.push_char(' ');
         append_arg(&mut cmd, *arg);
     }
@@ -697,7 +696,7 @@ fn with_argv<T>(prog: &str, args: &[~str],
                 cb: &fn(**libc::c_char) -> T) -> T {
     let mut argptrs = ~[prog.as_c_str(|b| b)];
     let mut tmps = ~[];
-    for args.iter().advance |arg| {
+    foreach arg in args.iter() {
         let t = @(*arg).clone();
         tmps.push(t);
         argptrs.push(t.as_c_str(|b| b));
@@ -715,7 +714,7 @@ fn with_envp<T>(env: Option<&[(~str, ~str)]>, cb: &fn(*c_void) -> T) -> T {
         let mut tmps = ~[];
         let mut ptrs = ~[];
 
-        for es.iter().advance |pair| {
+        foreach pair in es.iter() {
             // Use of match here is just to workaround limitations
             // in the stage0 irrefutable pattern impl.
             match pair {
@@ -744,7 +743,7 @@ fn with_envp<T>(env: Option<&[(~str, ~str)]>, cb: &fn(*mut c_void) -> T) -> T {
     match env {
       Some(es) => {
         let mut blk = ~[];
-        for es.iter().advance |pair| {
+        foreach pair in es.iter() {
             let kv = fmt!("%s=%s", pair.first(), pair.second());
             blk.push_all(kv.to_bytes_with_null());
         }
@@ -1300,7 +1299,7 @@ mod tests {
         let output = str::from_bytes(prog.finish_with_output().output);
 
         let r = os::env();
-        for r.iter().advance |&(ref k, ref v)| {
+        foreach &(ref k, ref v) in r.iter() {
             // don't check windows magical empty-named variables
             assert!(k.is_empty() || output.contains(fmt!("%s=%s", *k, *v)));
         }
@@ -1314,7 +1313,7 @@ mod tests {
         let output = str::from_bytes(prog.finish_with_output().output);
 
         let r = os::env();
-        for r.iter().advance |&(k, v)| {
+        foreach &(k, v) in r.iter() {
             // don't check android RANDOM variables
             if k != ~"RANDOM" {
                 assert!(output.contains(fmt!("%s=%s", k, v)) ||
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index b0ae719e00f..894351bcc53 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -149,7 +149,7 @@ pub fn from_char(ch: char) -> ~str {
 pub fn from_chars(chs: &[char]) -> ~str {
     let mut buf = ~"";
     buf.reserve(chs.len());
-    for chs.iter().advance |ch| {
+    foreach ch in chs.iter() {
         buf.push_char(*ch)
     }
     buf
@@ -178,7 +178,7 @@ impl<'self, S: Str> StrVector for &'self [S] {
         unsafe {
             do s.as_mut_buf |buf, _| {
                 let mut buf = buf;
-                for self.iter().advance |ss| {
+                foreach ss in self.iter() {
                     do ss.as_slice().as_imm_buf |ssbuf, sslen| {
                         let sslen = sslen - 1;
                         ptr::copy_memory(buf, ssbuf, sslen);
@@ -211,7 +211,7 @@ impl<'self, S: Str> StrVector for &'self [S] {
                 do sep.as_imm_buf |sepbuf, seplen| {
                     let seplen = seplen - 1;
                     let mut buf = cast::transmute_mut_unsafe(buf);
-                    for self.iter().advance |ss| {
+                    foreach ss in self.iter() {
                         do ss.as_slice().as_imm_buf |ssbuf, sslen| {
                             let sslen = sslen - 1;
                             if first {
@@ -486,7 +486,7 @@ impl<'self> Iterator<&'self str> for StrSplitIterator<'self> {
 pub fn replace(s: &str, from: &str, to: &str) -> ~str {
     let mut result = ~"";
     let mut last_end = 0;
-    for s.matches_index_iter(from).advance |(start, end)| {
+    foreach (start, end) in s.matches_index_iter(from) {
         result.push_str(unsafe{raw::slice_bytes(s, last_end, start)});
         result.push_str(to);
         last_end = end;
@@ -556,7 +556,7 @@ Section: Searching
 // Utility used by various searching functions
 fn match_at<'a,'b>(haystack: &'a str, needle: &'b str, at: uint) -> bool {
     let mut i = at;
-    for needle.byte_iter().advance |c| { if haystack[i] != c { return false; } i += 1u; }
+    foreach c in needle.byte_iter() { if haystack[i] != c { return false; } i += 1u; }
     return true;
 }
 
@@ -769,6 +769,7 @@ priv static MAX_UNICODE: uint = 1114112u;
 
 /// Unsafe operations
 pub mod raw {
+    use option::Some;
     use cast;
     use libc;
     use ptr;
@@ -886,7 +887,7 @@ pub mod raw {
     unsafe fn push_bytes(s: &mut ~str, bytes: &[u8]) {
         let new_len = s.len() + bytes.len();
         s.reserve_at_least(new_len);
-        for bytes.iter().advance |byte| { push_byte(&mut *s, *byte); }
+        foreach byte in bytes.iter() { push_byte(&mut *s, *byte); }
     }
 
     /// Removes the last byte from a string and returns it. (Not UTF-8 safe).
@@ -938,6 +939,7 @@ pub mod traits {
     use ops::Add;
     use cmp::{TotalOrd, Ordering, Less, Equal, Greater, Eq, Ord, Equiv, TotalEq};
     use super::{Str, eq_slice};
+    use option::{Some, None};
 
     impl<'self> Add<&'self str,~str> for &'self str {
         #[inline]
@@ -951,7 +953,7 @@ pub mod traits {
     impl<'self> TotalOrd for &'self str {
         #[inline]
         fn cmp(&self, other: & &'self str) -> Ordering {
-            for self.byte_iter().zip(other.byte_iter()).advance |(s_b, o_b)| {
+            foreach (s_b, o_b) in self.byte_iter().zip(other.byte_iter()) {
                 match s_b.cmp(&o_b) {
                     Greater => return Greater,
                     Less => return Less,
@@ -1453,7 +1455,7 @@ impl<'self> StrSlice<'self> for &'self str {
     fn escape_default(&self) -> ~str {
         let mut out: ~str = ~"";
         out.reserve_at_least(self.len());
-        for self.iter().advance |c| {
+        foreach c in self.iter() {
             do c.escape_default |c| {
                 out.push_char(c);
             }
@@ -1465,7 +1467,7 @@ impl<'self> StrSlice<'self> for &'self str {
     fn escape_unicode(&self) -> ~str {
         let mut out: ~str = ~"";
         out.reserve_at_least(self.len());
-        for self.iter().advance |c| {
+        foreach c in self.iter() {
             do c.escape_unicode |c| {
                 out.push_char(c);
             }
@@ -1567,7 +1569,7 @@ impl<'self> StrSlice<'self> for &'self str {
     pub fn replace(&self, from: &str, to: &str) -> ~str {
         let mut result = ~"";
         let mut last_end = 0;
-        for self.matches_index_iter(from).advance |(start, end)| {
+        foreach (start, end) in self.matches_index_iter(from) {
             result.push_str(unsafe{raw::slice_bytes(*self, last_end, start)});
             result.push_str(to);
             last_end = end;
@@ -1605,7 +1607,7 @@ impl<'self> StrSlice<'self> for &'self str {
     /// Converts to a vector of `u16` encoded as UTF-16.
     fn to_utf16(&self) -> ~[u16] {
         let mut u = ~[];
-        for self.iter().advance |ch| {
+        foreach ch in self.iter() {
             // Arithmetic with u32 literals is easier on the eyes than chars.
             let mut ch = ch as u32;
 
@@ -1758,12 +1760,12 @@ impl<'self> StrSlice<'self> for &'self str {
     /// or `None` if there is no match
     fn find<C: CharEq>(&self, search: C) -> Option<uint> {
         if search.only_ascii() {
-            for self.byte_iter().enumerate().advance |(i, b)| {
+            foreach (i, b) in self.byte_iter().enumerate() {
                 if search.matches(b as char) { return Some(i) }
             }
         } else {
             let mut index = 0;
-            for self.iter().advance |c| {
+            foreach c in self.iter() {
                 if search.matches(c) { return Some(index); }
                 index += c.len_utf8_bytes();
             }
@@ -1781,12 +1783,12 @@ impl<'self> StrSlice<'self> for &'self str {
     fn rfind<C: CharEq>(&self, search: C) -> Option<uint> {
         let mut index = self.len();
         if search.only_ascii() {
-            for self.byte_rev_iter().advance |b| {
+            foreach b in self.byte_rev_iter() {
                 index -= 1;
                 if search.matches(b as char) { return Some(index); }
             }
         } else {
-            for self.rev_iter().advance |c| {
+            foreach c in self.rev_iter() {
                 index -= c.len_utf8_bytes();
                 if search.matches(c) { return Some(index); }
             }
@@ -1855,7 +1857,7 @@ impl<'self> StrSlice<'self> for &'self str {
     /// Apply a function to each character.
     fn map_chars(&self, ff: &fn(char) -> char) -> ~str {
         let mut result = with_capacity(self.len());
-        for self.iter().advance |cc| {
+        foreach cc in self.iter() {
             result.push_char(ff(cc));
         }
         result
@@ -1871,12 +1873,12 @@ impl<'self> StrSlice<'self> for &'self str {
 
         let mut dcol = vec::from_fn(tlen + 1, |x| x);
 
-        for self.iter().enumerate().advance |(i, sc)| {
+        foreach (i, sc) in self.iter().enumerate() {
 
             let mut current = i;
             dcol[0] = current + 1;
 
-            for t.iter().enumerate().advance |(j, tc)| {
+            foreach (j, tc) in t.iter().enumerate() {
 
                 let next = dcol[j + 1];
 
@@ -1903,7 +1905,7 @@ impl<'self> StrSlice<'self> for &'self str {
     /// ~~~ {.rust}
     /// let string = "a\nb\nc";
     /// let mut lines = ~[];
-    /// for string.line_iter().advance |line| { lines.push(line) }
+    /// foreach line in string.line_iter() { lines.push(line) }
     ///
     /// assert!(string.subslice_offset(lines[0]) == 0); // &"a"
     /// assert!(string.subslice_offset(lines[1]) == 2); // &"b"
@@ -2238,7 +2240,7 @@ impl<T: Iterator<char>> Extendable<char, T> for ~str {
         let (lower, _) = iterator.size_hint();
         let reserve = lower + self.len();
         self.reserve_at_least(reserve);
-        for iterator.advance |ch| {
+        foreach ch in *iterator {
             self.push_char(ch)
         }
     }
@@ -2269,7 +2271,6 @@ mod tests {
     use libc;
     use ptr;
     use str::*;
-    use uint;
     use vec;
     use vec::{ImmutableVector, CopyableVector};
     use cmp::{TotalOrd, Less, Equal, Greater};
@@ -3055,7 +3056,7 @@ mod tests {
 
         let string = "a\nb\nc";
         let mut lines = ~[];
-        for string.line_iter().advance |line| { lines.push(line) }
+        foreach line in string.line_iter() { lines.push(line) }
         assert_eq!(string.subslice_offset(lines[0]), 0);
         assert_eq!(string.subslice_offset(lines[1]), 2);
         assert_eq!(string.subslice_offset(lines[2]), 4);
@@ -3159,7 +3160,7 @@ mod tests {
                 0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
                 0x000a_u16 ]) ];
 
-        for pairs.iter().advance |p| {
+        foreach p in pairs.iter() {
             let (s, u) = (*p).clone();
             assert!(s.to_utf16() == u);
             assert!(from_utf16(u) == s);
@@ -3173,7 +3174,7 @@ mod tests {
         let s = ~"ศไทย中华Việt Nam";
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
         let mut pos = 0;
-        for v.iter().advance |ch| {
+        foreach ch in v.iter() {
             assert!(s.char_at(pos) == *ch);
             pos += from_char(*ch).len();
         }
@@ -3184,7 +3185,7 @@ mod tests {
         let s = ~"ศไทย中华Việt Nam";
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
         let mut pos = s.len();
-        for v.rev_iter().advance |ch| {
+        foreach ch in v.rev_iter() {
             assert!(s.char_at_reverse(pos) == *ch);
             pos -= from_char(*ch).len();
         }
@@ -3276,7 +3277,7 @@ mod tests {
         let mut pos = 0;
         let mut it = s.iter();
 
-        for it.advance |c| {
+        foreach c in it {
             assert_eq!(c, v[pos]);
             pos += 1;
         }
@@ -3292,7 +3293,7 @@ mod tests {
         let mut pos = 0;
         let mut it = s.rev_iter();
 
-        for it.advance |c| {
+        foreach c in it {
             assert_eq!(c, v[pos]);
             pos += 1;
         }
@@ -3309,7 +3310,7 @@ mod tests {
         ];
         let mut pos = 0;
 
-        for s.byte_iter().advance |b| {
+        foreach b in s.byte_iter() {
             assert_eq!(b, v[pos]);
             pos += 1;
         }
@@ -3325,7 +3326,7 @@ mod tests {
         ];
         let mut pos = v.len();
 
-        for s.byte_rev_iter().advance |b| {
+        foreach b in s.byte_rev_iter() {
             pos -= 1;
             assert_eq!(b, v[pos]);
         }
@@ -3341,7 +3342,7 @@ mod tests {
         let mut pos = 0;
         let mut it = s.char_offset_iter();
 
-        for it.advance |c| {
+        foreach c in it {
             assert_eq!(c, (p[pos], v[pos]));
             pos += 1;
         }
@@ -3359,7 +3360,7 @@ mod tests {
         let mut pos = 0;
         let mut it = s.char_offset_rev_iter();
 
-        for it.advance |c| {
+        foreach c in it {
             assert_eq!(c, (p[pos], v[pos]));
             pos += 1;
         }
diff --git a/src/libstd/str/ascii.rs b/src/libstd/str/ascii.rs
index 24e48dbe139..3f24f98bd3d 100644
--- a/src/libstd/str/ascii.rs
+++ b/src/libstd/str/ascii.rs
@@ -14,9 +14,10 @@ use to_str::{ToStr,ToStrConsume};
 use str;
 use str::StrSlice;
 use cast;
-use iterator::IteratorUtil;
+use iterator::{Iterator, IteratorUtil};
 use vec::{CopyableVector, ImmutableVector, OwnedVector};
 use to_bytes::IterBytes;
+use option::{Some, None};
 
 /// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero.
 #[deriving(Clone, Eq)]
@@ -93,7 +94,7 @@ impl<'self> AsciiCast<&'self[Ascii]> for &'self [u8] {
 
     #[inline]
     fn is_ascii(&self) -> bool {
-        for self.iter().advance |b| {
+        foreach b in self.iter() {
             if !b.is_ascii() { return false; }
         }
         true
diff --git a/src/libstd/task/local_data_priv.rs b/src/libstd/task/local_data_priv.rs
index 477981c65e5..69c4bb20caf 100644
--- a/src/libstd/task/local_data_priv.rs
+++ b/src/libstd/task/local_data_priv.rs
@@ -167,7 +167,7 @@ pub unsafe fn local_pop<T: 'static>(handle: Handle,
     let map = get_local_map(handle);
     let key_value = key_to_key_value(key);
 
-    for map.mut_iter().advance |entry| {
+    foreach entry in map.mut_iter() {
         match *entry {
             Some((k, _, loan)) if k == key_value => {
                 if loan != NoLoan {
diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs
index 54e46826976..c7f34974a6e 100644
--- a/src/libstd/task/spawn.rs
+++ b/src/libstd/task/spawn.rs
@@ -96,7 +96,6 @@ use rt::local::Local;
 use rt::task::Task;
 use rt::kill::KillHandle;
 use rt::sched::Scheduler;
-use iterator::IteratorUtil;
 
 #[cfg(test)] use task::default_task_opts;
 #[cfg(test)] use comm;
@@ -356,7 +355,7 @@ impl Drop for Taskgroup {
             // If we are failing, the whole taskgroup needs to die.
             do RuntimeGlue::with_task_handle_and_failing |me, failing| {
                 if failing {
-                    for this.notifier.mut_iter().advance |x| {
+                    foreach x in this.notifier.mut_iter() {
                         x.failed = true;
                     }
                     // Take everybody down with us.
@@ -385,7 +384,7 @@ pub fn Taskgroup(tasks: TaskGroupArc,
        ancestors: AncestorList,
        is_main: bool,
        mut notifier: Option<AutoNotify>) -> Taskgroup {
-    for notifier.mut_iter().advance |x| {
+    foreach x in notifier.mut_iter() {
         x.failed = false;
     }
 
@@ -463,13 +462,13 @@ fn kill_taskgroup(state: TaskGroupInner, me: &TaskHandle, is_main: bool) {
         if newstate.is_some() {
             let TaskGroupData { members: members, descendants: descendants } =
                 newstate.unwrap();
-            for members.consume().advance |sibling| {
+            foreach sibling in members.consume() {
                 // Skip self - killing ourself won't do much good.
                 if &sibling != me {
                     RuntimeGlue::kill_task(sibling);
                 }
             }
-            for descendants.consume().advance |child| {
+            foreach child in descendants.consume() {
                 assert!(&child != me);
                 RuntimeGlue::kill_task(child);
             }
diff --git a/src/libstd/to_str.rs b/src/libstd/to_str.rs
index 50cbd36ced9..b87a1657065 100644
--- a/src/libstd/to_str.rs
+++ b/src/libstd/to_str.rs
@@ -14,11 +14,12 @@ The `ToStr` trait for converting to strings
 
 */
 
+use option::{Some, None};
 use str::OwnedStr;
 use hashmap::HashMap;
 use hashmap::HashSet;
 use hash::Hash;
-use iterator::IteratorUtil;
+use iterator::Iterator;
 use cmp::Eq;
 use vec::ImmutableVector;
 
@@ -55,7 +56,7 @@ impl<A:ToStr+Hash+Eq, B:ToStr> ToStr for HashMap<A, B> {
     fn to_str(&self) -> ~str {
         let mut acc = ~"{";
         let mut first = true;
-        for self.iter().advance |(key, value)| {
+        foreach (key, value) in self.iter() {
             if first {
                 first = false;
             }
@@ -76,7 +77,7 @@ impl<A:ToStr+Hash+Eq> ToStr for HashSet<A> {
     fn to_str(&self) -> ~str {
         let mut acc = ~"{";
         let mut first = true;
-        for self.iter().advance |element| {
+        foreach element in self.iter() {
             if first {
                 first = false;
             }
@@ -125,7 +126,7 @@ impl<'self,A:ToStr> ToStr for &'self [A] {
     fn to_str(&self) -> ~str {
         let mut acc = ~"[";
         let mut first = true;
-        for self.iter().advance |elt| {
+        foreach elt in self.iter() {
             if first {
                 first = false;
             }
@@ -144,7 +145,7 @@ impl<A:ToStr> ToStr for ~[A] {
     fn to_str(&self) -> ~str {
         let mut acc = ~"[";
         let mut first = true;
-        for self.iter().advance |elt| {
+        foreach elt in self.iter() {
             if first {
                 first = false;
             }
@@ -163,7 +164,7 @@ impl<A:ToStr> ToStr for @[A] {
     fn to_str(&self) -> ~str {
         let mut acc = ~"[";
         let mut first = true;
-        for self.iter().advance |elt| {
+        foreach elt in self.iter() {
             if first {
                 first = false;
             }
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index 6a0554a8c8d..704e3a500f1 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -164,7 +164,7 @@ impl<T, Iter: Iterator<(uint, T)>> FromIterator<(uint, T), Iter> for TrieMap<T>
 
 impl<T, Iter: Iterator<(uint, T)>> Extendable<(uint, T), Iter> for TrieMap<T> {
     fn extend(&mut self, iter: &mut Iter) {
-        for iter.advance |(k, v)| {
+        foreach (k, v) in *iter {
             self.insert(k, v);
         }
     }
@@ -235,7 +235,7 @@ impl<Iter: Iterator<uint>> FromIterator<uint, Iter> for TrieSet {
 
 impl<Iter: Iterator<uint>> Extendable<uint, Iter> for TrieSet {
     fn extend(&mut self, iter: &mut Iter) {
-        for iter.advance |elem| {
+        foreach elem in *iter {
             self.insert(elem);
         }
     }
@@ -283,7 +283,7 @@ impl<T> TrieNode<T> {
     }
 
     fn mutate_values<'a>(&'a mut self, f: &fn(&uint, &mut T) -> bool) -> bool {
-        for self.children.mut_iter().advance |child| {
+        foreach child in self.children.mut_iter() {
             match *child {
                 Internal(ref mut x) => if !x.mutate_values(|i,t| f(i,t)) {
                     return false
@@ -379,7 +379,7 @@ pub fn check_integrity<T>(trie: &TrieNode<T>) {
 
     let mut sum = 0;
 
-    for trie.children.iter().advance |x| {
+    foreach x in trie.children.iter() {
         match *x {
           Nothing => (),
           Internal(ref y) => {
@@ -544,7 +544,7 @@ mod test_map {
 
         let map: TrieMap<int> = xs.iter().transform(|&x| x).collect();
 
-        for xs.iter().advance |&(k, v)| {
+        foreach &(k, v) in xs.iter() {
             assert_eq!(map.find(&k), Some(&v));
         }
     }
@@ -553,6 +553,7 @@ mod test_map {
 #[cfg(test)]
 mod test_set {
     use super::*;
+    use prelude::*;
     use uint;
 
     #[test]
@@ -583,7 +584,7 @@ mod test_set {
 
         let set: TrieSet = xs.iter().transform(|&x| x).collect();
 
-        for xs.iter().advance |x| {
+        foreach x in xs.iter() {
             assert!(set.contains(x));
         }
     }
diff --git a/src/libstd/unstable/extfmt.rs b/src/libstd/unstable/extfmt.rs
index 1a136bbaa37..a8cdd1fb2dc 100644
--- a/src/libstd/unstable/extfmt.rs
+++ b/src/libstd/unstable/extfmt.rs
@@ -77,7 +77,6 @@ debug!("hello, %s!", "world");
 */
 
 use prelude::*;
-use iterator::IteratorUtil;
 
 /*
  * We have a 'ct' (compile-time) module that parses format strings into a
@@ -616,7 +615,7 @@ pub mod rt {
         let headsize = match head { Some(_) => 1, _ => 0 };
         let uwidth : uint = match cv.width {
             CountImplied => {
-                for head.iter().advance |&c| {
+                foreach &c in head.iter() {
                     buf.push_char(c);
                 }
                 return buf.push_str(s);
@@ -625,7 +624,7 @@ pub mod rt {
         };
         let strlen = s.char_len() + headsize;
         if uwidth <= strlen {
-            for head.iter().advance |&c| {
+            foreach &c in head.iter() {
                 buf.push_char(c);
             }
             return buf.push_str(s);
@@ -633,7 +632,7 @@ pub mod rt {
         let mut padchar = ' ';
         let diff = uwidth - strlen;
         if have_flag(cv.flags, flag_left_justify) {
-            for head.iter().advance |&c| {
+            foreach &c in head.iter() {
                 buf.push_char(c);
             }
             buf.push_str(s);
@@ -667,7 +666,7 @@ pub mod rt {
         // instead.
 
         if signed && zero_padding {
-            for head.iter().advance |&head| {
+            foreach &head in head.iter() {
                 if head == '+' || head == '-' || head == ' ' {
                     buf.push_char(head);
                     buf.push_str(padstr);
@@ -677,7 +676,7 @@ pub mod rt {
             }
         }
         buf.push_str(padstr);
-        for head.iter().advance |&c| {
+        foreach &c in head.iter() {
             buf.push_char(c);
         }
         buf.push_str(s);
diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs
index 4c52d897a72..1fae96e7847 100644
--- a/src/libstd/unstable/sync.rs
+++ b/src/libstd/unstable/sync.rs
@@ -425,7 +425,7 @@ mod tests {
                 }
             };
 
-            for futures.iter().advance |f| { f.recv() }
+            foreach f in futures.iter() { f.recv() }
 
             do total.with |total| {
                 assert!(**total == num_tasks * count)
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;
         }