range(a, b).foo() -> (a..b).foo()

sed -i 's/ range(\([^,]*\), *\([^()]*\))\./ (\1\.\.\2)\./g' **/*.rs

Author: Jorge Aparicio

src/liballoc/arc.rs

@@ -95,7 +95,7 @@ use heap::deallocate;
 /// use std::thread::Thread;
 ///
 /// fn main() {
-///     let numbers: Vec<_> = range(0, 100u32).map(|i| i as f32).collect();
+///     let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect();
 ///     let shared_numbers = Arc::new(numbers);
 ///
 ///     for _ in range(0u, 10) {

src/libcollections/bench.rs

@@ -70,7 +70,7 @@ pub fn find_rand_n<M, T, I, F>(n: uint,
 {
     // setup
     let mut rng = rand::weak_rng();
-    let mut keys = range(0, n).map(|_| rng.gen::<uint>() % n)
+    let mut keys = (0..n).map(|_| rng.gen::<uint>() % n)
                               .collect::<Vec<_>>();
 
     for k in keys.iter() {

src/libcollections/bit.rs

@@ -660,7 +660,7 @@ impl Bitv {
 
         let len = self.nbits/8 +
                   if self.nbits % 8 == 0 { 0 } else { 1 };
-        range(0, len).map(|i|
+        (0..len).map(|i|
             bit(self, i, 0) |
             bit(self, i, 1) |
             bit(self, i, 2) |
@@ -2283,7 +2283,7 @@ mod tests {
 
         assert_eq!(bitv.iter().collect::<Vec<bool>>(), bools);
 
-        let long = range(0, 10000).map(|i| i % 2 == 0).collect::<Vec<_>>();
+        let long = (0..10000).map(|i| i % 2 == 0).collect::<Vec<_>>();
         let bitv: Bitv = long.iter().map(|n| *n).collect();
         assert_eq!(bitv.iter().collect::<Vec<bool>>(), long)
     }
@@ -2647,7 +2647,7 @@ mod bitv_set_test {
         let idxs: Vec<uint> = bitv.iter().collect();
         assert_eq!(idxs, vec![0, 2, 3]);
 
-        let long: BitvSet = range(0u, 10000).filter(|&n| n % 2 == 0).collect();
+        let long: BitvSet = (0u..10000).filter(|&n| n % 2 == 0).collect();
         let real = range_step(0, 10000, 2).collect::<Vec<uint>>();
 
         let idxs: Vec<uint> = long.iter().collect();

src/libcollections/btree/map.rs

@@ -1661,7 +1661,7 @@ mod test {
         let size = 10000u;
 
         // Forwards
-        let mut map: BTreeMap<uint, uint> = range(0, size).map(|i| (i, i)).collect();
+        let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
 
         fn test<T>(size: uint, mut iter: T) where T: Iterator<Item=(uint, uint)> {
             for i in range(0, size) {
@@ -1681,7 +1681,7 @@ mod test {
         let size = 10000u;
 
         // Forwards
-        let mut map: BTreeMap<uint, uint> = range(0, size).map(|i| (i, i)).collect();
+        let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
 
         fn test<T>(size: uint, mut iter: T) where T: Iterator<Item=(uint, uint)> {
             for i in range(0, size) {
@@ -1701,7 +1701,7 @@ mod test {
         let size = 10000u;
 
         // Forwards
-        let mut map: BTreeMap<uint, uint> = range(0, size).map(|i| (i, i)).collect();
+        let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
 
         fn test<T>(size: uint, mut iter: T)
                 where T: Iterator<Item=(uint, uint)> + DoubleEndedIterator {
@@ -1727,7 +1727,7 @@ mod test {
         let size = 5u;
 
         // Forwards
-        let map: BTreeMap<uint, uint> = range(0, size).map(|i| (i, i)).collect();
+        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)) {
@@ -1741,11 +1741,11 @@ mod test {
     #[test]
     fn test_range_1000() {
         let size = 1000u;
-        let map: BTreeMap<uint, uint> = range(0, size).map(|i| (i, i)).collect();
+        let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
 
         fn test(map: &BTreeMap<uint, uint>, size: uint, min: Bound<&uint>, max: Bound<&uint>) {
             let mut kvs = map.range(min, max).map(|(&k, &v)| (k, v));
-            let mut pairs = range(0, size).map(|i| (i, i));
+            let mut pairs = (0..size).map(|i| (i, i));
 
             for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) {
                 assert_eq!(kv, pair);
@@ -1764,7 +1764,7 @@ mod test {
     #[test]
     fn test_range() {
         let size = 200u;
-        let map: BTreeMap<uint, uint> = range(0, size).map(|i| (i, i)).collect();
+        let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
 
         for i in range(0, size) {
             for j in range(i, size) {

src/libcollections/dlist.rs

@@ -1334,7 +1334,7 @@ mod tests {
 
     #[test]
     fn test_show() {
-        let list: DList<int> = range(0i, 10).collect();
+        let list: DList<int> = (0i..10).collect();
         assert_eq!(format!("{:?}", list), "DList [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
 
         let list: DList<&str> = vec!["just", "one", "test", "more"].iter()

src/libcollections/ring_buf.rs

@@ -1828,7 +1828,7 @@ mod tests {
 
     #[bench]
     fn bench_iter_1000(b: &mut test::Bencher) {
-        let ring: RingBuf<int> = range(0i, 1000).collect();
+        let ring: RingBuf<int> = (0i..1000).collect();
 
         b.iter(|| {
             let mut sum = 0;
@@ -1841,7 +1841,7 @@ mod tests {
 
     #[bench]
     fn bench_mut_iter_1000(b: &mut test::Bencher) {
-        let mut ring: RingBuf<int> = range(0i, 1000).collect();
+        let mut ring: RingBuf<int> = (0i..1000).collect();
 
         b.iter(|| {
             let mut sum = 0;
@@ -1977,7 +1977,7 @@ mod tests {
 
     #[test]
     fn test_swap() {
-        let mut d: RingBuf<int> = range(0i, 5).collect();
+        let mut d: RingBuf<int> = (0i..5).collect();
         d.pop_front();
         d.swap(0, 3);
         assert_eq!(d.iter().map(|&x|x).collect::<Vec<int>>(), vec!(4, 2, 3, 1));
@@ -2309,7 +2309,7 @@ mod tests {
 
     #[test]
     fn test_show() {
-        let ringbuf: RingBuf<int> = range(0i, 10).collect();
+        let ringbuf: RingBuf<int> = (0i..10).collect();
         assert_eq!(format!("{:?}", ringbuf), "RingBuf [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
 
         let ringbuf: RingBuf<&str> = vec!["just", "one", "test", "more"].iter()
@@ -2494,9 +2494,9 @@ mod tests {
 
             for len in range(0, final_len) {
                 let expected = if back {
-                    range(0, len).collect()
+                    (0..len).collect()
                 } else {
-                    range(0, len).rev().collect()
+                    (0..len).rev().collect()
                 };
                 for tail_pos in range(0, usable_cap) {
                     tester.tail = tail_pos;
@@ -2652,16 +2652,16 @@ mod tests {
             ring.push_back(i);
 
             let (left, right) = ring.as_slices();
-            let expected: Vec<_> = range(0, i+1).collect();
+            let expected: Vec<_> = (0..i+1).collect();
             assert_eq!(left, expected);
             assert_eq!(right, []);
         }
 
         for j in range(-last, 0) {
             ring.push_front(j);
             let (left, right) = ring.as_slices();
-            let expected_left: Vec<_> = range(-last, j+1).rev().collect();
-            let expected_right: Vec<_> = range(0, first).collect();
+            let expected_left: Vec<_> = (-last..j+1).rev().collect();
+            let expected_right: Vec<_> = (0..first).collect();
             assert_eq!(left, expected_left);
             assert_eq!(right, expected_right);
         }
@@ -2680,16 +2680,16 @@ mod tests {
             ring.push_back(i);
 
             let (left, right) = ring.as_mut_slices();
-            let expected: Vec<_> = range(0, i+1).collect();
+            let expected: Vec<_> = (0..i+1).collect();
             assert_eq!(left, expected);
             assert_eq!(right, []);
         }
 
         for j in range(-last, 0) {
             ring.push_front(j);
             let (left, right) = ring.as_mut_slices();
-            let expected_left: Vec<_> = range(-last, j+1).rev().collect();
-            let expected_right: Vec<_> = range(0, first).collect();
+            let expected_left: Vec<_> = (-last..j+1).rev().collect();
+            let expected_right: Vec<_> = (0..first).collect();
             assert_eq!(left, expected_left);
             assert_eq!(right, expected_right);
         }

src/libcollections/slice.rs

@@ -1165,7 +1165,7 @@ impl ElementSwaps {
         // element (equal to the original index).
         ElementSwaps{
             emit_reset: true,
-            sdir: range(0, length).map(|i| SizeDirection{ size: i, dir: Neg }).collect(),
+            sdir: (0..length).map(|i| SizeDirection{ size: i, dir: Neg }).collect(),
             swaps_made: 0
         }
     }
@@ -1526,7 +1526,7 @@ mod tests {
     #[test]
     fn test_from_fn() {
         // Test on-stack from_fn.
-        let mut v = range(0, 3).map(square).collect::<Vec<_>>();
+        let mut v = (0..3).map(square).collect::<Vec<_>>();
         {
             let v = v.as_slice();
             assert_eq!(v.len(), 3u);
@@ -1536,7 +1536,7 @@ mod tests {
         }
 
         // Test on-heap from_fn.
-        v = range(0, 5).map(square).collect::<Vec<_>>();
+        v = (0..5).map(square).collect::<Vec<_>>();
         {
             let v = v.as_slice();
             assert_eq!(v.len(), 5u);
@@ -2134,7 +2134,7 @@ mod tests {
                 // the second item represents which occurrence of that
                 // number this element is, i.e. the second elements
                 // will occur in sorted order.
-                let mut v = range(0, len).map(|_| {
+                let mut v = (0..len).map(|_| {
                         let n = thread_rng().gen::<uint>() % 10;
                         counts[n] += 1;
                         (n, counts[n])
@@ -2723,7 +2723,7 @@ mod tests {
         assert_eq!(xs.capacity(), 128);
         xs.shrink_to_fit();
         assert_eq!(xs.capacity(), 100);
-        assert_eq!(xs, range(0i, 100i).collect::<Vec<_>>());
+        assert_eq!(xs, (0i..100i).collect::<Vec<_>>());
     }
 
     #[test]
@@ -2854,7 +2854,7 @@ mod bench {
     fn iterator(b: &mut Bencher) {
         // peculiar numbers to stop LLVM from optimising the summation
         // out.
-        let v = range(0u, 100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect::<Vec<_>>();
+        let v = (0u..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect::<Vec<_>>();
 
         b.iter(|| {
             let mut sum = 0;
@@ -2882,7 +2882,7 @@ mod bench {
     #[bench]
     fn concat(b: &mut Bencher) {
         let xss: Vec<Vec<uint>> =
-            range(0, 100u).map(|i| range(0, i).collect()).collect();
+            (0..100u).map(|i| (0..i).collect()).collect();
         b.iter(|| {
             xss.as_slice().concat();
         });
@@ -2891,7 +2891,7 @@ mod bench {
     #[bench]
     fn connect(b: &mut Bencher) {
         let xss: Vec<Vec<uint>> =
-            range(0, 100u).map(|i| range(0, i).collect()).collect();
+            (0..100u).map(|i| (0..i).collect()).collect();
         b.iter(|| {
             xss.as_slice().connect(&0)
         });
@@ -2908,7 +2908,7 @@ mod bench {
 
     #[bench]
     fn starts_with_same_vector(b: &mut Bencher) {
-        let vec: Vec<uint> = range(0, 100).collect();
+        let vec: Vec<uint> = (0..100).collect();
         b.iter(|| {
             vec.as_slice().starts_with(vec.as_slice())
         })
@@ -2924,8 +2924,8 @@ mod bench {
 
     #[bench]
     fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
-        let vec: Vec<uint> = range(0, 100).collect();
-        let mut match_vec: Vec<uint> = range(0, 99).collect();
+        let vec: Vec<uint> = (0..100).collect();
+        let mut match_vec: Vec<uint> = (0..99).collect();
         match_vec.push(0);
         b.iter(|| {
             vec.as_slice().starts_with(match_vec.as_slice())
@@ -2934,7 +2934,7 @@ mod bench {
 
     #[bench]
     fn ends_with_same_vector(b: &mut Bencher) {
-        let vec: Vec<uint> = range(0, 100).collect();
+        let vec: Vec<uint> = (0..100).collect();
         b.iter(|| {
             vec.as_slice().ends_with(vec.as_slice())
         })
@@ -2950,8 +2950,8 @@ mod bench {
 
     #[bench]
     fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
-        let vec: Vec<uint> = range(0, 100).collect();
-        let mut match_vec: Vec<uint> = range(0, 100).collect();
+        let vec: Vec<uint> = (0..100).collect();
+        let mut match_vec: Vec<uint> = (0..100).collect();
         match_vec.as_mut_slice()[0] = 200;
         b.iter(|| {
             vec.as_slice().starts_with(match_vec.as_slice())
@@ -2960,7 +2960,7 @@ mod bench {
 
     #[bench]
     fn contains_last_element(b: &mut Bencher) {
-        let vec: Vec<uint> = range(0, 100).collect();
+        let vec: Vec<uint> = (0..100).collect();
         b.iter(|| {
             vec.contains(&99u)
         })
@@ -3069,7 +3069,7 @@ mod bench {
 
     #[bench]
     fn sort_sorted(b: &mut Bencher) {
-        let mut v = range(0u, 10000).collect::<Vec<_>>();
+        let mut v = (0u..10000).collect::<Vec<_>>();
         b.iter(|| {
             v.sort();
         });
@@ -3113,7 +3113,7 @@ mod bench {
 
     #[bench]
     fn sort_big_sorted(b: &mut Bencher) {
-        let mut v = range(0, 10000u).map(|i| (i, i, i, i)).collect::<Vec<_>>();
+        let mut v = (0..10000u).map(|i| (i, i, i, i)).collect::<Vec<_>>();
         b.iter(|| {
             v.sort();
         });

src/libcollections/str.rs

@@ -2122,7 +2122,7 @@ mod tests {
     #[test]
     fn test_chars_decoding() {
         let mut bytes = [0u8; 4];
-        for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
+        for c in (0u32..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
             let len = c.encode_utf8(&mut bytes).unwrap_or(0);
             let s = ::core::str::from_utf8(&bytes[..len]).unwrap();
             if Some(c) != s.chars().next() {
@@ -2134,7 +2134,7 @@ mod tests {
     #[test]
     fn test_chars_rev_decoding() {
         let mut bytes = [0u8; 4];
-        for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
+        for c in (0u32..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
             let len = c.encode_utf8(&mut bytes).unwrap_or(0);
             let s = ::core::str::from_utf8(&bytes[..len]).unwrap();
             if Some(c) != s.chars().rev().next() {

src/libcollections/vec.rs

@@ -2442,7 +2442,7 @@ mod tests {
         b.bytes = src_len as u64;
 
         b.iter(|| {
-            let dst = range(0, src_len).collect::<Vec<_>>();
+            let dst = (0..src_len).collect::<Vec<_>>();
             assert_eq!(dst.len(), src_len);
             assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
         })

src/libcore/fmt/float.rs

@@ -242,7 +242,7 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
                     if i < 0
                     || buf[i as uint] == b'-'
                     || buf[i as uint] == b'+' {
-                        for j in range(i as uint + 1, end).rev() {
+                        for j in (i as uint + 1..end).rev() {
                             buf[j + 1] = buf[j];
                         }
                         buf[(i + 1) as uint] = value2ascii(1);

src/libcore/iter.rs

@@ -717,7 +717,7 @@ pub trait IteratorExt: Iterator + Sized {
         Self: ExactSizeIterator + DoubleEndedIterator
     {
         let len = self.len();
-        for i in range(0, len).rev() {
+        for i in (0..len).rev() {
             if predicate(self.next_back().expect("rposition: incorrect ExactSizeIterator")) {
                 return Some(i);
             }

src/libcore/str/mod.rs

@@ -812,7 +812,7 @@ impl TwoWaySearcher {
 
             // See if the left part of the needle matches
             let start = if long_period { 0 } else { self.memory };
-            for i in range(start, self.crit_pos).rev() {
+            for i in (start..self.crit_pos).rev() {
                 if needle[i] != haystack[self.position + i] {
                     self.position += self.period;
                     if !long_period {