std: Fix for-range loops that can use iterators

Fix inappropriate for-range loops to use for-iterator constructs (or
other appropriate solution) instead.

Author: blake2-ppc

src/libextra/arc.rs

@@ -846,22 +846,16 @@ mod tests {
                 }
                 assert_eq!(*state, 42);
                 *state = 31337;
-                // FIXME: #7372: hits type inference bug with iterators
                 // send to other readers
-                for i in range(0u, reader_convos.len()) {
-                    match reader_convos[i] {
-                        (ref rc, _) => rc.send(()),
-                    }
+                for &(ref rc, _) in reader_convos.iter() {
+                    rc.send(())
                 }
             }
             let read_mode = arc.downgrade(write_mode);
             do (&read_mode).read |state| {
-                // FIXME: #7372: hits type inference bug with iterators
                 // complete handshake with other readers
-                for i in range(0u, reader_convos.len()) {
-                    match reader_convos[i] {
-                        (_, ref rp) => rp.recv(),
-                    }
+                for &(_, ref rp) in reader_convos.iter() {
+                    rp.recv()
                 }
                 wc1.send(()); // tell writer to try again
                 assert_eq!(*state, 31337);

src/libextra/bitv.rs

@@ -145,22 +145,24 @@ impl BigBitv {
         let len = b.storage.len();
         assert_eq!(self.storage.len(), len);
         let mut changed = false;
-        for i in range(0, len) {
+        for (i, (a, b)) in self.storage.mut_iter()
+                               .zip(b.storage.iter())
+                               .enumerate() {
             let mask = big_mask(nbits, i);
-            let w0 = self.storage[i] & mask;
-            let w1 = b.storage[i] & mask;
+            let w0 = *a & mask;
+            let w1 = *b & mask;
             let w = op(w0, w1) & mask;
             if w0 != w {
                 changed = true;
-                self.storage[i] = w;
+                *a = w;
             }
         }
         changed
     }
 
     #[inline]
     pub fn each_storage(&mut self, op: &fn(v: &mut uint) -> bool) -> bool {
-        range(0u, self.storage.len()).advance(|i| op(&mut self.storage[i]))
+        self.storage.mut_iter().advance(|elt| op(elt))
     }
 
     #[inline]
@@ -205,10 +207,9 @@ impl BigBitv {
 
     #[inline]
     pub fn equals(&self, b: &BigBitv, nbits: uint) -> bool {
-        let len = b.storage.len();
-        for i in range(0, len) {
+        for (i, elt) in b.storage.iter().enumerate() {
             let mask = big_mask(nbits, i);
-            if mask & self.storage[i] != mask & b.storage[i] {
+            if mask & self.storage[i] != mask & *elt {
                 return false;
             }
         }

src/libextra/smallintmap.rs

@@ -28,14 +28,12 @@ pub struct SmallIntMap<T> {
 impl<V> Container for SmallIntMap<V> {
     /// Return the number of elements in the map
     fn len(&self) -> uint {
-        let mut sz = 0;
-        for i in range(0u, self.v.len()) {
-            match self.v[i] {
-                Some(_) => sz += 1,
-                None => {}
-            }
-        }
-        sz
+        self.v.iter().count(|elt| elt.is_some())
+    }
+
+    /// Return true if there are no elements in the map
+    fn is_empty(&self) -> bool {
+        self.v.iter().all(|elt| elt.is_none())
     }
 }
 

src/libextra/sort.rs

@@ -469,10 +469,7 @@ impl<T:Clone + Ord> MergeState<T> {
                 base2: uint, len2: uint) {
         assert!(len1 != 0 && len2 != 0 && base1+len1 == base2);
 
-        let mut tmp = ~[];
-        for i in range(base1, base1+len1) {
-            tmp.push(array[i].clone());
-        }
+        let mut tmp = array.slice(base1, base1 + len1).to_owned();
 
         let mut c1 = 0;
         let mut c2 = base2;
@@ -579,10 +576,7 @@ impl<T:Clone + Ord> MergeState<T> {
                 base2: uint, len2: uint) {
         assert!(len1 != 1 && len2 != 0 && base1 + len1 == base2);
 
-        let mut tmp = ~[];
-        for i in range(base2, base2+len2) {
-            tmp.push(array[i].clone());
-        }
+        let mut tmp = array.slice(base2, base2 + len2).to_owned();
 
         let mut c1 = base1 + len1 - 1;
         let mut c2 = len2 - 1;

src/libstd/at_vec.rs

@@ -12,7 +12,7 @@
 
 use clone::Clone;
 use container::Container;
-use iterator::{Iterator, range};
+use iterator::Iterator;
 use option::{Option, Some, None};
 use sys;
 use unstable::raw::Repr;
@@ -92,8 +92,8 @@ pub fn append<T:Clone>(lhs: @[T], rhs: &[T]) -> @[T] {
         for x in lhs.iter() {
             push((*x).clone());
         }
-        for i in range(0u, rhs.len()) {
-            push(rhs[i].clone());
+        for elt in rhs.iter() {
+            push(elt.clone());
         }
     }
 }

src/libstd/hashmap.rs

@@ -19,7 +19,7 @@ use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 use clone::Clone;
 use cmp::{Eq, Equiv};
 use hash::Hash;
-use iterator::{Iterator, IteratorUtil, FromIterator, Extendable, range};
+use iterator::{Iterator, IteratorUtil, FromIterator, Extendable};
 use iterator::{FilterMap, Chain, Repeat, Zip};
 use num;
 use option::{None, Option, Some};
@@ -265,8 +265,8 @@ 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) {
-        for idx in range(0u, self.buckets.len()) {
-            self.buckets[idx] = None;
+        for bkt in self.buckets.mut_iter() {
+            *bkt = None;
         }
         self.size = 0;
     }

src/libstd/trie.rs

@@ -271,8 +271,8 @@ impl<T> TrieNode<T> {
 
 impl<T> TrieNode<T> {
     fn each<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
-        for idx in range(0u, self.children.len()) {
-            match self.children[idx] {
+        for elt in self.children.iter() {
+            match *elt {
                 Internal(ref x) => if !x.each(|i,t| f(i,t)) { return false },
                 External(k, ref v) => if !f(&k, v) { return false },
                 Nothing => ()

src/libstd/vec.rs

@@ -1597,8 +1597,8 @@ impl<T:Clone> OwnedCopyableVector<T> for ~[T] {
         let new_len = self.len() + rhs.len();
         self.reserve(new_len);
 
-        for i in range(0u, rhs.len()) {
-            self.push(unsafe { raw::get(rhs, i) })
+        for elt in rhs.iter() {
+            self.push((*elt).clone())
         }
     }