---

yaml
---
r: 196583
b: refs/heads/auto
c: 50cb31f
h: refs/heads/master
i:
  196581: 072a419
  196579: b08b5f2
  196575: 8913a43
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: 92d00262c36e12ed848ca8b248cb81f16e7f2deb
+refs/heads/auto: 50cb31f0e767a469751c644136754129f1ac4247
 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/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 the most complex features,
+chapters focus on Rust's 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 tests {
+mod test {
     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/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/liballoc/arc.rs

@@ -243,27 +243,29 @@ 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) }
 
 
-/// Try accessing a mutable reference to the contents behind an unique `Arc<T>`.
+/// Returns a mutable reference to the contained value if the `Arc<T>` is unique.
 ///
-/// The access is granted only if this is the only reference to the object.
-/// Otherwise, `None` is returned.
+/// Returns `None` if the `Arc<T>` is not unique.
 ///
 /// # Examples
 ///
 /// ```
 /// # #![feature(alloc)]
 /// extern crate alloc;
 /// # fn main() {
-/// use alloc::arc;
+/// use alloc::arc::{Arc, get_mut};
 ///
-/// let mut four = arc::Arc::new(4);
+/// let mut x = Arc::new(3);
+/// *get_mut(&mut x).unwrap() = 4;
+/// assert_eq!(*x, 4);
 ///
-/// arc::unique(&mut four).map(|num| *num = 5);
+/// let _y = x.clone();
+/// assert!(get_mut(&mut x).is_none());
 /// # }
 /// ```
 #[inline]
 #[unstable(feature = "alloc")]
-pub fn unique<T>(this: &mut Arc<T>) -> Option<&mut T> {
+pub fn get_mut<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
@@ -347,7 +349,7 @@ impl<T: Clone> Arc<T> {
            self.inner().weak.load(SeqCst) != 1 {
             *self = Arc::new((**self).clone())
         }
-        // As with `unique()`, the unsafety is ok because our reference was
+        // As with `get_mut()`, 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
@@ -691,7 +693,7 @@ mod tests {
     use std::sync::atomic::Ordering::{Acquire, SeqCst};
     use std::thread;
     use std::vec::Vec;
-    use super::{Arc, Weak, weak_count, strong_count, unique};
+    use super::{Arc, Weak, get_mut, weak_count, strong_count};
     use std::sync::Mutex;
 
     struct Canary(*mut atomic::AtomicUsize);
@@ -728,18 +730,16 @@ mod tests {
     }
 
     #[test]
-    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());
+    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());
     }
 
     #[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<'a, T>(rc: &'a mut Rc<T>) -> Option<&'a mut T> {
+pub fn get_mut<T>(rc: &mut Rc<T>) -> Option<&mut T> {
     if is_unique(rc) {
         let inner = unsafe { &mut **rc._ptr };
         Some(&mut inner.value)