---

yaml
---
r: 205745
b: refs/heads/beta
c: 14d9d1c
h: refs/heads/master
i:
  205743: 369318f
v: v3

Author: bors

[refs]

@@ -29,7 +29,7 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: 5c7a0ba06e21e9b8b22b8bdc27c16e10c6c1a2ce
+refs/heads/beta: 14d9d1c1cfaec1843a2d16e1795a9300ddd73588
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 579e31929feff51dcaf8d444648eff8de735f91a

branches/beta/src/doc/complement-design-faq.md

@@ -165,12 +165,13 @@ particularly easy to read.
 
 ## Why is `let` used to introduce variables?
 
-We don't use the term "variable", instead, we use "variable bindings". The
-simplest way for binding is the `let` syntax, other ways including `if let`,
-`while let` and `match`. Bindings also exist in function arguments positions.
+Instead of the term "variable", we use "variable bindings". The
+simplest way for creating a binding is by using the `let` syntax.
+Other ways include `if let`, `while let`, and `match`. Bindings also
+exist in function argument positions.
 
 Bindings always happen in pattern matching positions, and it's also Rust's way
-to declare mutability. One can also redeclare mutability of a binding in
+to declare mutability. One can also re-declare mutability of a binding in
 pattern matching. This is useful to avoid unnecessary `mut` annotations. An
 interesting historical note is that Rust comes, syntactically, most closely
 from ML, which also uses `let` to introduce bindings.

branches/beta/src/doc/trpl/hello-world.md

@@ -147,7 +147,7 @@ $ ./main  # or main.exe on Windows
 
 This prints out our `Hello, world!` text to our terminal.
 
-If you come from a dynamically typed language like Ruby, Python, or JavaScript,
+If you come from a dynamic language like Ruby, Python, or JavaScript,
 you may not be used to these two steps being separate. Rust is an
 ‘ahead-of-time compiled language’, which means that you can compile a program,
 give it to someone else, and they don't need to have Rust installed. If you

branches/beta/src/libcore/iter.rs

@@ -2246,8 +2246,9 @@ impl<I> RandomAccessIterator for Fuse<I> where I: RandomAccessIterator {
 impl<I> ExactSizeIterator for Fuse<I> where I: ExactSizeIterator {}
 
 impl<I> Fuse<I> {
-    /// Resets the fuse such that the next call to .next() or .next_back() will
-    /// call the underlying iterator again even if it previously returned None.
+    /// Resets the `Fuse` such that the next call to `.next()` or
+    /// `.next_back()` will call the underlying iterator again even if it
+    /// previously returned `None`.
     #[inline]
     #[unstable(feature = "core", reason = "seems marginal")]
     pub fn reset_fuse(&mut self) {