avoid using std::cmp::min, for it doesn't support f32...

[rust-101.git] / src / part03.rs

diff --git a/src/part03.rs b/src/part03.rs
index e34ef5878e93edc667640e0bc3283c7ba8ec6657..9ab153dcf4176688b6afc9565e0ea75bb57f31cc 100644 (file)
--- a/src/part03.rs
+++ b/src/part03.rs
@@ -6,7 +6,7 @@
 // I/O is a complicated topic, so the code to do that is not exactly pretty - but well,
 // let's get that behind us.
 
-// I/O is provided by the module `std::io`, so we first import that.
+// I/O is provided by the module `std::io`, so we first have import that with `use`.
 // We also import the I/O *prelude*, which brings a bunch of commonly used I/O stuff
 // directly available.
 use std::io::prelude::*;
@@ -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,8 +104,11 @@ trait Print {
 }
 impl<T: Print> SomethingOrNothing<T> {
     fn print2(self) {
-        panic!("Not yet implemented.")
+        unimplemented!()
     }
 }
 
+// **Exercise 03.2**: Building on exercise 02.2, implement all the things you need on `f32` to make your
+// program work with floating-point numbers.
+
 // [index](main.html) | [previous](part02.html) | [next](part04.html)