---

yaml
---
r: 210678
b: refs/heads/try
c: 9a3e98b
h: refs/heads/master
v: v3

Author: steveklabnik

[refs]

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

branches/try/src/doc/index.md

@@ -5,14 +5,15 @@ to jump to any particular section.
 
 # Getting Started
 
-If you haven't seen Rust at all yet, the first thing you should read is the
-introduction to [The Rust Programming Language](book/index.html). It'll give
-you a good idea of what Rust is like.
+If you haven't seen Rust at all yet, the first thing you should read is the [30
+minute intro](intro.html). It will give you an overview of the basic ideas of Rust
+at a high level.
 
-The book provides a lengthy explanation of Rust, its syntax, and its
-concepts. Upon completing the book, you'll be an intermediate Rust
-developer, and will have a good grasp of the fundamental ideas behind
-Rust.
+Once you know you really want to learn Rust, the next step is reading [The
+Rust Programming Language](book/index.html). It is a lengthy explanation of
+Rust, its syntax, and its concepts. Upon completing the book, you'll be an
+intermediate Rust developer, and will have a good grasp of the fundamental
+ideas behind Rust.
 
 [Rust By Example][rbe] was originally a community resource, but was then
 donated to the Rust project. As the name implies, it teaches you Rust through a
@@ -23,7 +24,7 @@ series of small examples.
 # Community & Getting Help
 
 If you need help with something, or just want to talk about Rust with others,
-there are a few places you can do that:
+there's a few places you can do that:
 
 The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/) are the
 fastest way to get help.
@@ -58,7 +59,7 @@ the language in as much detail as possible is in [the reference](reference.html)
 
 # Tools
 
-Rust is still a young language, so there isn't a ton of tooling yet, but the
+Rust's still a young language, so there isn't a ton of tooling yet, but the
 tools we have are really nice.
 
 [Cargo](http://crates.io) is Rust's package manager, and its website contains
@@ -68,21 +69,16 @@ lots of good documentation.
 
 # FAQs
 
-There are questions that are asked quite often, so we've made FAQs for them:
+There are questions that are asked quite often, and so we've made FAQs for them:
 
 * [Language Design FAQ](complement-design-faq.html)
 * [Language FAQ](complement-lang-faq.html)
 * [Project FAQ](complement-project-faq.html)
 * [How to submit a bug report](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports)
 
-# The Standard Library
+# The standard library
 
 We have [API documentation for the entire standard
 library](std/index.html). There's a list of crates on the left with more
 specific sections, or you can use the search bar at the top to search for
 something if you know its name.
-
-# The Error Index
-
-If you encounter an error while compiling your code you may be able to look it
-up in the [Rust Compiler Error Index](error-index.html).

branches/try/src/doc/reference.md

@@ -15,7 +15,6 @@
     * [Concurrency](concurrency.md)
     * [Error Handling](error-handling.md)
     * [FFI](ffi.md)
-    * [Borrow and AsRef](borrow-and-asref.md)
 * [Syntax and Semantics](syntax-and-semantics.md)
     * [Variable Bindings](variable-bindings.md)
     * [Functions](functions.md)

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

@@ -176,7 +176,7 @@ for a full example, the core of which is reproduced here:
 
 ```ignore
 declare_lint!(TEST_LINT, Warn,
-              "Warn about items named 'lintme'");
+              "Warn about items named 'lintme'")
 
 struct Pass;
 

branches/try/src/doc/trpl/borrow-and-asref.md

@@ -1,3 +1,67 @@
-% `Drop`
+% Drop
 
-Coming soon!
+Now that we’ve discussed traits, let’s talk about a particular trait provided
+by the Rust standard library, [`Drop`][drop]. The `Drop` trait provides a way
+to run some code when a value goes out of scope. For example:
+
+[drop]: ../std/ops/trait.Drop.html
+
+```rust
+struct HasDrop;
+
+impl Drop for HasDrop {
+    fn drop(&mut self) {
+        println!("Dropping!");
+    }
+}
+
+fn main() {
+    let x = HasDrop;
+
+    // do stuff
+
+} // x goes out of scope here
+```
+
+When `x` goes out of scope at the end of `main()`, the code for `Drop` will
+run. `Drop` has one method, which is also called `drop()`. It takes a mutable
+reference to `self`.
+
+That’s it! The mechanics of `Drop` are very simple, but there are some
+subtleties. For example, values are dropped in the opposite order they are
+declared. Here’s another example:
+
+```rust
+struct Firework {
+    strength: i32,
+}
+
+impl Drop for Firework {
+    fn drop(&mut self) {
+        println!("BOOM times {}!!!", self.strength);
+    }
+}
+
+fn main() {
+    let firecracker = Firework { strength: 1 };
+    let tnt = Firework { strength: 100 };
+}
+```
+
+This will output:
+
+```text
+BOOM times 100!!!
+BOOM times 1!!!
+```
+
+The TNT goes off before the firecracker does, because it was declared
+afterwards. Last in, first out.
+
+So what is `Drop` good for? Generally, `Drop` is used to clean up any resources
+associated with a `struct`. For example, the [`Arc<T>` type][arc] is a
+reference-counted type. When `Drop` is called, it will decrement the reference
+count, and if the total number of references is zero, will clean up the
+underlying value.
+
+[arc]: ../std/sync/struct.Arc.html

branches/try/src/doc/trpl/compiler-plugins.md

@@ -5,7 +5,7 @@ Rust’s most unique and compelling features, with which Rust developers should
 become quite acquainted. Ownership is how Rust achieves its largest goal,
 memory safety. There are a few distinct concepts, each with its own chapter:
 
-* [ownership][ownership], the key concept
+* [ownership][ownership], ownership, the key concept
 * [borrowing][borrowing], and their associated feature ‘references’
 * lifetimes, which you’re reading now
 

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

@@ -127,12 +127,12 @@ fn grow(&self) -> Circle {
 We just say we’re returning a `Circle`. With this method, we can grow a new
 circle to any arbitrary size.
 
-# Associated functions
+# Static methods
 
-You can also define associated functions that do not take a `self` parameter.
-Here’s a pattern that’s very common in Rust code:
+You can also define static methods that do not take a `self` parameter. Here’s a
+pattern that’s very common in Rust code:
 
-```rust
+```
 struct Circle {
     x: f64,
     y: f64,

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

@@ -6,7 +6,7 @@ become quite acquainted. Ownership is how Rust achieves its largest goal,
 memory safety. There are a few distinct concepts, each with its own
 chapter:
 
-* ownership, which you’re reading now
+* ownership, which you’re reading now.
 * [borrowing][borrowing], and their associated feature ‘references’
 * [lifetimes][lifetimes], an advanced concept of borrowing
 
@@ -23,7 +23,7 @@ Before we get to the details, two important notes about the ownership system.
 Rust has a focus on safety and speed. It accomplishes these goals through many
 ‘zero-cost abstractions’, which means that in Rust, abstractions cost as little
 as possible in order to make them work. The ownership system is a prime example
-of a zero-cost abstraction. All of the analysis we’ll talk about in this guide
+of a zero cost abstraction. All of the analysis we’ll talk about in this guide
 is _done at compile time_. You do not pay any run-time cost for any of these
 features.
 
@@ -41,7 +41,7 @@ With that in mind, let’s learn about ownership.
 
 # Ownership
 
-[Variable bindings][bindings] have a property in Rust: they ‘have ownership’
+[`Variable bindings`][bindings] have a property in Rust: they ‘have ownership’
 of what they’re bound to. This means that when a binding goes out of scope, the
 resource that they’re bound to are freed. For example:
 
@@ -106,8 +106,8 @@ take(v);
 println!("v[0] is: {}", v[0]);
 ```
 
-Same error: ‘use of moved value’. When we transfer ownership to something else,
-we say that we’ve ‘moved’ the thing we refer to. You don’t need any sort of
+Same error: “use of moved value.” When we transfer ownership to something else,
+we say that we’ve ‘moved’ the thing we refer to. You don’t need some sort of
 special annotation here, it’s the default thing that Rust does.
 
 ## The details
@@ -121,19 +121,19 @@ let v = vec![1, 2, 3];
 let v2 = v;
 ```
 
-The first line allocates memory for the vector object, `v`, and for the data it
-contains. The vector object is stored on the [stack][sh] and contains a pointer
-to the content (`[1, 2, 3]`) stored on the [heap][sh]. When we move `v` to `v2`,
-it creates a copy of that pointer, for `v2`. Which means that there would be two
-pointers to the content of the vector on the heap. It would violate Rust’s
-safety guarantees by introducing a data race. Therefore, Rust forbids using `v`
-after we’ve done the move.
+The first line creates some data for the vector on the [stack][sh], `v`. The
+vector’s data, however, is stored on the [heap][sh], and so it contains a
+pointer to that data. When we move `v` to `v2`, it creates a copy of that pointer,
+for `v2`. Which would mean two pointers to the contents of the vector on the
+heap. That would be a problem: it would violate Rust’s safety guarantees by
+introducing a data race. Therefore, Rust forbids using `v` after we’ve done the
+move.
 
 [sh]: the-stack-and-the-heap.html
 
 It’s also important to note that optimizations may remove the actual copy of
-the bytes on the stack, depending on circumstances. So it may not be as
-inefficient as it initially seems.
+the bytes, depending on circumstances. So it may not be as inefficient as it
+initially seems.
 
 ## `Copy` types
 

branches/try/src/doc/trpl/method-syntax.md

@@ -15,7 +15,7 @@ let x = true;
 let y: bool = false;
 ```
 
-A common use of booleans is in [`if` conditionals][if].
+A common use of booleans is in [`if` statements][if].
 
 [if]: if.html