Trailing spaces

Author: BertramScharpf

src/crates/using_lib.md

@@ -20,7 +20,7 @@ fn main() {
 ```txt
 # Where library.rlib is the path to the compiled library, assumed that it's
 # in the same directory here:
-$ rustc executable.rs --extern rary=library.rlib && ./executable 
+$ rustc executable.rs --extern rary=library.rlib && ./executable
 called rary's `public_function()`
 called rary's `indirect_access()`, that
 > called rary's `private_function()`

src/custom_types/enum/testcase_linked_list.md

@@ -33,7 +33,7 @@ impl List {
         // `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. 
+        // 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;

src/error/abort_unwind.md

@@ -2,7 +2,7 @@
 
 The previous section illustrates the error handling mechanism `panic`.  Different code paths can be conditionally compiled based on the panic setting. The current values available are `unwind` and `abort`.
 
-Building on the prior lemonade example, we explicitly use the panic strategy to exercise different lines of code.  
+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) {

src/error/option_unwrap/and_then.md

@@ -9,7 +9,7 @@ known in some languages as flatmap, comes in.
 `and_then()` calls its function input with the wrapped value and returns the result. If the `Option` is `None`, then it returns `None` instead.
 
 In the following example, `cookable_v3()` results in an `Option<Food>`.
-Using `map()` instead of `and_then()` would have given an 
+Using `map()` instead of `and_then()` would have given an
 `Option<Option<Food>>`, which is an invalid type for `eat()`.
 
 ```rust,editable

src/error/option_unwrap/defaults.md

@@ -10,7 +10,7 @@ There is more than one way to unpack an `Option` and fall back on a default if i
 `or()`is chainable and eagerly evaluates its argument, as is shown in the following example. Note that because `or`'s arguments are evaluated eagerly, the variable passed to `or` is moved.
 
 ```rust,editable
-#[derive(Debug)] 
+#[derive(Debug)]
 enum Fruit { Apple, Orange, Banana, Kiwi, Lemon }
 
 fn main() {
@@ -35,7 +35,7 @@ fn main() {
 Another alternative is to use `or_else`, which is also chainable, and evaluates lazily, as is shown in the following example:
 
 ```rust,editable
-#[derive(Debug)] 
+#[derive(Debug)]
 enum Fruit { Apple, Orange, Banana, Kiwi, Lemon }
 
 fn main() {
@@ -84,7 +84,7 @@ fn main() {
 Instead of explicitly providing a value to fall back on, we can pass a closure to `get_or_insert_with`, as follows:
 
 ```rust,editable
-#[derive(Debug)] 
+#[derive(Debug)]
 enum Fruit { Apple, Orange, Banana, Kiwi, Lemon }
 
 fn main() {

src/error/result/enter_question_mark.md

@@ -44,7 +44,7 @@ at older code. The same `multiply` function from the previous example
 would look like this using `try!`:
 
 ```rust,editable,edition2015
-// To compile and run this example without errors, while using Cargo, change the value 
+// To compile and run this example without errors, while using Cargo, change the value
 // of the `edition` field, in the `[package]` section of the `Cargo.toml` file, to "2015".
 
 use std::num::ParseIntError;

src/flow_control/for.md

@@ -71,7 +71,7 @@ fn main() {
             _ => println!("Hello {}", name),
         }
     }
-    
+
     println!("names: {:?}", names);
 }
 ```
@@ -90,7 +90,7 @@ fn main() {
             _ => println!("Hello {}", name),
         }
     }
-    
+
     println!("names: {:?}", names);
     // FIXME ^ Comment out this line
 }

src/flow_control/if_let.md

@@ -70,18 +70,18 @@ fn main() {
     let a = Foo::Bar;
     let b = Foo::Baz;
     let c = Foo::Qux(100);
-    
+
     // Variable a matches Foo::Bar
     if let Foo::Bar = a {
         println!("a is foobar");
     }
-    
+
     // Variable b does not match Foo::Bar
     // So this will print nothing
     if let Foo::Bar = b {
         println!("b is foobar");
     }
-    
+
     // Variable c matches Foo::Qux which has a value
     // Similar to Some() in the previous example
     if let Foo::Qux(value) = c {

src/flow_control/let_else.md

@@ -34,7 +34,7 @@ patterns with an unfortunate bit of repetition and an outer `let`:
 
 ```rust
 # use std::str::FromStr;
-# 
+#
 # fn get_count_item(s: &str) -> (u64, &str) {
 #     let mut it = s.split(' ');
     let (count_str, item) = match (it.next(), it.next()) {
@@ -48,7 +48,7 @@ patterns with an unfortunate bit of repetition and an outer `let`:
     };
 #     (count, item)
 # }
-# 
+#
 # assert_eq!(get_count_item("3 chairs"), (3, "chairs"));
 ```
 

src/flow_control/while_let.md

@@ -34,7 +34,7 @@ Using `while let` makes this sequence much nicer:
 fn main() {
     // Make `optional` of type `Option<i32>`
     let mut optional = Some(0);
-    
+
     // This reads: "while `let` destructures `optional` into
     // `Some(i)`, evaluate the block (`{}`). Else `break`.
     while let Some(i) = optional {