---

yaml
---
r: 229199
b: refs/heads/try
c: c1f938d
h: refs/heads/master
i:
  229197: aeabca1
  229195: 80fc1f3
  229191: 06b8c49
  229183: 80eba7c
v: v3

Author: JanLikar

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 76ff835ca0b6669b185e6a4aeedc144432db91f8
+refs/heads/try: c1f938d7b834852aede4f865a18ee2226668a8e6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/mk/main.mk

@@ -13,7 +13,7 @@
 ######################################################################
 
 # The version number
-CFG_RELEASE_NUM=1.4.0
+CFG_RELEASE_NUM=1.3.0
 
 # An optional number to put after the label, e.g. '.2' -> '-beta.2'
 # NB Make sure it starts with a dot to conform to semver pre-release

branches/try/src/doc/trpl/concurrency.md

@@ -115,7 +115,7 @@ languages. It will not compile:
 use std::thread;
 
 fn main() {
-    let mut data = vec![1, 2, 3];
+    let mut data = vec![1u32, 2, 3];
 
     for i in 0..3 {
         thread::spawn(move || {
@@ -135,34 +135,28 @@ This gives us an error:
         ^~~~
 ```
 
-Rust knows this wouldn't be safe! If we had a reference to `data` in each
-thread, and the thread takes ownership of the reference, we'd have three
-owners!
-
-So, we need some type that lets us have more than one reference to a value and
-that we can share between threads, that is it must implement `Sync`.
-
-We'll use `Arc<T>`, rust's standard atomic reference count type, which
-wraps a value up with some extra runtime bookkeeping which allows us to
-share the ownership of the value between multiple references at the same time.
-
-The bookkeeping consists of a count of how many of these references exist to
-the value, hence the reference count part of the name.
-
-The Atomic part means `Arc<T>` can safely be accessed from multiple threads.
-To do this the compiler guarantees that mutations of the internal count use
-indivisible operations which can't have data races.
+In this case, we know that our code _should_ be safe, but Rust isn't sure. And
+it's actually not safe: if we had a reference to `data` in each thread, and the
+thread takes ownership of the reference, we have three owners! That's bad. We
+can fix this by using the `Arc<T>` type, which is an atomic reference counted
+pointer. The 'atomic' part means that it's safe to share across threads.
 
+`Arc<T>` assumes one more property about its contents to ensure that it is safe
+to share across threads: it assumes its contents are `Sync`. But in our
+case, we want to be able to mutate the value. We need a type that can ensure
+only one person at a time can mutate what's inside. For that, we can use the
+`Mutex<T>` type. Here's the second version of our code. It still doesn't work,
+but for a different reason:
 
 ```ignore
 use std::thread;
-use std::sync::Arc;
+use std::sync::Mutex;
 
 fn main() {
-    let mut data = Arc::new(vec![1, 2, 3]);
+    let mut data = Mutex::new(vec![1u32, 2, 3]);
 
     for i in 0..3 {
-        let data = data.clone();
+        let data = data.lock().unwrap();
         thread::spawn(move || {
             data[i] += 1;
         });
@@ -172,36 +166,36 @@ fn main() {
 }
 ```
 
-We now call `clone()` on our `Arc<T>`, which increases the internal count.
-This handle is then moved into the new thread.
-
-And... still gives us an error.
+Here's the error:
 
 ```text
-<anon>:11:24 error: cannot borrow immutable borrowed content as mutable
-<anon>:11                    data[i] += 1;
-                             ^~~~
+<anon>:9:9: 9:22 error: the trait `core::marker::Send` is not implemented for the type `std::sync::mutex::MutexGuard<'_, collections::vec::Vec<u32>>` [E0277]
+<anon>:11         thread::spawn(move || {
+                  ^~~~~~~~~~~~~
+<anon>:9:9: 9:22 note: `std::sync::mutex::MutexGuard<'_, collections::vec::Vec<u32>>` cannot be sent between threads safely
+<anon>:11         thread::spawn(move || {
+                  ^~~~~~~~~~~~~
 ```
 
-`Arc<T>` assumes one more property about its contents to ensure that it is safe
-to share across threads: it assumes its contents are `Sync`. This is true for
-our value if it's immutable, but we want to be able to mutate it, so we need
-something else to persuade the borrow checker we know what we're doing.
+You see, [`Mutex`](../std/sync/struct.Mutex.html) has a
+[`lock`](../std/sync/struct.Mutex.html#method.lock)
+method which has this signature:
 
-It looks like we need some type that allows us to safely mutate a shared value,
-for example a type that that can ensure only one thread at a time is able to
-mutate the value inside it at any one time.
+```ignore
+fn lock(&self) -> LockResult<MutexGuard<T>>
+```
 
-For that, we can use the `Mutex<T>` type!
+Because `Send` is not implemented for `MutexGuard<T>`, we can't transfer the
+guard across thread boundaries, which gives us our error.
 
-Here's the working version:
+We can use `Arc<T>` to fix this. Here's the working version:
 
 ```rust
 use std::sync::{Arc, Mutex};
 use std::thread;
 
 fn main() {
-    let data = Arc::new(Mutex::new(vec![1, 2, 3]));
+    let data = Arc::new(Mutex::new(vec![1u32, 2, 3]));
 
     for i in 0..3 {
         let data = data.clone();
@@ -215,37 +209,15 @@ fn main() {
 }
 ```
 
-
-If we'd tried to use `Mutex<T>` without wrapping it in an `Arc<T>` we would have
-seen another error like:
-
-```text
-error: the trait `core::marker::Send` is not implemented for the type `std::sync::mutex::MutexGuard<'_, collections::vec::Vec<u32>>` [E0277]
- thread::spawn(move || {
-                  ^~~~~~~~~~~~~
-note: `std::sync::mutex::MutexGuard<'_, collections::vec::Vec<u32>>` cannot be sent between threads safely
- thread::spawn(move || {
-                  ^~~~~~~~~~~~~
-```
-
-You see, [`Mutex`](../std/sync/struct.Mutex.html) has a
-[`lock`](../std/sync/struct.Mutex.html#method.lock)
-method which has this signature:
-
-```ignore
-fn lock(&self) -> LockResult<MutexGuard<T>>
-```
-
-and because `Send` is not implemented for `MutexGuard<T>`, we couldn't have
-transferred the guard across thread boundaries on it's own.
-
-Let's examine the body of the thread more closely:
+We now call `clone()` on our `Arc`, which increases the internal count. This
+handle is then moved into the new thread. Let's examine the body of the
+thread more closely:
 
 ```rust
 # use std::sync::{Arc, Mutex};
 # use std::thread;
 # fn main() {
-#     let data = Arc::new(Mutex::new(vec![1, 2, 3]));
+#     let data = Arc::new(Mutex::new(vec![1u32, 2, 3]));
 #     for i in 0..3 {
 #         let data = data.clone();
 thread::spawn(move || {
@@ -283,7 +255,7 @@ use std::thread;
 use std::sync::mpsc;
 
 fn main() {
-    let data = Arc::new(Mutex::new(0));
+    let data = Arc::new(Mutex::new(0u32));
 
     let (tx, rx) = mpsc::channel();
 
@@ -321,7 +293,7 @@ fn main() {
         let tx = tx.clone();
 
         thread::spawn(move || {
-            let answer = 42;
+            let answer = 42u32;
 
             tx.send(answer);
         });