Fix type inference problems in tests and docs

src/doc/intro.md

@@ -480,14 +480,12 @@ use std::sync::{Arc,Mutex};
 fn main() {
     let numbers = Arc::new(Mutex::new(vec![1is, 2, 3]));
 
-    for i in 0..3 {
+    for i in 0us..3 {
         let number = numbers.clone();
         Thread::spawn(move || {
             let mut array = number.lock().unwrap();
-
-            array[i as usize] += 1;
-
-            println!("numbers[{}] is {}", i, array[i as usize]);
+            array[i] += 1;
+            println!("numbers[{}] is {}", i, array[i]);
         });
     }
 }

src/doc/trpl/looping.md

@@ -123,7 +123,7 @@ We now loop forever with `loop` and use `break` to break out early.
 iteration. This will only print the odd numbers:
 
 ```{rust}
-for x in 0..10 {
+for x in 0u32..10 {
     if x % 2 == 0 { continue; }
 
     println!("{}", x);

src/doc/trpl/threads.md

@@ -179,7 +179,7 @@ for init_val in 0 .. 3 {
 }
 
 let result = rx.recv().unwrap() + rx.recv().unwrap() + rx.recv().unwrap();
-# fn some_expensive_computation(_i: u32) -> u32 { 42 }
+# fn some_expensive_computation(_i: i32) -> i32 { 42 }
 ```
 
 Cloning a `Sender` produces a new handle to the same channel, allowing multiple
@@ -207,7 +207,7 @@ let rxs = (0 .. 3).map(|&:init_val| {
 
 // Wait on each port, accumulating the results
 let result = rxs.iter().fold(0, |&:accum, rx| accum + rx.recv().unwrap() );
-# fn some_expensive_computation(_i: u32) -> u32 { 42 }
+# fn some_expensive_computation(_i: i32) -> i32 { 42 }
 ```
 
 ## Backgrounding computations: Futures

src/test/bench/shootout-binarytrees.rs

@@ -41,7 +41,7 @@
 extern crate arena;
 
 use std::iter::range_step;
-use std::thread::Thread;
+use std::thread::{Thread, JoinGuard};
 use arena::TypedArena;
 
 struct Tree<'a> {
@@ -71,6 +71,18 @@ fn bottom_up_tree<'r>(arena: &'r TypedArena<Tree<'r>>, item: i32, depth: i32)
     }
 }
 
+fn inner(depth: i32, iterations: i32) -> String {
+    let mut chk = 0;
+    for i in 1 .. iterations + 1 {
+        let arena = TypedArena::new();
+        let a = bottom_up_tree(&arena, i, depth);
+        let b = bottom_up_tree(&arena, -i, depth);
+        chk += item_check(&a) + item_check(&b);
+    }
+    format!("{}\t trees of depth {}\t check: {}",
+            iterations * 2, depth, chk)
+}
+
 fn main() {
     let args = std::os::args();
     let args = args.as_slice();
@@ -97,20 +109,10 @@ fn main() {
     let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth);
 
     let messages = range_step(min_depth, max_depth + 1, 2).map(|depth| {
-            use std::num::Int;
-            let iterations = 2.pow((max_depth - depth + min_depth) as usize);
-            Thread::scoped(move|| {
-                let mut chk = 0;
-                for i in 1 .. iterations + 1 {
-                    let arena = TypedArena::new();
-                    let a = bottom_up_tree(&arena, i, depth);
-                    let b = bottom_up_tree(&arena, -i, depth);
-                    chk += item_check(&a) + item_check(&b);
-                }
-                format!("{}\t trees of depth {}\t check: {}",
-                        iterations * 2, depth, chk)
-            })
-        }).collect::<Vec<_>>();
+        use std::num::Int;
+        let iterations = 2.pow((max_depth - depth + min_depth) as usize);
+        Thread::scoped(move || inner(depth, iterations))
+    }).collect::<Vec<_>>();
 
     for message in messages.into_iter() {
         println!("{}", message.join().ok().unwrap());