Merge pull request #1765 from ravicodelabs/minor-edits

Various minor edits for typo fixes, formatting fixes, and clarifications

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/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

src/trait/clone.md

@@ -40,11 +40,11 @@ fn main() {
 
     // Clone `moved_pair` into `cloned_pair` (resources are included)
     let cloned_pair = moved_pair.clone();
-    // Drop the original pair using std::mem::drop
+    // Drop the moved original pair using std::mem::drop
     drop(moved_pair);
 
     // Error! `moved_pair` has been dropped
-    //println!("copy: {:?}", moved_pair);
+    //println!("moved and dropped: {:?}", moved_pair);
     // TODO ^ Try uncommenting this line
 
     // The result from .clone() can still be used!

src/trait/disambiguating.md

@@ -1,8 +1,8 @@
 # Disambiguating overlapping traits
 
 A type can implement many different traits. What if two traits both require
-the same name? For example, many traits might have a method named `get()`.
-They might even have different return types!
+the same name for a function? For example, many traits might have a method 
+named `get()`. They might even have different return types!
 
 Good news: because each trait implementation gets its own `impl` block, it's
 clear which trait's `get` method you're implementing.