---

yaml
---
r: 128635
b: refs/heads/try
c: 87d2bf4
h: refs/heads/master
i:
  128633: 1a7f678
  128631: 12397a0
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: dac73ad3c1b92f51cade8dbac4879ffb951ded3f
+refs/heads/try: 87d2bf400ce1bc2cec832f9d5b8e763f06bb7f43
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/mk/platform.mk

@@ -377,7 +377,7 @@ RUSTC_CROSS_FLAGS_arm-unknown-linux-gnueabi :=
 # mipsel-linux configuration
 CC_mipsel-linux=mipsel-linux-gcc
 CXX_mipsel-linux=mipsel-linux-g++
-CPP_mipsel-linux=mipsel-linux-gcc 
+CPP_mipsel-linux=mipsel-linux-gcc
 AR_mipsel-linux=mipsel-linux-ar
 CFG_LIB_NAME_mipsel-linux=lib$(1).so
 CFG_STATIC_LIB_NAME_mipsel-linux=lib$(1).a
@@ -641,7 +641,7 @@ define CFG_MAKE_TOOLCHAIN
 	CXX_$(1)=$(CROSS_PREFIX_$(1))$(CXX_$(1))
 	CPP_$(1)=$(CROSS_PREFIX_$(1))$(CPP_$(1))
 	AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
-	RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(CXX_$(1))) \
+	RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(CC_$(1))) \
 	    -C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
 
 	RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))

branches/try/src/doc/guide.md

@@ -1647,14 +1647,14 @@ $ cargo build
 $
 ```
 
-Excellent! Open up your `src/guessing_game.rs` again. We'll be writing all of
+Excellent! Open up your `src/main.rs` again. We'll be writing all of
 our code in this file. We'll talk about multiple-file projects later on in the
 guide.
 
 ## Processing a Guess
 
 Let's get to it! The first thing we need to do for our guessing game is
-allow our player to input a guess. Put this in your `src/guessing_game.rs`:
+allow our player to input a guess. Put this in your `src/main.rs`:
 
 ```{rust,no_run}
 use std::io;
@@ -1734,9 +1734,9 @@ this using `cargo build`:
 ```{notrust,no_run}
 $ cargo build
    Compiling guessing_game v0.1.0 (file:/home/you/projects/guessing_game)
-src/guessing_game.rs:7:26: 7:34 error: the type of this value must be known in this context
-src/guessing_game.rs:7     let secret_number = (rand::random() % 100i) + 1i;
-                                                ^~~~~~~~
+src/main.rs:7:26: 7:34 error: the type of this value must be known in this context
+src/main.rs:7     let secret_number = (rand::random() % 100i) + 1i;
+                                       ^~~~~~~~
 error: aborting due to previous error
 ```
 
@@ -1896,12 +1896,12 @@ If we try to compile, we'll get some errors:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.1.0 (file:/home/you/projects/guessing_game)
-src/guessing_game.rs:20:15: 20:20 error: mismatched types: expected `int` but found `collections::string::String` (expected int but found struct collections::string::String)
-src/guessing_game.rs:20     match cmp(input, secret_number) {
-                                      ^~~~~
-src/guessing_game.rs:20:22: 20:35 error: mismatched types: expected `int` but found `uint` (expected int but found uint)
-src/guessing_game.rs:20     match cmp(input, secret_number) {
-                                             ^~~~~~~~~~~~~
+src/main.rs:20:15: 20:20 error: mismatched types: expected `int` but found `collections::string::String` (expected int but found struct collections::string::String)
+src/main.rs:20     match cmp(input, secret_number) {
+                             ^~~~~
+src/main.rs:20:22: 20:35 error: mismatched types: expected `int` but found `uint` (expected int but found uint)
+src/main.rs:20     match cmp(input, secret_number) {
+                                    ^~~~~~~~~~~~~
 error: aborting due to 2 previous errors
 ```
 
@@ -1950,9 +1950,9 @@ And try compiling again:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.1.0 (file:/home/you/projects/guessing_game)
-src/guessing_game.rs:20:15: 20:20 error: mismatched types: expected `uint` but found `collections::string::String` (expected uint but found struct collections::string::String)
-src/guessing_game.rs:20     match cmp(input, secret_number) {
-                                      ^~~~~
+src/main.rs:20:15: 20:20 error: mismatched types: expected `uint` but found `collections::string::String` (expected uint but found struct collections::string::String)
+src/main.rs:20     match cmp(input, secret_number) {
+                             ^~~~~
 error: aborting due to previous error
 ```
 
@@ -2053,9 +2053,9 @@ Let's try it out!
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.1.0 (file:/home/you/projects/guessing_game)
-src/guessing_game.rs:22:15: 22:24 error: mismatched types: expected `uint` but found `core::option::Option<uint>` (expected uint but found enum core::option::Option)
-src/guessing_game.rs:22     match cmp(input_num, secret_number) {
-                                      ^~~~~~~~~
+src/main.rs:22:15: 22:24 error: mismatched types: expected `uint` but found `core::option::Option<uint>` (expected uint but found enum core::option::Option)
+src/main.rs:22     match cmp(input_num, secret_number) {
+                             ^~~~~~~~~
 error: aborting due to previous error
 ```
 
@@ -3295,7 +3295,7 @@ fn times_four(x: int) -> int { x * 4 }
 #[cfg(test)]
 mod test {
     use super::add_three;
-    use super::add_four;
+    use super::times_four;
 
     #[test]
     fn test_add_three() {
@@ -3344,7 +3344,7 @@ about yet, and that's these lines:
 
 ```{rust,ignore}
 use super::add_three;
-use super::add_four;
+use super::times_four;
 ```
 
 Because we've made a nested module, we can import functions from the parent
@@ -3614,7 +3614,209 @@ guide](http://doc.rust-lang.org/guide-pointers.html#rc-and-arc).
 
 # Patterns
 
-# Lambdas
+# Closures
+
+So far, we've made lots of functions in Rust. But we've given them all names.
+Rust also allows us to create anonymous functions too. Rust's anonymous
+functions are called **closure**s. By themselves, closures aren't all that
+interesting, but when you combine them with functions that take closures as
+arguments, really powerful things are possible.
+
+Let's make a closure:
+
+```{rust}
+let add_one = |x| { 1i + x };
+
+println!("The 5 plus 1 is {}.", add_one(5i));
+```
+
+We create a closure using the `|...| { ... }` syntax, and then we create a
+binding so we can use it later. Note that we call the function using the
+binding name and two parentheses, just like we would for a named function.
+
+Let's compare syntax. The two are pretty close:
+
+```{rust}
+let add_one = |x: int| -> int { 1i + x };
+fn  add_one   (x: int) -> int { 1i + x }
+```
+
+As you may have noticed, closures infer their argument and return types, so you
+don't need to declare one. This is different from named functions, which
+default to returning unit (`()`).
+
+There's one big difference between a closure and named functions, and it's in
+the name: a function "closes over its environment." What's that mean? It means
+this:
+
+```{rust}
+fn main() {
+    let x = 5i;
+
+    let printer = || { println!("x is: {}", x); };
+
+    printer(); // prints "x is: 5"
+}
+```
+
+The `||` syntax means this is an anonymous closure that takes no arguments.
+Without it, we'd just have a block of code in `{}`s.
+
+In other words, a closure has access to variables in the scope that it's
+defined. The closure borrows any variables that it uses. This will error:
+
+```{rust,ignore}
+fn main() {
+    let mut x = 5i;
+
+    let printer = || { println!("x is: {}", x); };
+
+    x = 6i; // error: cannot assign to `x` because it is borrowed
+}
+```
+
+## Procs
+
+Rust has a second type of closure, called a **proc**. Procs are created
+with the `proc` keyword:
+
+```{rust}
+let x = 5i;
+
+let p = proc() { x * x };
+println!("{}", p()); // prints 25
+```
+
+Procs have a big difference from closures: they may only be called once. This
+will error when we try to compile:
+
+```{rust,ignore}
+let x = 5i;
+
+let p = proc() { x * x };
+println!("{}", p());
+println!("{}", p()); // error: use of moved value `p`
+```
+
+This restriction is important. Procs are allowed to consume values that they
+capture, and thus have to be restricted to being called once for soundness
+reasons: any value consumed would be invalid on a second call.
+
+Procs are most useful with Rust's concurrency features, and so we'll just leave
+it at this for now. We'll talk about them more in the "Tasks" section of the
+guide.
+
+## Accepting closures as arguments
+
+Closures are most useful as an argument to another function. Here's an example:
+
+```{rust}
+fn twice(x: int, f: |int| -> int) -> int {
+    f(x) + f(x)
+}
+
+fn main() {
+    let square = |x: int| { x * x };
+
+    twice(5i, square); // evaluates to 50
+}
+```
+
+Let's break example down, starting with `main`:
+
+```{rust}
+let square = |x: int| { x * x };
+```
+
+We've seen this before. We make a closure that takes an integer, and returns
+its square.
+
+```{rust,ignore}
+twice(5i, square); // evaluates to 50
+```
+
+This line is more interesting. Here, we call our function, `twice`, and we pass
+it two arguments: an integer, `5`, and our closure, `square`. This is just like
+passing any other two variable bindings to a function, but if you've never
+worked with closures before, it can seem a little complex. Just think: "I'm
+passing two variables, one is an int, and one is a function."
+
+Next, let's look at how `twice` is defined:
+
+```{rust,ignore}
+fn twice(x: int, f: |int| -> int) -> int {
+```
+
+`twice` takes two arguments, `x` and `f`. That's why we called it with two
+arguments. `x` is an `int`, we've done that a ton of times. `f` is a function,
+though, and that function takes an `int` and returns an `int`. Notice
+how the `|int| -> int` syntax looks a lot like our definition of `square`
+above, if we added the return type in:
+
+```{rust}
+let square = |x: int| -> int { x * x };
+//           |int|    -> int
+```
+
+This function takes an `int` and returns an `int`.
+
+This is the most complicated function signature we've seen yet! Give it a read
+a few times until you can see how it works. It takes a teeny bit of practice, and
+then it's easy.
+
+Finally, `twice` returns an `int` as well.
+
+Okay, let's look at the body of `twice`:
+
+```{rust}
+fn twice(x: int, f: |int| -> int) -> int {
+  f(x) + f(x)
+}
+```
+
+Since our closure is named `f`, we can call it just like we called our closures
+before. And we pass in our `x` argument to each one. Hence 'twice.'
+
+If you do the math, `(5 * 5) + (5 * 5) == 50`, so that's the output we get.
+
+Play around with this concept until you're comfortable with it. Rust's standard
+library uses lots of closures, where appropriate, so you'll be using
+this technique a lot.
+
+If we didn't want to give `square` a name, we could also just define it inline.
+This example is the same as the previous one:
+
+```{rust}
+fn twice(x: int, f: |int| -> int) -> int {
+    f(x) + f(x)
+}
+
+fn main() {
+    twice(5i, |x: int| { x * x }); // evaluates to 50
+}
+```
+
+A named function's name can be used wherever you'd use a closure. Another
+way of writing the previous example:
+
+```{rust}
+fn twice(x: int, f: |int| -> int) -> int {
+    f(x) + f(x)
+}
+
+fn square(x: int) -> int { x * x }
+
+fn main() {
+    twice(5i, square); // evaluates to 50
+}
+```
+
+Doing this is not particularly common, but every once in a while, it's useful.
+
+That's all you need to get the hang of closures! Closures are a little bit
+strange at first, but once you're used to using them, you'll miss them in any
+language that doesn't have them. Passing functions to other functions is
+incredibly powerful.  Next, let's look at one of those things: iterators.
 
 # iterators
 

branches/try/src/doc/intro.md

@@ -359,10 +359,11 @@ fn main() {
             // Take the lock, along with exclusive access to the underlying array
             let mut numbers = numbers_lock.lock();
 
-            // This is ugly for now, but will be replaced by
-            // `numbers[num as uint] += 1` in the near future.
+            // This is ugly for now because of the need for `get_mut`, but
+            // will be replaced by `numbers[num as uint] += 1`
+            // in the near future.
             // See: https://github.com/rust-lang/rust/issues/6515
-            *numbers.get_mut(num as uint) = *numbers.get_mut(num as uint) + 1;
+            *numbers.get_mut(num as uint) += 1;
 
             println!("{}", (*numbers)[num as uint]);
 

branches/try/src/doc/rust.md

@@ -112,8 +112,7 @@ production. See [tokens](#tokens) for more information.
 
 ## Input format
 
-Rust input is interpreted as a sequence of Unicode codepoints encoded in UTF-8,
-normalized to Unicode normalization form NFKC.
+Rust input is interpreted as a sequence of Unicode codepoints encoded in UTF-8.
 Most Rust grammar rules are defined in terms of printable ASCII-range codepoints,
 but a small number are defined in terms of Unicode properties or explicit
 codepoint lists. [^inputformat]

branches/try/src/doc/tutorial.md

@@ -76,7 +76,7 @@ OS X, the install page provides links to native installers.
 > the precise details of which are not discussed here.
 
 For Linux and OS X, the install page provides links to binary tarballs.
-To install the Rust compiler from the from a binary tarball, download
+To install the Rust compiler from a binary tarball, download
 the binary package, extract it, and execute the `install.sh` script in
 the root directory of the package.
 
@@ -2196,7 +2196,7 @@ and may not be overridden:
 Types are sendable
 unless they contain references.
 
-* `Share` - Types that are *threadsafe*
+* `Share` - Types that are *threadsafe*.
 These are types that are safe to be used across several threads with access to
 a `&T` pointer. `Mutex<T>` is an example of a *sharable* type with internal mutable data.
 

branches/try/src/etc/ctags.rust

@@ -7,5 +7,5 @@
 --regex-Rust=/^[ \t]*(pub[ \t]+)?mod[ \t]+([a-zA-Z0-9_]+)/\2/m,modules,module names/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?static[ \t]+([a-zA-Z0-9_]+)/\2/c,consts,static constants/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?trait[ \t]+([a-zA-Z0-9_]+)/\2/t,traits,traits/
---regex-Rust=/^[ \t]*(pub[ \t]+)?impl([ \t\n]+<.*>)?[ \t]+([a-zA-Z0-9_]+)/\3/i,impls,trait implementations/
+--regex-Rust=/^[ \t]*(pub[ \t]+)?impl([ \t\n]*<[^>]*>)?[ \t]+(([a-zA-Z0-9_:]+)[ \t]*(<[^>]*>)?[ \t]+(for)[ \t]+)?([a-zA-Z0-9_]+)/\4 \6 \7/i,impls,trait implementations/
 --regex-Rust=/^[ \t]*macro_rules![ \t]+([a-zA-Z0-9_]+)/\1/d,macros,macro definitions/