---

yaml
---
r: 229197
b: refs/heads/try
c: d5b522e
h: refs/heads/master
i:
  229195: 80fc1f3
v: v3

Author: c-nixon

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 8228240ca88371150314d5474b6795c5410c7a8e
+refs/heads/try: d5b522e20e4aa862a62e086706187a51c9478a59
 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

@@ -135,28 +135,34 @@ This gives us an error:
         ^~~~
 ```
 
-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.
+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.
 
-`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::Mutex;
+use std::sync::Arc;
 
 fn main() {
-    let mut data = Mutex::new(vec![1, 2, 3]);
+    let mut data = Arc::new(vec![1, 2, 3]);
 
     for i in 0..3 {
-        let data = data.lock().unwrap();
+        let data = data.clone();
         thread::spawn(move || {
             data[i] += 1;
         });
@@ -166,29 +172,29 @@ fn main() {
 }
 ```
 
-Here's the error:
+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.
 
 ```text
-<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 || {
-                  ^~~~~~~~~~~~~
+<anon>:11:24 error: cannot borrow immutable borrowed content as mutable
+<anon>:11                    data[i] += 1;
+                             ^~~~
 ```
 
-You see, [`Mutex`](../std/sync/struct.Mutex.html) has a
-[`lock`](../std/sync/struct.Mutex.html#method.lock)
-method which has this signature:
+`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.
 
-```ignore
-fn lock(&self) -> LockResult<MutexGuard<T>>
-```
+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.
 
-Because `Send` is not implemented for `MutexGuard<T>`, we can't transfer the
-guard across thread boundaries, which gives us our error.
+For that, we can use the `Mutex<T>` type!
 
-We can use `Arc<T>` to fix this. Here's the working version:
+Here's the working version:
 
 ```rust
 use std::sync::{Arc, Mutex};
@@ -209,9 +215,31 @@ fn main() {
 }
 ```
 
-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:
+
+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:
 
 ```rust
 # use std::sync::{Arc, Mutex};

branches/try/src/liballoc/arc.rs

@@ -71,8 +71,7 @@
 
 use boxed::Box;
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use core::atomic;
 use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst};

branches/try/src/liballoc/boxed.rs

@@ -53,8 +53,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use heap;
 use raw_vec::RawVec;

branches/try/src/liballoc/lib.rs

@@ -75,6 +75,7 @@
 #![feature(coerce_unsized)]
 #![feature(core)]
 #![feature(core_intrinsics)]
+#![feature(core_prelude)]
 #![feature(core_slice_ext)]
 #![feature(custom_attribute)]
 #![feature(fundamental)]
@@ -92,17 +93,17 @@
 #![feature(unsize)]
 #![feature(core_slice_ext)]
 #![feature(core_str_ext)]
-#![cfg_attr(stage0, feature(core, core_prelude))]
 
 #![cfg_attr(test, feature(test, alloc, rustc_private, box_raw))]
 #![cfg_attr(all(not(feature = "external_funcs"), not(feature = "external_crate")),
             feature(libc))]
 
+#[macro_use]
+extern crate core;
+
 #[cfg(all(not(feature = "external_funcs"), not(feature = "external_crate")))]
 extern crate libc;
 
-#[cfg(stage0)] #[macro_use] extern crate core;
-
 // Allow testing this library
 
 #[cfg(test)] #[macro_use] extern crate std;

branches/try/src/liballoc/rc.rs

@@ -150,8 +150,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 #[cfg(not(test))]
 use boxed::Box;

branches/try/src/libcollections/binary_heap.rs

@@ -151,8 +151,7 @@
 #![allow(missing_docs)]
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use core::iter::{FromIterator};
 use core::mem::swap;

branches/try/src/libcollections/bit.rs

@@ -86,8 +86,7 @@
 //! println!("There are {} primes below {}", num_primes, max_prime);
 //! ```
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use core::cmp::Ordering;
 use core::cmp;

branches/try/src/libcollections/btree/map.rs

@@ -17,8 +17,7 @@
 
 use self::Entry::*;
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use core::cmp::Ordering;
 use core::fmt::Debug;
@@ -531,8 +530,7 @@ enum Continuation<A, B> {
 /// to nodes. By using this module much better safety guarantees can be made, and more search
 /// boilerplate gets cut out.
 mod stack {
-    #[cfg(stage0)]
-    use core::prelude::v1::*;
+    use core::prelude::*;
     use core::marker;
     use core::mem;
     use core::ops::{Deref, DerefMut};

branches/try/src/libcollections/btree/node.rs

@@ -16,8 +16,7 @@ pub use self::SearchResult::*;
 pub use self::ForceResult::*;
 pub use self::TraversalItem::*;
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use core::cmp::Ordering::{Greater, Less, Equal};
 use core::intrinsics::arith_offset;

branches/try/src/libcollections/btree/set.rs

@@ -11,8 +11,7 @@
 // This is pretty much entirely stolen from TreeSet, since BTreeMap has an identical interface
 // to TreeMap
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use core::cmp::Ordering::{self, Less, Greater, Equal};
 use core::fmt::Debug;

branches/try/src/libcollections/enum_set.rs

@@ -17,9 +17,7 @@
             reason = "matches collection reform specification, \
                       waiting for dust to settle")]
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
-
+use core::prelude::*;
 use core::marker;
 use core::fmt;
 use core::iter::{FromIterator};

branches/try/src/libcollections/lib.rs

@@ -33,7 +33,9 @@
 #![feature(alloc)]
 #![feature(box_patterns)]
 #![feature(box_syntax)]
+#![feature(core)]
 #![feature(core_intrinsics)]
+#![feature(core_prelude)]
 #![feature(core_slice_ext)]
 #![feature(core_str_ext)]
 #![feature(heap_api)]
@@ -60,12 +62,12 @@
 #![feature(utf8_error)]
 #![cfg_attr(test, feature(rand, test))]
 #![cfg_attr(not(test), feature(str_words))]
-#![cfg_attr(stage0, feature(core, core_prelude))]
 
 #![feature(no_std)]
 #![no_std]
 
-#[cfg(stage0)] #[macro_use] extern crate core;
+#[macro_use]
+extern crate core;
 
 extern crate rustc_unicode;
 extern crate alloc;

branches/try/src/libcollections/linked_list.rs

@@ -21,8 +21,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use alloc::boxed::Box;
 use core::cmp::Ordering;

branches/try/src/libcollections/string.rs

@@ -12,8 +12,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use core::fmt;
 use core::hash;

branches/try/src/libcollections/vec.rs

@@ -58,9 +58,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
-
+use core::prelude::*;
 use alloc::raw_vec::RawVec;
 use alloc::boxed::Box;
 use alloc::heap::EMPTY;

branches/try/src/libcollections/vec_deque.rs

@@ -18,8 +18,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use core::cmp::Ordering;
 use core::fmt;

branches/try/src/libcollections/vec_map.rs

@@ -20,8 +20,7 @@
 
 use self::Entry::*;
 
-#[cfg(stage0)]
-use core::prelude::v1::*;
+use core::prelude::*;
 
 use core::cmp::{max, Ordering};
 use core::fmt;

branches/try/src/libcore/fmt/builders.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use prelude::v1::*;
+use prelude::*;
 use fmt::{self, Write, FlagV1};
 
 struct PadAdapter<'a, 'b: 'a> {

branches/try/src/libcore/fmt/mod.rs

@@ -12,7 +12,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use prelude::v1::*;
+use prelude::*;
 
 use cell::{Cell, RefCell, Ref, RefMut, BorrowState};
 use marker::PhantomData;

branches/try/src/libcore/fmt/num.rs

@@ -12,7 +12,7 @@
 
 // FIXME: #6220 Implement floating point formatting
 
-use prelude::v1::*;
+use prelude::*;
 
 use fmt;
 use num::Zero;

branches/try/src/libcore/hash/mod.rs

@@ -62,7 +62,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use prelude::v1::*;
+use prelude::*;
 
 use mem;
 
@@ -183,7 +183,7 @@ pub fn hash<T: Hash, H: Hasher + Default>(value: &T) -> u64 {
 //////////////////////////////////////////////////////////////////////////////
 
 mod impls {
-    use prelude::v1::*;
+    use prelude::*;
 
     use slice;
     use super::*;