---

yaml
---
r: 207705
b: refs/heads/tmp
c: 5dc03a8
h: refs/heads/master
i:
  207703: 20d80c5
v: v3

Author: eddyb

[refs]

@@ -32,7 +32,7 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: cd7d89af9169885642d43597302af69f842bbd78
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: e510eecf9fda5d4fc56bc5659355fc20fe68a7b8
+refs/heads/tmp: 5dc03a8246e76e9e3900d98f2f5d2574abaeaa6b
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 704c2ee730d2e948d11a2edd77e3f35de8329a6e
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/src/doc/trpl/dining-philosophers.md

@@ -2,28 +2,26 @@
 
 For our second project, let’s look at a classic concurrency problem. It’s
 called ‘the dining philosophers’. It was originally conceived by Dijkstra in
-1965, but we’ll use a lightly adapted version from [this paper][paper] by Tony
-Hoare in 1985.
+1965, but we’ll use the version from [this paper][paper] by Tony Hoare in 1985.
 
 [paper]: http://www.usingcsp.com/cspbook.pdf
 
 > In ancient times, a wealthy philanthropist endowed a College to accommodate
-> five eminent philosophers. Each philosopher had a room in which they could
-> engage in their professional activity of thinking; there was also a common
+> five eminent philosophers. Each philosopher had a room in which she could
+> engage in her professional activity of thinking; there was also a common
 > dining room, furnished with a circular table, surrounded by five chairs, each
 > labelled by the name of the philosopher who was to sit in it. They sat
 > anticlockwise around the table. To the left of each philosopher there was
 > laid a golden fork, and in the centre stood a large bowl of spaghetti, which
-> was constantly replenished. A philosopher was expected to spend most of
-> their time thinking; but when they felt hungry, they went to the dining
-> room, sat down in their own chair, picked up their own fork on their left,
-> and plunged it into the spaghetti. But such is the tangled nature of
-> spaghetti that a second fork is required to carry it to the mouth. The
-> philosopher therefore had also to pick up the fork on their right. When
-> they were finished they would put down both their forks, get up from their
-> chair, and continue thinking. Of course, a fork can be used by only one
-> philosopher at a time. If the other philosopher wants it, they just have
-> to wait until the fork is available again.
+> was constantly replenished. A philosopher was expected to spend most of her
+> time thinking; but when she felt hungry, she went to the dining room, sat down
+> in her own chair, picked up her own fork on her left, and plunged it into the
+> spaghetti. But such is the tangled nature of spaghetti that a second fork is
+> required to carry it to the mouth. The philosopher therefore had also to pick
+> up the fork on her right. When she was finished she would put down both her
+> forks, get up from her chair, and continue thinking. Of course, a fork can be
+> used by only one philosopher at a time. If the other philosopher wants it, she
+> just has to wait until the fork is available again.
 
 This classic problem shows off a few different elements of concurrency. The
 reason is that it's actually slightly tricky to implement: a simple
@@ -62,10 +60,10 @@ impl Philosopher {
 }
 
 fn main() {
-    let p1 = Philosopher::new("Judith Butler");
+    let p1 = Philosopher::new("Baruch Spinoza");
     let p2 = Philosopher::new("Gilles Deleuze");
     let p3 = Philosopher::new("Karl Marx");
-    let p4 = Philosopher::new("Emma Goldman");
+    let p4 = Philosopher::new("Friedrich Nietzsche");
     let p5 = Philosopher::new("Michel Foucault");
 }
 ```
@@ -161,10 +159,10 @@ look at `main()` again:
 # }
 # 
 fn main() {
-    let p1 = Philosopher::new("Judith Butler");
+    let p1 = Philosopher::new("Baruch Spinoza");
     let p2 = Philosopher::new("Gilles Deleuze");
     let p3 = Philosopher::new("Karl Marx");
-    let p4 = Philosopher::new("Emma Goldman");
+    let p4 = Philosopher::new("Friedrich Nietzsche");
     let p5 = Philosopher::new("Michel Foucault");
 }
 ```
@@ -178,10 +176,10 @@ that `new()` function, it would look like this:
 #     name: String,
 # }
 fn main() {
-    let p1 = Philosopher { name: "Judith Butler".to_string() };
+    let p1 = Philosopher { name: "Baruch Spinoza".to_string() };
     let p2 = Philosopher { name: "Gilles Deleuze".to_string() };
     let p3 = Philosopher { name: "Karl Marx".to_string() };
-    let p4 = Philosopher { name: "Emma Goldman".to_string() };
+    let p4 = Philosopher { name: "Friedrich Nietzche".to_string() };
     let p5 = Philosopher { name: "Michel Foucault".to_string() };
 }
 ```
@@ -213,10 +211,10 @@ impl Philosopher {
 
 fn main() {
     let philosophers = vec![
-        Philosopher::new("Judith Butler"),
+        Philosopher::new("Baruch Spinoza"),
         Philosopher::new("Gilles Deleuze"),
         Philosopher::new("Karl Marx"),
-        Philosopher::new("Emma Goldman"),
+        Philosopher::new("Friedrich Nietzsche"),
         Philosopher::new("Michel Foucault"),
     ];
 
@@ -249,10 +247,10 @@ mention they’re done eating. Running this program should give you the followin
 output:
 
 ```text
-Judith Butler is done eating.
+Baruch Spinoza is done eating.
 Gilles Deleuze is done eating.
 Karl Marx is done eating.
-Emma Goldman is done eating.
+Friedrich Nietzsche is done eating.
 Michel Foucault is done eating.
 ```
 
@@ -287,10 +285,10 @@ impl Philosopher {
 
 fn main() {
     let philosophers = vec![
-        Philosopher::new("Judith Butler"),
+        Philosopher::new("Baruch Spinoza"),
         Philosopher::new("Gilles Deleuze"),
         Philosopher::new("Karl Marx"),
-        Philosopher::new("Emma Goldman"),
+        Philosopher::new("Friedrich Nietzsche"),
         Philosopher::new("Michel Foucault"),
     ];
 
@@ -325,14 +323,14 @@ simulate the time it takes a philosopher to eat.
 If you run this program, you should see each philosopher eat in turn:
 
 ```text
-Judith Butler is eating.
-Judith Butler is done eating.
+Baruch Spinoza is eating.
+Baruch Spinoza is done eating.
 Gilles Deleuze is eating.
 Gilles Deleuze is done eating.
 Karl Marx is eating.
 Karl Marx is done eating.
-Emma Goldman is eating.
-Emma Goldman is done eating.
+Friedrich Nietzsche is eating.
+Friedrich Nietzsche is done eating.
 Michel Foucault is eating.
 Michel Foucault is done eating.
 ```
@@ -368,10 +366,10 @@ impl Philosopher {
 
 fn main() {
     let philosophers = vec![
-        Philosopher::new("Judith Butler"),
+        Philosopher::new("Baruch Spinoza"),
         Philosopher::new("Gilles Deleuze"),
         Philosopher::new("Karl Marx"),
-        Philosopher::new("Emma Goldman"),
+        Philosopher::new("Friedrich Nietzsche"),
         Philosopher::new("Michel Foucault"),
     ];
 
@@ -460,11 +458,11 @@ We have multi-threading!
 ```text
 Gilles Deleuze is eating.
 Gilles Deleuze is done eating.
-Emma Goldman is eating.
-Emma Goldman is done eating.
+Friedrich Nietzsche is eating.
+Friedrich Nietzsche is done eating.
 Michel Foucault is eating.
-Judith Butler is eating.
-Judith Butler is done eating.
+Baruch Spinoza is eating.
+Baruch Spinoza is done eating.
 Karl Marx is eating.
 Karl Marx is done eating.
 Michel Foucault is done eating.
@@ -534,10 +532,10 @@ fn main() {
     ]});
 
     let philosophers = vec![
-        Philosopher::new("Judith Butler", 0, 1),
+        Philosopher::new("Baruch Spinoza", 0, 1),
         Philosopher::new("Gilles Deleuze", 1, 2),
         Philosopher::new("Karl Marx", 2, 3),
-        Philosopher::new("Emma Goldman", 3, 4),
+        Philosopher::new("Friedrich Nietzsche", 3, 4),
         Philosopher::new("Michel Foucault", 0, 4),
     ];
 
@@ -645,10 +643,10 @@ count will go up, and when each thread ends, it will go back down.
 
 ```rust,ignore
 let philosophers = vec![
-    Philosopher::new("Judith Butler", 0, 1),
+    Philosopher::new("Baruch Spinoza", 0, 1),
     Philosopher::new("Gilles Deleuze", 1, 2),
     Philosopher::new("Karl Marx", 2, 3),
-    Philosopher::new("Emma Goldman", 3, 4),
+    Philosopher::new("Friedrich Nietzsche", 3, 4),
     Philosopher::new("Michel Foucault", 0, 4),
 ];
 ```
@@ -681,12 +679,12 @@ and so you’ll get some output like this:
 
 ```text
 Gilles Deleuze is eating.
-Emma Goldman is eating.
-Emma Goldman is done eating.
+Friedrich Nietzsche is eating.
+Friedrich Nietzsche is done eating.
 Gilles Deleuze is done eating.
-Judith Butler is eating.
+Baruch Spinoza is eating.
 Karl Marx is eating.
-Judith Butler is done eating.
+Baruch Spinoza is done eating.
 Michel Foucault is eating.
 Karl Marx is done eating.
 Michel Foucault is done eating.

branches/tmp/src/liballoc/rc.rs

@@ -144,7 +144,7 @@
 //!     // At the end of the method, gadget_owner, gadget1 and gadget2 get
 //!     // destroyed. There are now no strong (`Rc<T>`) references to the gadgets.
 //!     // Once they get destroyed, the Gadgets get destroyed. This zeroes the
-//!     // reference count on Gadget Man, they get destroyed as well.
+//!     // reference count on Gadget Man, so he gets destroyed as well.
 //! }
 //! ```
 

branches/tmp/src/libcollections/lib.rs

@@ -39,6 +39,7 @@
 #![feature(str_char)]
 #![feature(str_words)]
 #![feature(slice_patterns)]
+#![feature(debug_builders)]
 #![feature(utf8_error)]
 #![cfg_attr(test, feature(rand, rustc_private, test, hash, collections,
                           collections_drain, collections_range))]

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

@@ -54,7 +54,6 @@ impl<'a, 'b: 'a> fmt::Write for PadAdapter<'a, 'b> {
 ///
 /// Constructed by the `Formatter::debug_struct` method.
 #[must_use]
-#[stable(feature = "debug_builders", since = "1.2.0")]
 pub struct DebugStruct<'a, 'b: 'a> {
     fmt: &'a mut fmt::Formatter<'b>,
     result: fmt::Result,
@@ -73,7 +72,7 @@ pub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str)
 
 impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
     /// Adds a new field to the generated struct output.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn field(&mut self, name: &str, value: &fmt::Debug) -> &mut DebugStruct<'a, 'b> {
         self.result = self.result.and_then(|_| {
             let prefix = if self.has_fields {
@@ -95,7 +94,7 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
     }
 
     /// Finishes output and returns any error encountered.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn finish(&mut self) -> fmt::Result {
         if self.has_fields {
             self.result = self.result.and_then(|_| {
@@ -118,7 +117,6 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
 ///
 /// Constructed by the `Formatter::debug_tuple` method.
 #[must_use]
-#[stable(feature = "debug_builders", since = "1.2.0")]
 pub struct DebugTuple<'a, 'b: 'a> {
     fmt: &'a mut fmt::Formatter<'b>,
     result: fmt::Result,
@@ -136,7 +134,7 @@ pub fn debug_tuple_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str) -> D
 
 impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
     /// Adds a new field to the generated tuple struct output.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn field(&mut self, value: &fmt::Debug) -> &mut DebugTuple<'a, 'b> {
         self.result = self.result.and_then(|_| {
             let (prefix, space) = if self.has_fields {
@@ -158,7 +156,7 @@ impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
     }
 
     /// Finishes output and returns any error encountered.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn finish(&mut self) -> fmt::Result {
         if self.has_fields {
             self.result = self.result.and_then(|_| {
@@ -213,7 +211,6 @@ impl<'a, 'b: 'a> DebugInner<'a, 'b> {
 ///
 /// Constructed by the `Formatter::debug_set` method.
 #[must_use]
-#[stable(feature = "debug_builders", since = "1.2.0")]
 pub struct DebugSet<'a, 'b: 'a> {
     inner: DebugInner<'a, 'b>,
 }
@@ -231,14 +228,14 @@ pub fn debug_set_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugSet<'a, 'b
 
 impl<'a, 'b: 'a> DebugSet<'a, 'b> {
     /// Adds a new entry to the set output.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn entry(&mut self, entry: &fmt::Debug) -> &mut DebugSet<'a, 'b> {
         self.inner.entry(entry);
         self
     }
 
     /// Adds the contents of an iterator of entries to the set output.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>
             where D: fmt::Debug, I: IntoIterator<Item=D> {
         for entry in entries {
@@ -248,7 +245,7 @@ impl<'a, 'b: 'a> DebugSet<'a, 'b> {
     }
 
     /// Finishes output and returns any error encountered.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn finish(&mut self) -> fmt::Result {
         self.inner.finish();
         self.inner.result.and_then(|_| self.inner.fmt.write_str("}"))
@@ -259,7 +256,6 @@ impl<'a, 'b: 'a> DebugSet<'a, 'b> {
 ///
 /// Constructed by the `Formatter::debug_list` method.
 #[must_use]
-#[stable(feature = "debug_builders", since = "1.2.0")]
 pub struct DebugList<'a, 'b: 'a> {
     inner: DebugInner<'a, 'b>,
 }
@@ -277,14 +273,14 @@ pub fn debug_list_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugList<'a,
 
 impl<'a, 'b: 'a> DebugList<'a, 'b> {
     /// Adds a new entry to the list output.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn entry(&mut self, entry: &fmt::Debug) -> &mut DebugList<'a, 'b> {
         self.inner.entry(entry);
         self
     }
 
     /// Adds the contents of an iterator of entries to the list output.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugList<'a, 'b>
             where D: fmt::Debug, I: IntoIterator<Item=D> {
         for entry in entries {
@@ -294,7 +290,7 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> {
     }
 
     /// Finishes output and returns any error encountered.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn finish(&mut self) -> fmt::Result {
         self.inner.finish();
         self.inner.result.and_then(|_| self.inner.fmt.write_str("]"))
@@ -305,7 +301,6 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> {
 ///
 /// Constructed by the `Formatter::debug_map` method.
 #[must_use]
-#[stable(feature = "debug_builders", since = "1.2.0")]
 pub struct DebugMap<'a, 'b: 'a> {
     fmt: &'a mut fmt::Formatter<'b>,
     result: fmt::Result,
@@ -323,7 +318,7 @@ pub fn debug_map_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugMap<'a, 'b
 
 impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     /// Adds a new entry to the map output.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn entry(&mut self, key: &fmt::Debug, value: &fmt::Debug) -> &mut DebugMap<'a, 'b> {
         self.result = self.result.and_then(|_| {
             if self.is_pretty() {
@@ -341,7 +336,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     }
 
     /// Adds the contents of an iterator of entries to the map output.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
             where K: fmt::Debug, V: fmt::Debug, I: IntoIterator<Item=(K, V)> {
         for (k, v) in entries {
@@ -351,7 +346,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     }
 
     /// Finishes output and returns any error encountered.
-    #[stable(feature = "debug_builders", since = "1.2.0")]
+    #[unstable(feature = "debug_builders", reason = "method was just created")]
     pub fn finish(&mut self) -> fmt::Result {
         let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" };
         self.result.and_then(|_| write!(self.fmt, "{}}}", prefix))