for x in range(a, b) -> for x in a..b

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

Author: Jorge Aparicio

src/liballoc/arc.rs

@@ -37,7 +37,7 @@
 //!
 //! let five = Arc::new(5i);
 //!
-//! for _ in range(0u, 10) {
+//! for _ in 0u..10 {
 //!     let five = five.clone();
 //!
 //!     Thread::spawn(move || {
@@ -54,7 +54,7 @@
 //!
 //! let five = Arc::new(Mutex::new(5i));
 //!
-//! for _ in range(0u, 10) {
+//! for _ in 0u..10 {
 //!     let five = five.clone();
 //!
 //!     Thread::spawn(move || {
@@ -98,7 +98,7 @@ use heap::deallocate;
 ///     let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect();
 ///     let shared_numbers = Arc::new(numbers);
 ///
-///     for _ in range(0u, 10) {
+///     for _ in 0u..10 {
 ///         let child_numbers = shared_numbers.clone();
 ///
 ///         Thread::spawn(move || {

src/libarena/lib.rs

@@ -311,7 +311,7 @@ impl Arena {
 #[test]
 fn test_arena_destructors() {
     let arena = Arena::new();
-    for i in range(0u, 10) {
+    for i in 0u..10 {
         // Arena allocate something with drop glue to make sure it
         // doesn't leak.
         arena.alloc(|| Rc::new(i));
@@ -340,7 +340,7 @@ fn test_arena_alloc_nested() {
 fn test_arena_destructors_fail() {
     let arena = Arena::new();
     // Put some stuff in the arena.
-    for i in range(0u, 10) {
+    for i in 0u..10 {
         // Arena allocate something with drop glue to make sure it
         // doesn't leak.
         arena.alloc(|| { Rc::new(i) });
@@ -410,7 +410,7 @@ impl<T> TypedArenaChunk<T> {
         // Destroy all the allocated objects.
         if intrinsics::needs_drop::<T>() {
             let mut start = self.start();
-            for _ in range(0, len) {
+            for _ in 0..len {
                 ptr::read(start as *const T); // run the destructor on the pointer
                 start = start.offset(mem::size_of::<T>() as int)
             }
@@ -530,7 +530,7 @@ mod tests {
     #[test]
     pub fn test_copy() {
         let arena = TypedArena::new();
-        for _ in range(0u, 100000) {
+        for _ in 0u..100000 {
             arena.alloc(Point {
                 x: 1,
                 y: 2,
@@ -585,7 +585,7 @@ mod tests {
     #[test]
     pub fn test_noncopy() {
         let arena = TypedArena::new();
-        for _ in range(0u, 100000) {
+        for _ in 0u..100000 {
             arena.alloc(Noncopy {
                 string: "hello world".to_string(),
                 array: vec!( 1, 2, 3, 4, 5 ),

src/libcollections/bench.rs

@@ -24,7 +24,7 @@ pub fn insert_rand_n<M, I, R>(n: uint,
     // setup
     let mut rng = rand::weak_rng();
 
-    for _ in range(0, n) {
+    for _ in 0..n {
         insert(map, rng.gen::<uint>() % n);
     }
 
@@ -46,7 +46,7 @@ pub fn insert_seq_n<M, I, R>(n: uint,
     R: FnMut(&mut M, uint),
 {
     // setup
-    for i in range(0u, n) {
+    for i in 0u..n {
         insert(map, i * 2);
     }
 
@@ -97,7 +97,7 @@ pub fn find_seq_n<M, T, I, F>(n: uint,
     F: FnMut(&M, uint) -> T,
 {
     // setup
-    for i in range(0u, n) {
+    for i in 0u..n {
         insert(map, i);
     }
 

src/libcollections/bit.rs

@@ -68,7 +68,7 @@
 //! // Simple primality tests below our max bound
 //! let print_primes = 20;
 //! print!("The primes below {} are: ", print_primes);
-//! for x in range(0, print_primes) {
+//! for x in 0..print_primes {
 //!     if primes.contains(&x) {
 //!         print!("{} ", x);
 //!     }
@@ -104,7 +104,7 @@ type MatchWords<'a> = Chain<Enumerate<Blocks<'a>>, Skip<Take<Enumerate<Repeat<u3
 
 fn reverse_bits(byte: u8) -> u8 {
     let mut result = 0;
-    for i in range(0, u8::BITS) {
+    for i in 0..u8::BITS {
         result |= ((byte >> i) & 1) << (u8::BITS - 1 - i);
     }
     result
@@ -320,7 +320,7 @@ impl Bitv {
 
         bitv.nbits = len;
 
-        for i in range(0, complete_words) {
+        for i in 0..complete_words {
             bitv.storage.push(
                 ((reverse_bits(bytes[i * 4 + 0]) as u32) << 0) |
                 ((reverse_bits(bytes[i * 4 + 1]) as u32) << 8) |
@@ -353,7 +353,7 @@ impl Bitv {
     /// ```
     pub fn from_fn<F>(len: uint, mut f: F) -> Bitv where F: FnMut(uint) -> bool {
         let mut bitv = Bitv::from_elem(len, false);
-        for i in range(0u, len) {
+        for i in 0u..len {
             bitv.set(i, f(i));
         }
         bitv
@@ -830,7 +830,7 @@ impl Bitv {
 
         // Fill in words after the old tail word
         let stop_idx = cmp::min(self.storage.len(), new_nblocks);
-        for idx in range(old_last_word + 1, stop_idx) {
+        for idx in old_last_word + 1..stop_idx {
             self.storage[idx] = full_value;
         }
 
@@ -2232,12 +2232,12 @@ mod tests {
     #[test]
     fn test_equal_sneaky_big() {
         let mut a = Bitv::from_elem(100, false);
-        for i in range(0u, 100) {
+        for i in 0u..100 {
             a.set(i, true);
         }
 
         let mut b = Bitv::from_elem(100, true);
-        for i in range(0u, 100) {
+        for i in 0u..100 {
             b.set(i, true);
         }
 
@@ -2526,7 +2526,7 @@ mod bitv_bench {
         let mut r = rng();
         let mut bitv = 0 as uint;
         b.iter(|| {
-            for _ in range(0u, 100) {
+            for _ in 0u..100 {
                 bitv |= 1 << ((r.next_u32() as uint) % u32::BITS);
             }
             black_box(&bitv);
@@ -2538,7 +2538,7 @@ mod bitv_bench {
         let mut r = rng();
         let mut bitv = Bitv::from_elem(BENCH_BITS, false);
         b.iter(|| {
-            for _ in range(0u, 100) {
+            for _ in 0u..100 {
                 bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
             }
             black_box(&bitv);
@@ -2550,7 +2550,7 @@ mod bitv_bench {
         let mut r = rng();
         let mut bitv = Bitv::from_elem(BENCH_BITS, false);
         b.iter(|| {
-            for _ in range(0u, 100) {
+            for _ in 0u..100 {
                 bitv.set((r.next_u32() as uint) % BENCH_BITS, r.gen());
             }
             black_box(&bitv);
@@ -2562,7 +2562,7 @@ mod bitv_bench {
         let mut r = rng();
         let mut bitv = Bitv::from_elem(u32::BITS, false);
         b.iter(|| {
-            for _ in range(0u, 100) {
+            for _ in 0u..100 {
                 bitv.set((r.next_u32() as uint) % u32::BITS, true);
             }
             black_box(&bitv);
@@ -2583,7 +2583,7 @@ mod bitv_bench {
         let bitv = Bitv::from_elem(u32::BITS, false);
         b.iter(|| {
             let mut sum = 0u;
-            for _ in range(0u, 10) {
+            for _ in 0u..10 {
                 for pres in bitv.iter() {
                     sum += pres as uint;
                 }
@@ -3021,7 +3021,7 @@ mod bitv_set_bench {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
-            for _ in range(0u, 100) {
+            for _ in 0u..100 {
                 bitv.insert((r.next_u32() as uint) % u32::BITS);
             }
             black_box(&bitv);
@@ -3033,7 +3033,7 @@ mod bitv_set_bench {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
-            for _ in range(0u, 100) {
+            for _ in 0u..100 {
                 bitv.insert((r.next_u32() as uint) % BENCH_BITS);
             }
             black_box(&bitv);

src/libcollections/btree/map.rs

@@ -1601,39 +1601,39 @@ mod test {
         let size = 10000u;
         assert_eq!(map.len(), 0);
 
-        for i in range(0, size) {
+        for i in 0..size {
             assert_eq!(map.insert(i, 10*i), None);
             assert_eq!(map.len(), i + 1);
         }
 
-        for i in range(0, size) {
+        for i in 0..size {
             assert_eq!(map.get(&i).unwrap(), &(i*10));
         }
 
-        for i in range(size, size*2) {
+        for i in size..size*2 {
             assert_eq!(map.get(&i), None);
         }
 
-        for i in range(0, size) {
+        for i in 0..size {
             assert_eq!(map.insert(i, 100*i), Some(10*i));
             assert_eq!(map.len(), size);
         }
 
-        for i in range(0, size) {
+        for i in 0..size {
             assert_eq!(map.get(&i).unwrap(), &(i*100));
         }
 
-        for i in range(0, size/2) {
+        for i in 0..size/2 {
             assert_eq!(map.remove(&(i*2)), Some(i*200));
             assert_eq!(map.len(), size - i - 1);
         }
 
-        for i in range(0, size/2) {
+        for i in 0..size/2 {
             assert_eq!(map.get(&(2*i)), None);
             assert_eq!(map.get(&(2*i+1)).unwrap(), &(i*200 + 100));
         }
 
-        for i in range(0, size/2) {
+        for i in 0..size/2 {
             assert_eq!(map.remove(&(2*i)), None);
             assert_eq!(map.remove(&(2*i+1)), Some(i*200 + 100));
             assert_eq!(map.len(), size/2 - i - 1);
@@ -1664,7 +1664,7 @@ mod test {
         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) {
+            for i in 0..size {
                 assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
                 assert_eq!(iter.next().unwrap(), (i, i));
             }
@@ -1684,7 +1684,7 @@ mod test {
         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) {
+            for i in 0..size {
                 assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
                 assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1));
             }
@@ -1705,12 +1705,12 @@ mod test {
 
         fn test<T>(size: uint, mut iter: T)
                 where T: Iterator<Item=(uint, uint)> + DoubleEndedIterator {
-            for i in range(0, size / 4) {
+            for i in 0..size / 4 {
                 assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2)));
                 assert_eq!(iter.next().unwrap(), (i, i));
                 assert_eq!(iter.next_back().unwrap(), (size - i - 1, size - i - 1));
             }
-            for i in range(size / 4, size * 3 / 4) {
+            for i in size / 4..size * 3 / 4 {
                 assert_eq!(iter.size_hint(), (size * 3 / 4 - i, Some(size * 3 / 4 - i)));
                 assert_eq!(iter.next().unwrap(), (i, i));
             }
@@ -1766,8 +1766,8 @@ mod test {
         let size = 200u;
         let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
 
-        for i in range(0, size) {
-            for j in range(i, size) {
+        for i in 0..size {
+            for j in i..size {
                 let mut kvs = map.range(Included(&i), Included(&j)).map(|(&k, &v)| (k, v));
                 let mut pairs = range_inclusive(i, j).map(|i| (i, i));
 
@@ -1917,7 +1917,7 @@ mod bench {
         let mut map = BTreeMap::<uint, uint>::new();
         let mut rng = weak_rng();
 
-        for _ in range(0, size) {
+        for _ in 0..size {
             map.insert(rng.gen(), rng.gen());
         }
 

src/libcollections/btree/node.rs

@@ -501,7 +501,7 @@ impl<K: Clone, V: Clone> Clone for Node<K, V> {
 ///     let mut small_node = Node::make_leaf_root(3);
 ///     let mut large_node = Node::make_leaf_root(100);
 ///
-///     for i in range(0, 100) {
+///     for i in 0..100 {
 ///         // Insert to the end
 ///         large_node.edge_handle(i).insert_as_leaf(i, i);
 ///     }

src/libcollections/dlist.rs

@@ -592,7 +592,7 @@ impl<T> DList<T> {
             // instead of skipping using .skip() (which creates a new struct),
             // we skip manually so we can access the head field without
             // depending on implementation details of Skip
-            for _ in range(0, at - 1) {
+            for _ in 0..at - 1 {
                 iter.next();
             }
             iter.head
@@ -1070,10 +1070,10 @@ mod tests {
             let mut n = m.split_off(2);
             assert_eq!(m.len(), 2);
             assert_eq!(n.len(), 3);
-            for elt in range(1i, 3) {
+            for elt in 1i..3 {
                 assert_eq!(m.pop_front(), Some(elt));
             }
-            for elt in range(3i, 6) {
+            for elt in 3i..6 {
                 assert_eq!(n.pop_front(), Some(elt));
             }
         }
@@ -1084,10 +1084,10 @@ mod tests {
             let mut n = m.split_off(4);
             assert_eq!(m.len(), 4);
             assert_eq!(n.len(), 1);
-            for elt in range(1i, 5) {
+            for elt in 1i..5 {
                 assert_eq!(m.pop_front(), Some(elt));
             }
-            for elt in range(5i, 6) {
+            for elt in 5i..6 {
                 assert_eq!(n.pop_front(), Some(elt));
             }
         }
@@ -1325,7 +1325,7 @@ mod tests {
 
     #[test]
     fn test_fuzz() {
-        for _ in range(0u, 25) {
+        for _ in 0u..25 {
             fuzz_test(3);
             fuzz_test(16);
             fuzz_test(189);
@@ -1347,7 +1347,7 @@ mod tests {
     fn fuzz_test(sz: int) {
         let mut m: DList<int> = DList::new();
         let mut v = vec![];
-        for i in range(0, sz) {
+        for i in 0..sz {
             check_links(&m);
             let r: u8 = rand::random();
             match r % 6 {