---

yaml
---
r: 30990
b: refs/heads/incoming
c: 82fd711
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 0b434af7ebefdc82dfa58396b374970d1bbb5a7d
+refs/heads/incoming: 82fd71137a87ad4568eee24142d22bf87a4d2e2b
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/doc/tutorial.md

@@ -152,9 +152,9 @@ example, by changing `io::println` to some nonexistent function), and
 then compile it, you'll see an error message like this:
 
 ~~~~ {.notrust}
-hello.rs:2:4: 2:16 error: unresolved name: io::print_with_unicorns
-hello.rs:2     io::print_with_unicorns("hello? yes, this is rust");
-               ^~~~~~~~~~~~~~~~~~~~~~~
+hello.rs:2:4: 2:16 error: unresolved name: io::print_it
+hello.rs:2     io::print_it("hello? yes, this is rust");
+               ^~~~~~~~~~~~
 ~~~~
 
 In its simplest form, a Rust program is a `.rs` file with some types
@@ -178,11 +178,9 @@ included in that directory. In particular, if you are running emacs
 24, then using emacs's internal package manager to install `rust-mode`
 is the easiest way to keep it up to date. There is also a package for
 Sublime Text 2, available both [standalone][sublime] and through
-[Sublime Package Control][sublime-pkg], and support for Kate
-under `src/etc/kate`.
+[Sublime Package Control][sublime-pkg].
 
-There is ctags support via `src/etc/ctags.rust`, but many other
-tools and editors are not provided for yet. If you end up writing a Rust
+Other editors are not provided for yet. If you end up writing a Rust
 mode for your favorite editor, let us know so that we can link to it.
 
 [sublime]: http://github.com/dbp/sublime-rust
@@ -193,7 +191,7 @@ mode for your favorite editor, let us know so that we can link to it.
 Assuming you've programmed in any C-family language (C++, Java,
 JavaScript, C#, or PHP), Rust will feel familiar. Code is arranged
 in blocks delineated by curly braces; there are control structures
-for branching and looping, like the familiar `if` and `while`; function
+for branching and looping, like the familiar `if` and `when`; function
 calls are written `myfunc(arg1, arg2)`; operators are written the same
 and mostly have the same precedence as in C; comments are again like C.
 
@@ -229,14 +227,13 @@ while count < 10 {
 }
 ~~~~
 
-Although Rust can almost always infer the types of local variables, you
-can specify a variable's type by following it with a colon, then the type
-name. 
+Although Rust can almost always infer the types of local variables, it
+can help readability to specify a variable's type by following it with
+a colon, then the type name. 
 
 ~~~~
-let monster_size: float = 57.8;
-let imaginary_size = monster_size * 10;
-let monster_size: int = 50;
+let my_favorite_value: float = 57.8;
+let my_favorite_value: int = my_favorite_value as int;
 ~~~~
 
 Local variables may shadow earlier declarations, as in the previous
@@ -251,14 +248,14 @@ underscores where they help readability, while writing types in camel case.
 
 ~~~
 let my_variable = 100;
-type MyType = int;     // some built-in types are _not_ camel case
+type MyType = int; // built-in types though are _not_ camel case
 ~~~
 
 ## Expression syntax
 
 Though it isn't apparent in all code, there is a fundamental
-difference between Rust's syntax and predecessors like C.
-Many constructs that are statements in C are expressions
+difference between Rust's syntax and its predecessors in this family
+of languages. Many constructs that are statements in C are expressions
 in Rust, allowing code to be more concise. For example, you might
 write a piece of code like this:
 
@@ -278,25 +275,24 @@ But, in Rust, you don't have to repeat the name `price`:
 
 ~~~~
 # let item = "salad";
-let price =
-    if item == "salad" {
-        3.50
-    } else if item == "muffin" {
-        2.25
-    } else {
-        2.00
-    };
+let price = if item == "salad" {
+    3.50
+} else if item == "muffin" {
+    2.25
+} else {
+    2.00
+};
 ~~~~
 
 Both pieces of code are exactly equivalent—they assign a value to
-`price` depending on the condition that holds. Note that there
-are not semicolons in the blocks of the second snippet. This is
+`price` depending on the condition that holds. Note that the
+semicolons are omitted from the blocks in the second snippet. This is
 important; the lack of a semicolon after the last statement in a
 braced block gives the whole block the value of that last expression.
 
 Put another way, the semicolon in Rust *ignores the value of an expression*.
 Thus, if the branches of the `if` had looked like `{ 4; }`, the above example
-would simply assign `()` (nil or void) to `price`. But without the semicolon, each
+would simply assign nil (void) to `price`. But without the semicolon, each
 branch has a different value, and `price` gets the value of the branch that
 was taken.
 
@@ -350,7 +346,8 @@ if x {
 let y = if x { foo() } else { bar() };
 ~~~
 
-This may sound a intricate, but it is super-useful and will grow on you.
+This may sound a bit intricate, but it is super-useful, and it will
+grow on you (hopefully).
 
 ## Types
 
@@ -368,8 +365,7 @@ The basic types include the usual boolean, integral, and floating point types.
 ------------------------- -----------------------------------------------
 
 These can be combined in composite types, which will be described in
-more detail later on (the `T`s here stand for any other type,
-while N should be a literal number):
+more detail later on (the `T`s here stand for any other type):
 
 ------------------------- -----------------------------------------------
 `[T * N]`                 Vector (like an array in other languages) with N elements
@@ -396,7 +392,7 @@ the type `fn() -> bool` or the function declaration `fn foo() -> bool
 optionally write `-> ()`, but usually the return annotation is simply
 left off, as in `fn main() { ... }`.
 
-Types can be given names or aliases with `type` declarations:
+Types can be given names with `type` declarations:
 
 ~~~~
 type MonsterSize = uint;
@@ -405,25 +401,9 @@ type MonsterSize = uint;
 This will provide a synonym, `MonsterSize`, for unsigned integers. It will not
 actually create a new, incompatible type—`MonsterSize` and `uint` can be used
 interchangeably, and using one where the other is expected is not a type
-error.
-
-To create data types which are not synonyms, `struct` and `enum`
-can be used. They're described in more detail below, but they look like this:
-
-~~~~
-enum HidingPlaces {
-   Closet(uint),
-   UnderTheBed(uint)
-}
-
-struct HeroicBabysitter {
-   bedtime_stories: uint,
-   sharpened_stakes: uint
-}
-
-struct BabysitterSize(uint);  // a single-variant struct
-enum MonsterSize = uint;      // a single-variant enum
-~~~~
+error. Read about [single-variant enums](#single_variant_enum)
+further on if you need to create a type name that's not just a
+synonym.
 
 ## Literals
 
@@ -455,7 +435,7 @@ The nil literal is written just like the type: `()`. The keywords
 
 Character literals are written between single quotes, as in `'x'`. Just as in
 C, Rust understands a number of character escapes, using the backslash
-character, such as `\n`, `\r`, and `\t`. String literals,
+character, `\n`, `\r`, and `\t` being the most common. String literals,
 written between double quotes, allow the same escape sequences. Rust strings
 may contain newlines.
 
@@ -486,8 +466,8 @@ assert y == 4u;
 
 The main difference with C is that `++` and `--` are missing, and that
 the logical bitwise operators have higher precedence — in C, `x & 2 > 0`
-means `x & (2 > 0)`, but in Rust, it means `(x & 2) > 0`, which is
-more likely what a novice expects.
+comes out as `x & (2 > 0)`, in Rust, it means `(x & 2) > 0`, which is
+more likely to be what you expect (unless you are a C veteran).
 
 ## Syntax extensions
 
@@ -505,7 +485,7 @@ don't match the types of the arguments.
 ~~~~
 # let mystery_object = ();
 
-io::println(fmt!("%s is %d", "the answer", 42));
+io::println(fmt!("%s is %d", "the answer", 43));
 
 // %? will conveniently print any type
 io::println(fmt!("what is this thing: %?", mystery_object));
@@ -576,14 +556,18 @@ underscore (`_`) is a wildcard pattern that matches everything.
 
 The patterns in an match arm are followed by a fat arrow, `=>`, then an
 expression to evaluate. Each case is separated by commas. It's often
-convenient to use a block expression for each case, in which case the
+convenient to use a block expression for a case, in which case the
 commas are optional.
 
 ~~~
 # let my_number = 1;
 match my_number {
-  0 => { io::println("zero") }
-  _ => { io::println("something else") }
+  0 => {
+    io::println("zero")
+  }
+  _ => {
+    io::println("something else")
+  }
 }
 ~~~