convert remaining range(a, b) to a..b

Author: Jorge Aparicio

src/libcollections/binary_heap.rs

@@ -67,7 +67,7 @@
 //! // for a simpler implementation.
 //! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: uint, goal: uint) -> uint {
 //!     // dist[node] = current shortest distance from `start` to `node`
-//!     let mut dist: Vec<_> = range(0, adj_list.len()).map(|_| uint::MAX).collect();
+//!     let mut dist: Vec<_> = (0..adj_list.len()).map(|_| uint::MAX).collect();
 //!
 //!     let mut heap = BinaryHeap::new();
 //!

src/libcollections/btree/map.rs

@@ -1730,7 +1730,7 @@ mod test {
         let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
 
         let mut j = 0u;
-        for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(range(2u, size)) {
+        for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2u..size) {
             assert_eq!(k, i);
             assert_eq!(v, i);
             j += 1;

src/libcollections/dlist.rs

@@ -599,7 +599,7 @@ impl<T> DList<T> {
         }  else {
             // better off starting from the end
             let mut iter = self.iter_mut();
-            for _ in range(0, len - 1 - (at - 1)) {
+            for _ in 0..len - 1 - (at - 1) {
                 iter.next_back();
             }
             iter.tail

src/libcollections/ring_buf.rs

@@ -388,7 +388,7 @@ impl<T> RingBuf<T> {
     /// use std::collections::RingBuf;
     ///
     /// let mut buf = RingBuf::with_capacity(15);
-    /// buf.extend(range(0u, 4));
+    /// buf.extend(0u..4);
     /// assert_eq!(buf.capacity(), 15);
     /// buf.shrink_to_fit();
     /// assert!(buf.capacity() >= 4);
@@ -483,7 +483,7 @@ impl<T> RingBuf<T> {
     #[unstable(feature = "collections",
                reason = "matches collection reform specification; waiting on panic semantics")]
     pub fn truncate(&mut self, len: uint) {
-        for _ in range(len, self.len()) {
+        for _ in len..self.len() {
             self.pop_back();
         }
     }

src/libcollections/slice.rs

@@ -1254,7 +1254,7 @@ impl Iterator for ElementSwaps {
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
         // For a vector of size n, there are exactly n! permutations.
-        let n = range(2, self.sdir.len() + 1).product();
+        let n = (2..self.sdir.len() + 1).product();
         (n - self.swaps_made, Some(n - self.swaps_made))
     }
 }
@@ -1385,7 +1385,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
     // .offset-ing.
     for start in range_step(0, len, insertion) {
         // start <= i < len;
-        for i in range(start, cmp::min(start + insertion, len)) {
+        for i in start..cmp::min(start + insertion, len) {
             // j satisfies: start <= j <= i;
             let mut j = i as int;
             unsafe {

src/libcollections/vec.rs

@@ -1079,7 +1079,7 @@ impl<T: Clone> Vec<T> {
     pub fn push_all(&mut self, other: &[T]) {
         self.reserve(other.len());
 
-        for i in range(0, other.len()) {
+        for i in 0..other.len() {
             let len = self.len();
 
             // Unsafe code so this can be optimised to a memcpy (or something similarly
@@ -1988,12 +1988,12 @@ mod tests {
         let mut v = Vec::new();
         let mut w = Vec::new();
 
-        v.extend(range(0i, 3));
+        v.extend(0i..3);
         for i in 0i..3 { w.push(i) }
 
         assert_eq!(v, w);
 
-        v.extend(range(3i, 10));
+        v.extend(3i..10);
         for i in 3i..10 { w.push(i) }
 
         assert_eq!(v, w);
@@ -2499,7 +2499,7 @@ mod tests {
     }
 
     fn do_bench_from_slice(b: &mut Bencher, src_len: uint) {
-        let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+        let src: Vec<uint> = FromIterator::from_iter(0..src_len);
 
         b.bytes = src_len as u64;
 
@@ -2531,7 +2531,7 @@ mod tests {
     }
 
     fn do_bench_from_iter(b: &mut Bencher, src_len: uint) {
-        let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+        let src: Vec<uint> = FromIterator::from_iter(0..src_len);
 
         b.bytes = src_len as u64;
 
@@ -2563,8 +2563,8 @@ mod tests {
     }
 
     fn do_bench_extend(b: &mut Bencher, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(range(0, dst_len));
-        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+        let dst: Vec<uint> = FromIterator::from_iter(0..dst_len);
+        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = src_len as u64;
 
@@ -2612,8 +2612,8 @@ mod tests {
     }
 
     fn do_bench_push_all(b: &mut Bencher, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(range(0, dst_len));
-        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+        let dst: Vec<uint> = FromIterator::from_iter(0..dst_len);
+        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = src_len as u64;
 
@@ -2661,8 +2661,8 @@ mod tests {
     }
 
     fn do_bench_push_all_move(b: &mut Bencher, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(range(0u, dst_len));
-        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+        let dst: Vec<uint> = FromIterator::from_iter(0u..dst_len);
+        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = src_len as u64;
 
@@ -2710,7 +2710,7 @@ mod tests {
     }
 
     fn do_bench_clone(b: &mut Bencher, src_len: uint) {
-        let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+        let src: Vec<uint> = FromIterator::from_iter(0..src_len);
 
         b.bytes = src_len as u64;
 
@@ -2742,8 +2742,8 @@ mod tests {
     }
 
     fn do_bench_clone_from(b: &mut Bencher, times: uint, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(range(0, src_len));
-        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+        let dst: Vec<uint> = FromIterator::from_iter(0..src_len);
+        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = (times * src_len) as u64;
 

src/libcollections/vec_map.rs

@@ -459,7 +459,7 @@ impl<V> VecMap<V> {
     pub fn insert(&mut self, key: uint, value: V) -> Option<V> {
         let len = self.v.len();
         if len <= key {
-            self.v.extend(range(0, key - len + 1).map(|_| None));
+            self.v.extend((0..key - len + 1).map(|_| None));
         }
         replace(&mut self.v[key], Some(value))
     }

src/libcore/borrow.rs

@@ -125,7 +125,7 @@ impl<T> ToOwned<T> for T where T: Clone {
 /// use std::borrow::Cow;
 ///
 /// fn abs_all(input: &mut Cow<Vec<int>, [int]>) {
-///     for i in range(0, input.len()) {
+///     for i in 0..input.len() {
 ///         let v = input[i];
 ///         if v < 0 {
 ///             // clones into a vector the first time (if not already owned)

src/libcore/str/mod.rs

@@ -800,7 +800,7 @@ impl TwoWaySearcher {
             // See if the right part of the needle matches
             let start = if long_period { self.crit_pos }
                         else { cmp::max(self.crit_pos, self.memory) };
-            for i in range(start, needle.len()) {
+            for i in start..needle.len() {
                 if needle[i] != haystack[self.position + i] {
                     self.position += i - self.crit_pos + 1;
                     if !long_period {

src/libcoretest/iter.rs

@@ -305,7 +305,7 @@ fn test_cycle() {
 #[test]
 fn test_iterator_nth() {
     let v: &[_] = &[0i, 1, 2, 3, 4];
-    for i in range(0u, v.len()) {
+    for i in 0u..v.len() {
         assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
     }
     assert_eq!(v.iter().nth(v.len()), None);
@@ -458,7 +458,7 @@ fn test_min_by() {
 
 #[test]
 fn test_by_ref() {
-    let mut xs = range(0i, 10);
+    let mut xs = 0i..10;
     // sum the first five values
     let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b);
     assert_eq!(partial_sum, 10);
@@ -730,32 +730,32 @@ fn test_random_access_cycle() {
 
 #[test]
 fn test_double_ended_range() {
-    assert!(range(11i, 14).rev().collect::<Vec<int>>() == vec![13i, 12, 11]);
+    assert!((11i..14).rev().collect::<Vec<int>>() == vec![13i, 12, 11]);
     for _ in (10i..0).rev() {
         panic!("unreachable");
     }
 
-    assert!(range(11u, 14).rev().collect::<Vec<uint>>() == vec![13u, 12, 11]);
+    assert!((11u..14).rev().collect::<Vec<uint>>() == vec![13u, 12, 11]);
     for _ in (10u..0).rev() {
         panic!("unreachable");
     }
 }
 
 #[test]
 fn test_range() {
-    assert!(range(0i, 5).collect::<Vec<int>>() == vec![0i, 1, 2, 3, 4]);
-    assert!(range(-10i, -1).collect::<Vec<int>>() ==
+    assert!((0i..5).collect::<Vec<int>>() == vec![0i, 1, 2, 3, 4]);
+    assert!((-10i..-1).collect::<Vec<int>>() ==
                vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]);
-    assert!(range(0i, 5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]);
-    assert_eq!(range(200i, -5).count(), 0);
-    assert_eq!(range(200i, -5).rev().count(), 0);
-    assert_eq!(range(200i, 200).count(), 0);
-    assert_eq!(range(200i, 200).rev().count(), 0);
+    assert!((0i..5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]);
+    assert_eq!((200i..-5).count(), 0);
+    assert_eq!((200i..-5).rev().count(), 0);
+    assert_eq!((200i..200).count(), 0);
+    assert_eq!((200i..200).rev().count(), 0);
 
-    assert_eq!(range(0i, 100).size_hint(), (100, Some(100)));
+    assert_eq!((0i..100).size_hint(), (100, Some(100)));
     // this test is only meaningful when sizeof uint < sizeof u64
-    assert_eq!(range(uint::MAX - 1, uint::MAX).size_hint(), (1, Some(1)));
-    assert_eq!(range(-10i, -1).size_hint(), (9, Some(9)));
+    assert_eq!((uint::MAX - 1..uint::MAX).size_hint(), (1, Some(1)));
+    assert_eq!((-10i..-1).size_hint(), (9, Some(9)));
 }
 
 #[test]
@@ -892,7 +892,7 @@ fn bench_rposition(b: &mut Bencher) {
 #[bench]
 fn bench_skip_while(b: &mut Bencher) {
     b.iter(|| {
-        let it = range(0u, 100);
+        let it = 0u..100;
         let mut sum = 0;
         it.skip_while(|&x| { sum += x; sum < 4000 }).all(|_| true);
     });