---

yaml
---
r: 205744
b: refs/heads/beta
c: 5c7a0ba
h: refs/heads/master
v: v3

Author: meqif

[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: 049de3fe7f61d6ae5e6079981ed8e0e7701ea28e
+refs/heads/beta: 5c7a0ba06e21e9b8b22b8bdc27c16e10c6c1a2ce
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 579e31929feff51dcaf8d444648eff8de735f91a

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

@@ -165,13 +165,12 @@ particularly easy to read.
 
 ## Why is `let` used to introduce variables?
 
-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.
+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.
 
 Bindings always happen in pattern matching positions, and it's also Rust's way
-to declare mutability. One can also re-declare mutability of a binding in
+to declare mutability. One can also redeclare 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 dynamic language like Ruby, Python, or JavaScript,
+If you come from a dynamically typed 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,9 +2246,8 @@ 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) {

branches/beta/src/librustc/diagnostics.rs

@@ -173,6 +173,21 @@ This error indicates that an attempt was made to divide by zero (or take the
 remainder of a zero divisor) in a static or constant expression.
 "##,
 
+E0133: r##"
+Using unsafe functionality, such as dereferencing raw pointers and calling
+functions via FFI or marked as unsafe, is potentially dangerous and disallowed
+by safety checks. As such, those safety checks can be temporarily relaxed by
+wrapping the unsafe instructions inside an `unsafe` block. For instance:
+
+unsafe fn f() { return; }
+
+fn main() {
+    unsafe { f(); }
+}
+
+See also http://doc.rust-lang.org/book/unsafe-code.html
+"##,
+
 E0152: r##"
 Lang items are already implemented in the standard library. Unless you are
 writing a free-standing application (e.g. a kernel), you do not need to provide
@@ -405,7 +420,6 @@ register_diagnostics! {
     E0080, // enum variant: constant evaluation error
     E0109,
     E0110,
-    E0133,
     E0134,
     E0135,
     E0136,