add some @-magic to generate a workspace

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

diff --git a/src/part03.rs b/src/part03.rs
index 45caaec1557685dcc464dc01984c4a61d234204e..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?"),
         }
     }
@@ -107,4 +108,7 @@ impl<T: Print> SomethingOrNothing<T> {
     }
 }
 
+// **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)