X-Git-Url: https://git.ralfj.de/rust-101.git/blobdiff_plain/177a1f127af6601f373be9742c31351f556633ab..4816335a8c0e5bcb2514d9c7857596348fa72ff4:/src/part03.rs?ds=sidebyside

diff --git a/src/part03.rs b/src/part03.rs
index e34ef58..0e7db1d 100644
--- a/src/part03.rs
+++ b/src/part03.rs
@@ -56,14 +56,15 @@ fn read_vec() -> Vec<i32> {
         // of the function), but that's a bit too much magic for my taste. We are being more explicit here:
         // `parse::<i32>` is `parse` with its generic type set to `i32`.
         match line.parse::<i32>() {
-        // `parse` returns again a `Result`, and this time we use a `match` to handle errors (like, the user entering
-        // something that is not a number).
-        // This is a common pattern in Rust: Operations that could go wrong will return `Option` or `Result`.
-        // The only way to get to the value we are interested in is through pattern matching (and through helper functions
-        // like `unwrap()`). If we call a function that returns a `Result`, and throw the return value away,
-        // the compiler will emit a warning. It is hence impossible for us to *forget* handling an error,
-        // or to accidentally use a value that doesn't make any sense because there was an error producing it.
+            // `parse` returns again a `Result`, and this time we use a `match` to handle errors (like, the user entering
+            // something that is not a number).
+            // This is a common pattern in Rust: Operations that could go wrong will return `Option` or `Result`.
+            // The only way to get to the value we are interested in is through pattern matching (and through helper functions
+            // like `unwrap()`). If we call a function that returns a `Result`, and throw the return value away,
+            // the compiler will emit a warning. It is hence impossible for us to *forget* handling an error,
+            // or to accidentally use a value that doesn't make any sense because there was an error producing it.
             Ok(num) => vec.push(num),
+            // We don't care about the particular error, so we ignore it with a `_`.
             Err(_) => println!("What did I say about numbers?"),
         }
     }
@@ -76,7 +77,7 @@ fn read_vec() -> Vec<i32> {
 // as the documentation is quite easy to navigate and you should get used to that.
 
 // For the rest of the code, we just re-use part 02 by importing it with `use`.
-// I already sneaked a bunch of `pub` in the other module to make this possible: Only
+// I already sneaked a bunch of `pub` in part 02 to make this possible: Only
 // items declared public can be imported elsewhere.
 use part02::{SomethingOrNothing,Something,Nothing,vec_min};
 
@@ -88,7 +89,7 @@ pub fn main() {
     min.print();
 }
 
-// **Exercise**: Define a trait `Print` to write a generic version of `SomethingOrNothing::print`.
+// **Exercise 03.1**: Define a trait `Print` to write a generic version of `SomethingOrNothing::print`.
 // Implement that trait for `i32`, and change the code above to use it.
 // I will again provide a skeleton for this solution. It also shows how to attach bounds to generic
 // implementations (just compare it to the `impl` block from the previous exercise).
@@ -103,7 +104,7 @@ trait Print {
 }
 impl<T: Print> SomethingOrNothing<T> {
     fn print2(self) {
-        panic!("Not yet implemented.")
+        unimplemented!()
     }
 }