about summary refs log tree commit diff
path: root/src/libstd/sync
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/sync')
-rw-r--r--src/libstd/sync/barrier.rs6
-rw-r--r--src/libstd/sync/condvar.rs4
-rw-r--r--src/libstd/sync/mpsc/mod.rs78
-rw-r--r--src/libstd/sync/mpsc/mpsc_queue.rs6
-rw-r--r--src/libstd/sync/mpsc/select.rs20
-rw-r--r--src/libstd/sync/mpsc/spsc_queue.rs4
-rw-r--r--src/libstd/sync/mpsc/sync.rs4
-rw-r--r--src/libstd/sync/mutex.rs8
-rw-r--r--src/libstd/sync/once.rs6
-rw-r--r--src/libstd/sync/rwlock.rs8
-rw-r--r--src/libstd/sync/task_pool.rs12
11 files changed, 78 insertions, 78 deletions
diff --git a/src/libstd/sync/barrier.rs b/src/libstd/sync/barrier.rs
index 40710d627c0..581e540d3b6 100644
--- a/src/libstd/sync/barrier.rs
+++ b/src/libstd/sync/barrier.rs
@@ -18,7 +18,7 @@ use sync::{Mutex, Condvar};
 /// use std::thread::Thread;
 ///
 /// let barrier = Arc::new(Barrier::new(10));
-/// for _ in range(0u, 10) {
+/// for _ in 0u..10 {
 ///     let c = barrier.clone();
 ///     // The same messages will be printed together.
 ///     // You will NOT see any interleaving.
@@ -121,7 +121,7 @@ mod tests {
         let barrier = Arc::new(Barrier::new(N));
         let (tx, rx) = channel();
 
-        for _ in range(0u, N - 1) {
+        for _ in 0u..N - 1 {
             let c = barrier.clone();
             let tx = tx.clone();
             Thread::spawn(move|| {
@@ -139,7 +139,7 @@ mod tests {
         let mut leader_found = barrier.wait().is_leader();
 
         // Now, the barrier is cleared and we should get data.
-        for _ in range(0u, N - 1) {
+        for _ in 0u..N - 1 {
             if rx.recv().unwrap() {
                 assert!(!leader_found);
                 leader_found = true;
diff --git a/src/libstd/sync/condvar.rs b/src/libstd/sync/condvar.rs
index a7a5b084582..2ae81ad7dff 100644
--- a/src/libstd/sync/condvar.rs
+++ b/src/libstd/sync/condvar.rs
@@ -392,7 +392,7 @@ mod tests {
 
         let data = Arc::new((Mutex::new(0), Condvar::new()));
         let (tx, rx) = channel();
-        for _ in range(0, N) {
+        for _ in 0..N {
             let data = data.clone();
             let tx = tx.clone();
             Thread::spawn(move|| {
@@ -417,7 +417,7 @@ mod tests {
         cond.notify_all();
         drop(cnt);
 
-        for _ in range(0, N) {
+        for _ in 0..N {
             rx.recv().unwrap();
         }
     }
diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs
index 322c6137984..6a43eccbaba 100644
--- a/src/libstd/sync/mpsc/mod.rs
+++ b/src/libstd/sync/mpsc/mod.rs
@@ -74,14 +74,14 @@
 //! // where tx is the sending half (tx for transmission), and rx is the receiving
 //! // half (rx for receiving).
 //! let (tx, rx) = channel();
-//! for i in range(0i, 10i) {
+//! for i in 0i..10i {
 //!     let tx = tx.clone();
 //!     Thread::spawn(move|| {
 //!         tx.send(i).unwrap();
 //!     });
 //! }
 //!
-//! for _ in range(0i, 10i) {
+//! for _ in 0i..10i {
 //!     let j = rx.recv().unwrap();
 //!     assert!(0 <= j && j < 10);
 //! }
@@ -390,13 +390,13 @@ pub struct SendError<T>(pub T);
 ///
 /// The `recv` operation can only fail if the sending half of a channel is
 /// disconnected, implying that no further messages will ever be received.
-#[derive(PartialEq, Eq, Clone, Copy, Show)]
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RecvError;
 
 /// This enumeration is the list of the possible reasons that try_recv could not
 /// return data when called.
-#[derive(PartialEq, Clone, Copy, Show)]
+#[derive(PartialEq, Clone, Copy, Debug)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub enum TryRecvError {
     /// This channel is currently empty, but the sender(s) have not yet
@@ -1147,9 +1147,9 @@ mod test {
     fn stress() {
         let (tx, rx) = channel::<int>();
         let t = Thread::scoped(move|| {
-            for _ in range(0u, 10000) { tx.send(1i).unwrap(); }
+            for _ in 0u..10000 { tx.send(1i).unwrap(); }
         });
-        for _ in range(0u, 10000) {
+        for _ in 0u..10000 {
             assert_eq!(rx.recv().unwrap(), 1);
         }
         t.join().ok().unwrap();
@@ -1162,7 +1162,7 @@ mod test {
         let (tx, rx) = channel::<int>();
 
         let t = Thread::scoped(move|| {
-            for _ in range(0, AMT * NTHREADS) {
+            for _ in 0..AMT * NTHREADS {
                 assert_eq!(rx.recv().unwrap(), 1);
             }
             match rx.try_recv() {
@@ -1171,10 +1171,10 @@ mod test {
             }
         });
 
-        for _ in range(0, NTHREADS) {
+        for _ in 0..NTHREADS {
             let tx = tx.clone();
             Thread::spawn(move|| {
-                for _ in range(0, AMT) { tx.send(1).unwrap(); }
+                for _ in 0..AMT { tx.send(1).unwrap(); }
             });
         }
         drop(tx);
@@ -1187,13 +1187,13 @@ mod test {
         let (tx2, rx2) = channel::<int>();
         let t1 = Thread::scoped(move|| {
             tx1.send(()).unwrap();
-            for _ in range(0i, 40) {
+            for _ in 0i..40 {
                 assert_eq!(rx2.recv().unwrap(), 1);
             }
         });
         rx1.recv().unwrap();
         let t2 = Thread::scoped(move|| {
-            for _ in range(0i, 40) {
+            for _ in 0i..40 {
                 tx2.send(1).unwrap();
             }
         });
@@ -1205,11 +1205,11 @@ mod test {
     fn recv_from_outside_runtime() {
         let (tx, rx) = channel::<int>();
         let t = Thread::scoped(move|| {
-            for _ in range(0i, 40) {
+            for _ in 0i..40 {
                 assert_eq!(rx.recv().unwrap(), 1);
             }
         });
-        for _ in range(0u, 40) {
+        for _ in 0u..40 {
             tx.send(1).unwrap();
         }
         t.join().ok().unwrap();
@@ -1346,7 +1346,7 @@ mod test {
 
     #[test]
     fn oneshot_multi_thread_close_stress() {
-        for _ in range(0, stress_factor()) {
+        for _ in 0..stress_factor() {
             let (tx, rx) = channel::<int>();
             let _t = Thread::spawn(move|| {
                 drop(rx);
@@ -1357,7 +1357,7 @@ mod test {
 
     #[test]
     fn oneshot_multi_thread_send_close_stress() {
-        for _ in range(0, stress_factor()) {
+        for _ in 0..stress_factor() {
             let (tx, rx) = channel::<int>();
             let _t = Thread::spawn(move|| {
                 drop(rx);
@@ -1370,7 +1370,7 @@ mod test {
 
     #[test]
     fn oneshot_multi_thread_recv_close_stress() {
-        for _ in range(0, stress_factor()) {
+        for _ in 0..stress_factor() {
             let (tx, rx) = channel::<int>();
             Thread::spawn(move|| {
                 let res = Thread::scoped(move|| {
@@ -1388,7 +1388,7 @@ mod test {
 
     #[test]
     fn oneshot_multi_thread_send_recv_stress() {
-        for _ in range(0, stress_factor()) {
+        for _ in 0..stress_factor() {
             let (tx, rx) = channel();
             let _t = Thread::spawn(move|| {
                 tx.send(box 10i).unwrap();
@@ -1399,7 +1399,7 @@ mod test {
 
     #[test]
     fn stream_send_recv_stress() {
-        for _ in range(0, stress_factor()) {
+        for _ in 0..stress_factor() {
             let (tx, rx) = channel();
 
             send(tx, 0);
@@ -1429,22 +1429,22 @@ mod test {
     fn recv_a_lot() {
         // Regression test that we don't run out of stack in scheduler context
         let (tx, rx) = channel();
-        for _ in range(0i, 10000) { tx.send(()).unwrap(); }
-        for _ in range(0i, 10000) { rx.recv().unwrap(); }
+        for _ in 0i..10000 { tx.send(()).unwrap(); }
+        for _ in 0i..10000 { rx.recv().unwrap(); }
     }
 
     #[test]
     fn shared_chan_stress() {
         let (tx, rx) = channel();
         let total = stress_factor() + 100;
-        for _ in range(0, total) {
+        for _ in 0..total {
             let tx = tx.clone();
             Thread::spawn(move|| {
                 tx.send(()).unwrap();
             });
         }
 
-        for _ in range(0, total) {
+        for _ in 0..total {
             rx.recv().unwrap();
         }
     }
@@ -1530,7 +1530,7 @@ mod test {
             tx2.send(()).unwrap();
         });
         // make sure the other task has gone to sleep
-        for _ in range(0u, 5000) { Thread::yield_now(); }
+        for _ in 0u..5000 { Thread::yield_now(); }
 
         // upgrade to a shared chan and send a message
         let t = tx.clone();
@@ -1654,9 +1654,9 @@ mod sync_tests {
     fn stress() {
         let (tx, rx) = sync_channel::<int>(0);
         Thread::spawn(move|| {
-            for _ in range(0u, 10000) { tx.send(1).unwrap(); }
+            for _ in 0u..10000 { tx.send(1).unwrap(); }
         });
-        for _ in range(0u, 10000) {
+        for _ in 0u..10000 {
             assert_eq!(rx.recv().unwrap(), 1);
         }
     }
@@ -1669,7 +1669,7 @@ mod sync_tests {
         let (dtx, drx) = sync_channel::<()>(0);
 
         Thread::spawn(move|| {
-            for _ in range(0, AMT * NTHREADS) {
+            for _ in 0..AMT * NTHREADS {
                 assert_eq!(rx.recv().unwrap(), 1);
             }
             match rx.try_recv() {
@@ -1679,10 +1679,10 @@ mod sync_tests {
             dtx.send(()).unwrap();
         });
 
-        for _ in range(0, NTHREADS) {
+        for _ in 0..NTHREADS {
             let tx = tx.clone();
             Thread::spawn(move|| {
-                for _ in range(0, AMT) { tx.send(1).unwrap(); }
+                for _ in 0..AMT { tx.send(1).unwrap(); }
             });
         }
         drop(tx);
@@ -1810,7 +1810,7 @@ mod sync_tests {
 
     #[test]
     fn oneshot_multi_thread_close_stress() {
-        for _ in range(0, stress_factor()) {
+        for _ in 0..stress_factor() {
             let (tx, rx) = sync_channel::<int>(0);
             let _t = Thread::spawn(move|| {
                 drop(rx);
@@ -1821,7 +1821,7 @@ mod sync_tests {
 
     #[test]
     fn oneshot_multi_thread_send_close_stress() {
-        for _ in range(0, stress_factor()) {
+        for _ in 0..stress_factor() {
             let (tx, rx) = sync_channel::<int>(0);
             let _t = Thread::spawn(move|| {
                 drop(rx);
@@ -1834,7 +1834,7 @@ mod sync_tests {
 
     #[test]
     fn oneshot_multi_thread_recv_close_stress() {
-        for _ in range(0, stress_factor()) {
+        for _ in 0..stress_factor() {
             let (tx, rx) = sync_channel::<int>(0);
             let _t = Thread::spawn(move|| {
                 let res = Thread::scoped(move|| {
@@ -1852,7 +1852,7 @@ mod sync_tests {
 
     #[test]
     fn oneshot_multi_thread_send_recv_stress() {
-        for _ in range(0, stress_factor()) {
+        for _ in 0..stress_factor() {
             let (tx, rx) = sync_channel::<Box<int>>(0);
             let _t = Thread::spawn(move|| {
                 tx.send(box 10i).unwrap();
@@ -1863,7 +1863,7 @@ mod sync_tests {
 
     #[test]
     fn stream_send_recv_stress() {
-        for _ in range(0, stress_factor()) {
+        for _ in 0..stress_factor() {
             let (tx, rx) = sync_channel::<Box<int>>(0);
 
             send(tx, 0);
@@ -1893,22 +1893,22 @@ mod sync_tests {
     fn recv_a_lot() {
         // Regression test that we don't run out of stack in scheduler context
         let (tx, rx) = sync_channel(10000);
-        for _ in range(0u, 10000) { tx.send(()).unwrap(); }
-        for _ in range(0u, 10000) { rx.recv().unwrap(); }
+        for _ in 0u..10000 { tx.send(()).unwrap(); }
+        for _ in 0u..10000 { rx.recv().unwrap(); }
     }
 
     #[test]
     fn shared_chan_stress() {
         let (tx, rx) = sync_channel(0);
         let total = stress_factor() + 100;
-        for _ in range(0, total) {
+        for _ in 0..total {
             let tx = tx.clone();
             Thread::spawn(move|| {
                 tx.send(()).unwrap();
             });
         }
 
-        for _ in range(0, total) {
+        for _ in 0..total {
             rx.recv().unwrap();
         }
     }
@@ -1994,7 +1994,7 @@ mod sync_tests {
             tx2.send(()).unwrap();
         });
         // make sure the other task has gone to sleep
-        for _ in range(0u, 5000) { Thread::yield_now(); }
+        for _ in 0u..5000 { Thread::yield_now(); }
 
         // upgrade to a shared chan and send a message
         let t = tx.clone();
@@ -2082,7 +2082,7 @@ mod sync_tests {
             rx2.recv().unwrap();
         }
 
-        for _ in range(0u, 100) {
+        for _ in 0u..100 {
             repro()
         }
     }
diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs
index c222c313ba6..53eba131674 100644
--- a/src/libstd/sync/mpsc/mpsc_queue.rs
+++ b/src/libstd/sync/mpsc/mpsc_queue.rs
@@ -181,11 +181,11 @@ mod tests {
         let (tx, rx) = channel();
         let q = Arc::new(q);
 
-        for _ in range(0, nthreads) {
+        for _ in 0..nthreads {
             let tx = tx.clone();
             let q = q.clone();
             Thread::spawn(move|| {
-                for i in range(0, nmsgs) {
+                for i in 0..nmsgs {
                     q.push(i);
                 }
                 tx.send(()).unwrap();
@@ -200,7 +200,7 @@ mod tests {
             }
         }
         drop(tx);
-        for _ in range(0, nthreads) {
+        for _ in 0..nthreads {
             rx.recv().unwrap();
         }
     }
diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs
index e97c82a5b1b..f70e2dee8ee 100644
--- a/src/libstd/sync/mpsc/select.rs
+++ b/src/libstd/sync/mpsc/select.rs
@@ -421,10 +421,10 @@ mod test {
         let (tx3, rx3) = channel::<int>();
 
         let _t = Thread::spawn(move|| {
-            for _ in range(0u, 20) { Thread::yield_now(); }
+            for _ in 0u..20 { Thread::yield_now(); }
             tx1.send(1).unwrap();
             rx3.recv().unwrap();
-            for _ in range(0u, 20) { Thread::yield_now(); }
+            for _ in 0u..20 { Thread::yield_now(); }
         });
 
         select! {
@@ -445,7 +445,7 @@ mod test {
         let (tx3, rx3) = channel::<()>();
 
         let _t = Thread::spawn(move|| {
-            for _ in range(0u, 20) { Thread::yield_now(); }
+            for _ in 0u..20 { Thread::yield_now(); }
             tx1.send(1).unwrap();
             tx2.send(2).unwrap();
             rx3.recv().unwrap();
@@ -472,7 +472,7 @@ mod test {
         let (tx3, rx3) = channel::<()>();
 
         let _t = Thread::spawn(move|| {
-            for i in range(0, AMT) {
+            for i in 0..AMT {
                 if i % 2 == 0 {
                     tx1.send(i).unwrap();
                 } else {
@@ -482,7 +482,7 @@ mod test {
             }
         });
 
-        for i in range(0, AMT) {
+        for i in 0..AMT {
             select! {
                 i1 = rx1.recv() => { assert!(i % 2 == 0 && i == i1.unwrap()); },
                 i2 = rx2.recv() => { assert!(i % 2 == 1 && i == i2.unwrap()); }
@@ -550,7 +550,7 @@ mod test {
             tx3.send(()).unwrap();
         });
 
-        for _ in range(0u, 1000) { Thread::yield_now(); }
+        for _ in 0u..1000 { Thread::yield_now(); }
         drop(tx1.clone());
         tx2.send(()).unwrap();
         rx3.recv().unwrap();
@@ -663,7 +663,7 @@ mod test {
             tx2.send(()).unwrap();
         });
 
-        for _ in range(0u, 100) { Thread::yield_now() }
+        for _ in 0u..100 { Thread::yield_now() }
         tx1.send(()).unwrap();
         rx2.recv().unwrap();
     }
@@ -683,7 +683,7 @@ mod test {
             tx2.send(()).unwrap();
         });
 
-        for _ in range(0u, 100) { Thread::yield_now() }
+        for _ in 0u..100 { Thread::yield_now() }
         tx1.send(()).unwrap();
         rx2.recv().unwrap();
     }
@@ -702,7 +702,7 @@ mod test {
             tx2.send(()).unwrap();
         });
 
-        for _ in range(0u, 100) { Thread::yield_now() }
+        for _ in 0u..100 { Thread::yield_now() }
         tx1.send(()).unwrap();
         rx2.recv().unwrap();
     }
@@ -720,7 +720,7 @@ mod test {
     fn sync2() {
         let (tx, rx) = sync_channel::<int>(0);
         let _t = Thread::spawn(move|| {
-            for _ in range(0u, 100) { Thread::yield_now() }
+            for _ in 0u..100 { Thread::yield_now() }
             tx.send(1).unwrap();
         });
         select! {
diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs
index c1983fcab19..45503f0b58e 100644
--- a/src/libstd/sync/mpsc/spsc_queue.rs
+++ b/src/libstd/sync/mpsc/spsc_queue.rs
@@ -325,7 +325,7 @@ mod test {
             let (tx, rx) = channel();
             let q2 = q.clone();
             let _t = Thread::spawn(move|| {
-                for _ in range(0u, 100000) {
+                for _ in 0u..100000 {
                     loop {
                         match q2.pop() {
                             Some(1i) => break,
@@ -336,7 +336,7 @@ mod test {
                 }
                 tx.send(()).unwrap();
             });
-            for _ in range(0i, 100000) {
+            for _ in 0i..100000 {
                 q.push(1);
             }
             rx.recv().unwrap();
diff --git a/src/libstd/sync/mpsc/sync.rs b/src/libstd/sync/mpsc/sync.rs
index d38f14a9130..da3ce51a652 100644
--- a/src/libstd/sync/mpsc/sync.rs
+++ b/src/libstd/sync/mpsc/sync.rs
@@ -105,7 +105,7 @@ struct Buffer<T> {
     size: uint,
 }
 
-#[derive(Show)]
+#[derive(Debug)]
 pub enum Failure {
     Empty,
     Disconnected,
@@ -150,7 +150,7 @@ impl<T: Send> Packet<T> {
                     tail: ptr::null_mut(),
                 },
                 buf: Buffer {
-                    buf: range(0, cap + if cap == 0 {1} else {0}).map(|_| None).collect(),
+                    buf: (0..cap + if cap == 0 {1} else {0}).map(|_| None).collect(),
                     start: 0,
                     size: 0,
                 },
diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs
index f7fdd60eb8c..c31010c170d 100644
--- a/src/libstd/sync/mutex.rs
+++ b/src/libstd/sync/mutex.rs
@@ -60,7 +60,7 @@ use sys_common::mutex as sys;
 /// let data = Arc::new(Mutex::new(0));
 ///
 /// let (tx, rx) = channel();
-/// for _ in range(0u, 10) {
+/// for _ in 0u..10 {
 ///     let (data, tx) = (data.clone(), tx.clone());
 ///     Thread::spawn(move || {
 ///         // The shared static can only be accessed once the lock is held.
@@ -371,7 +371,7 @@ mod test {
         static K: uint = 3;
 
         fn inc() {
-            for _ in range(0, J) {
+            for _ in 0..J {
                 unsafe {
                     let _g = M.lock().unwrap();
                     CNT += 1;
@@ -380,7 +380,7 @@ mod test {
         }
 
         let (tx, rx) = channel();
-        for _ in range(0, K) {
+        for _ in 0..K {
             let tx2 = tx.clone();
             Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
             let tx2 = tx.clone();
@@ -388,7 +388,7 @@ mod test {
         }
 
         drop(tx);
-        for _ in range(0, 2 * K) {
+        for _ in 0..2 * K {
             rx.recv().unwrap();
         }
         assert_eq!(unsafe {CNT}, J * K * 2);
diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs
index 1c489540581..0604003cecd 100644
--- a/src/libstd/sync/once.rs
+++ b/src/libstd/sync/once.rs
@@ -147,10 +147,10 @@ mod test {
         static mut run: bool = false;
 
         let (tx, rx) = channel();
-        for _ in range(0u, 10) {
+        for _ in 0u..10 {
             let tx = tx.clone();
             Thread::spawn(move|| {
-                for _ in range(0u, 4) { Thread::yield_now() }
+                for _ in 0u..4 { Thread::yield_now() }
                 unsafe {
                     O.call_once(|| {
                         assert!(!run);
@@ -170,7 +170,7 @@ mod test {
             assert!(run);
         }
 
-        for _ in range(0u, 10) {
+        for _ in 0u..10 {
             rx.recv().unwrap();
         }
     }
diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs
index 12befbf72e3..b5817ad64f6 100644
--- a/src/libstd/sync/rwlock.rs
+++ b/src/libstd/sync/rwlock.rs
@@ -416,11 +416,11 @@ mod tests {
         static M: uint = 1000;
 
         let (tx, rx) = channel::<()>();
-        for _ in range(0, N) {
+        for _ in 0..N {
             let tx = tx.clone();
             Thread::spawn(move|| {
                 let mut rng = rand::thread_rng();
-                for _ in range(0, M) {
+                for _ in 0..M {
                     if rng.gen_weighted_bool(N) {
                         drop(R.write().unwrap());
                     } else {
@@ -488,7 +488,7 @@ mod tests {
 
         Thread::spawn(move|| {
             let mut lock = arc2.write().unwrap();
-            for _ in range(0u, 10) {
+            for _ in 0u..10 {
                 let tmp = *lock;
                 *lock = -1;
                 Thread::yield_now();
@@ -499,7 +499,7 @@ mod tests {
 
         // Readers try to catch the writer in the act
         let mut children = Vec::new();
-        for _ in range(0u, 5) {
+        for _ in 0u..5 {
             let arc3 = arc.clone();
             children.push(Thread::scoped(move|| {
                 let lock = arc3.read().unwrap();
diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs
index 3fac998d3e7..1bfcbcf96f1 100644
--- a/src/libstd/sync/task_pool.rs
+++ b/src/libstd/sync/task_pool.rs
@@ -66,7 +66,7 @@ impl<'a> Drop for Sentinel<'a> {
 /// let pool = TaskPool::new(4u);
 ///
 /// let (tx, rx) = channel();
-/// for _ in range(0, 8u) {
+/// for _ in 0..8u {
 ///     let tx = tx.clone();
 ///     pool.execute(move|| {
 ///         tx.send(1u).unwrap();
@@ -96,7 +96,7 @@ impl TaskPool {
         let rx = Arc::new(Mutex::new(rx));
 
         // Threadpool threads
-        for _ in range(0, threads) {
+        for _ in 0..threads {
             spawn_in_pool(rx.clone());
         }
 
@@ -151,7 +151,7 @@ mod test {
         let pool = TaskPool::new(TEST_TASKS);
 
         let (tx, rx) = channel();
-        for _ in range(0, TEST_TASKS) {
+        for _ in 0..TEST_TASKS {
             let tx = tx.clone();
             pool.execute(move|| {
                 tx.send(1u).unwrap();
@@ -174,13 +174,13 @@ mod test {
         let pool = TaskPool::new(TEST_TASKS);
 
         // Panic all the existing threads.
-        for _ in range(0, TEST_TASKS) {
+        for _ in 0..TEST_TASKS {
             pool.execute(move|| -> () { panic!() });
         }
 
         // Ensure new threads were spawned to compensate.
         let (tx, rx) = channel();
-        for _ in range(0, TEST_TASKS) {
+        for _ in 0..TEST_TASKS {
             let tx = tx.clone();
             pool.execute(move|| {
                 tx.send(1u).unwrap();
@@ -198,7 +198,7 @@ mod test {
         let waiter = Arc::new(Barrier::new(TEST_TASKS + 1));
 
         // Panic all the existing threads in a bit.
-        for _ in range(0, TEST_TASKS) {
+        for _ in 0..TEST_TASKS {
             let waiter = waiter.clone();
             pool.execute(move|| {
                 waiter.wait();
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-01-14 23:52:54 +0000