---

yaml
---
r: 196582
b: refs/heads/auto
c: 92d0026
h: refs/heads/master
v: v3

Author: GuillaumeGomez

[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: 6f852f562094c926e2aaca11c9f508f60e449302
+refs/heads/auto: 92d00262c36e12ed848ca8b248cb81f16e7f2deb
 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/README.md

@@ -28,7 +28,7 @@ and will be able to understand most Rust code and write more complex programs.
 
 In a similar fashion to "Intermediate," this section is full of individual,
 deep-dive chapters, which stand alone and can be read in any order. These
-chapters focus on Rust's most complex features.
+chapters focus on the most complex features,
 
 <h2 class="section-header"><a href="unstable.html">Unstable</a></h2>
 

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/closures.md

@@ -54,7 +54,7 @@ The second is that the syntax is similar, but a bit different. I've added spaces
 here to make them look a little closer:
 
 ```rust
-fn  plus_one_v1   (x: i32 ) -> i32 { x + 1 }
+fn  plus_one_v1 (  x: i32 ) -> i32 { x + 1 }
 let plus_one_v2 = |x: i32 | -> i32 { x + 1 };
 let plus_one_v3 = |x: i32 |          x + 1  ;
 ```

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 test {
+mod tests {
     use super::*;
 
     #[test]

branches/auto/src/liballoc/arc.rs

@@ -243,29 +243,27 @@ pub fn weak_count<T>(this: &Arc<T>) -> usize { this.inner().weak.load(SeqCst) -
 pub fn strong_count<T>(this: &Arc<T>) -> usize { this.inner().strong.load(SeqCst) }
 
 
-/// Returns a mutable reference to the contained value if the `Arc<T>` is unique.
+/// Try accessing a mutable reference to the contents behind an unique `Arc<T>`.
 ///
-/// Returns `None` if the `Arc<T>` is not unique.
+/// The access is granted only if this is the only reference to the object.
+/// Otherwise, `None` is returned.
 ///
 /// # Examples
 ///
 /// ```
 /// # #![feature(alloc)]
 /// extern crate alloc;
 /// # fn main() {
-/// use alloc::arc::{Arc, get_mut};
+/// use alloc::arc;
 ///
-/// let mut x = Arc::new(3);
-/// *get_mut(&mut x).unwrap() = 4;
-/// assert_eq!(*x, 4);
+/// let mut four = arc::Arc::new(4);
 ///
-/// let _y = x.clone();
-/// assert!(get_mut(&mut x).is_none());
+/// arc::unique(&mut four).map(|num| *num = 5);
 /// # }
 /// ```
 #[inline]
 #[unstable(feature = "alloc")]
-pub fn get_mut<T>(this: &mut Arc<T>) -> Option<&mut T> {
+pub fn unique<T>(this: &mut Arc<T>) -> Option<&mut T> {
     if strong_count(this) == 1 && weak_count(this) == 0 {
         // This unsafety is ok because we're guaranteed that the pointer
         // returned is the *only* pointer that will ever be returned to T. Our
@@ -349,7 +347,7 @@ impl<T: Clone> Arc<T> {
            self.inner().weak.load(SeqCst) != 1 {
             *self = Arc::new((**self).clone())
         }
-        // As with `get_mut()`, the unsafety is ok because our reference was
+        // As with `unique()`, the unsafety is ok because our reference was
         // either unique to begin with, or became one upon cloning the contents.
         let inner = unsafe { &mut **self._ptr };
         &mut inner.data
@@ -693,7 +691,7 @@ mod tests {
     use std::sync::atomic::Ordering::{Acquire, SeqCst};
     use std::thread;
     use std::vec::Vec;
-    use super::{Arc, Weak, get_mut, weak_count, strong_count};
+    use super::{Arc, Weak, weak_count, strong_count, unique};
     use std::sync::Mutex;
 
     struct Canary(*mut atomic::AtomicUsize);
@@ -730,16 +728,18 @@ mod tests {
     }
 
     #[test]
-    fn test_arc_get_mut() {
-        let mut x = Arc::new(3);
-        *get_mut(&mut x).unwrap() = 4;
-        assert_eq!(*x, 4);
-        let y = x.clone();
-        assert!(get_mut(&mut x).is_none());
-        drop(y);
-        assert!(get_mut(&mut x).is_some());
-        let _w = x.downgrade();
-        assert!(get_mut(&mut x).is_none());
+    fn test_arc_unique() {
+        let mut x = Arc::new(10);
+        assert!(unique(&mut x).is_some());
+        {
+            let y = x.clone();
+            assert!(unique(&mut x).is_none());
+        }
+        {
+            let z = x.downgrade();
+            assert!(unique(&mut x).is_none());
+        }
+        assert!(unique(&mut x).is_some());
     }
 
     #[test]

branches/auto/src/liballoc/rc.rs

@@ -324,7 +324,7 @@ pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> {
 /// ```
 #[inline]
 #[unstable(feature = "alloc")]
-pub fn get_mut<T>(rc: &mut Rc<T>) -> Option<&mut T> {
+pub fn get_mut<'a, T>(rc: &'a mut Rc<T>) -> Option<&'a mut T> {
     if is_unique(rc) {
         let inner = unsafe { &mut **rc._ptr };
         Some(&mut inner.value)