---

yaml
---
r: 196590
b: refs/heads/auto
c: b3bcbb1
h: refs/heads/master
v: v3

Author: Manishearth

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 6e86c636e550cec54f51f1ce56a1f583dd37c90d
+refs/heads/auto: b3bcbb1a22f6aa8c39055100b920904283fc8c2c
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/intro.md

@@ -457,30 +457,25 @@ a problem. That’s what it means by ‘cannot move out of captured outer
 variable’: our `thread::scoped` closure wants to take ownership, and it can’t,
 because the closure for `map` won’t let it.
 
-What to do here? Rust has two types that helps us: `Arc<T>` and `Mutex<T>`.
-*Arc* stands for "atomically reference counted". In other words, an Arc will
-keep track of the number of references to something, and not free the
-associated resource until the count is zero. The *atomic* portion refers to an
-Arc's usage of concurrency primitives to atomically update the count, making it
-safe across threads. If we use an Arc, we can have our three references. But,
-an Arc does not allow mutable borrows of the data it holds, and we want to
-modify what we're sharing. In this case, we can use a `Mutex<T>` inside of our
-Arc. A Mutex will synchronize our accesses, so that we can ensure that our
-mutation doesn't cause a data race.
-
-Here's what using an Arc with a Mutex looks like:
+What to do here? Rust has a type that helps us: `Mutex<T>`. Because the threads
+are scoped, it is possible to use an _immutable_ reference to `numbers` inside
+of the closure. However, Rust prevents us from having multiple _mutable_
+references to the same object, so we need a `Mutex` to be able to modify what
+we're sharing. A Mutex will synchronize our accesses, so that we can ensure
+that our mutation doesn't cause a data race.
+
+Here's what using a Mutex looks like:
 
 ```{rust}
 use std::thread;
-use std::sync::{Arc,Mutex};
+use std::sync::Mutex;
 
 fn main() {
-    let numbers = Arc::new(Mutex::new(vec![1, 2, 3]));
+    let numbers = &Mutex::new(vec![1, 2, 3]);
 
     let guards: Vec<_> = (0..3).map(|i| {
-        let number = numbers.clone();
         thread::scoped(move || {
-            let mut array = number.lock().unwrap();
+            let mut array = numbers.lock().unwrap();
             array[i] += 1;
             println!("numbers[{}] is {}", i, array[i]);
         })
@@ -489,12 +484,9 @@ fn main() {
 ```
 
 We first have to `use` the appropriate library, and then we wrap our vector in
-an Arc with the call to `Arc::new()`. Inside of the loop, we make a new
-reference to the Arc with the `clone()` method. This will increment the
-reference count. When each new `numbers` variable binding goes out of scope, it
-will decrement the count. The `lock()` call will return us a reference to the
-value inside the Mutex, and block any other calls to `lock()` until said
-reference goes out of scope.
+a `Mutex` with the call to `Mutex::new()`. Inside of the loop, the `lock()`
+call will return us a reference to the value inside the Mutex, and block any
+other calls to `lock()` until said reference goes out of scope.
 
 We can compile and run this program without error, and in fact, see the
 non-deterministic aspect:

branches/auto/src/doc/trpl/benchmark-tests.md

@@ -13,7 +13,7 @@ pub fn add_two(a: i32) -> i32 {
 }
 
 #[cfg(test)]
-mod tests {
+mod test {
     use super::*;
     use test::Bencher;
 

branches/auto/src/doc/trpl/hello-cargo.md

@@ -1,7 +1,7 @@
 % Hello, Cargo!
 
 [Cargo](http://crates.io) is a tool that Rustaceans use to help manage their
-Rust projects. Cargo is currently in an alpha state, just like Rust, and so it
+Rust projects. Cargo is currently in a pre-1.0 state, just like Rust, and so it
 is still a work in progress. However, it is already good enough to use for many
 Rust projects, and so it is assumed that Rust projects will use Cargo from the
 beginning.

branches/auto/src/doc/trpl/testing.md

@@ -382,7 +382,7 @@ pub fn add_two(a: i32) -> i32 {
 }
 
 #[cfg(test)]
-mod tests {
+mod test {
     use super::*;
 
     #[test]

branches/auto/src/doc/trpl/traits.md

@@ -229,8 +229,6 @@ everything is fine:
 
 ```{rust}
 # #![feature(core)]
-use shapes::HasArea;
-
 mod shapes {
     use std::f64::consts;
 
@@ -251,6 +249,7 @@ mod shapes {
     }
 }
 
+use shapes::HasArea;
 
 fn main() {
     let c = shapes::Circle {