cargo fmt

exercise/closures_iterators/src/main.rs

@@ -41,7 +41,11 @@ fn main() {
     // Hint: .to_uppercase() is a method on `str` which returns a String
 
     let words = vec!["autobot", "beach", "car", "decepticon", "energon", "frothy"];
-    let transformed = words.into_iter().filter(|w| !w.contains("h")).map(|w| w.to_uppercase()).collect::<Vec<String>>();
+    let transformed = words
+        .into_iter()
+        .filter(|w| !w.contains("h"))
+        .map(|w| w.to_uppercase())
+        .collect::<Vec<String>>();
     println!("Transformed: {:?}", transformed);
 
     // Challenge:

exercise/errors/src/lib.rs

@@ -24,7 +24,7 @@ pub enum DolphinError {
     #[error("The dolphin is too young")]
     TooYoung,
     #[error("The dolphin's name is too long and annoying to say")]
-    LongName
+    LongName,
 }
 
 pub struct Dolphin {

exercise/errors/src/main.rs

@@ -3,14 +3,12 @@
 use aquarium::Dolphin;
 // Silence some warnings so they don't distract from the exercise.
 #[allow(clippy::vec_init_then_push)]
-
 // (You already did #1 in lib.rs, right?)
 //
 // 2a. Uncomment and finish the play_time function below
 // - Bring anyhow::Result into scope with a `use` statement
 // - Have the play_time function return a `Result<Vec<String>>`. The vector of Strings will
 //   represent successful outcomes of various dolphin tricks.
-
 use anyhow::Result;
 
 fn play_time(dolphin: &Dolphin) -> Result<Vec<String>> {
@@ -18,10 +16,10 @@ fn play_time(dolphin: &Dolphin) -> Result<Vec<String>> {
     // 2b. Call the .say_your_name() method on `dolphin`, use `?` to unwrap the value, and push
     // the value onto the `responses` vector.
     //
-    let response = dolphin.say_your_name()?;   // this can be done with an intermediate variable...
+    let response = dolphin.say_your_name()?; // this can be done with an intermediate variable...
     responses.push(response); // ...or all on one line. Either way is fine!
-    //
-    // 2c. Do the same thing as #2b for the .flip() method
+                              //
+                              // 2c. Do the same thing as #2b for the .flip() method
     responses.push(dolphin.flip()?);
     //
     // 2d. Do the same thing as #2b for the .shake_hands() method

exercise/logging/Cargo.toml

@@ -4,10 +4,5 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-# I'm glad you came to add the `log` dependency! I got it all ready for you, just uncomment:
-#
-# log = "0.4"
-
-# And here's the env_logger dependency that you'll need in main.rs
-#
-# env_logger = "0.9"
+log = "0.4" # I'm glad you came to add the `log` dependency! I got it all ready for you, just uncomment:
+env_logger = "0.9" # And here's the env_logger dependency that you'll need in main.rs

exercise/logging/src/lib.rs

@@ -6,6 +6,8 @@
 //
 // Hint: You need to update Cargo.toml to add the `log` dependency, first.
 
+use log::{debug, error, info, trace, warn};
+
 #[derive(Debug)]
 pub struct Frog {
     energy: u8,
@@ -15,19 +17,23 @@ pub struct Frog {
 impl Frog {
     pub fn new() -> Self {
         // 2. Use debug!() to log "A new Frog has been created"
+        debug!(target: "Frog::new", "A new Frog has been created");
         Default::default()
     }
     pub fn hop(&mut self) {
         self.energy -= 1;
         // 3. Use info!() to log that a Frog hopped, and how much energy is left
+        info!(target: "Frog::hop", "A frog hopped! It has {} energy left", self.energy);
         if self.energy == 0 {
             // 4. Use warn!() to warn that the frog will go to sleep since he ran out of energy
+            warn!(target: "Frog::hop", "The frog will go to sleep since he ran out of energy");
             self.sleep();
         }
     }
     pub fn sleep(&mut self) {
         if self.sleeping {
             // 5. Use error!() to log a (non-fatal) error stating that the Frog is already asleep
+            error!(target: "Frog::sleep", "The frog is already asleep");
         } else {
             self.sleeping = true;
         }
@@ -37,9 +43,12 @@ impl Frog {
 impl Default for Frog {
     fn default() -> Self {
         // 6. Use trace!() to log that a default value was generated, with the debug representation
-        Frog {
+        let frog = Frog {
             energy: 5,
             sleeping: false,
-        }
+        };
+
+        trace!(target: "Frog::Default", "A default Frog value was generated: {:?}", frog);
+        frog
     }
 }

exercise/logging/src/main.rs

@@ -8,6 +8,7 @@ use frogger::Frog;
 
 fn main() {
     // 8. Initialize env_logger using the init() function at the top level of the library
+    env_logger::init();
 
     // 9. Run this program with `cargo run` and take a look at the default output.
     // - Now run it again with an explicit log level, like `RUST_LOG=info cargo run`

exercise/testing/benches/somename.rs

@@ -2,7 +2,9 @@ use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use testing::sploosh;
 
 pub fn sploosh_benchmark(c: &mut Criterion) {
-    c.bench_function("sploosh", |b| b.iter(|| sploosh(black_box(8), black_box(9), black_box(10))));
+    c.bench_function("sploosh", |b| {
+        b.iter(|| sploosh(black_box(8), black_box(9), black_box(10)))
+    });
 }
 
 criterion_group!(benches, sploosh_benchmark);

exercise/testing/tests/more_tests.rs

@@ -1,4 +1,4 @@
-use testing::{sploosh, splish};
+use testing::{splish, sploosh};
 
 #[test]
 pub fn test_sploosh_splish() {

exercise/threads_channels/src/main.rs

@@ -22,8 +22,8 @@ fn main() {
     // join handle in a variable called `handle`. Once you've done this you should be able to run
     // the code and see the output from the child thread's expensive sum in the middle of the main
     // thread's processing of letters.
-    //
-    //let handle = ...
+
+    let handle = thread::spawn(|| expensive_sum(my_vector));
 
     // While the child thread is running, the main thread will also do some work
     for letter in vec!["a", "b", "c", "d", "e", "f"] {
@@ -37,63 +37,90 @@ fn main() {
     // to a variable named `result`
     // - Get the i32 out of `result` and store it in a `sum` variable.
 
-    // let result =
-    // let sum =
-    // println!("The child thread's expensive sum is {}", sum);
+    let result = handle.join();
+    let sum = result.unwrap();
+    println!("The child thread's expensive sum is {}", sum);
 
     // 3. Time for some fun with channels!
     // - Uncomment the block comment below (Find and remove the `/*` and `*/`).
     // - Create variables `tx` and `rx` and assign them to the sending and receiving ends of an
     // unbounded channel. Hint: An unbounded channel can be created with `channel::unbounded()`
 
-    /*
-        // let ...
+    let (tx, rx) = channel::unbounded();
 
-        // Cloning a channel makes another variable connected to that end of the channel so that you can
-        // send it to another thread. We want another variable that can be used for sending...
-        let tx2 = tx.clone();
+    // Cloning a channel makes another variable connected to that end of the channel so that you can
+    // send it to another thread. We want another variable that can be used for sending...
+    let tx2 = tx.clone();
 
-        // 4. Examine the flow of execution of "Thread A" and "Thread B" below. Do you see how their
-        // output will mix with each other?
-        // - Run this code. Notice the order of output from Thread A and Thread B.
-        // - Increase the value passed to the first `sleep_ms()` call in Thread A so that both the
-        // Thread B outputs occur *before* Thread A outputs anything.
-        // - Run the code again and make sure the output comes in a different order.
+    // 4. Examine the flow of execution of "Thread A" and "Thread B" below. Do you see how their
+    // output will mix with each other?
+    // - Run this code. Notice the order of output from Thread A and Thread B.
+    // - Increase the value passed to the first `sleep_ms()` call in Thread A so that both the
+    // Thread B outputs occur *before* Thread A outputs anything.
+    // - Run the code again and make sure the output comes in a different order.
 
-        // Thread A
-        let handle_a = thread::spawn(move || {
-            sleep_ms(0);
-            tx2.send("Thread A: 1").unwrap();
-            sleep_ms(200);
-            tx2.send("Thread A: 2").unwrap();
-        });
+    // Thread A
+    let handle_a = thread::spawn(move || {
+        sleep_ms(500);
+        tx2.send("Thread A: 1").unwrap();
+        sleep_ms(200);
+        tx2.send("Thread A: 2").unwrap();
+    });
 
-        sleep_ms(100); // Make sure Thread A has time to get going before we spawn Thread B
+    sleep_ms(100); // Make sure Thread A has time to get going before we spawn Thread B
 
-        // Thread B
-        let handle_b = thread::spawn(move || {
-            sleep_ms(0);
-            tx.send("Thread B: 1").unwrap();
-            sleep_ms(200);
-            tx.send("Thread B: 2").unwrap();
-        });
+    // Thread B
+    let handle_b = thread::spawn(move || {
+        sleep_ms(0);
+        tx.send("Thread B: 1").unwrap();
+        sleep_ms(200);
+        tx.send("Thread B: 2").unwrap();
+    });
 
-        // Using a Receiver channel as an iterator is a convenient way to get values until the channel
-        // gets closed. A Receiver channel is automatically closed once all Sender channels have been
-        // closed. Both our threads automatically close their Sender channels when they exit and the
-        // destructors for the channels get automatically called.
-        for msg in rx {
-            println!("Main thread: Received {}", msg);
-        }
+    // Using a Receiver channel as an iterator is a convenient way to get values until the channel
+    // gets closed. A Receiver channel is automatically closed once all Sender channels have been
+    // closed. Both our threads automatically close their Sender channels when they exit and the
+    // destructors for the channels get automatically called.
+    for msg in rx {
+        println!("Main thread: Received {}", msg);
+    }
 
-        // 5. Oops, we forgot to join "Thread A" and "Thread B". That's bad hygiene!
-        // - Use the thread handles to join both threads without getting any compiler warnings.
-    */
+    // 5. Oops, we forgot to join "Thread A" and "Thread B". That's bad hygiene!
+    // - Use the thread handles to join both threads without getting any compiler warnings.
+    let _ = handle_a.join();
+    let _ = handle_b.join();
 
     // Challenge: Make two child threads and give them each a receiving end to a channel. From the
     // main thread loop through several values and print each out and then send it to the channel.
     // On the child threads print out the values you receive. Close the sending side in the main
     // thread by calling `drop(tx)` (assuming you named your sender channel variable `tx`). Join
     // the child threads.
+
+    let (tx, rx) = channel::unbounded();
+    let rx2 = rx.clone();
+
+    let thread_a_handle = thread::spawn(move || {
+        for n in rx {
+            println!("Thread A received: {}", n);
+            sleep_ms(10);
+        }
+    });
+
+    let thread_b_handle = thread::spawn(move || {
+        for n in rx2 {
+            println!("Thread B received: {}", n);
+            sleep_ms(10);
+        }
+    });
+
+    for number in vec![1, 2, 3, 4, 5] {
+        println!("NUMBER: {}", number);
+        let _ = tx.send(number);
+    }
+    drop(tx);
+
+    let _ = thread_a_handle.join();
+    let _ = thread_b_handle.join();
+
     println!("Main thread: Exiting.")
 }

exercise/traits/src/main.rs

@@ -17,7 +17,7 @@ impl Default for Party {
         Self {
             at_restaurant: true,
             num_people: 8,
-            cake: Cake::Chocolate
+            cake: Cake::Chocolate,
         }
     }
 }
@@ -110,7 +110,10 @@ fn main() {
     // consuming it. Change the code above to pass in a &party. Then uncomment and run the code
     // below. After all, you want to smell your cake and eat it, too!
 
-    println!("Yum! I'm eating this cake: {:?}. Oops, I dropped it on the floor.", party.cake);
+    println!(
+        "Yum! I'm eating this cake: {:?}. Oops, I dropped it on the floor.",
+        party.cake
+    );
 }
 
 pub fn admire_cake(cake: Cake) {