---

yaml
---
r: 211679
b: refs/heads/auto
c: f56782a
h: refs/heads/master
i:
  211677: be5f17a
  211675: ea769ad
  211671: 1dcb522
  211663: 5fc37fb
  211647: 9f887d0
v: v3

Author: bors

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 677367599e8383c355b8e8261cafe3ce44c9c6de
+refs/heads/auto: f56782ab9c8d0f64b9a714cc24d925a81ac3211b
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

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

@@ -7,7 +7,7 @@
 * [Learn Rust](learn-rust.md)
     * [Guessing Game](guessing-game.md)
     * [Dining Philosophers](dining-philosophers.md)
-    * [Rust inside other languages](rust-inside-other-languages.md)
+    * [Rust Inside Other Languages](rust-inside-other-languages.md)
 * [Effective Rust](effective-rust.md)
     * [The Stack and the Heap](the-stack-and-the-heap.md)
     * [Testing](testing.md)

branches/auto/src/doc/trpl/installing-rust.md

@@ -43,11 +43,11 @@ Some people, and somewhat rightfully so, get very upset when we tell you to
 `curl | sh`. Basically, when you do this, you are trusting that the good
 people who maintain Rust aren't going to hack your computer and do bad things.
 That's a good instinct! If you're one of those people, please check out the
-documentation on [building Rust from Source][from source], or [the official
-binary downloads][install page].
+documentation on [building Rust from Source][from-source], or [the official
+binary downloads][install-page].
 
-[from source]: https://github.com/rust-lang/rust#building-from-source
-[install page]: http://www.rust-lang.org/install.html
+[from-source]: https://github.com/rust-lang/rust#building-from-source
+[install-page]: http://www.rust-lang.org/install.html
 
 Oh, we should also mention the officially supported platforms:
 

branches/auto/src/doc/trpl/macros.md

@@ -30,8 +30,8 @@ mind.
 
 # Defining a macro
 
-You may have seen the `vec!` macro, used to initialize a [vector][] with any
-number of elements.
+You may have seen the `vec!` macro, used to initialize a [vector][vector] with
+any number of elements.
 
 [vector]: vectors.html
 
@@ -349,7 +349,7 @@ fn main() {
 }
 ```
 
-This holds for `let` bindings and loop labels, but not for [items][].
+This holds for `let` bindings and loop labels, but not for [items][items].
 So the following code does compile:
 
 ```rust
@@ -470,15 +470,15 @@ which syntactic form it matches.
 * `stmt`: a single statement. Example: `let x = 3`.
 * `block`: a brace-delimited sequence of statements. Example:
   `{ log(error, "hi"); return 12; }`.
-* `item`: an [item][]. Examples: `fn foo() { }`; `struct Bar;`.
+* `item`: an [item][item]. Examples: `fn foo() { }`; `struct Bar;`.
 * `meta`: a "meta item", as found in attributes. Example: `cfg(target_os = "windows")`.
 * `tt`: a single token tree.
 
 There are additional rules regarding the next token after a metavariable:
 
 * `expr` variables may only be followed by one of: `=> , ;`
 * `ty` and `path` variables may only be followed by one of: `=> , : = > as`
-* `pat` variables may only be followed by one of: `=> , =`
+* `pat` variables may only be followed by one of: `=> , = if in`
 * Other variables may be followed by any token.
 
 These rules provide some flexibility for Rust’s syntax to evolve without

branches/auto/src/doc/trpl/nightly-rust.md

@@ -46,11 +46,11 @@ Some people, and somewhat rightfully so, get very upset when we tell you to
 `curl | sh`. Basically, when you do this, you are trusting that the good
 people who maintain Rust aren't going to hack your computer and do bad things.
 That's a good instinct! If you're one of those people, please check out the
-documentation on [building Rust from Source][from source], or [the official
-binary downloads][install page].
+documentation on [building Rust from Source][from-source], or [the official
+binary downloads][install-page].
 
-[from source]: https://github.com/rust-lang/rust#building-from-source
-[install page]: http://www.rust-lang.org/install.html
+[from-source]: https://github.com/rust-lang/rust#building-from-source
+[install-page]: http://www.rust-lang.org/install.html
 
 Oh, we should also mention the officially supported platforms:
 
@@ -91,9 +91,9 @@ If not, there are a number of places where you can get help. The easiest is
 [the #rust IRC channel on irc.mozilla.org][irc], which you can access through
 [Mibbit][mibbit]. Click that link, and you'll be chatting with other Rustaceans
 (a silly nickname we call ourselves), and we can help you out. Other great
-resources include [the user’s forum][users], and [Stack Overflow][stack overflow].
+resources include [the user’s forum][users], and [Stack Overflow][stackoverflow].
 
 [irc]: irc://irc.mozilla.org/#rust
 [mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
 [users]: http://users.rust-lang.org/ 
-[stack overflow]: http://stackoverflow.com/questions/tagged/rust
+[stackoverflow]: http://stackoverflow.com/questions/tagged/rust

branches/auto/src/doc/trpl/rust-inside-other-languages.md

@@ -6,24 +6,24 @@ Rust’s greatest strengths: a lack of a substantial runtime.
 As organizations grow, they increasingly rely on a multitude of programming
 languages. Different programming languages have different strengths and
 weaknesses, and a polyglot stack lets you use a particular language where
-its strengths make sense, and use a different language where it’s weak.
+its strengths make sense and a different one where it’s weak.
 
 A very common area where many programming languages are weak is in runtime
 performance of programs. Often, using a language that is slower, but offers
-greater programmer productivity is a worthwhile trade-off. To help mitigate
-this, they provide a way to write some of your system in C, and then call
-the C code as though it were written in the higher-level language. This is
+greater programmer productivity, is a worthwhile trade-off. To help mitigate
+this, they provide a way to write some of your system in C and then call
+that C code as though it were written in the higher-level language. This is
 called a ‘foreign function interface’, often shortened to ‘FFI’.
 
 Rust has support for FFI in both directions: it can call into C code easily,
 but crucially, it can also be called _into_ as easily as C. Combined with
 Rust’s lack of a garbage collector and low runtime requirements, this makes
 Rust a great candidate to embed inside of other languages when you need
-some extra oomph.
+that extra oomph.
 
 There is a whole [chapter devoted to FFI][ffi] and its specifics elsewhere in
 the book, but in this chapter, we’ll examine this particular use-case of FFI,
-with three examples, in Ruby, Python, and JavaScript.
+with examples in Ruby, Python, and JavaScript.
 
 [ffi]: ffi.html
 
@@ -40,18 +40,18 @@ optimizations can stack allocate particular numbers, but rather than relying
 on an optimizer to do its job, we may want to ensure that we’re always using
 primitive number types rather than some sort of object type.
 
-Second, many languages have a ‘global interpreter lock’, which limits
+Second, many languages have a ‘global interpreter lock’ (GIL), which limits
 concurrency in many situations. This is done in the name of safety, which is
 a positive effect, but it limits the amount of work that can be done at the
 same time, which is a big negative.
 
 To emphasize these two aspects, we’re going to create a little project that
-uses these two aspects heavily. Since the focus of the example is the embedding
-of Rust into the languages, rather than the problem itself, we’ll just use a
+uses these two aspects heavily. Since the focus of the example is to embed
+Rust into other languages, rather than the problem itself, we’ll just use a
 toy example:
 
 > Start ten threads. Inside each thread, count from one to five million. After
-> All ten threads are finished, print out ‘done!’.
+> all ten threads are finished, print out ‘done!’.
 
 I chose five million based on my particular computer. Here’s an example of this
 code in Ruby:
@@ -69,7 +69,7 @@ threads = []
   end
 end
 
-threads.each {|t| t.join }
+threads.each { |t| t.join }
 puts "done!"
 ```
 
@@ -82,12 +82,12 @@ sort of process monitoring tool, like `top`, I can see that it only uses one
 core on my machine. That’s the GIL kicking in.
 
 While it’s true that this is a synthetic program, one can imagine many problems
-that are similar to this in the real world. For our purposes, spinning up some
+that are similar to this in the real world. For our purposes, spinning up a few
 busy threads represents some sort of parallel, expensive computation.
 
 # A Rust library
 
-Let’s re-write this problem in Rust. First, let’s make a new project with
+Let’s rewrite this problem in Rust. First, let’s make a new project with
 Cargo:
 
 ```bash
@@ -129,7 +129,7 @@ src/lib.rs:3 fn process() {
 src/lib.rs:4     let handles: Vec<_> = (0..10).map(|_| {
 src/lib.rs:5         thread::spawn(|| {
 src/lib.rs:6             let mut x = 0;
-src/lib.rs:7             for _ in (0..5_000_001) {
+src/lib.rs:7             for _ in (0..5_000_000) {
 src/lib.rs:8                 x += 1
              ...
 src/lib.rs:6:17: 6:22 warning: variable `x` is assigned to, but never used, #[warn(unused_variables)] on by default
@@ -151,7 +151,7 @@ Finally, we join on each thread.
 Right now, however, this is a Rust library, and it doesn’t expose anything
 that’s callable from C. If we tried to hook this up to another language right
 now, it wouldn’t work. We only need to make two small changes to fix this,
-though. The first is modify the beginning of our code:
+though. The first is to modify the beginning of our code:
 
 ```rust,ignore
 #[no_mangle]
@@ -161,7 +161,7 @@ pub extern fn process() {
 We have to add a new attribute, `no_mangle`. When you create a Rust library, it
 changes the name of the function in the compiled output. The reasons for this
 are outside the scope of this tutorial, but in order for other languages to
-know how to call the function, we need to not do that. This attribute turns
+know how to call the function, we can’t do that. This attribute turns
 that behavior off.
 
 The other change is the `pub extern`. The `pub` means that this function should
@@ -178,7 +178,7 @@ crate-type = ["dylib"]
 ```
 
 This tells Rust that we want to compile our library into a standard dynamic
-library. By default, Rust compiles into an ‘rlib’, a Rust-specific format.
+library. By default, Rust compiles an ‘rlib’, a Rust-specific format.
 
 Let’s build the project now:
 
@@ -204,7 +204,7 @@ Now that we’ve got our Rust library built, let’s use it from our Ruby.
 
 # Ruby
 
-Open up a `embed.rb` file inside of our project, and do this:
+Open up an `embed.rb` file inside of our project, and do this:
 
 ```ruby
 require 'ffi'
@@ -217,7 +217,7 @@ end
 
 Hello.process
 
-puts "done!"
+puts 'done!'
 ```
 
 Before we can run this, we need to install the `ffi` gem:
@@ -241,7 +241,7 @@ done!
 $
 ```
 
-Whoah, that was fast! On my system, this took `0.086` seconds, rather than
+Whoa, that was fast! On my system, this took `0.086` seconds, rather than
 the two seconds the pure Ruby version took. Let’s break down this Ruby
 code:
 
@@ -258,11 +258,11 @@ module Hello
   ffi_lib 'target/release/libembed.so'
 ```
 
-The `ffi` gem’s authors recommend using a module to scope the functions
-we’ll import from the shared library. Inside, we `extend` the necessary
-`FFI::Library` module, and then call `ffi_lib` to load up our shared
-object library. We just pass it the path that our library is stored,
-which as we saw before, is `target/release/libembed.so`.
+The `Hello` module is used to attach the native functions from the shared
+library. Inside, we `extend` the necessary `FFI::Library` module and then call
+`ffi_lib` to load up our shared object library. We just pass it the path that
+our library is stored, which, as we saw before, is
+`target/release/libembed.so`.
 
 ```ruby
 attach_function :process, [], :void
@@ -280,10 +280,10 @@ Hello.process
 
 This is the actual call into Rust. The combination of our `module`
 and the call to `attach_function` sets this all up. It looks like
-a Ruby function, but is actually Rust!
+a Ruby function but is actually Rust!
 
 ```ruby
-puts "done!"
+puts 'done!'
 ```
 
 Finally, as per our project’s requirements, we print out `done!`.
@@ -329,7 +329,7 @@ After that installs, we can use it:
 var ffi = require('ffi');
 
 var lib = ffi.Library('target/release/libembed', {
-  'process': [ 'void', []  ]
+  'process': ['void', []]
 });
 
 lib.process();
@@ -340,7 +340,7 @@ console.log("done!");
 It looks more like the Ruby example than the Python example. We use
 the `ffi` module to get access to `ffi.Library()`, which loads up
 our shared object. We need to annotate the return type and argument
-types of the function, which are 'void' for return, and an empty
+types of the function, which are `void` for return and an empty
 array to signify no arguments. From there, we just call it and
 print the result.
 

branches/auto/src/doc/trpl/strings.md

@@ -49,6 +49,20 @@ fn main() {
 }
 ```
 
+This coercion does not happen for functions that accept one of `&str`’s traits
+instead of `&str`. For example, [`TcpStream::connect`][connect] has a parameter
+of type `ToSocketAddrs`. A `&str` is okay but a `String` must be explicitly
+converted using `&*`.
+
+```rust,no_run
+use std::net::TcpStream;
+
+TcpStream::connect("192.168.0.1:3000"); // &str parameter
+
+let addr_string = "192.168.0.1:3000".to_string();
+TcpStream::connect(&*addr_string); // convert addr_string to &str
+```
+
 Viewing a `String` as a `&str` is cheap, but converting the `&str` to a
 `String` involves allocating memory. No reason to do that unless you have to!
 
@@ -127,3 +141,4 @@ This is because `&String` can automatically coerce to a `&str`. This is a
 feature called ‘[`Deref` coercions][dc]’.
 
 [dc]: deref-coercions.html
+[connect]: ../std/net/struct.TcpStream.html#method.connect

branches/auto/src/doc/trpl/the-stack-and-the-heap.md

@@ -454,7 +454,7 @@ At the end of `bar()`, it calls `baz()`:
 | (2<sup>30</sup>) - 1 |      | 5                    |
 | ...                  | ...  | ...                  |
 | 12                   | g    | 100                  |
-| 11                   | f    | 4                    |
+| 11                   | f    | 9                    |
 | 10                   | e    | 9                    |
 | 9                    | d    | (2<sup>30</sup>) - 1 |
 | 8                    | c    | 5                    |