---

yaml
---
r: 196586
b: refs/heads/auto
c: 59d8898
h: refs/heads/master
v: v3

Author: joshtriplett

[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: 6efb8352e8b066d23f6c67ffcf8ab6e60642fe2e
+refs/heads/auto: 59d889805e7303e862d02f22aba0887ce49975e7
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/intro.md

@@ -457,25 +457,30 @@ 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 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:
+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:
 
 ```{rust}
 use std::thread;
-use std::sync::Mutex;
+use std::sync::{Arc,Mutex};
 
 fn main() {
-    let numbers = &Mutex::new(vec![1, 2, 3]);
+    let numbers = Arc::new(Mutex::new(vec![1, 2, 3]));
 
     let guards: Vec<_> = (0..3).map(|i| {
+        let number = numbers.clone();
         thread::scoped(move || {
-            let mut array = numbers.lock().unwrap();
+            let mut array = number.lock().unwrap();
             array[i] += 1;
             println!("numbers[{}] is {}", i, array[i]);
         })
@@ -484,9 +489,12 @@ fn main() {
 ```
 
 We first have to `use` the appropriate library, and then we wrap our vector in
-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.
+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.
 
 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 test {
+mod tests {
     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 a pre-1.0 state, just like Rust, and so it
+Rust projects. Cargo is currently in an alpha 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 test {
+mod tests {
     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 {