---

yaml
---
r: 219005
b: refs/heads/snap-stage3
c: a3b19c8
h: refs/heads/master
i:
  219003: 300bf75
v: v3

Author: steveklabnik

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: c044791d80ea0dc5c4b57b6030a67b69f8510239
-refs/heads/snap-stage3: ae74652b4a0e0e56a91d9a9dd71ab01e51131dc5
+refs/heads/snap-stage3: a3b19c8858ec6dd29d71fde7bc2d78b2ac386d34
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/snap-stage3/src/doc/index.md

@@ -25,7 +25,7 @@ series of small examples.
 If you need help with something, or just want to talk about Rust with others,
 there are a few places you can do that:
 
-The Rust IRC channels on [irc.mozilla.org](irc://irc.mozilla.org/) are the
+The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/) are the
 fastest way to get help.
 [`#rust`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) is
 the general discussion channel, and you'll find people willing to help you with
@@ -40,15 +40,15 @@ There's also
 [`#rust-internals`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals), which is for discussion of the development of Rust itself.
 
 You can also get help on [Stack
-Overflow](https://stackoverflow.com/questions/tagged/rust). Searching for your
+Overflow](http://stackoverflow.com/questions/tagged/rust). Searching for your
 problem might reveal someone who has asked it before!
 
-There is an active [subreddit](https://reddit.com/r/rust) with lots of
+There is an active [subreddit](http://reddit.com/r/rust) with lots of
 discussion and news about Rust.
 
-There is also a [user forum](https://users.rust-lang.org), for all
-user-oriented discussion, and a [developer 
-forum](https://internals.rust-lang.org/), where the development of Rust
+There is also a [user forum](http://users.rust-lang.org), for all
+user-oriented discussion, and a [developer
+forum](http://internals.rust-lang.org/), where the development of Rust
 itself is discussed.
 
 # Specification
@@ -61,7 +61,7 @@ the language in as much detail as possible is in [the reference](reference.html)
 Rust is still a young language, so there isn't a ton of tooling yet, but the
 tools we have are really nice.
 
-[Cargo](https://crates.io) is Rust's package manager, and its website contains
+[Cargo](http://crates.io) is Rust's package manager, and its website contains
 lots of good documentation.
 
 [`rustdoc`](book/documentation.html) is used to generate documentation for Rust code.

branches/snap-stage3/src/doc/trpl/for-loops.md

@@ -41,45 +41,3 @@ so our loop will print `0` through `9`, not `10`.
 Rust does not have the “C-style” `for` loop on purpose. Manually controlling
 each element of the loop is complicated and error prone, even for experienced C
 developers.
-
-# Enumerate
-
-When you need to keep track of how many times you already looped, you can use the `.enumerate()` function.
-
-## On ranges:
-
-```rust
-for (i,j) in (5..10).enumerate() {
-    println!("i = {} and j = {}", i, j);
-}
-```
-
-Outputs:
-
-```text
-i = 0 and j = 5
-i = 1 and j = 6
-i = 2 and j = 7
-i = 3 and j = 8
-i = 4 and j = 9
-```
-
-Don't forget to add the parentheses around the range.
-
-## On iterators:
-
-```rust
-# let lines = "hello\nworld".lines();
-for (linenumber, line) in lines.enumerate() {
-    println!("{}: {}", linenumber, line);
-}
-```
-
-Outputs:
-
-```text
-0: Content of line one
-1: Content of line two
-2: Content of line tree
-3: Content of line four
-```

branches/snap-stage3/src/doc/trpl/hello-cargo.md

@@ -33,8 +33,7 @@ $ mv main.rs src/main.rs
 ```
 
 Note that since we're creating an executable, we used `main.rs`. If we
-want to make a library instead, we should use `lib.rs`. This convention is required
-for Cargo to successfully compile our projects, but it can be overridden if we wish. 
+want to make a library instead, we should use `lib.rs`.
 Custom file locations for the entry point can be specified
 with a [`[[lib]]` or `[[bin]]`][crates-custom] key in the TOML file described below.
 
@@ -63,17 +62,18 @@ version = "0.0.1"
 authors = [ "Your name <[email protected]>" ]
 ```
 
-This file is in the [TOML][toml] format. TOML is similar to INI, but has some 
-extra goodies. According to the TOML docs, 
+This file is in the [TOML][toml] format. Let’s let it explain itself to you:
 
 > TOML aims to be a minimal configuration file format that's easy to read due
 > to obvious semantics. TOML is designed to map unambiguously to a hash table.
 > TOML should be easy to parse into data structures in a wide variety of
 > languages.
 
+TOML is very similar to INI, but with some extra goodies.
+
 [toml]: https://github.com/toml-lang/toml
 
-Once you have this file in place, we should be ready to build! To do so, run:
+Once you have this file in place, we should be ready to build! Try this:
 
 ```bash
 $ cargo build
@@ -82,7 +82,7 @@ $ ./target/debug/hello_world
 Hello, world!
 ```
 
-Bam! We built our project with `cargo build`, and ran it with
+Bam! We build our project with `cargo build`, and run it with
 `./target/debug/hello_world`. We can do both in one step with `cargo run`:
 
 ```bash
@@ -103,9 +103,9 @@ Hello, world!
 ```
 
 This hasn’t bought us a whole lot over our simple use of `rustc`, but think
-about the future: when our project gets more complex, we need to do more
+about the future: when our project gets more complex, we would need to do more
 things to get all of the parts to properly compile. With Cargo, as our project
-grows, we can just run `cargo build`, and it’ll work the right way.
+grows, we can just `cargo build`, and it’ll work the right way.
 
 When your project is finally ready for release, you can use
 `cargo build --release` to compile your project with optimizations.
@@ -118,7 +118,7 @@ name = "hello_world"
 version = "0.0.1"
 ```
 
-The `Cargo.lock` file is used by Cargo to keep track of dependencies in your application.
+This file is used by Cargo to keep track of dependencies in your application.
 Right now, we don’t have any, so it’s a bit sparse. You won't ever need
 to touch this file yourself, just let Cargo handle it.
 
@@ -170,7 +170,7 @@ This is all we need to get started. First, let’s check out `Cargo.toml`:
 [package]
 
 name = "hello_world"
-version = "0.1.0"
+version = "0.0.1"
 authors = ["Your Name <[email protected]>"]
 ```
 

branches/snap-stage3/src/doc/trpl/macros.md

@@ -224,7 +224,7 @@ more" match. Both forms optionally include a separator, which can be any token
 except `+` or `*`.
 
 This system is based on
-"[Macro-by-Example](https://www.cs.indiana.edu/ftp/techreports/TR206.pdf)"
+"[Macro-by-Example](http://www.cs.indiana.edu/ftp/techreports/TR206.pdf)"
 (PDF link).
 
 # Hygiene
@@ -319,7 +319,7 @@ syntax context where it was introduced. It’s as though the variable `state`
 inside `main` is painted a different "color" from the variable `state` inside
 the macro, and therefore they don’t conflict.
 
-[hygienic macro system]: https://en.wikipedia.org/wiki/Hygienic_macro
+[hygienic macro system]: http://en.wikipedia.org/wiki/Hygienic_macro
 
 This also restricts the ability of macros to introduce new bindings at the
 invocation site. Code such as the following will not work:
@@ -622,7 +622,7 @@ invocation gives you another opportunity to pattern-match the macro’s
 arguments.
 
 As an extreme example, it is possible, though hardly advisable, to implement
-the [Bitwise Cyclic Tag](https://esolangs.org/wiki/Bitwise_Cyclic_Tag) automaton
+the [Bitwise Cyclic Tag](http://esolangs.org/wiki/Bitwise_Cyclic_Tag) automaton
 within Rust’s macro system.
 
 ```rust

branches/snap-stage3/src/doc/trpl/references-and-borrowing.md

@@ -155,7 +155,7 @@ 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.
+* 0 to N references (`&T`) to a resource.
 * exactly one mutable reference (`&mut T`)
 
 

branches/snap-stage3/src/liballoc/arc.rs

@@ -98,7 +98,6 @@ use heap::deallocate;
 /// increase the reference counter.
 ///
 /// ```
-/// # #![feature(alloc, core)]
 /// use std::sync::Arc;
 /// use std::thread;
 ///
@@ -297,7 +296,6 @@ impl<T: ?Sized> Clone for Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(alloc)]
     /// use std::sync::Arc;
     ///
     /// let five = Arc::new(5);
@@ -392,7 +390,6 @@ impl<T: ?Sized> Drop for Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(alloc)]
     /// use std::sync::Arc;
     ///
     /// {