remove obsolete `foreach` keyword

this has been replaced by `for`

34 files changed, 231 insertions, 231 deletions

diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index ab1dd3d45f1..4ece53d0e7f 100644
--- a/src/libstd/at_vec.rs
+++ b/src/libstd/at_vec.rs
@@ -91,10 +91,10 @@ 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| {
-        foreach x in lhs.iter() {
+        for x in lhs.iter() {
             push((*x).clone());
         }
-        foreach i in range(0u, rhs.len()) {
+        for i in range(0u, rhs.len()) {
             push(rhs[i].clone());
         }
     }
@@ -104,7 +104,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| {
-        foreach elem in v.iter() {
+        for elem in v.iter() {
             push(f(elem));
         }
     }
@@ -147,7 +147,7 @@ pub fn to_managed_consume<T>(v: ~[T]) -> @[T] {
     let mut av = @[];
     unsafe {
         raw::reserve(&mut av, v.len());
-        foreach x in v.consume_iter() {
+        for x in v.consume_iter() {
             raw::push(&mut av, x);
         }
         av
@@ -329,7 +329,7 @@ mod test {
         // Some code that could use that, then:
         fn seq_range(lo: uint, hi: uint) -> @[uint] {
             do build |push| {
-                foreach i in range(lo, hi) {
+                for i in range(lo, hi) {
                     push(i);
                 }
             }
diff --git a/src/libstd/cmp.rs b/src/libstd/cmp.rs
index abb04e637ca..43a632562b2 100644
--- a/src/libstd/cmp.rs
+++ b/src/libstd/cmp.rs
@@ -238,7 +238,7 @@ mod test {
         }
 
         let xs = [Less, Equal, Greater];
-        foreach &o in xs.iter() {
+        for &o in xs.iter() {
             t(Less, o, Less);
             t(Equal, o, o);
             t(Greater, o, Greater);
diff --git a/src/libstd/either.rs b/src/libstd/either.rs
index d0378fa947b..6bdc45d7204 100644
--- a/src/libstd/either.rs
+++ b/src/libstd/either.rs
@@ -47,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| {
-        foreach elt in eithers.iter() {
+        for elt in eithers.iter() {
             match *elt {
                 Left(ref l) => { push((*l).clone()); }
                 _ => { /* fallthrough */ }
@@ -59,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| {
-        foreach elt in eithers.iter() {
+        for elt in eithers.iter() {
             match *elt {
                 Right(ref r) => { push((*r).clone()); }
                 _ => { /* fallthrough */ }
@@ -75,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] = ~[];
-    foreach elt in eithers.consume_iter() {
+    for 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 5d4b9b4e3f0..c9d031ed1b1 100644
--- a/src/libstd/hash.rs
+++ b/src/libstd/hash.rs
@@ -385,7 +385,7 @@ impl Streaming for SipState {
     fn result_str(&mut self) -> ~str {
         let r = self.result_bytes();
         let mut s = ~"";
-        foreach b in r.iter() {
+        for b in r.iter() {
             s.push_str(uint::to_str_radix(*b as uint, 16u));
         }
         s
@@ -487,7 +487,7 @@ mod tests {
 
         fn to_hex_str(r: &[u8, ..8]) -> ~str {
             let mut s = ~"";
-            foreach b in r.iter() {
+            for 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 4de5d316fc0..c24661bf938 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -159,7 +159,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
 
         self.size = 0;
         // consume_rev_iter is more efficient
-        foreach bucket in old_buckets.consume_rev_iter() {
+        for bucket in old_buckets.consume_rev_iter() {
             self.insert_opt_bucket(bucket);
         }
     }
@@ -264,7 +264,7 @@ impl<K:Hash + Eq,V> Container for HashMap<K, V> {
 impl<K:Hash + Eq,V> Mutable for HashMap<K, V> {
     /// Clear the map, removing all key-value pairs.
     fn clear(&mut self) {
-        foreach idx in range(0u, self.buckets.len()) {
+        for idx in range(0u, self.buckets.len()) {
             self.buckets[idx] = None;
         }
         self.size = 0;
@@ -513,7 +513,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());
-        foreach (key, value) in self.iter() {
+        for (key, value) in self.iter() {
             new_map.insert((*key).clone(), (*value).clone());
         }
         new_map
@@ -550,7 +550,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)> {
-        foreach elt in self.iter {
+        for elt in self.iter {
             match elt {
                 &Some(ref bucket) => return Some((&bucket.key, &bucket.value)),
                 &None => {},
@@ -563,7 +563,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)> {
-        foreach elt in self.iter {
+        for elt in self.iter {
             match elt {
                 &Some(ref mut bucket) => return Some((&bucket.key, &mut bucket.value)),
                 &None => {},
@@ -576,7 +576,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)> {
-        foreach elt in self.iter {
+        for elt in self.iter {
             match elt {
                 Some(Bucket {key, value, _}) => return Some((key, value)),
                 None => {},
@@ -589,7 +589,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> {
-        foreach elt in self.iter {
+        for elt in self.iter {
             match elt {
                 &Some(ref bucket) => return Some(&bucket.key),
                 &None => {},
@@ -602,7 +602,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> {
-        foreach elt in self.iter {
+        for elt in self.iter {
             match elt {
                 Some(bucket) => return Some(bucket.key),
                 None => {},
@@ -623,7 +623,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) {
-        foreach (k, v) in *iter {
+        for (k, v) in *iter {
             self.insert(k, v);
         }
     }
@@ -758,7 +758,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) {
-        foreach k in *iter {
+        for k in *iter {
             self.insert(k);
         }
     }
@@ -926,11 +926,11 @@ mod test_map {
     #[test]
     fn test_iterate() {
         let mut m = HashMap::with_capacity(4);
-        foreach i in range(0u, 32) {
+        for i in range(0u, 32) {
             assert!(m.insert(i, i*2));
         }
         let mut observed = 0;
-        foreach (k, v) in m.iter() {
+        for (k, v) in m.iter() {
             assert_eq!(*v, *k * 2);
             observed |= (1 << *k);
         }
@@ -1007,7 +1007,7 @@ mod test_map {
 
         let map: HashMap<int, int> = xs.iter().transform(|&x| x).collect();
 
-        foreach &(k, v) in xs.iter() {
+        for &(k, v) in xs.iter() {
             assert_eq!(map.find(&k), Some(&v));
         }
     }
@@ -1074,11 +1074,11 @@ mod test_set {
     #[test]
     fn test_iterate() {
         let mut a = HashSet::new();
-        foreach i in range(0u, 32) {
+        for i in range(0u, 32) {
             assert!(a.insert(i));
         }
         let mut observed = 0;
-        foreach k in a.iter() {
+        for k in a.iter() {
             observed |= (1 << *k);
         }
         assert_eq!(observed, 0xFFFF_FFFF);
@@ -1107,7 +1107,7 @@ mod test_set {
 
         let mut i = 0;
         let expected = [3, 5, 11, 77];
-        foreach x in a.intersection_iter(&b) {
+        for x in a.intersection_iter(&b) {
             assert!(expected.contains(x));
             i += 1
         }
@@ -1130,7 +1130,7 @@ mod test_set {
 
         let mut i = 0;
         let expected = [1, 5, 11];
-        foreach x in a.difference_iter(&b) {
+        for x in a.difference_iter(&b) {
             assert!(expected.contains(x));
             i += 1
         }
@@ -1156,7 +1156,7 @@ mod test_set {
 
         let mut i = 0;
         let expected = [-2, 1, 5, 11, 14, 22];
-        foreach x in a.symmetric_difference_iter(&b) {
+        for x in a.symmetric_difference_iter(&b) {
             assert!(expected.contains(x));
             i += 1
         }
@@ -1186,7 +1186,7 @@ mod test_set {
 
         let mut i = 0;
         let expected = [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24];
-        foreach x in a.union_iter(&b) {
+        for x in a.union_iter(&b) {
             assert!(expected.contains(x));
             i += 1
         }
@@ -1199,7 +1199,7 @@ mod test_set {
 
         let set: HashSet<int> = xs.iter().transform(|&x| x).collect();
 
-        foreach x in xs.iter() {
+        for x in xs.iter() {
             assert!(set.contains(x));
         }
     }
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 606c958b408..f750f3f3195 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -1281,7 +1281,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();
-    foreach f in flags.iter() {
+    for f in flags.iter() {
         match *f {
           Append => fflags |= O_APPEND as c_int,
           Create => fflags |= O_CREAT as c_int,
@@ -1940,7 +1940,7 @@ mod tests {
                 if len <= ivals.len() {
                     assert_eq!(res.len(), len);
                 }
-                foreach (iv, c) in ivals.iter().zip(res.iter()) {
+                for (iv, c) in ivals.iter().zip(res.iter()) {
                     assert!(*iv == *c as int)
                 }
             }
@@ -2054,7 +2054,7 @@ mod tests {
         // write the ints to the file
         {
             let file = io::file_writer(&path, [io::Create]).unwrap();
-            foreach i in uints.iter() {
+            for i in uints.iter() {
                 file.write_le_u64(*i);
             }
         }
@@ -2062,7 +2062,7 @@ mod tests {
         // then read them back and check that they are the same
         {
             let file = io::file_reader(&path).unwrap();
-            foreach i in uints.iter() {
+            for i in uints.iter() {
                 assert_eq!(file.read_le_u64(), *i);
             }
         }
@@ -2076,7 +2076,7 @@ mod tests {
         // write the ints to the file
         {
             let file = io::file_writer(&path, [io::Create]).unwrap();
-            foreach i in uints.iter() {
+            for i in uints.iter() {
                 file.write_be_u64(*i);
             }
         }
@@ -2084,7 +2084,7 @@ mod tests {
         // then read them back and check that they are the same
         {
             let file = io::file_reader(&path).unwrap();
-            foreach i in uints.iter() {
+            for i in uints.iter() {
                 assert_eq!(file.read_be_u64(), *i);
             }
         }
@@ -2098,7 +2098,7 @@ mod tests {
         // write the ints to the file
         {
             let file = io::file_writer(&path, [io::Create]).unwrap();
-            foreach i in ints.iter() {
+            for i in ints.iter() {
                 file.write_be_i32(*i);
             }
         }
@@ -2106,7 +2106,7 @@ mod tests {
         // then read them back and check that they are the same
         {
             let file = io::file_reader(&path).unwrap();
-            foreach i in ints.iter() {
+            for 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 3b829841484..0769aa6a764 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;
-    /// foreach x: uint in it {
+    /// for x: uint in it {
     ///     assert_eq!(x, ys[i]);
     ///     i += 1;
     /// }
@@ -330,7 +330,7 @@ pub trait IteratorUtil<A> {
     /// ~~~ {.rust}
     /// use std::iterator::Counter;
     ///
-    /// foreach i in Counter::new(0, 10) {
+    /// for 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;
-        foreach x in *self { last = Some(x); }
+        for 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 {
-        foreach x in *self { if !f(x) { return false; } }
+        for x in *self { if !f(x) { return false; } }
         true
     }
 
     #[inline]
     fn any(&mut self, f: &fn(A) -> bool) -> bool {
-        foreach x in *self { if f(x) { return true; } }
+        for 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> {
-        foreach x in *self {
+        for 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;
-        foreach x in *self {
+        for 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;
-        foreach x in *self {
+        for 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> {
-        foreach x in self.iter {
+        for 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> {
-        foreach x in self.iter {
+        for x in self.iter {
             match (self.f)(x) {
                 Some(y) => return Some(y),
                 None => ()
@@ -1373,8 +1373,8 @@ impl<'self, A, T: Iterator<A>, B, U: Iterator<B>> Iterator<B> for
     #[inline]
     fn next(&mut self) -> Option<B> {
         loop {
-            foreach inner in self.frontiter.mut_iter() {
-                foreach x in *inner {
+            for inner in self.frontiter.mut_iter() {
+                for x in *inner {
                     return Some(x)
                 }
             }
@@ -1403,7 +1403,7 @@ impl<'self,
     #[inline]
     fn next_back(&mut self) -> Option<B> {
         loop {
-            foreach inner in self.backiter.mut_iter() {
+            for inner in self.backiter.mut_iter() {
                 match inner.next_back() {
                     None => (),
                     y => return y
@@ -1577,7 +1577,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;
-        foreach &x in it {
+        for &x in it {
             assert_eq!(x, expected[i]);
             i += 1;
         }
@@ -1586,7 +1586,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;
-        foreach x in it {
+        for x in it {
             assert_eq!(x, expected[i]);
             i += 1;
         }
@@ -1604,7 +1604,7 @@ mod tests {
     fn test_iterator_enumerate() {
         let xs = [0u, 1, 2, 3, 4, 5];
         let mut it = xs.iter().enumerate();
-        foreach (i, &x) in it {
+        for (i, &x) in it {
             assert_eq!(i, x);
         }
     }
@@ -1615,7 +1615,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;
-        foreach &x in it {
+        for &x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1628,7 +1628,7 @@ mod tests {
         let ys = [15, 16, 17, 19];
         let mut it = xs.iter().skip_while(|&x| *x < 15u);
         let mut i = 0;
-        foreach &x in it {
+        for &x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1641,7 +1641,7 @@ mod tests {
         let ys = [13, 15, 16, 17, 19, 20, 30];
         let mut it = xs.iter().skip(5);
         let mut i = 0;
-        foreach &x in it {
+        for &x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1654,7 +1654,7 @@ mod tests {
         let ys = [0u, 1, 2, 3, 5];
         let mut it = xs.iter().take_(5);
         let mut i = 0;
-        foreach &x in it {
+        for &x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1673,7 +1673,7 @@ mod tests {
 
         let mut it = xs.iter().scan(0, add);
         let mut i = 0;
-        foreach x in it {
+        for x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1686,7 +1686,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;
-        foreach x in it {
+        for x in it {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -1721,7 +1721,7 @@ mod tests {
 
         let mut it = Unfoldr::new(0, count);
         let mut i = 0;
-        foreach counted in it {
+        for counted in it {
             assert_eq!(counted, i);
             i += 1;
         }
@@ -1733,7 +1733,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));
-        foreach (i, x) in it.take_(100).enumerate() {
+        for (i, x) in it.take_(100).enumerate() {
             assert_eq!(i % cycle_len, x);
         }
 
@@ -1745,7 +1745,7 @@ mod tests {
     #[test]
     fn test_iterator_nth() {
         let v = &[0, 1, 2, 3, 4];
-        foreach i in range(0u, v.len()) {
+        for i in range(0u, v.len()) {
             assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
         }
     }
@@ -1959,7 +1959,7 @@ mod tests {
         let mut b = a.clone();
         assert_eq!(len, b.indexable());
         let mut n = 0;
-        foreach (i, elt) in a.enumerate() {
+        for (i, elt) in a.enumerate() {
             assert_eq!(Some(elt), b.idx(i));
             n += 1;
         }
@@ -2049,7 +2049,7 @@ mod tests {
         // test .transform and .peek_ that don't implement Clone
         let it = xs.iter().peek_(|_| {});
         assert_eq!(xs.len(), it.indexable());
-        foreach (i, elt) in xs.iter().enumerate() {
+        for (i, elt) in xs.iter().enumerate() {
             assert_eq!(Some(elt), it.idx(i));
         }
 
@@ -2062,7 +2062,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());
-        foreach (i, elt) in xs.iter().enumerate() {
+        for (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 547c453b02d..417251d3740 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -502,7 +502,7 @@ mod tests {
         let x = Some(());
         let mut y = Some(5);
         let mut y2 = 0;
-        foreach _x in x.iter() {
+        for _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 f78f5812863..2d0b7d4f849 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -219,7 +219,7 @@ pub fn env() -> ~[(~str,~str)] {
 
         fn env_convert(input: ~[~str]) -> ~[(~str, ~str)] {
             let mut pairs = ~[];
-            foreach p in input.iter() {
+            for p in input.iter() {
                 let vs: ~[&str] = p.splitn_iter('=', 1).collect();
                 debug!("splitting: len: %u",
                     vs.len());
@@ -1119,7 +1119,7 @@ pub fn set_exit_status(code: int) {
 
 unsafe fn load_argc_and_argv(argc: c_int, argv: **c_char) -> ~[~str] {
     let mut args = ~[];
-    foreach i in range(0u, argc as uint) {
+    for i in range(0u, argc as uint) {
         args.push(str::raw::from_c_str(*argv.offset(i as int)));
     }
     args
@@ -1168,7 +1168,7 @@ pub fn real_args() -> ~[~str] {
     let szArgList = unsafe { CommandLineToArgvW(lpCmdLine, lpArgCount) };
 
     let mut args = ~[];
-    foreach i in range(0u, nArgs as uint) {
+    for i in range(0u, nArgs as uint) {
         unsafe {
             // Determine the length of this argument.
             let ptr = *szArgList.offset(i as int);
@@ -1425,7 +1425,7 @@ impl MemoryMap {
         let mut offset: off_t = 0;
         let len = round_up(min_len, page_size()) as size_t;
 
-        foreach &o in options.iter() {
+        for &o in options.iter() {
             match o {
                 MapReadable => { prot |= libc::PROT_READ; },
                 MapWritable => { prot |= libc::PROT_WRITE; },
@@ -1498,7 +1498,7 @@ impl MemoryMap {
         let mut offset: uint = 0;
         let len = round_up(min_len, page_size()) as SIZE_T;
 
-        foreach &o in options.iter() {
+        for &o in options.iter() {
             match o {
                 MapReadable => { readable = true; },
                 MapWritable => { writable = true; },
@@ -1794,7 +1794,7 @@ mod tests {
     fn test_env_getenv() {
         let e = env();
         assert!(e.len() > 0u);
-        foreach p in e.iter() {
+        for p in e.iter() {
             let (n, v) = (*p).clone();
             debug!(n.clone());
             let v2 = getenv(n);
@@ -1838,7 +1838,7 @@ mod tests {
         setenv("HOME", "");
         assert!(os::homedir().is_none());
 
-        foreach s in oldhome.iter() { setenv("HOME", *s) }
+        for s in oldhome.iter() { setenv("HOME", *s) }
     }
 
     #[test]
@@ -1886,7 +1886,7 @@ mod tests {
         // Just assuming that we've got some contents in the current directory
         assert!(dirs.len() > 0u);
 
-        foreach dir in dirs.iter() {
+        for dir in dirs.iter() {
             debug!((*dir).clone());
         }
     }
diff --git a/src/libstd/path.rs b/src/libstd/path.rs
index 989a5cbd35b..76001ae4188 100644
--- a/src/libstd/path.rs
+++ b/src/libstd/path.rs
@@ -647,8 +647,8 @@ impl GenericPath for PosixPath {
 
     fn push_many<S: Str>(&self, cs: &[S]) -> PosixPath {
         let mut v = self.components.clone();
-        foreach e in cs.iter() {
-            foreach s in e.as_slice().split_iter(posix::is_sep) {
+        for e in cs.iter() {
+            for 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();
-        foreach s in s.split_iter(posix::is_sep) {
+        for 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();
-        foreach e in cs.iter() {
-            foreach s in e.as_slice().split_iter(windows::is_sep) {
+        for e in cs.iter() {
+            for 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();
-        foreach s in s.split_iter(windows::is_sep) {
+        for 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 = ~[];
-    foreach c in components.iter() {
+    for 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 2819744c560..1fd534825a5 100644
--- a/src/libstd/pipes.rs
+++ b/src/libstd/pipes.rs
@@ -598,7 +598,7 @@ pub fn wait_many<T: Selectable>(pkts: &mut [T]) -> uint {
 
     let mut data_avail = false;
     let mut ready_packet = pkts.len();
-    foreach (i, p) in pkts.mut_iter().enumerate() {
+    for (i, p) in pkts.mut_iter().enumerate() {
         unsafe {
             let p = &mut *p.header();
             let old = p.mark_blocked(this);
@@ -620,7 +620,7 @@ pub fn wait_many<T: Selectable>(pkts: &mut [T]) -> uint {
         let event = wait_event(this) as *PacketHeader;
 
         let mut pos = None;
-        foreach (i, p) in pkts.mut_iter().enumerate() {
+        for (i, p) in pkts.mut_iter().enumerate() {
             if p.header() == event {
                 pos = Some(i);
                 break;
@@ -638,7 +638,7 @@ pub fn wait_many<T: Selectable>(pkts: &mut [T]) -> uint {
 
     debug!("%?", &mut pkts[ready_packet]);
 
-    foreach p in pkts.mut_iter() {
+    for p in pkts.mut_iter() {
         unsafe {
             (*p.header()).unblock()
         }
@@ -849,7 +849,7 @@ pub fn select<T:Send,Tb:Send>(mut endpoints: ~[RecvPacketBuffered<T, Tb>])
                                     Option<T>,
                                     ~[RecvPacketBuffered<T, Tb>]) {
     let mut endpoint_headers = ~[];
-    foreach endpoint in endpoints.mut_iter() {
+    for endpoint in endpoints.mut_iter() {
         endpoint_headers.push(endpoint.header());
     }
 
diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 69e1852e662..b7d72c11ff7 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -495,7 +495,7 @@ impl<R: Rng> RngUtil for R {
     fn gen_char_from(&mut self, chars: &str) -> char {
         assert!(!chars.is_empty());
         let mut cs = ~[];
-        foreach c in chars.iter() { cs.push(c) }
+        for c in chars.iter() { cs.push(c) }
         self.choose(cs)
     }
 
@@ -559,7 +559,7 @@ impl<R: Rng> RngUtil for R {
     fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
                                        -> Option<T> {
         let mut total = 0u;
-        foreach item in v.iter() {
+        for item in v.iter() {
             total += item.weight;
         }
         if total == 0u {
@@ -567,7 +567,7 @@ impl<R: Rng> RngUtil for R {
         }
         let chosen = self.gen_uint_range(0u, total);
         let mut so_far = 0u;
-        foreach item in v.iter() {
+        for item in v.iter() {
             so_far += item.weight;
             if so_far > chosen {
                 return Some(item.item.clone());
@@ -582,8 +582,8 @@ impl<R: Rng> RngUtil for R {
      */
     fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T] {
         let mut r = ~[];
-        foreach item in v.iter() {
-            foreach _ in range(0u, item.weight) {
+        for item in v.iter() {
+            for _ in range(0u, item.weight) {
                 r.push(item.item.clone());
             }
         }
@@ -765,7 +765,7 @@ impl IsaacRng {
         );
 
         let r = [(0, MIDPOINT), (MIDPOINT, 0)];
-        foreach &(mr_offset, m2_offset) in r.iter() {
+        for &(mr_offset, m2_offset) in r.iter() {
             do uint::range_step(0, MIDPOINT, 4) |base| {
                 rngstep!(0, 13);
                 rngstep!(1, -6);
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
index edab639dfbe..a53e3e796a7 100644
--- a/src/libstd/repr.rs
+++ b/src/libstd/repr.rs
@@ -176,7 +176,7 @@ impl ReprVisitor {
 
     pub fn write_escaped_slice(&self, slice: &str) {
         self.writer.write_char('"');
-        foreach ch in slice.iter() {
+        for 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 89803d022f8..7a578465841 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -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());
-    foreach t in ts.iter() {
+    for t in ts.iter() {
         match op(t) {
           Ok(v) => vs.push(v),
           Err(u) => return Err(u)
diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs
index e701cb64fb6..6f26e3bd9ef 100644
--- a/src/libstd/rt/args.rs
+++ b/src/libstd/rt/args.rs
@@ -112,7 +112,7 @@ mod imp {
     // Copied from `os`.
     unsafe fn load_argc_and_argv(argc: int, argv: **u8) -> ~[~str] {
         let mut args = ~[];
-        foreach i in range(0u, argc as uint) {
+        for i in range(0u, argc as uint) {
             args.push(str::raw::from_c_str(*(argv as **libc::c_char).offset(i as int)));
         }
         args
diff --git a/src/libstd/rt/borrowck.rs b/src/libstd/rt/borrowck.rs
index bb66a901234..dcfcc3a9fc6 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 ";
-            foreach entry in borrow_list.rev_iter() {
+            for 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/io/net/tcp.rs b/src/libstd/rt/io/net/tcp.rs
index 764ef283eb8..780aa9cb75c 100644
--- a/src/libstd/rt/io/net/tcp.rs
+++ b/src/libstd/rt/io/net/tcp.rs
@@ -421,7 +421,7 @@ mod test {
 
             do spawntask {
                 let mut listener = TcpListener::bind(addr);
-                foreach i in range(0, MAX) {
+                for i in range(0, MAX) {
                     let stream = Cell::new(listener.accept());
                     rtdebug!("accepted");
                     // Start another task to handle the connection
@@ -460,7 +460,7 @@ mod test {
 
             do spawntask {
                 let mut listener = TcpListener::bind(addr);
-                foreach i in range(0, MAX) {
+                for i in range(0, MAX) {
                     let stream = Cell::new(listener.accept());
                     rtdebug!("accepted");
                     // Start another task to handle the connection
@@ -499,7 +499,7 @@ mod test {
 
             do spawntask {
                 let mut listener = TcpListener::bind(addr);
-                foreach _ in range(0, MAX) {
+                for _ in range(0, MAX) {
                     let stream = Cell::new(listener.accept());
                     rtdebug!("accepted");
                     // Start another task to handle the connection
@@ -537,7 +537,7 @@ mod test {
 
             do spawntask {
                 let mut listener = TcpListener::bind(addr);
-                foreach _ in range(0, MAX) {
+                for _ in range(0, MAX) {
                     let stream = Cell::new(listener.accept());
                     rtdebug!("accepted");
                     // Start another task to handle the connection
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index f0f4b646103..4cfe0efacfe 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -303,7 +303,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
     let on_exit: ~fn(bool) = |exit_success| {
 
         let mut handles = handles.take();
-        foreach handle in handles.mut_iter() {
+        for handle in handles.mut_iter() {
             handle.send(Shutdown);
         }
 
@@ -379,7 +379,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
     rtdebug!("waiting for threads");
 
     // Wait for schedulers
-    foreach thread in threads.consume_iter() {
+    for thread in threads.consume_iter() {
         thread.join();
     }
 
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index dfe003253c2..18cfeade157 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -761,7 +761,7 @@ mod test {
         let mut task_run_count = 0;
         let task_run_count_ptr: *mut uint = &mut task_run_count;
         do run_in_newsched_task || {
-            foreach _ in range(0u, total) {
+            for _ in range(0u, total) {
                 do spawntask || {
                     unsafe { *task_run_count_ptr = *task_run_count_ptr + 1};
                 }
@@ -960,7 +960,7 @@ mod test {
     #[test]
     fn test_stress_schedule_task_states() {
         let n = stress_factor() * 120;
-        foreach _ in range(0, n as int) {
+        for _ in range(0, n as int) {
             test_schedule_home_states();
         }
     }
diff --git a/src/libstd/rt/select.rs b/src/libstd/rt/select.rs
index a5adb25b526..006b777b71b 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");
     }
 
-    foreach (index, port) in ports.mut_iter().enumerate() {
+    for (index, port) in ports.mut_iter().enumerate() {
         if port.optimistic_check() {
             return index;
         }
@@ -53,7 +53,7 @@ pub fn select<A: Select>(ports: &mut [A]) -> uint {
     do sched.deschedule_running_task_and_then |sched, task| {
         let task_handles = task.make_selectable(ports.len());
 
-        foreach (index, (port, task_handle)) in
+        for (index, (port, task_handle)) in
                 ports.mut_iter().zip(task_handles.consume_iter()).enumerate() {
             // If one of the ports has data by now, it will wake the handle.
             if port.block_on(sched, task_handle) {
@@ -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.
-    foreach (index, port) in ports.mut_slice(0, ready_index).mut_rev_iter().enumerate() {
+    for (index, port) in ports.mut_slice(0, ready_index).mut_rev_iter().enumerate() {
         if port.unblock_from() {
             ready_index = index;
         }
@@ -128,7 +128,7 @@ mod test {
         let (ports, chans) = unzip(from_fn(num_ports, |_| oneshot::<()>()));
         let mut dead_chans = ~[];
         let mut ports = ports;
-        foreach (i, chan) in chans.consume_iter().enumerate() {
+        for (i, chan) in chans.consume_iter().enumerate() {
             if send_on_chans.contains(&i) {
                 chan.send(());
             } else {
@@ -145,7 +145,7 @@ mod test {
         let (ports, chans) = unzip(from_fn(num_ports, |_| stream::<()>()));
         let mut dead_chans = ~[];
         let mut ports = ports;
-        foreach (i, chan) in chans.consume_iter().enumerate() {
+        for (i, chan) in chans.consume_iter().enumerate() {
             if send_on_chans.contains(&i) {
                 chan.send(());
             } else {
@@ -192,7 +192,7 @@ mod test {
             let mut ports = ports;
             let mut port = Some(port);
             let order = [5u,0,4,3,2,6,9,8,7,1];
-            foreach &index in order.iter() {
+            for &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);
@@ -272,7 +272,7 @@ mod test {
                     let send_on_chans = send_on_chans.clone();
                     do task::spawn {
                         let mut ports = ~[];
-                        foreach i in range(0u, NUM_CHANS) {
+                        for i in range(0u, NUM_CHANS) {
                             let (p,c) = oneshot();
                             ports.push(p);
                             if send_on_chans.contains(&i) {
diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs
index 66ae085b1a0..2d45b1cd139 100644
--- a/src/libstd/rt/test.rs
+++ b/src/libstd/rt/test.rs
@@ -169,7 +169,7 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
         let mut handles = ~[];
         let mut scheds = ~[];
 
-        foreach _ in range(0u, nthreads) {
+        for _ in range(0u, nthreads) {
             let loop_ = ~UvEventLoop::new();
             let mut sched = ~Scheduler::new(loop_,
                                             work_queue.clone(),
@@ -184,7 +184,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
-            foreach handle in handles.mut_iter() {
+            for handle in handles.mut_iter() {
                 handle.send(Shutdown);
             }
 
@@ -223,7 +223,7 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
         }
 
         // Wait for schedulers
-        foreach thread in threads.consume_iter() {
+        for thread in threads.consume_iter() {
             thread.join();
         }
     }
@@ -346,7 +346,7 @@ fn base_port() -> uint {
 
     let mut final_base = base;
 
-    foreach &(dir, base) in bases.iter() {
+    for &(dir, base) in bases.iter() {
         if path.contains(dir) {
             final_base = base;
             break;
diff --git a/src/libstd/rt/tube.rs b/src/libstd/rt/tube.rs
index c014d0abda2..247893f75de 100644
--- a/src/libstd/rt/tube.rs
+++ b/src/libstd/rt/tube.rs
@@ -166,7 +166,7 @@ mod test {
                 sched.enqueue_blocked_task(task);
             }
 
-            foreach i in range(0, MAX) {
+            for i in range(0, MAX) {
                 let j = tube.recv();
                 assert!(j == i);
             }
diff --git a/src/libstd/rt/uv/net.rs b/src/libstd/rt/uv/net.rs
index 773adb3848a..5ac9f52f335 100644
--- a/src/libstd/rt/uv/net.rs
+++ b/src/libstd/rt/uv/net.rs
@@ -701,7 +701,7 @@ mod test {
                     if status.is_none() {
                         rtdebug!("got %d bytes", nread);
                         let buf = buf.unwrap();
-                        foreach byte in buf.slice(0, nread as uint).iter() {
+                        for byte in buf.slice(0, nread as uint).iter() {
                             assert!(*byte == count as u8);
                             rtdebug!("%u", *byte as uint);
                             count += 1;
@@ -777,7 +777,7 @@ mod test {
                         rtdebug!("got %d bytes", nread);
                         let buf = buf.unwrap();
                         let r = buf.slice(0, nread as uint);
-                        foreach byte in r.iter() {
+                        for byte in r.iter() {
                             assert!(*byte == count as u8);
                             rtdebug!("%u", *byte as uint);
                             count += 1;
@@ -848,7 +848,7 @@ mod test {
                 rtdebug!("got %d bytes", nread);
 
                 let buf = buf.unwrap();
-                foreach &byte in buf.slice(0, nread as uint).iter() {
+                for &byte in buf.slice(0, nread as uint).iter() {
                     assert!(byte == count as u8);
                     rtdebug!("%u", byte as uint);
                     count += 1;
@@ -908,7 +908,7 @@ mod test {
                 rtdebug!("got %d bytes", nread);
 
                 let buf = buf.unwrap();
-                foreach &byte in buf.slice(0, nread as uint).iter() {
+                for &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/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs
index e15e3adb8c9..5c17aea9341 100644
--- a/src/libstd/rt/uv/uvio.rs
+++ b/src/libstd/rt/uv/uvio.rs
@@ -843,7 +843,7 @@ fn test_simple_tcp_server_and_client() {
                 let mut buf = [0, .. 2048];
                 let nread = stream.read(buf).unwrap();
                 assert_eq!(nread, 8);
-                foreach i in range(0u, nread) {
+                for i in range(0u, nread) {
                     rtdebug!("%u", buf[i] as uint);
                     assert_eq!(buf[i], i as u8);
                 }
@@ -873,7 +873,7 @@ fn test_simple_udp_server_and_client() {
                 let mut buf = [0, .. 2048];
                 let (nread,src) = server_socket.recvfrom(buf).unwrap();
                 assert_eq!(nread, 8);
-                foreach i in range(0u, nread) {
+                for i in range(0u, nread) {
                     rtdebug!("%u", buf[i] as uint);
                     assert_eq!(buf[i], i as u8);
                 }
@@ -908,7 +908,7 @@ fn test_read_and_block() {
 
             while current < expected {
                 let nread = stream.read(buf).unwrap();
-                foreach i in range(0u, nread) {
+                for i in range(0u, nread) {
                     let val = buf[i] as uint;
                     assert_eq!(val, current % 8);
                     current += 1;
@@ -973,7 +973,7 @@ fn test_read_read_read() {
                     let nread = stream.read(buf).unwrap();
                     rtdebug!("read %u bytes", nread as uint);
                     total_bytes_read += nread;
-                    foreach i in range(0u, nread) {
+                    for i in range(0u, nread) {
                         assert_eq!(buf[i], 1);
                     }
                 }
@@ -1065,7 +1065,7 @@ fn test_udp_many_read() {
                     let (nread, src) = res.unwrap();
                     assert_eq!(src, server_out_addr);
                     total_bytes_recv += nread;
-                    foreach i in range(0u, nread) {
+                    for i in range(0u, nread) {
                         assert_eq!(buf[i], 1);
                     }
                 }
diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index 4c67d844c7e..ef3d881c5fe 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -174,9 +174,9 @@ impl Process {
                                    in_fd, out_fd, err_fd);
 
         unsafe {
-            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); }
+            for pipe in in_pipe.iter() { libc::close(pipe.input); }
+            for pipe in out_pipe.iter() { libc::close(pipe.out); }
+            for pipe in err_pipe.iter() { libc::close(pipe.out); }
         }
 
         Process {
@@ -321,7 +321,7 @@ impl Process {
      * If the child has already been finished then the exit code is returned.
      */
     pub fn finish(&mut self) -> int {
-        foreach &code in self.exit_code.iter() {
+        for &code in self.exit_code.iter() {
             return code;
         }
         self.close_input();
@@ -520,7 +520,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
         CloseHandle(si.hStdOutput);
         CloseHandle(si.hStdError);
 
-        foreach msg in create_err.iter() {
+        for msg in create_err.iter() {
             fail!("failure in CreateProcess: %s", *msg);
         }
 
@@ -576,7 +576,7 @@ fn zeroed_process_information() -> libc::types::os::arch::extra::PROCESS_INFORMA
 pub fn make_command_line(prog: &str, args: &[~str]) -> ~str {
     let mut cmd = ~"";
     append_arg(&mut cmd, prog);
-    foreach arg in args.iter() {
+    for arg in args.iter() {
         cmd.push_char(' ');
         append_arg(&mut cmd, *arg);
     }
@@ -587,7 +587,7 @@ pub fn make_command_line(prog: &str, args: &[~str]) -> ~str {
         if quote {
             cmd.push_char('"');
         }
-        foreach i in range(0u, arg.len()) {
+        for i in range(0u, arg.len()) {
             append_char_at(cmd, arg, i);
         }
         if quote {
@@ -694,7 +694,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 = ~[];
-    foreach arg in args.iter() {
+    for arg in args.iter() {
         let t = @(*arg).clone();
         tmps.push(t);
         argptrs.push(t.as_c_str(|b| b));
@@ -712,7 +712,7 @@ fn with_envp<T>(env: Option<&[(~str, ~str)]>, cb: &fn(*c_void) -> T) -> T {
         let mut tmps = ~[];
         let mut ptrs = ~[];
 
-        foreach pair in es.iter() {
+        for pair in es.iter() {
             // Use of match here is just to workaround limitations
             // in the stage0 irrefutable pattern impl.
             match pair {
@@ -741,7 +741,7 @@ fn with_envp<T>(env: Option<&[(~str, ~str)]>, cb: &fn(*mut c_void) -> T) -> T {
     match env {
       Some(es) => {
         let mut blk = ~[];
-        foreach pair in es.iter() {
+        for pair in es.iter() {
             let kv = fmt!("%s=%s", pair.first(), pair.second());
             blk.push_all(kv.to_bytes_with_null());
         }
@@ -1297,7 +1297,7 @@ mod tests {
         let output = str::from_bytes(prog.finish_with_output().output);
 
         let r = os::env();
-        foreach &(ref k, ref v) in r.iter() {
+        for &(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)));
         }
@@ -1311,7 +1311,7 @@ mod tests {
         let output = str::from_bytes(prog.finish_with_output().output);
 
         let r = os::env();
-        foreach &(k, v) in r.iter() {
+        for &(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 c30888529be..3db0f203d81 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());
-    foreach ch in chs.iter() {
+    for 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;
-                foreach ss in self.iter() {
+                for 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);
-                    foreach ss in self.iter() {
+                    for 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;
-    foreach (start, end) in s.matches_index_iter(from) {
+    for (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;
-    foreach c in needle.byte_iter() { if haystack[i] != c { return false; } i += 1u; }
+    for c in needle.byte_iter() { if haystack[i] != c { return false; } i += 1u; }
     return true;
 }
 
@@ -887,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);
-        foreach byte in bytes.iter() { push_byte(&mut *s, *byte); }
+        for byte in bytes.iter() { push_byte(&mut *s, *byte); }
     }
 
     /// Removes the last byte from a string and returns it. (Not UTF-8 safe).
@@ -953,7 +953,7 @@ pub mod traits {
     impl<'self> TotalOrd for &'self str {
         #[inline]
         fn cmp(&self, other: & &'self str) -> Ordering {
-            foreach (s_b, o_b) in self.byte_iter().zip(other.byte_iter()) {
+            for (s_b, o_b) in self.byte_iter().zip(other.byte_iter()) {
                 match s_b.cmp(&o_b) {
                     Greater => return Greater,
                     Less => return Less,
@@ -1467,7 +1467,7 @@ impl<'self> StrSlice<'self> for &'self str {
     fn escape_default(&self) -> ~str {
         let mut out: ~str = ~"";
         out.reserve_at_least(self.len());
-        foreach c in self.iter() {
+        for c in self.iter() {
             do c.escape_default |c| {
                 out.push_char(c);
             }
@@ -1479,7 +1479,7 @@ impl<'self> StrSlice<'self> for &'self str {
     fn escape_unicode(&self) -> ~str {
         let mut out: ~str = ~"";
         out.reserve_at_least(self.len());
-        foreach c in self.iter() {
+        for c in self.iter() {
             do c.escape_unicode |c| {
                 out.push_char(c);
             }
@@ -1581,7 +1581,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;
-        foreach (start, end) in self.matches_index_iter(from) {
+        for (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;
@@ -1619,7 +1619,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 = ~[];
-        foreach ch in self.iter() {
+        for ch in self.iter() {
             // Arithmetic with u32 literals is easier on the eyes than chars.
             let mut ch = ch as u32;
 
@@ -1772,12 +1772,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() {
-            foreach (i, b) in self.byte_iter().enumerate() {
+            for (i, b) in self.byte_iter().enumerate() {
                 if search.matches(b as char) { return Some(i) }
             }
         } else {
             let mut index = 0;
-            foreach c in self.iter() {
+            for c in self.iter() {
                 if search.matches(c) { return Some(index); }
                 index += c.len_utf8_bytes();
             }
@@ -1795,12 +1795,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() {
-            foreach b in self.byte_rev_iter() {
+            for b in self.byte_rev_iter() {
                 index -= 1;
                 if search.matches(b as char) { return Some(index); }
             }
         } else {
-            foreach c in self.rev_iter() {
+            for c in self.rev_iter() {
                 index -= c.len_utf8_bytes();
                 if search.matches(c) { return Some(index); }
             }
@@ -1869,7 +1869,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());
-        foreach cc in self.iter() {
+        for cc in self.iter() {
             result.push_char(ff(cc));
         }
         result
@@ -1885,12 +1885,12 @@ impl<'self> StrSlice<'self> for &'self str {
 
         let mut dcol = vec::from_fn(tlen + 1, |x| x);
 
-        foreach (i, sc) in self.iter().enumerate() {
+        for (i, sc) in self.iter().enumerate() {
 
             let mut current = i;
             dcol[0] = current + 1;
 
-            foreach (j, tc) in t.iter().enumerate() {
+            for (j, tc) in t.iter().enumerate() {
 
                 let next = dcol[j + 1];
 
@@ -1917,7 +1917,7 @@ impl<'self> StrSlice<'self> for &'self str {
     /// ~~~ {.rust}
     /// let string = "a\nb\nc";
     /// let mut lines = ~[];
-    /// foreach line in string.line_iter() { lines.push(line) }
+    /// for line in string.line_iter() { lines.push(line) }
     ///
     /// assert!(string.subslice_offset(lines[0]) == 0); // &"a"
     /// assert!(string.subslice_offset(lines[1]) == 2); // &"b"
@@ -2252,7 +2252,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);
-        foreach ch in *iterator {
+        for ch in *iterator {
             self.push_char(ch)
         }
     }
@@ -3068,7 +3068,7 @@ mod tests {
 
         let string = "a\nb\nc";
         let mut lines = ~[];
-        foreach line in string.line_iter() { lines.push(line) }
+        for 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);
@@ -3172,7 +3172,7 @@ mod tests {
                 0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
                 0x000a_u16 ]) ];
 
-        foreach p in pairs.iter() {
+        for p in pairs.iter() {
             let (s, u) = (*p).clone();
             assert!(s.to_utf16() == u);
             assert!(from_utf16(u) == s);
@@ -3186,7 +3186,7 @@ mod tests {
         let s = ~"ศไทย中华Việt Nam";
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
         let mut pos = 0;
-        foreach ch in v.iter() {
+        for ch in v.iter() {
             assert!(s.char_at(pos) == *ch);
             pos += from_char(*ch).len();
         }
@@ -3197,7 +3197,7 @@ mod tests {
         let s = ~"ศไทย中华Việt Nam";
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
         let mut pos = s.len();
-        foreach ch in v.rev_iter() {
+        for ch in v.rev_iter() {
             assert!(s.char_at_reverse(pos) == *ch);
             pos -= from_char(*ch).len();
         }
@@ -3289,7 +3289,7 @@ mod tests {
         let mut pos = 0;
         let mut it = s.iter();
 
-        foreach c in it {
+        for c in it {
             assert_eq!(c, v[pos]);
             pos += 1;
         }
@@ -3305,7 +3305,7 @@ mod tests {
         let mut pos = 0;
         let mut it = s.rev_iter();
 
-        foreach c in it {
+        for c in it {
             assert_eq!(c, v[pos]);
             pos += 1;
         }
@@ -3322,7 +3322,7 @@ mod tests {
         ];
         let mut pos = 0;
 
-        foreach b in s.byte_iter() {
+        for b in s.byte_iter() {
             assert_eq!(b, v[pos]);
             pos += 1;
         }
@@ -3338,7 +3338,7 @@ mod tests {
         ];
         let mut pos = v.len();
 
-        foreach b in s.byte_rev_iter() {
+        for b in s.byte_rev_iter() {
             pos -= 1;
             assert_eq!(b, v[pos]);
         }
@@ -3354,7 +3354,7 @@ mod tests {
         let mut pos = 0;
         let mut it = s.char_offset_iter();
 
-        foreach c in it {
+        for c in it {
             assert_eq!(c, (p[pos], v[pos]));
             pos += 1;
         }
@@ -3372,7 +3372,7 @@ mod tests {
         let mut pos = 0;
         let mut it = s.char_offset_rev_iter();
 
-        foreach c in it {
+        for 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 3f24f98bd3d..dd730f20689 100644
--- a/src/libstd/str/ascii.rs
+++ b/src/libstd/str/ascii.rs
@@ -94,7 +94,7 @@ impl<'self> AsciiCast<&'self[Ascii]> for &'self [u8] {
 
     #[inline]
     fn is_ascii(&self) -> bool {
-        foreach b in self.iter() {
+        for 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 69c4bb20caf..95d3cbaf89b 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);
 
-    foreach entry in map.mut_iter() {
+    for 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 e6f115958fd..3bf2f255f57 100644
--- a/src/libstd/task/spawn.rs
+++ b/src/libstd/task/spawn.rs
@@ -299,7 +299,7 @@ fn each_ancestor(list:        &mut AncestorList,
                         // safe to skip it. This will leave our TaskHandle
                         // hanging around in the group even after it's freed,
                         // but that's ok because, by virtue of the group being
-                        // dead, nobody will ever kill-all (foreach) over it.)
+                        // dead, nobody will ever kill-all (for) over it.)
                         if nobe_is_dead { true } else { forward_blk(tg_opt) }
                     };
                 /*##########################################################*
@@ -357,7 +357,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 {
-                    foreach x in this.notifier.mut_iter() {
+                    for x in this.notifier.mut_iter() {
                         x.failed = true;
                     }
                     // Take everybody down with us.
@@ -387,7 +387,7 @@ pub fn Taskgroup(tasks: TaskGroupArc,
        ancestors: AncestorList,
        is_main: bool,
        mut notifier: Option<AutoNotify>) -> Taskgroup {
-    foreach x in notifier.mut_iter() {
+    for x in notifier.mut_iter() {
         x.failed = false;
     }
 
@@ -465,13 +465,13 @@ fn kill_taskgroup(state: TaskGroupInner, me: &TaskHandle, is_main: bool) {
         if newstate.is_some() {
             let TaskGroupData { members: members, descendants: descendants } =
                 newstate.unwrap();
-            foreach sibling in members.consume() {
+            for sibling in members.consume() {
                 // Skip self - killing ourself won't do much good.
                 if &sibling != me {
                     RuntimeGlue::kill_task(sibling);
                 }
             }
-            foreach child in descendants.consume() {
+            for 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 b87a1657065..4649aac08b9 100644
--- a/src/libstd/to_str.rs
+++ b/src/libstd/to_str.rs
@@ -56,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;
-        foreach (key, value) in self.iter() {
+        for (key, value) in self.iter() {
             if first {
                 first = false;
             }
@@ -77,7 +77,7 @@ impl<A:ToStr+Hash+Eq> ToStr for HashSet<A> {
     fn to_str(&self) -> ~str {
         let mut acc = ~"{";
         let mut first = true;
-        foreach element in self.iter() {
+        for element in self.iter() {
             if first {
                 first = false;
             }
@@ -126,7 +126,7 @@ impl<'self,A:ToStr> ToStr for &'self [A] {
     fn to_str(&self) -> ~str {
         let mut acc = ~"[";
         let mut first = true;
-        foreach elt in self.iter() {
+        for elt in self.iter() {
             if first {
                 first = false;
             }
@@ -145,7 +145,7 @@ impl<A:ToStr> ToStr for ~[A] {
     fn to_str(&self) -> ~str {
         let mut acc = ~"[";
         let mut first = true;
-        foreach elt in self.iter() {
+        for elt in self.iter() {
             if first {
                 first = false;
             }
@@ -164,7 +164,7 @@ impl<A:ToStr> ToStr for @[A] {
     fn to_str(&self) -> ~str {
         let mut acc = ~"[";
         let mut first = true;
-        foreach elt in self.iter() {
+        for elt in self.iter() {
             if first {
                 first = false;
             }
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index 9bcf430ff90..962704172b4 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) {
-        foreach (k, v) in *iter {
+        for (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) {
-        foreach elem in *iter {
+        for elem in *iter {
             self.insert(elem);
         }
     }
@@ -261,7 +261,7 @@ impl<T> TrieNode<T> {
 
 impl<T> TrieNode<T> {
     fn each<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
-        foreach idx in range(0u, self.children.len()) {
+        for idx in range(0u, self.children.len()) {
             match self.children[idx] {
                 Internal(ref x) => if !x.each(|i,t| f(i,t)) { return false },
                 External(k, ref v) => if !f(&k, v) { return false },
@@ -282,7 +282,7 @@ impl<T> TrieNode<T> {
     }
 
     fn mutate_values<'a>(&'a mut self, f: &fn(&uint, &mut T) -> bool) -> bool {
-        foreach child in self.children.mut_iter() {
+        for child in self.children.mut_iter() {
             match *child {
                 Internal(ref mut x) => if !x.mutate_values(|i,t| f(i,t)) {
                     return false
@@ -378,7 +378,7 @@ pub fn check_integrity<T>(trie: &TrieNode<T>) {
 
     let mut sum = 0;
 
-    foreach x in trie.children.iter() {
+    for x in trie.children.iter() {
         match *x {
           Nothing => (),
           Internal(ref y) => {
@@ -430,7 +430,7 @@ mod test_map {
             true
         };
 
-        foreach x in range(0u, n) {
+        for x in range(0u, n) {
             assert!(trie.contains_key(&x));
             assert!(!trie.insert(x, x + 1));
             check_integrity(&trie.root);
@@ -555,7 +555,7 @@ mod test_map {
 
         let map: TrieMap<int> = xs.iter().transform(|&x| x).collect();
 
-        foreach &(k, v) in xs.iter() {
+        for &(k, v) in xs.iter() {
             assert_eq!(map.find(&k), Some(&v));
         }
     }
@@ -596,7 +596,7 @@ mod test_set {
 
         let set: TrieSet = xs.iter().transform(|&x| x).collect();
 
-        foreach x in xs.iter() {
+        for x in xs.iter() {
             assert!(set.contains(x));
         }
     }
diff --git a/src/libstd/unstable/extfmt.rs b/src/libstd/unstable/extfmt.rs
index 5417af50081..7b05515f74a 100644
--- a/src/libstd/unstable/extfmt.rs
+++ b/src/libstd/unstable/extfmt.rs
@@ -615,7 +615,7 @@ pub mod rt {
         let headsize = match head { Some(_) => 1, _ => 0 };
         let uwidth : uint = match cv.width {
             CountImplied => {
-                foreach &c in head.iter() {
+                for &c in head.iter() {
                     buf.push_char(c);
                 }
                 return buf.push_str(s);
@@ -624,7 +624,7 @@ pub mod rt {
         };
         let strlen = s.char_len() + headsize;
         if uwidth <= strlen {
-            foreach &c in head.iter() {
+            for &c in head.iter() {
                 buf.push_char(c);
             }
             return buf.push_str(s);
@@ -632,7 +632,7 @@ pub mod rt {
         let mut padchar = ' ';
         let diff = uwidth - strlen;
         if have_flag(cv.flags, flag_left_justify) {
-            foreach &c in head.iter() {
+            for &c in head.iter() {
                 buf.push_char(c);
             }
             buf.push_str(s);
@@ -666,7 +666,7 @@ pub mod rt {
         // instead.
 
         if signed && zero_padding {
-            foreach &head in head.iter() {
+            for &head in head.iter() {
                 if head == '+' || head == '-' || head == ' ' {
                     buf.push_char(head);
                     buf.push_str(padstr);
@@ -676,7 +676,7 @@ pub mod rt {
             }
         }
         buf.push_str(padstr);
-        foreach &c in head.iter() {
+        for &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 88c9c6ccb3a..225ac5c92ad 100644
--- a/src/libstd/unstable/sync.rs
+++ b/src/libstd/unstable/sync.rs
@@ -456,13 +456,13 @@ mod tests {
 
             let total = Exclusive::new(~0);
 
-            foreach _ in range(0u, num_tasks) {
+            for _ in range(0u, num_tasks) {
                 let total = total.clone();
                 let (port, chan) = comm::stream();
                 futures.push(port);
 
                 do task::spawn || {
-                    foreach _ in range(0u, count) {
+                    for _ in range(0u, count) {
                         do total.with |count| {
                             **count += 1;
                         }
@@ -471,7 +471,7 @@ mod tests {
                 }
             };
 
-            foreach f in futures.iter() { f.recv() }
+            for 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 1f6adaf040b..f037aa2b7e7 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 = ~[];
-    foreach elem in v.iter() { result.push_all_move(f(elem)); }
+    for 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;
-        foreach inner in self.iter() {
+        for 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;
-        foreach &inner in self.iter() {
+        for &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 = ~[];
-    foreach p in v.iter() {
+    for 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 = ~[];
-    foreach p in v.consume_iter() {
+    for p in v.consume_iter() {
         let (t, u) = p;
         ts.push(t);
         us.push(u);
@@ -473,7 +473,7 @@ pub fn each_permutation<T:Clone>(values: &[T], fun: &fn(perm : &[T]) -> bool) ->
         indices.swap(k, l);
         indices.mut_slice(k+1, length).reverse();
         // fixup permutation based on indices
-        foreach i in range(k, length) {
+        for i in range(k, length) {
             permutation[i] = values[indices[i]].clone();
         }
     }
@@ -589,7 +589,7 @@ pub mod traits {
 
     impl<'self,T:TotalOrd> TotalOrd for &'self [T] {
         fn cmp(&self, other: & &'self [T]) -> Ordering {
-            foreach (s,o) in self.iter().zip(other.iter()) {
+            for (s,o) in self.iter().zip(other.iter()) {
                 match s.cmp(o) {
                     Equal => {},
                     non_eq => { return non_eq; }
@@ -611,7 +611,7 @@ pub mod traits {
 
     impl<'self,T:Ord> Ord for &'self [T] {
         fn lt(&self, other: & &'self [T]) -> bool {
-            foreach (s,o) in self.iter().zip(other.iter()) {
+            for (s,o) in self.iter().zip(other.iter()) {
                 if *s < *o { return true; }
                 if *s > *o { return false; }
             }
@@ -725,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());
-        foreach e in self.iter() {
+        for e in self.iter() {
             result.push((*e).clone());
         }
         result
@@ -880,7 +880,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
      *
      * ~~~ {.rust}
      * let v = &[1,2,3,4];
-     * foreach win in v.window_iter() {
+     * for win in v.window_iter() {
      *     printfln!(win);
      * }
      * ~~~
@@ -909,7 +909,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
      *
      * ~~~ {.rust}
      * let v = &[1,2,3,4,5];
-     * foreach win in v.chunk_iter() {
+     * for win in v.chunk_iter() {
      *     printfln!(win);
      * }
      * ~~~
@@ -975,7 +975,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
      */
     #[inline]
     fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
-        foreach (i, t) in self.rev_iter().enumerate() {
+        for (i, t) in self.rev_iter().enumerate() {
             if f(t) { return Some(self.len() - i - 1); }
         }
         None
@@ -1075,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 {
-        foreach elt in self.iter() { if *x == *elt { return true; } }
+        for elt in self.iter() { if *x == *elt { return true; } }
         false
     }
 }
@@ -1113,7 +1113,7 @@ impl<'self,T:Clone> ImmutableCopyableVector<T> for &'self [T] {
         let mut lefts  = ~[];
         let mut rights = ~[];
 
-        foreach elt in self.iter() {
+        for elt in self.iter() {
             if f(elt) {
                 lefts.push((*elt).clone());
             } else {
@@ -1170,7 +1170,7 @@ impl<T> OwnedVector<T> for ~[T] {
     ///
     /// ~~~ {.rust}
     /// let v = ~[~"a", ~"b"];
-    /// foreach s in v.consume_iter() {
+    /// for s in v.consume_iter() {
     ///   // s has type ~str, not &~str
     ///   println(s);
     /// }
@@ -1461,7 +1461,7 @@ impl<T> OwnedVector<T> for ~[T] {
             assert!(newlen <= oldlen);
             unsafe {
                 // This loop is optimized out for non-drop types.
-                foreach i in range(newlen, oldlen) {
+                for i in range(newlen, oldlen) {
                     ptr::read_and_zero_ptr(ptr::mut_offset(p, i as int));
                 }
             }
@@ -1477,7 +1477,7 @@ impl<T> OwnedVector<T> for ~[T] {
         let len = self.len();
         let mut deleted: uint = 0;
 
-        foreach i in range(0u, len) {
+        for i in range(0u, len) {
             if !f(&self[i]) {
                 deleted += 1;
             } else if deleted > 0 {
@@ -1499,7 +1499,7 @@ impl<T> OwnedVector<T> for ~[T] {
         let mut lefts  = ~[];
         let mut rights = ~[];
 
-        foreach elt in self.consume_iter() {
+        for elt in self.consume_iter() {
             if f(&elt) {
                 lefts.push(elt);
             } else {
@@ -1561,7 +1561,7 @@ impl<T:Clone> OwnedCopyableVector<T> for ~[T] {
         let new_len = self.len() + rhs.len();
         self.reserve(new_len);
 
-        foreach i in range(0u, rhs.len()) {
+        for i in range(0u, rhs.len()) {
             self.push(unsafe { raw::get(rhs, i) })
         }
     }
@@ -1832,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 {
-        foreach (a, b) in self.mut_iter().zip(src.mut_slice(start, end).mut_iter()) {
+        for (a, b) in self.mut_iter().zip(src.mut_slice(start, end).mut_iter()) {
             util::swap(a, b);
         }
         cmp::min(self.len(), end-start)
@@ -1867,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 {
-        foreach (a, b) in self.mut_iter().zip(src.iter()) {
+        for (a, b) in self.mut_iter().zip(src.iter()) {
             *a = b.clone();
         }
         cmp::min(self.len(), src.len())
@@ -2276,7 +2276,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);
-        foreach x in *iterator {
+        for x in *iterator {
             xs.push(x);
         }
         xs
@@ -2288,7 +2288,7 @@ impl<A, T: Iterator<A>> Extendable<A, T> for ~[A] {
         let (lower, _) = iterator.size_hint();
         let len = self.len();
         self.reserve(len + lower);
-        foreach x in *iterator {
+        for x in *iterator {
             self.push(x);
         }
     }
@@ -3246,7 +3246,7 @@ mod tests {
     fn test_mut_iterator() {
         use iterator::*;
         let mut xs = [1, 2, 3, 4, 5];
-        foreach x in xs.mut_iter() {
+        for x in xs.mut_iter() {
             *x += 1;
         }
         assert_eq!(xs, [2, 3, 4, 5, 6])
@@ -3259,7 +3259,7 @@ mod tests {
         let xs = [1, 2, 5, 10, 11];
         let ys = [11, 10, 5, 2, 1];
         let mut i = 0;
-        foreach &x in xs.rev_iter() {
+        for &x in xs.rev_iter() {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -3270,7 +3270,7 @@ mod tests {
     fn test_mut_rev_iterator() {
         use iterator::*;
         let mut xs = [1u, 2, 3, 4, 5];
-        foreach (i,x) in xs.mut_rev_iter().enumerate() {
+        for (i,x) in xs.mut_rev_iter().enumerate() {
             *x += i;
         }
         assert_eq!(xs, [5, 5, 5, 5, 5])
@@ -3514,12 +3514,12 @@ mod tests {
         {
             let (left, right) = values.mut_split(2);
             assert_eq!(left.slice(0, left.len()), [1, 2]);
-            foreach p in left.mut_iter() {
+            for p in left.mut_iter() {
                 *p += 1;
             }
 
             assert_eq!(right.slice(0, right.len()), [3, 4, 5]);
-            foreach p in right.mut_iter() {
+            for p in right.mut_iter() {
                 *p += 2;
             }
         }
@@ -3536,25 +3536,25 @@ mod tests {
         assert_eq!(v.len(), 3);
         let mut cnt = 0;
 
-        foreach f in v.iter() {
+        for f in v.iter() {
             assert!(*f == Foo);
             cnt += 1;
         }
         assert_eq!(cnt, 3);
 
-        foreach f in v.slice(1, 3).iter() {
+        for f in v.slice(1, 3).iter() {
             assert!(*f == Foo);
             cnt += 1;
         }
         assert_eq!(cnt, 5);
 
-        foreach f in v.mut_iter() {
+        for f in v.mut_iter() {
             assert!(*f == Foo);
             cnt += 1;
         }
         assert_eq!(cnt, 8);
 
-        foreach f in v.consume_iter() {
+        for f in v.consume_iter() {
             assert!(f == Foo);
             cnt += 1;
         }
@@ -3566,7 +3566,7 @@ mod tests {
         let xs: [Foo, ..3] = [Foo, Foo, Foo];
         assert_eq!(fmt!("%?", xs.slice(0, 2).to_owned()), ~"~[{}, {}]");
         cnt = 0;
-        foreach f in xs.iter() {
+        for f in xs.iter() {
             assert!(*f == Foo);
             cnt += 1;
         }
@@ -3588,7 +3588,7 @@ mod bench {
 
         do bh.iter {
             let mut sum = 0;
-            foreach x in v.iter() {
+            for x in v.iter() {
                 sum += *x;
             }
             // sum == 11806, to stop dead code elimination.
@@ -3602,7 +3602,7 @@ mod bench {
 
         do bh.iter {
             let mut i = 0;
-            foreach x in v.mut_iter() {
+            for x in v.mut_iter() {
                 *x = i;
                 i += 1;
             }