---

yaml
---
r: 212453
b: refs/heads/master
c: c5d0e2a
h: refs/heads/master
i:
  212451: 3149a56
v: v3

Author: pmarcelll

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 2fbbd54afe4297032f521fa80ed0e5230d6e03e3
+refs/heads/master: c5d0e2a0733b5271d1044979cf824dccb2a3c3d5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: 1864973ae17213c5a58c4dd3f9af6d1b6c7d2e05

trunk/mk/docs.mk

@@ -169,7 +169,6 @@ DOC_TARGETS += doc/not_found.html
 doc/not_found.html: $(D)/not_found.md $(HTML_DEPS) | doc/
 	@$(call E, rustdoc: $@)
 	$(Q)$(RUSTDOC) $(RUSTDOC_HTML_OPTS_NO_CSS) \
-		--markdown-no-toc \
 		--markdown-css http://doc.rust-lang.org/rust.css $<
 
 define DEF_DOC

trunk/src/doc/grammar.md

@@ -281,8 +281,7 @@ type_path_tail : '<' type_expr [ ',' type_expr ] + '>'
 ## Macros
 
 ```antlr
-expr_macro_rules : "macro_rules" '!' ident '(' macro_rule * ')' ';' 
-                 | "macro_rules" '!' ident '{' macro_rule * '}' ;
+expr_macro_rules : "macro_rules" '!' ident '(' macro_rule * ')' ;
 macro_rule : '(' matcher * ')' "=>" '(' transcriber * ')' ';' ;
 matcher : '(' matcher * ')' | '[' matcher * ']'
         | '{' matcher * '}' | '$' ident ':' ident

trunk/src/doc/not_found.md

@@ -11,20 +11,20 @@ Looks like you've taken a wrong turn.
 
 Some things that might be helpful to you though:
 
-# Search
+## Search
 
 * <form action="https://duckduckgo.com/">
     <input type="text" id="site-search" name="q" size="80"></input>
     <input type="submit" value="Search DuckDuckGo">
 </form>
 * Rust doc search: <span id="core-search"></span>
 
-# Reference
+## Reference
 
 * [The Rust official site](http://rust-lang.org)
 * [The Rust reference](http://doc.rust-lang.org/reference.html)
 
-# Docs
+## Docs
 
 * [The standard library](http://doc.rust-lang.org/std/)
 

trunk/src/doc/reference.md

@@ -1367,6 +1367,7 @@ Traits can include default implementations of methods, as in:
 ```
 trait Foo {
     fn bar(&self);
+
     fn baz(&self) { println!("We called baz."); }
 }
 ```

trunk/src/doc/trpl/const-and-static.md

@@ -64,10 +64,7 @@ unsafe {
 
 [unsafe]: unsafe.html
 
-Furthermore, any type stored in a `static` must be `Sync`, and may not have
-a [`Drop`][drop] implementation.
-
-[drop]: drop.html
+Furthermore, any type stored in a `static` must be `Sync`.
 
 # Initializing
 
@@ -81,3 +78,7 @@ Almost always, if you can choose between the two, choose `const`. It’s pretty
 rare that you actually want a memory location associated with your constant,
 and using a const allows for optimizations like constant propagation not only
 in your crate but downstream crates.
+
+A const can be thought of as a `#define` in C: it has metadata overhead but it
+has no runtime overhead. “Should I use a #define or a static in C,” is largely
+the same question as whether you should use a const or a static in Rust.

trunk/src/doc/trpl/dining-philosophers.md

@@ -674,13 +674,9 @@ let handles: Vec<_> = philosophers.into_iter().map(|p| {
 
 Finally, inside of our `map()`/`collect()` loop, we call `table.clone()`. The
 `clone()` method on `Arc<T>` is what bumps up the reference count, and when it
-goes out of scope, it decrements the count. This is needed so that we know how
-many references to `table` exist across our threads. If we didn’t have a count,
-we wouldn’t know how to deallocate it.
-
-You’ll notice we can introduce a new binding to `table` here, and it will
-shadow the old one. This is often used so that you don’t need to come up with
-two unique names.
+goes out of scope, it decrements the count. You’ll notice we can introduce a
+new binding to `table` here, and it will shadow the old one. This is often used
+so that you don’t need to come up with two unique names.
 
 With this, our program works! Only two philosophers can eat at any one time,
 and so you’ll get some output like this:

trunk/src/doc/trpl/enums.md

@@ -64,45 +64,3 @@ equality yet, but we’ll find out in the [`traits`][traits] section.
 [match]: match.html
 [if-let]: if-let.html
 [traits]: traits.html
-
-# Constructors as functions
-
-An enum’s constructors can also be used like functions. For example:
-
-```rust
-# enum Message {
-# Write(String),
-# }
-let m = Message::Write("Hello, world".to_string());
-```
-
-Is the same as
-
-```rust
-# enum Message {
-# Write(String),
-# }
-fn foo(x: String) -> Message {
-    Message::Write(x)
-}
-
-let x = foo("Hello, world".to_string());
-```
-
-This is not immediately useful to us, but when we get to
-[`closures`][closures], we’ll talk about passing functions as arguments to
-other functions. For example, with [`iterators`][iterators], we can do this
-to convert a vector of `String`s into a vector of `Message::Write`s:
-
-```rust
-# enum Message {
-# Write(String),
-# }
-
-let v = vec!["Hello".to_string(), "World".to_string()];
-
-let v1: Vec<Message> = v.into_iter().map(Message::Write).collect();
-```
-
-[closures]: closures.html
-[iterators]: iterators.html

trunk/src/doc/trpl/ffi.md

@@ -238,7 +238,7 @@ However it is often desired that the callback is targeted to a special
 Rust object. This could be the object that represents the wrapper for the
 respective C object.
 
-This can be achieved by passing an raw pointer to the object down to the
+This can be achieved by passing an unsafe pointer to the object down to the
 C library. The C library can then include the pointer to the Rust object in
 the notification. This will allow the callback to unsafely access the
 referenced Rust object.
@@ -342,10 +342,8 @@ Note that frameworks are only available on OSX targets.
 The different `kind` values are meant to differentiate how the native library
 participates in linkage. From a linkage perspective, the rust compiler creates
 two flavors of artifacts: partial (rlib/staticlib) and final (dylib/binary).
-Native dynamic library and framework dependencies are propagated to the final
-artifact boundary, while static library dependencies are not propagated at
-all, because the static libraries are integrated directly into the subsequent
-artifact.
+Native dynamic libraries and frameworks are propagated to the final artifact
+boundary, while static libraries are not propagated at all.
 
 A few examples of how this model can be used are:
 
@@ -370,7 +368,7 @@ On OSX, frameworks behave with the same semantics as a dynamic library.
 
 # Unsafe blocks
 
-Some operations, like dereferencing raw pointers or calling functions that have been marked
+Some operations, like dereferencing unsafe pointers or calling functions that have been marked
 unsafe are only allowed inside unsafe blocks. Unsafe blocks isolate unsafety and are a promise to
 the compiler that the unsafety does not leak out of the block.
 

trunk/src/doc/trpl/functions.md

@@ -144,9 +144,7 @@ an expression, and a `let` can only begin a statement, not an expression.
 Note that assigning to an already-bound variable (e.g. `y = 5`) is still an
 expression, although its value is not particularly useful. Unlike other
 languages where an assignment evaluates to the assigned value (e.g. `5` in the
-previous example), in Rust the value of an assignment is an empty tuple `()`
-because the assigned value can have [just one owner](ownership.html), and any
-other returned value would be too surprising:
+previous example), in Rust the value of an assignment is an empty tuple `()`:
 
 ```rust
 let mut y = 5;

trunk/src/doc/trpl/method-syntax.md

@@ -86,8 +86,8 @@ impl Circle {
 # Chaining method calls
 
 So, now we know how to call a method, such as `foo.bar()`. But what about our
-original example, `foo.bar().baz()`? This is called ‘method chaining’. Let’s
-look at an example:
+original example, `foo.bar().baz()`? This is called ‘method chaining’, and we
+can do it by returning `self`.
 
 ```rust
 struct Circle {

trunk/src/doc/trpl/patterns.md

@@ -154,31 +154,6 @@ match x {
 
 This prints `Got an int!`.
 
-If you’re using `if` with multiple patterns, the `if` applies to both sides:
-
-```rust
-let x = 4;
-let y = false;
-
-match x {
-    4 | 5 if y => println!("yes"),
-    _ => println!("no"),
-}
-```
-
-This prints `no`, because the `if` applies to the whole of `4 | 5`, and not to
-just the `5`, In other words, the the precedence of `if` behaves like this:
-
-```text
-(4 | 5) if y => ...
-```
-
-not this:
-
-```text
-4 | (5 if y) => ...
-```
-
 # ref and ref mut
 
 If you want to get a [reference][ref], use the `ref` keyword:

trunk/src/doc/trpl/raw-pointers.md

@@ -52,9 +52,9 @@ println!("raw points at {}", *raw);
 It gives this error:
 
 ```text
-error: dereference of raw pointer requires unsafe function or block [E0133]
-     println!("raw points at {}", *raw);
-                                  ^~~~
+error: dereference of unsafe pointer requires unsafe function or block [E0133]
+     println!("raw points at{}", *raw);
+                                 ^~~~
 ```
 
 When you dereference a raw pointer, you’re taking responsibility that it’s not

trunk/src/doc/trpl/references-and-borrowing.md

@@ -151,9 +151,9 @@ As it turns out, there are rules.
 
 Here’s the rules about borrowing in Rust:
 
-First, any borrow must last for a scope no greater than that of the owner.
-Second, you may have one or the other of these two kinds of borrows, but not
-both at the same time:
+First, any borrow must last for a smaller scope than the owner. Second, you may
+have one or the other of these two kinds of borrows, but not both at the same
+time:
 
 * one or more references (`&T`) to a resource.
 * exactly one mutable reference (`&mut T`)

trunk/src/doc/trpl/strings.md

@@ -117,30 +117,6 @@ let dog = hachiko.chars().nth(1); // kinda like hachiko[1]
 
 This emphasizes that we have to go through the whole list of `chars`.
 
-## Slicing
-
-You can get a slice of a string with slicing syntax:
-
-```rust
-let dog = "hachiko";
-let hachi = &dog[0..5];
-```
-
-But note that these are _byte_ offsets, not _character_ offsets. So
-this will fail at runtime:
-
-```rust,should_panic
-let dog = "忠犬ハチ公";
-let hachi = &dog[0..2];
-```
-
-with this error:
-
-```text
-thread '<main>' panicked at 'index 0 and/or 2 in `忠犬ハチ公` do not lie on
-character boundary'
-```
-
 ## Concatenation
 
 If you have a `String`, you can concatenate a `&str` to the end of it: