Merge branch 'master' into master

Author: gpk2000

src/custom_types/enum/testcase_linked_list.md

@@ -32,6 +32,9 @@ impl List {
         // depends on the variant of `self`
         // `self` has type `&List`, and `*self` has type `List`, matching on a
         // concrete type `T` is preferred over a match on a reference `&T`
+        // after Rust 2018 you can use self here and tail (with no ref) below as well,
+        // rust will infer &s and ref tail. 
+        // See https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/default-match-bindings.html
         match *self {
             // Can't take ownership of the tail, because `self` is borrowed;
             // instead take a reference to the tail

src/custom_types/structs.md

@@ -3,8 +3,7 @@
 There are three types of structures ("structs") that can be created using the
 `struct` keyword:
 
-* Tuple structs, which are, basically, named tuples.
-* The classic [C structs][c_struct]
+* Tuple structs, which are, basically, named tuples. The classic [C structs][c_struct]
 * Unit structs, which are field-less, are useful for generics.
 
 ```rust,editable
@@ -86,7 +85,7 @@ fn main() {
 
 ### Activity
 
-1. Add a function `rect_area` which calculates the area of a rectangle (try
+1. Add a function `rect_area` which calculates the area of a `Rectangle` (try
    using nested destructuring).
 2. Add a function `square` which takes a `Point` and a `f32` as arguments, and
    returns a `Rectangle` with its lower left corner on the point, and a width and

src/error/option_unwrap.md

@@ -1,13 +1,13 @@
 # `Option` & `unwrap`
 
 In the last example, we showed that we can induce program failure at will.
-We told our program to `panic` if the royal received an inappropriate
-gift - a snake. But what if the royal expected a gift and didn't receive
-one? That case would be just as bad, so it needs to be handled!
+We told our program to `panic` if we drink a sugary lemonade.
+But what if we expect _some_ drink but don't receive one?
+That case would be just as bad, so it needs to be handled!
 
-We *could* test this against the null string (`""`) as we do with a snake.
+We *could* test this against the null string (`""`) as we do with a lemonade.
 Since we're using Rust, let's instead have the compiler point out cases
-where there's no gift.
+where there's no drink.
 
 An `enum` called `Option<T>` in the `std` library is used when absence is a
 possibility. It manifests itself as one of two "options":
@@ -24,41 +24,41 @@ handling. In the following example, explicit handling yields a more
 controlled result while retaining the option to `panic` if desired.
 
 ```rust,editable,ignore,mdbook-runnable
-// The commoner has seen it all, and can handle any gift well.
-// All gifts are handled explicitly using `match`.
-fn give_commoner(gift: Option<&str>) {
+// The adult has seen it all, and can handle any drink well.
+// All drinks are handled explicitly using `match`.
+fn give_adult(drink: Option<&str>) {
     // Specify a course of action for each case.
-    match gift {
-        Some("snake") => println!("Yuck! I'm putting this snake back in the forest."),
+    match drink {
+        Some("lemonade") => println!("Yuck! Too sugary."),
         Some(inner)   => println!("{}? How nice.", inner),
-        None          => println!("No gift? Oh well."),
+        None          => println!("No drink? Oh well."),
     }
 }
 
-// Our sheltered royal will `panic` at the sight of snakes.
-// All gifts are handled implicitly using `unwrap`.
-fn give_royal(gift: Option<&str>) {
+// Others will `panic` before drinking sugary drinks.
+// All drinks are handled implicitly using `unwrap`.
+fn drink(drink: Option<&str>) {
     // `unwrap` returns a `panic` when it receives a `None`.
-    let inside = gift.unwrap();
-    if inside == "snake" { panic!("AAAaaaaa!!!!"); }
+    let inside = drink.unwrap();
+    if inside == "lemonade" { panic!("AAAaaaaa!!!!"); }
 
     println!("I love {}s!!!!!", inside);
 }
 
 fn main() {
-    let food  = Some("cabbage");
-    let snake = Some("snake");
+    let water  = Some("water");
+    let lemonade = Some("lemonade");
     let void  = None;
 
-    give_commoner(food);
-    give_commoner(snake);
-    give_commoner(void);
+    give_adult(water);
+    give_adult(lemonade);
+    give_adult(void);
 
-    let bird = Some("robin");
+    let coffee = Some("coffee");
     let nothing = None;
 
-    give_royal(bird);
-    give_royal(nothing);
+    drink(coffee);
+    drink(nothing);
 }
 ```
 

src/expression.md

@@ -2,7 +2,7 @@
 
 A Rust program is (mostly) made up of a series of statements:
 
-```
+```rust,editable
 fn main() {
     // statement
     // statement
@@ -13,7 +13,7 @@ fn main() {
 There are a few kinds of statements in Rust. The most common two are declaring
 a variable binding, and using a `;` with an expression:
 
-```
+```rust,editable
 fn main() {
     // variable binding
     let x = 5;

src/generics/multi_bounds.md

@@ -1,6 +1,6 @@
 # Multiple bounds
 
-Multiple bounds can be applied with a `+`. Like normal, different types are
+Multiple bounds for a single type can be applied with a `+`. Like normal, different types are
 separated with `,`.
 
 ```rust,editable

src/generics/new_types.md

@@ -40,13 +40,14 @@ fn main() {
 
 Uncomment the last print statement to observe that the type supplied must be `Years`.
 
-To obtain the `newtype`'s value as the base type, you may use tuple syntax like so:
+To obtain the `newtype`'s value as the base type, you may use the tuple or destructuring syntax like so:
 ```rust, editable
 struct Years(i64);
 
 fn main() {
     let years = Years(42);
-    let years_as_primitive: i64 = years.0;
+    let years_as_primitive_1: i64 = years.0; // Tuple
+    let Years(years_as_primitive_2) = years; // Destructuring
 }
 ```
 

src/hello/print/print_display.md

@@ -108,7 +108,7 @@ each requires its own implementation. This is detailed further in
 ### Activity
 
 After checking the output of the above example, use the `Point2D` struct as a
-guide to add a Complex struct to the example. When printed in the same
+guide to add a `Complex` struct to the example. When printed in the same
 way, the output should be:
 
 ```txt
@@ -125,5 +125,5 @@ Debug: Complex { real: 3.3, imag: 7.2 }
 [fmt]: https://doc.rust-lang.org/std/fmt/
 [macros]: ../../macros.md
 [structs]: ../../custom_types/structs.md
-[traits]: ../../trait.md
+[traits]: https://doc.rust-lang.org/std/fmt/#formatting-traits
 [use]: ../../mod/use.md

src/primitives/tuples.md

@@ -64,7 +64,7 @@ fn main() {
 
 ### Activity
 
- 1. *Recap*: Add the `fmt::Display` trait to the Matrix `struct` in the above example,
+ 1. *Recap*: Add the `fmt::Display` trait to the `Matrix` struct in the above example,
     so that if you switch from printing the debug format `{:?}` to the display
     format `{}`, you see the following output:
 

src/scope/lifetime/static_lifetime.md

@@ -85,7 +85,7 @@ fn main() {
     print_it(i);
 
     // oops, &i only has the lifetime defined by the scope of
-    // use_it(), so it's not 'static:
+    // main(), so it's not 'static:
     print_it(&i);
 }
 ```

src/scope/lifetime/trait.md

@@ -6,9 +6,9 @@ Note that `impl` may have annotation of lifetimes too.
 ```rust,editable
 // A struct with annotation of lifetimes.
 #[derive(Debug)]
- struct Borrowed<'a> {
-     x: &'a i32,
- }
+struct Borrowed<'a> {
+    x: &'a i32,
+}
 
 // Annotate lifetimes to impl.
 impl<'a> Default for Borrowed<'a> {