@-ify part 01; update main for non-Linux users

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

diff --git a/src/part03.rs b/src/part03.rs
index ddaa47e01fbcf12e37e3b59156f8815830d75219..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 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::*;
 // 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>() {
         // 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),
             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?"),
         }
     }
             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`.
 // 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};
 
 // items declared public can be imported elsewhere.
 use part02::{SomethingOrNothing,Something,Nothing,vec_min};
 


@@ -103,8 +104,11 @@ trait Print {
 }
 impl<T: Print> SomethingOrNothing<T> {
     fn print2(self) {
 }
 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)
 // [index](main.html) | [previous](part02.html) | [next](part04.html)