---

yaml
---
r: 210815
b: refs/heads/try
c: 568f13a
h: refs/heads/master
i:
  210813: 2ba101c
  210811: 56d7209
  210807: a0e6cab
  210799: cfa9d06
  210783: 592b64d
  210751: f8639a6
  210687: 661f593
v: v3

Author: habnabit

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: 5501f076c207ae3b2466e330aa5ba8cb38bf4096
+refs/heads/try: 568f13ac7008db205dbd21dc5615614e3fc63b24
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

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

@@ -6,7 +6,7 @@ and more cores, yet many programmers aren't prepared to fully utilize them.
 
 Rust's memory safety features also apply to its concurrency story too. Even
 concurrent Rust programs must be memory safe, having no data races. Rust's type
-system is up to the task, and gives you powerful ways to reason about
+system is up to the thread, and gives you powerful ways to reason about
 concurrent code at compile time.
 
 Before we talk about the concurrency features that come with Rust, it's important

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

@@ -73,9 +73,6 @@ a name is all we need. We choose the [`String`][string] type for the name,
 rather than `&str`. Generally speaking, working with a type which owns its
 data is easier than working with one that uses references.
 
-[struct]: structs.html
-[string]: strings.html
-
 Let’s continue:
 
 ```rust

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

@@ -55,9 +55,6 @@ fn process_color_change(msg: Message) {
 }
 ```
 
-Both variants are named `Digit`, but since they’re scoped to the `enum` name
-there's no ambiguity.
-
 Not supporting these operations may seem rather limiting, but it’s a limitation
 which we can overcome. There are two ways: by implementing equality ourselves,
 or by pattern matching variants with [`match`][match] expressions, which you’ll
@@ -66,4 +63,3 @@ equality yet, but we’ll find out in the [`traits`][traits] section.
 
 [match]: match.html
 [if-let]: if-let.html
-[traits]: traits.html

branches/try/src/doc/trpl/guessing-game.md

@@ -213,12 +213,12 @@ The next part will use this handle to get input from the user:
 ```
 
 Here, we call the [`read_line()`][read_line] method on our handle.
-[Methods][method] are like associated functions, but are only available on a
+[Method][method]s are like associated functions, but are only available on a
 particular instance of a type, rather than the type itself. We’re also passing
 one argument to `read_line()`: `&mut guess`.
 
 [read_line]: ../std/io/struct.Stdin.html#method.read_line
-[method]: method-syntax.html
+[method]: methods.html
 
 Remember how we bound `guess` above? We said it was mutable. However,
 `read_line` doesn’t take a `String` as an argument: it takes a `&mut String`.

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

@@ -97,4 +97,4 @@ Unlike the previous uses of `match`, you can’t use the normal `if`
 statement to do this. You can use the [`if let`][if-let] statement,
 which can be seen as an abbreviated form of `match`.
 
-[if-let]: if-let.html
+[if-let][if-let.html]

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

@@ -35,7 +35,7 @@ let y = &mut x;
 
 `y` is an immutable binding to a mutable reference, which means that you can’t
 bind `y` to something else (`y = &mut z`), but you can mutate the thing that’s
-bound to `y` (`*y = 5`). A subtle distinction.
+bound to `y`. (`*y = 5`) A subtle distinction.
 
 Of course, if you need both:
 

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

@@ -66,7 +66,7 @@ match x {
 }
 ```
 
-This prints `something else`.
+This prints `something else`
 
 # Bindings
 
@@ -152,7 +152,7 @@ match x {
 }
 ```
 
-This prints `Got an int!`.
+This prints `Got an int!`
 
 # ref and ref mut
 

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

@@ -196,5 +196,3 @@ useful. For instance, a library may ask you to create a structure that
 implements a certain [trait][trait] to handle events. If you don’t have
 any data you need to store in the structure, you can just create a
 unit-like struct.
-
-[trait]: traits.html

branches/try/src/doc/trpl/the-stack-and-the-heap.md

@@ -430,7 +430,7 @@ Next, `foo()` calls `bar()` with `x` and `z`:
 |  2<sup>30</sup>      |      | 20                   |
 | (2<sup>30</sup>) - 1 |      | 5                    |
 | ...                  | ...  | ...                  |
-| 10                   | e    | 9                    |
+| 10                   | e    | 4                    |
 | 9                    | d    | (2<sup>30</sup>) - 1 |
 | 8                    | c    | 5                    |
 | 7                    | b    | 4                    |
@@ -455,7 +455,7 @@ At the end of `bar()`, it calls `baz()`:
 | ...                  | ...  | ...                  |
 | 12                   | g    | 100                  |
 | 11                   | f    | 4                    |
-| 10                   | e    | 9                    |
+| 10                   | e    | 4                    |
 | 9                    | d    | (2<sup>30</sup>) - 1 |
 | 8                    | c    | 5                    |
 | 7                    | b    | 4                    |
@@ -477,7 +477,7 @@ After `baz()` is over, we get rid of `f` and `g`:
 |  2<sup>30</sup>      |      | 20                   |
 | (2<sup>30</sup>) - 1 |      | 5                    |
 | ...                  | ...  | ...                  |
-| 10                   | e    | 9                    |
+| 10                   | e    | 4                    |
 | 9                    | d    | (2<sup>30</sup>) - 1 |
 | 8                    | c    | 5                    |
 | 7                    | b    | 4                    |

branches/try/src/doc/trpl/while-loops.md

@@ -3,7 +3,7 @@
 Rust also has a `while` loop. It looks like this:
 
 ```{rust}
-let mut x = 5; // mut x: i32
+let mut x = 5; // mut x: u32
 let mut done = false; // mut done: bool
 
 while !done {

branches/try/src/libcollections/str.rs

@@ -396,7 +396,6 @@ macro_rules! utf8_acc_cont_byte {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Borrow<str> for String {
-    #[inline]
     fn borrow(&self) -> &str { &self[..] }
 }
 

branches/try/src/libstd/lib.rs

@@ -40,7 +40,7 @@
 //! [`result`](result/index.html) modules define optional and
 //! error-handling types, `Option` and `Result`. The
 //! [`iter`](iter/index.html) module defines Rust's iterator trait,
-//! [`Iterator`](iter/trait.Iterator.html), which works with the `for`
+//! [`Iterater`](iter/trait.Iterator.html), which works with the `for`
 //! loop to access collections.
 //!
 //! The common container type, `Vec`, a growable vector backed by an array,