Merge pull request #1947 from BertramScharpf/bsch

Minor fixes (whitespace, typo, i32->u32)

Author: marioidival

po/es.po

@@ -593,7 +593,7 @@ msgstr "Sacando `Result`s de `Option`s"
 
 #: src/SUMMARY.md:172 src/error/multiple_error_types/define_error_type.md:1
 msgid "Defining an error type"
-msgstr "Defniniendo un tipo de error"
+msgstr "Definiendo un tipo de error"
 
 #: src/SUMMARY.md:173 src/error/multiple_error_types/boxing_errors.md:1
 msgid "`Box`ing errors"

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/c_like.md

@@ -25,8 +25,8 @@ fn main() {
     println!("zero is {}", Number::Zero as i32);
     println!("one is {}", Number::One as i32);
 
-    println!("roses are #{:06x}", Color::Red as i32);
-    println!("violets are #{:06x}", Color::Blue as i32);
+    println!("roses are #{:06x}", Color::Red as u32);
+    println!("violets are #{:06x}", Color::Blue as u32);
 }
 ```
 

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() {
@@ -27,15 +27,15 @@ fn main() {
     // But the variable named `apple` has been moved regardless, and cannot be used anymore.
     // println!("Variable apple was moved, so this line won't compile: {:?}", apple);
     // TODO: uncomment the line above to see the compiler error
- }
+}
 ```
 
 ## `or_else()` is chainable, evaluates lazily, keeps empty value intact
 
 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 {