Merge branch 'rust-lang:master' into patch-2

Author: aviad-dev

src/cargo/test.md

@@ -42,13 +42,13 @@ $ cargo test
     Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs
      Running target/debug/deps/blah-d3b32b97275ec472
 
-running 3 tests
+running 4 tests
 test test_bar ... ok
 test test_baz ... ok
 test test_foo_bar ... ok
 test test_foo ... ok
 
-test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
+test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
 ```
 
 You can also run tests whose name matches a pattern:
@@ -135,7 +135,7 @@ Corro
 ```
 What actually gets put into `ferris.txt` is this:
 ```shell
-$ cargo test test_foo
+$ cargo test test_file && cat ferris.txt
 Corro
 Ferris
 Corro

src/error/abort_unwind.md

@@ -6,14 +6,17 @@ The previous section illustrates the error handling mechanism `panic`.  Differen
 Building on the prior lemonade example, we explicitly use the panic strategy to exercise different lines of code.  
 
 ```rust,editable,mdbook-runnable
-
 fn drink(beverage: &str) {
-   // You shouldn't drink too much sugary beverages.
+    // You shouldn't drink too much sugary beverages.
     if beverage == "lemonade" {
-        if cfg!(panic="abort"){ println!("This is not your party. Run!!!!");}
-        else{ println!("Spit it out!!!!");}
+        if cfg!(panic = "abort") {
+            println!("This is not your party. Run!!!!");
+        } else {
+            println!("Spit it out!!!!");
+        }
+    } else {
+        println!("Some refreshing {} is all I need.", beverage);
     }
-    else{ println!("Some refreshing {} is all I need.", beverage); }
 }
 
 fn main() {
@@ -25,16 +28,22 @@ fn main() {
 Here is another example focusing on rewriting `drink()` and explicitly use the `unwind` keyword.
 
 ```rust,editable
-
 #[cfg(panic = "unwind")]
-fn ah(){ println!("Spit it out!!!!");}
+fn ah() {
+    println!("Spit it out!!!!");
+}
 
-#[cfg(not(panic="unwind"))]
-fn ah(){ println!("This is not your party. Run!!!!");}
+#[cfg(not(panic = "unwind"))]
+fn ah() {
+    println!("This is not your party. Run!!!!");
+}
 
-fn drink(beverage: &str){
-    if beverage == "lemonade"{ ah();}
-    else{println!("Some refreshing {} is all I need.", beverage);}
+fn drink(beverage: &str) {
+    if beverage == "lemonade" {
+        ah();
+    } else {
+        println!("Some refreshing {} is all I need.", beverage);
+    }
 }
 
 fn main() {

src/error/multiple_error_types/boxing_errors.md

@@ -12,7 +12,7 @@ via [`From`][from].
 use std::error;
 use std::fmt;
 
-// Change the alias to `Box<error::Error>`.
+// Change the alias to use `Box<dyn error::Error>`.
 type Result<T> = std::result::Result<T, Box<dyn error::Error>>;
 
 #[derive(Debug, Clone)]

src/error/multiple_error_types/reenter_question_mark.md

@@ -26,7 +26,7 @@ Here, we rewrite the previous example using `?`. As a result, the
 use std::error;
 use std::fmt;
 
-// Change the alias to `Box<dyn error::Error>`.
+// Change the alias to use `Box<dyn error::Error>`.
 type Result<T> = std::result::Result<T, Box<dyn error::Error>>;
 
 #[derive(Debug)]

src/error/option_unwrap/defaults.md

@@ -38,7 +38,6 @@ Another alternative is to use `or_else`, which is also chainable, and evaluates
 enum Fruit { Apple, Orange, Banana, Kiwi, Lemon }
 
 fn main() {
-    let apple = Some(Fruit::Apple);
     let no_fruit: Option<Fruit> = None;
     let get_kiwi_as_fallback = || {
         println!("Providing kiwi as fallback");

src/flow_control/match/guard.md

@@ -16,10 +16,10 @@ fn main() {
     match temperature {
         Temperature::Celsius(t) if t > 30 => println!("{}C is above 30 Celsius", t),
         // The `if condition` part ^ is a guard
-        Temperature::Celsius(t) => println!("{}C is below 30 Celsius", t),
+        Temperature::Celsius(t) => println!("{}C is equal to or below 30 Celsius", t),
 
         Temperature::Fahrenheit(t) if t > 86 => println!("{}F is above 86 Fahrenheit", t),
-        Temperature::Fahrenheit(t) => println!("{}F is below 86 Fahrenheit", t),
+        Temperature::Fahrenheit(t) => println!("{}F is equal to or below 86 Fahrenheit", t),
     }
 }
 ```

src/fn/closures.md

@@ -14,7 +14,7 @@ variable names *must* be specified.
 
 Other characteristics of closures include:
 * using `||` instead of `()` around input variables.
-* optional body delimitation (`{}`) for a single expression (mandatory otherwise).
+* optional body delimitation (`{}`) for a single line expression (mandatory otherwise).
 * the ability to capture the outer environment variables.
 
 ```rust,editable

src/fn/closures/capture.md

@@ -44,7 +44,7 @@ fn main() {
     // borrows `count`.
     //
     // A `mut` is required on `inc` because a `&mut` is stored inside. Thus,
-    // calling the closure mutates the closure which requires a `mut`.
+    // calling the closure mutates `count` which requires a `mut`.
     let mut inc = || {
         count += 1;
         println!("`count`: {}", count);

src/macros/dsl.md

@@ -12,7 +12,7 @@ an expression and have the output printed to console.
 macro_rules! calculate {
     (eval $e:expr) => {
         {
-            let val: usize = $e; // Force types to be integers
+            let val: usize = $e; // Force types to be unsigned integers
             println!("{} = {}", stringify!{$e}, val);
         }
     };

src/meta/playground.md

@@ -14,7 +14,7 @@ fn main() {
 ```
 
 This allows the reader to both run your code sample, but also modify and tweak
-it. The key here is the adding the word `editable` to your codefence block
+it. The key here is the adding of the word `editable` to your codefence block
 separated by a comma.
 
 ````markdown