chore(workflow): cleanup of unused workflows

Cargo.lock

@@ -167,10 +167,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "exercises"
-version = "0.0.0"
-
 [[package]]
 name = "fastrand"
 version = "2.4.1"

Cargo.toml

@@ -1,10 +1,7 @@
 [workspace]
-members = [
-  "rustlings-macros",
-  "dev",
-]
 exclude = [
   "tests/test_exercises",
+  "dev",
 ]
 
 [workspace.package]

exercises/02_functions/functions4.rs

@@ -8,7 +8,7 @@ fn is_even(num: i64) -> bool {
 }
 
 // TODO: Fix the function signature.
-fn sale_price(price: i64) -> i64 {
+fn sale_price(price: i64) -> {
     if is_even(price) {
         price - 10
     } else {

exercises/02_functions/functions5.rs

@@ -1,6 +1,6 @@
 // TODO: Fix the function body without changing the signature.
 fn square(num: i32) -> i32 {
-    num * num
+    num * num;
 }
 
 fn main() {

exercises/03_if/if1.rs

@@ -4,11 +4,6 @@ fn bigger(a: i32, b: i32) -> i32 {
     // Do not use:
     // - another function call
     // - additional variables
-    if a > b {
-        a
-    } else {
-        b
-    }
 }
 
 fn main() {

exercises/03_if/if2.rs

@@ -2,10 +2,8 @@
 fn picky_eater(food: &str) -> &str {
     if food == "strawberry" {
         "Yummy!"
-    } else if food == "potato" {
-        "I guess I can eat that."
     } else {
-        "No thanks!"
+        1
     }
 }
 

exercises/03_if/if3.rs

@@ -3,11 +3,11 @@ fn animal_habitat(animal: &str) -> &str {
     let identifier = if animal == "crab" {
         1
     } else if animal == "gopher" {
-        2
+        2.0
     } else if animal == "snake" {
         3
     } else {
-        0
+        "Unknown"
     };
 
     // Don't change the expression below!

exercises/04_primitive_types/primitive_types1.rs

@@ -8,8 +8,7 @@ fn main() {
 
     // TODO: Define a boolean variable with the name `is_evening` before the `if` statement below.
     // The value of the variable should be the negation (opposite) of `is_morning`.
-    let is_evening = true;
+    // let …
-
     if is_evening {
         println!("Good evening!");
     }

exercises/04_primitive_types/primitive_types2.rs

@@ -17,7 +17,6 @@ fn main() {
     // Try a letter, try a digit (in single quotes), try a special character, try a character
     // from a different language than your own, try an emoji 😉
     // let your_character = '';
-    let your_character = '僕';
 
     if your_character.is_alphabetic() {
         println!("Alphabetical!");

exercises/04_primitive_types/primitive_types3.rs

@@ -2,14 +2,6 @@ fn main() {
     // TODO: Create an array called `a` with at least 100 elements in it.
     // let a = ???
 
-    let a = [
-        1, 2, 3, 4, 5, 6, 7, 1, 231, 234, 11, 4512, 51, 5, 12, 51, 25, 12, 45, 134, 12, 412, 45,
-        12, 512, 512, 5, 12, 512, 4, 124, 12, 5, 125, 123, 3412, 45, 123, 5123, 5, 12345, 123, 412,
-        56, 1236, 234, 6345, 6534, 6, 547, 456, 754, 6, 345, 34, 534, 6, 235, 123, 4523, 4523, 5,
-        235, 235, 2, 532, 523, 23, 124, 21, 2, 3, 51235, 664, 3466, 345,312,312,421,412,45,1245,123,423,523,56,234,5234,5234,5,346,345,6745,7456,7456,7,456,7456,7,4, 2, 6, 23, 12, 4512, 512,
-        5, 512, 5, 125, 125, 125, 12, 56, 75, 7456, 87,
-    ];
-
     if a.len() >= 100 {
         println!("Wow, that's a big array!");
     } else {

exercises/04_primitive_types/primitive_types4.rs

@@ -11,7 +11,6 @@ mod tests {
         // TODO: Get a slice called `nice_slice` out of the array `a` so that the test passes.
         // let nice_slice = ???
 
-        let nice_slice = &a[1..4];
         assert_eq!([2, 3, 4], nice_slice);
     }
 }

exercises/04_primitive_types/primitive_types5.rs

@@ -4,7 +4,5 @@ fn main() {
     // TODO: Destructure the `cat` tuple in one statement so that the println works.
     // let /* your pattern here */ = cat;
 
-    let (name, age) = cat;
-
     println!("{name} is {age} years old");
 }

exercises/04_primitive_types/primitive_types6.rs

@@ -4,7 +4,6 @@ fn main() {
 
 #[cfg(test)]
 mod tests {
-
     #[test]
     fn indexing_tuple() {
         let numbers = (1, 2, 3);
@@ -12,7 +11,6 @@ mod tests {
         // TODO: Use a tuple index to access the second element of `numbers`
         // and assign it to a variable called `second`.
         // let second = ???;
-        let second = numbers.1;
 
         assert_eq!(second, 2, "This is not the 2nd number in the tuple!");
     }

exercises/05_vecs/vecs1.rs

@@ -1,8 +1,6 @@
 fn elems_to_vec(a: i32, b: i32, c: i32) -> Vec<i32> {
     // TODO: Return a vector containing the elements a, b and c (in this order).
     // Use the "vec!" macro.
-    let vector: Vec<i32> = vec![a, b, c];
-    vector
 }
 
 fn main() {

exercises/05_vecs/vecs2.rs

@@ -4,8 +4,6 @@ fn vec_loop(input: &[i32]) -> Vec<i32> {
     for element in input {
         // TODO: Multiply each element in the `input` slice by 2 and push it to
         // the `output` vector.
-
-        output.push(element * 2);
     }
 
     output

exercises/06_move_semantics/move_semantics1.rs

@@ -1,6 +1,6 @@
 // TODO: Fix the compiler error in this function.
 fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
-    let mut vec = vec;
+    let vec = vec;
 
     vec.push(88);
 

exercises/06_move_semantics/move_semantics2.rs

@@ -20,7 +20,7 @@ mod tests {
     fn move_semantics2() {
         let vec0 = vec![22, 44, 66];
 
-        let vec1 = fill_vec(vec0.clone());
+        let vec1 = fill_vec(vec0);
 
         assert_eq!(vec0, [22, 44, 66]);
         assert_eq!(vec1, [22, 44, 66, 88]);

exercises/06_move_semantics/move_semantics3.rs

@@ -1,5 +1,5 @@
 // TODO: Fix the compiler error in the function without adding any new line.
-fn fill_vec(mut vec: Vec<i32>) -> Vec<i32> {
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
     vec.push(88);
 
     vec

exercises/06_move_semantics/move_semantics4.rs

@@ -10,8 +10,8 @@ mod tests {
     fn move_semantics4() {
         let mut x = Vec::new();
         let y = &mut x;
-        y.push(42);
         let z = &mut x;
+        y.push(42);
         z.push(13);
         assert_eq!(x, [42, 13]);
     }

exercises/06_move_semantics/move_semantics5.rs

@@ -4,12 +4,12 @@
 // removing references (the character `&`).
 
 // Shouldn't take ownership
-fn get_char(data: &String) -> char {
+fn get_char(data: String) -> char {
     data.chars().last().unwrap()
 }
 
 // Should take ownership
-fn string_uppercase(mut data: String) {
+fn string_uppercase(mut data: &String) {
     data = data.to_uppercase();
 
     println!("{data}");
@@ -18,7 +18,7 @@ fn string_uppercase(mut data: String) {
 fn main() {
     let data = "Rust is great!".to_string();
 
-    get_char(&data);
+    get_char(data);
 
-    string_uppercase(data);
+    string_uppercase(&data);
 }

exercises/07_structs/structs1.rs

@@ -1,12 +1,9 @@
 struct ColorRegularStruct {
     // TODO: Add the fields that the test `regular_structs` expects.
     // What types should the fields have? What are the minimum and maximum values for RGB colors?
-    red: u8,
-    green: u8,
-    blue: u8,
 }
 
-struct ColorTupleStruct(u8, u8, u8);
+struct ColorTupleStruct(/* TODO: Add the fields that the test `tuple_structs` expects */);
 
 #[derive(Debug)]
 struct UnitStruct;
@@ -23,11 +20,7 @@ mod tests {
     fn regular_structs() {
         // TODO: Instantiate a regular struct.
         // let green =
-        let green = ColorRegularStruct {
+
-            red: 0,
-            green: 255,
-            blue: 0,
-        };
         assert_eq!(green.red, 0);
         assert_eq!(green.green, 255);
         assert_eq!(green.blue, 0);
@@ -37,7 +30,7 @@ mod tests {
     fn tuple_structs() {
         // TODO: Instantiate a tuple struct.
         // let green =
-        let green = ColorTupleStruct(0, 255, 0);
+
         assert_eq!(green.0, 0);
         assert_eq!(green.1, 255);
         assert_eq!(green.2, 0);
@@ -46,7 +39,7 @@ mod tests {
     #[test]
     fn unit_structs() {
         // TODO: Instantiate a unit struct.
-        let unit_struct = UnitStruct;
+        // let unit_struct =
         let message = format!("{unit_struct:?}s are fun!");
 
         assert_eq!(message, "UnitStructs are fun!");

exercises/07_structs/structs2.rs

@@ -36,12 +36,6 @@ mod tests {
         // TODO: Create your own order using the update syntax and template above!
         // let your_order =
 
-        let your_order = Order {
-            name: "Hacker in Rust".to_string(),
-            count: 1,
-            ..order_template
-        };
-
         assert_eq!(your_order.name, "Hacker in Rust");
         assert_eq!(your_order.year, order_template.year);
         assert_eq!(your_order.made_by_phone, order_template.made_by_phone);

exercises/07_structs/structs3.rs

@@ -10,18 +10,19 @@ struct Fireworks {
     rockets: usize,
 }
 
-impl Fireworks {
+// TODO: Turn this function into an associated function on `Fireworks`.
-    fn new() -> Self {
+fn new_fireworks() -> Fireworks {
-        Self { rockets: 0 }
+    Fireworks { rockets: 0 }
-    }
+}
 
-    fn add_rockets(&mut self, rockets: usize) {
+// TODO: Turn this function into a method on `Fireworks`.
-        self.rockets += rockets
+fn add_rockets(fireworks: &mut Fireworks, rockets: usize) {
-    }
+    fireworks.rockets += rockets
+}
 
-    fn start(self) -> String {
+// TODO: Turn this function into a method on `Fireworks`.
-        "🚀".repeat(self.rockets)
+fn start(fireworks: Fireworks) -> String {
-    }
+    "🚀".repeat(fireworks.rockets)
 }
 
 fn main() {

exercises/08_enums/enums1.rs

@@ -1,11 +1,6 @@
 #[derive(Debug)]
 enum Message {
     // TODO: Define a few types of messages as used below.
-    Resize,
-    Move,
-    Echo,
-    ChangeColor,
-    Quit,
 }
 
 fn main() {

exercises/08_enums/enums2.rs

@@ -7,11 +7,6 @@ struct Point {
 #[derive(Debug)]
 enum Message {
     // TODO: Define the different variants used below.
-    Resize { width: u64, height: u64 },
-    Move(Point),
-    Echo(String),
-    ChangeColor(u64, u64, u64),
-    Quit,
 }
 
 impl Message {

exercises/08_enums/enums3.rs

@@ -46,13 +46,6 @@ impl State {
     fn process(&mut self, message: Message) {
         // TODO: Create a match expression to process the different message
         // variants using the methods defined above.
-        match message {
-            Message::Resize { width, height } => self.resize(width, height),
-            Message::Move(point) => self.move_position(point),
-            Message::Echo(s) => self.echo(s),
-            Message::ChangeColor(red, green, blue) => self.change_color(red, green, blue),
-            Message::Quit => self.quit(),
-        }
     }
 }
 

exercises/09_strings/strings1.rs

@@ -1,6 +1,6 @@
 // TODO: Fix the compiler error without changing the function signature.
 fn current_favorite_color() -> String {
-    "blue".to_string()
+    "blue"
 }
 
 fn main() {

exercises/09_strings/strings2.rs

@@ -6,7 +6,7 @@ fn is_a_color_word(attempt: &str) -> bool {
 fn main() {
     let word = String::from("green"); // Don't change this line.
 
-    if is_a_color_word(&word) {
+    if is_a_color_word(word) {
         println!("That is a color word I know!");
     } else {
         println!("That is not a color word I know.");

exercises/09_strings/strings3.rs

@@ -1,18 +1,13 @@
 fn trim_me(input: &str) -> &str {
     // TODO: Remove whitespace from both ends of a string.
-    input.trim()
 }
 
 fn compose_me(input: &str) -> String {
     // TODO: Add " world!" to the string! There are multiple ways to do this.
-    let world = " world!";
-    let s: String = input.to_owned() + world;
-    s
 }
 
 fn replace_me(input: &str) -> String {
     // TODO: Replace "cars" in the string with "balloons".
-    input.replace("cars", "balloons")
 }
 
 fn main() {

exercises/09_strings/strings4.rs

@@ -13,23 +13,23 @@ fn string(arg: String) {
 // Your task is to replace `placeholder(…)` with either `string_slice(…)`
 // or `string(…)` depending on what you think each value is.
 fn main() {
-    string_slice("blue");
+    placeholder("blue");
 
-    string("red".to_string());
+    placeholder("red".to_string());
 
-    string(String::from("hi"));
+    placeholder(String::from("hi"));
 
-    string("rust is fun!".to_owned());
+    placeholder("rust is fun!".to_owned());
 
-    string(format!("Interpolation {}", "Station"));
+    placeholder(format!("Interpolation {}", "Station"));
 
     // WARNING: This is byte indexing, not character indexing.
     // Character indexing can be done using `s.chars().nth(INDEX)`.
-    string_slice(&String::from("abc")[0..1]);
+    placeholder(&String::from("abc")[0..1]);
 
-    string_slice("  hello there ".trim());
+    placeholder("  hello there ".trim());
 
-    string("Happy Monday!".replace("Mon", "Tues"));
+    placeholder("Happy Monday!".replace("Mon", "Tues"));
 
-    string("mY sHiFt KeY iS sTiCkY".to_lowercase());
+    placeholder("mY sHiFt KeY iS sTiCkY".to_lowercase());
 }

exercises/10_modules/modules1.rs

@@ -5,7 +5,7 @@ mod sausage_factory {
         String::from("Ginger")
     }
 
-    pub fn make_sausage() {
+    fn make_sausage() {
         get_secret_recipe();
         println!("sausage!");
     }

exercises/10_modules/modules2.rs

@@ -5,9 +5,6 @@ mod delicious_snacks {
     // TODO: Add the following two `use` statements after fixing them.
     // use self::fruits::PEAR as ???;
     // use self::veggies::CUCUMBER as ???;
-    
-    pub use self::fruits::PEAR as fruit;
-    pub use self::veggies::CUCUMBER as veggie;
 
     mod fruits {
         pub const PEAR: &str = "Pear";

exercises/10_modules/modules3.rs

@@ -4,8 +4,6 @@
 // TODO: Bring `SystemTime` and `UNIX_EPOCH` from the `std::time` module into
 // your scope. Bonus style points if you can do it with one line!
 // use ???;
-use std::time::SystemTime;
-use std::time::UNIX_EPOCH;
 
 fn main() {
     match SystemTime::now().duration_since(UNIX_EPOCH) {

exercises/11_hashmaps/hashmaps1.rs

@@ -9,11 +9,10 @@ use std::collections::HashMap;
 fn fruit_basket() -> HashMap<String, u32> {
     // TODO: Declare the hash map.
     // let mut basket =
-    let mut basket = HashMap::new();
+
     // Two bananas are already given for you :)
     basket.insert(String::from("banana"), 2);
-    basket.insert(String::from("apple"), 2);
+
-    basket.insert(String::from("mango"), 1);
     // TODO: Put more fruits in your basket.
 
     basket

exercises/11_hashmaps/hashmaps2.rs

@@ -28,12 +28,10 @@ fn fruit_basket(basket: &mut HashMap<Fruit, u32>) {
         Fruit::Pineapple,
     ];
 
-    for _fruit in fruit_kinds {
+    for fruit in fruit_kinds {
         // TODO: Insert new fruits if they are not already present in the
         // basket. Note that you are not allowed to put any type of fruit that's
         // already present!
-        basket.insert(Fruit::Banana, 4);
-        basket.insert(Fruit::Pineapple, 3);
     }
 }
 

exercises/11_hashmaps/hashmaps3.rs

@@ -27,11 +27,6 @@ fn build_scores_table(results: &str) -> HashMap<&str, TeamScores> {
         let team_1_score: u8 = split_iterator.next().unwrap().parse().unwrap();
         let team_2_score: u8 = split_iterator.next().unwrap().parse().unwrap();
 
-        scores.entry(team_1_name).or_default().goals_scored += team_1_score;
-        scores.entry(team_2_name).or_default().goals_scored += team_2_score;
-
-        scores.entry(team_1_name).or_default().goals_conceded += team_2_score;
-        scores.entry(team_2_name).or_default().goals_conceded += team_1_score;
         // TODO: Populate the scores table with the extracted details.
         // Keep in mind that goals scored by team 1 will be the number of goals
         // conceded by team 2. Similarly, goals scored by team 2 will be the

exercises/12_options/options1.rs

@@ -4,14 +4,6 @@
 // `hour_of_day` is higher than 23.
 fn maybe_ice_cream(hour_of_day: u16) -> Option<u16> {
     // TODO: Complete the function body.
-
-    if hour_of_day < 22 {
-        Some(5)
-    } else if hour_of_day <= 23 {
-        Some(0)
-    } else {
-        None
-    }
 }
 
 fn main() {
@@ -26,7 +18,7 @@ mod tests {
     fn raw_value() {
         // TODO: Fix this test. How do you get the value contained in the
         // Option?
-        let ice_creams = maybe_ice_cream(12).unwrap();
+        let ice_creams = maybe_ice_cream(12);
 
         assert_eq!(ice_creams, 5); // Don't change this line.
     }

exercises/12_options/options2.rs

@@ -10,12 +10,8 @@ mod tests {
         let optional_target = Some(target);
 
         // TODO: Make this an if-let statement whose value is `Some`.
-        //
+        word = optional_target {
-        // word = optional_target {
+            assert_eq!(word, target);
-        //     assert_eq!(word, target);
-        // }
-        if let Some(word) = optional_target {
-            assert_eq!(word, target)
         }
     }
 
@@ -33,13 +29,7 @@ mod tests {
         // TODO: Make this a while-let statement. Remember that `Vec::pop()`
         // adds another layer of `Option`. You can do nested pattern matching
         // in if-let and while-let statements.
-        //
+        integer = optional_integers.pop() {
-        // integer = optional_integers.pop() {
-        //     assert_eq!(integer, cursor);
-        //     cursor -= 1;
-        // }
-
-        while let Some(Some(integer)) = optional_integers.pop() {
             assert_eq!(integer, cursor);
             cursor -= 1;
         }

exercises/12_options/options3.rs

@@ -9,9 +9,7 @@ fn main() {
 
     // TODO: Fix the compiler error by adding something to this match statement.
     match optional_point {
-        Some(ref p) => {
+        Some(p) => println!("Coordinates are {},{}", p.x, p.y),
-            println!("Coordinates are {},{}", p.x, p.y)
-        }
         _ => panic!("No match!"),
     }
 

exercises/13_error_handling/errors1.rs

@@ -4,12 +4,12 @@
 // construct to `Option` that can be used to express error conditions. Change
 // the function signature and body to return `Result<String, String>` instead
 // of `Option<String>`.
-fn generate_nametag_text(name: String) -> Result<String, String> {
+fn generate_nametag_text(name: String) -> Option<String> {
     if name.is_empty() {
         // Empty names aren't allowed
-        Err("Empty names aren't allowed".to_string())
+        None
     } else {
-        Ok(format!("Hi! My name is {name}"))
+        Some(format!("Hi! My name is {name}"))
     }
 }
 

exercises/13_error_handling/errors2.rs

@@ -21,7 +21,7 @@ fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
     let cost_per_item = 5;
 
     // TODO: Handle the error case as described above.
-    let qty = item_quantity.parse::<i32>()?;
+    let qty = item_quantity.parse::<i32>();
 
     Ok(qty * cost_per_item + processing_fee)
 }

exercises/13_error_handling/errors3.rs

@@ -15,7 +15,7 @@ fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
 
 // TODO: Fix the compiler error by changing the signature and body of the
 // `main` function.
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() {
     let mut tokens = 100;
     let pretend_user_input = "8";
 
@@ -24,10 +24,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     if cost > tokens {
         println!("You can't afford that many!");
-        Ok(())
     } else {
         tokens -= cost;
         println!("You now have {tokens} tokens.");
-        Ok(())
     }
 }

exercises/13_error_handling/errors4.rs

@@ -1,5 +1,3 @@
-use std::cmp::Ordering;
-
 #[derive(PartialEq, Debug)]
 enum CreationError {
     Negative,
@@ -13,11 +11,7 @@ impl PositiveNonzeroInteger {
     fn new(value: i64) -> Result<Self, CreationError> {
         // TODO: This function shouldn't always return an `Ok`.
         // Read the tests below to clarify what should be returned.
-        match value.cmp(&0) {
+        Ok(Self(value as u64))
-            Ordering::Less => Err(CreationError::Negative),
-            Ordering::Equal => Err(CreationError::Zero),
-            Ordering::Greater => Ok(Self(value as u64)),
-        }
     }
 }
 

exercises/13_error_handling/errors5.rs

@@ -48,7 +48,7 @@ impl PositiveNonzeroInteger {
 
 // TODO: Add the correct return type `Result<(), Box<dyn ???>>`. What can we
 // use to describe both errors? Is there a trait which both errors implement?
-fn main() -> Result<(), Box<dyn Error>> {
+fn main() {
     let pretend_user_input = "42";
     let x: i64 = pretend_user_input.parse()?;
     println!("output={:?}", PositiveNonzeroInteger::new(x)?);

exercises/13_error_handling/errors6.rs

@@ -34,7 +34,7 @@ impl PositiveNonzeroInteger {
     fn parse(s: &str) -> Result<Self, ParsePosNonzeroError> {
         // TODO: change this to return an appropriate error instead of panicking
         // when `parse()` returns an error.
-        let x: i64 = s.parse().map_err(ParsePosNonzeroError::ParseInt)?;
+        let x: i64 = s.parse().unwrap();
         Self::new(x).map_err(ParsePosNonzeroError::Creation)
     }
 }

exercises/14_generics/generics1.rs

@@ -6,7 +6,7 @@ fn main() {
     // TODO: Fix the compiler error by annotating the type of the vector
     // `Vec<T>`. Choose `T` as some integer type that can be created from
     // `u8` and `i8`.
-    let mut numbers: Vec<i16> = Vec::new();
+    let mut numbers = Vec::new();
 
     // Don't change the lines below.
     let n1: u8 = 42;

exercises/14_generics/generics2.rs

@@ -1,12 +1,12 @@
 // This powerful wrapper provides the ability to store a positive integer value.
 // TODO: Rewrite it using a generic so that it supports wrapping ANY type.
-struct Wrapper<T> {
+struct Wrapper {
-    value: T,
+    value: u32,
 }
 
 // TODO: Adapt the struct's implementation to be generic over the wrapped value.
-impl<T> Wrapper<T> {
+impl Wrapper {
-    fn new(value: T) -> Self {
+    fn new(value: u32) -> Self {
         Wrapper { value }
     }
 }

exercises/15_traits/traits1.rs

@@ -6,9 +6,6 @@ trait AppendBar {
 
 impl AppendBar for String {
     // TODO: Implement `AppendBar` for the type `String`.
-    fn append_bar(self) -> Self {
-        self + &String::from("Bar")
-    }
 }
 
 fn main() {

exercises/15_traits/traits2.rs

@@ -4,12 +4,6 @@ trait AppendBar {
 
 // TODO: Implement the trait `AppendBar` for a vector of strings.
 // `append_bar` should push the string "Bar" into the vector.
-impl AppendBar for Vec<String> {
-    fn append_bar(mut self) -> Self {
-        self.push(String::from("Bar"));
-        self
-    }
-}
 
 fn main() {
     // You can optionally experiment here.

exercises/15_traits/traits3.rs

@@ -3,9 +3,7 @@ trait Licensed {
     // implementors like the two structs below can share that default behavior
     // without repeating the function.
     // The default license information should be the string "Default license".
-    fn licensing_info(&self) -> String {
+    fn licensing_info(&self) -> String;
-        String::from("Default license")
-    }
 }
 
 struct SomeSoftware {

exercises/15_traits/traits4.rs

@@ -11,7 +11,7 @@ impl Licensed for SomeSoftware {}
 impl Licensed for OtherSoftware {}
 
 // TODO: Fix the compiler error by only changing the signature of this function.
-fn compare_license_types(software1: impl Licensed, software2: impl Licensed) -> bool {
+fn compare_license_types(software1: ???, software2: ???) -> bool {
     software1.licensing_info() == software2.licensing_info()
 }
 

exercises/15_traits/traits5.rs

@@ -19,7 +19,7 @@ impl SomeTrait for OtherStruct {}
 impl OtherTrait for OtherStruct {}
 
 // TODO: Fix the compiler error by only changing the signature of this function.
-fn some_func(item: impl SomeTrait + OtherTrait) -> bool {
+fn some_func(item: ???) -> bool {
     item.some_function() && item.other_function()
 }
 

exercises/16_lifetimes/lifetimes1.rs

@@ -4,7 +4,7 @@
 // not own their own data. What if their owner goes out of scope?
 
 // TODO: Fix the compiler error by updating the function signature.
-fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+fn longest(x: &str, y: &str) -> &str {
     if x.len() > y.len() {
         x
     } else {

exercises/16_lifetimes/lifetimes2.rs

@@ -15,6 +15,6 @@ fn main() {
     {
         let string2 = String::from("xyz");
         result = longest(&string1, &string2);
-        println!("The longest string is '{result}'");
     }
+    println!("The longest string is '{result}'");
 }

exercises/16_lifetimes/lifetimes3.rs

@@ -1,9 +1,9 @@
 // Lifetimes are also needed when structs hold references.
 
 // TODO: Fix the compiler errors about the struct.
-struct Book<'a> {
+struct Book {
-    author: &'a str,
+    author: &str,
-    title: &'a str,
+    title: &str,
 }
 
 fn main() {

exercises/17_tests/tests1.rs

@@ -13,12 +13,11 @@ fn main() {
 mod tests {
     // TODO: Import `is_even`. You can use a wildcard to import everything in
     // the outer module.
-    use super::*;
 
     #[test]
     fn you_can_assert() {
         // TODO: Test the function `is_even` with some values.
-        assert!(!is_even(1));
+        assert!();
-        assert!(is_even(12));
+        assert!();
     }
 }

exercises/17_tests/tests2.rs

@@ -15,9 +15,9 @@ mod tests {
     #[test]
     fn you_can_assert_eq() {
         // TODO: Test the function `power_of_2` with some values.
-        assert_eq!(power_of_2(2), 4);
+        assert_eq!();
-        assert_eq!(power_of_2(3), 8);
+        assert_eq!();
-        assert_eq!(power_of_2(10), 1024);
+        assert_eq!();
-        assert_eq!(power_of_2(42),  4398046511104);
+        assert_eq!();
     }
 }

exercises/17_tests/tests3.rs

@@ -29,14 +29,13 @@ mod tests {
         // TODO: This test should check if the rectangle has the size that we
         // pass to its constructor.
         let rect = Rectangle::new(10, 20);
-        assert_eq!(rect.width, 10); // Check width
+        assert_eq!(todo!(), 10); // Check width
-        assert_eq!(rect.height, 20); // Check height
+        assert_eq!(todo!(), 20); // Check height
     }
 
     // TODO: This test should check if the program panics when we try to create
     // a rectangle with negative width.
     #[test]
-    #[should_panic]
     fn negative_width() {
         let _rect = Rectangle::new(-10, 10);
     }
@@ -44,7 +43,6 @@ mod tests {
     // TODO: This test should check if the program panics when we try to create
     // a rectangle with negative height.
     #[test]
-    #[should_panic]
     fn negative_height() {
         let _rect = Rectangle::new(10, -10);
     }

exercises/18_iterators/iterators1.rs

@@ -13,13 +13,13 @@ mod tests {
         let my_fav_fruits = &["banana", "custard apple", "avocado", "peach", "raspberry"];
 
         // TODO: Create an iterator over the slice.
-        let mut fav_fruits_iterator = my_fav_fruits.iter();
+        let mut fav_fruits_iterator = todo!();
 
         assert_eq!(fav_fruits_iterator.next(), Some(&"banana"));
-        assert_eq!(fav_fruits_iterator.next(), Some(&"custard apple")); // TODO: Replace `todo!()`
+        assert_eq!(fav_fruits_iterator.next(), todo!()); // TODO: Replace `todo!()`
         assert_eq!(fav_fruits_iterator.next(), Some(&"avocado"));
-        assert_eq!(fav_fruits_iterator.next(), Some(&"peach")); // TODO: Replace `todo!()`
+        assert_eq!(fav_fruits_iterator.next(), todo!()); // TODO: Replace `todo!()`
         assert_eq!(fav_fruits_iterator.next(), Some(&"raspberry"));
-        assert_eq!(fav_fruits_iterator.next(), None); // TODO: Replace `todo!()`
+        assert_eq!(fav_fruits_iterator.next(), todo!()); // TODO: Replace `todo!()`
     }
 }

exercises/18_iterators/iterators2.rs

@@ -1,15 +1,13 @@
 // In this exercise, you'll learn some of the unique advantages that iterators
 // can offer.
 
-// I failed.
-
 // TODO: Complete the `capitalize_first` function.
 // "hello" -> "Hello"
 fn capitalize_first(input: &str) -> String {
     let mut chars = input.chars();
     match chars.next() {
         None => String::new(),
-        Some(first) => first.to_uppercase().to_string() + chars.as_str(),
+        Some(first) => todo!(),
     }
 }
 
@@ -18,7 +16,6 @@ fn capitalize_first(input: &str) -> String {
 // ["hello", "world"] -> ["Hello", "World"]
 fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
     // ???
-    words.iter().map(|word| capitalize_first(word)).collect()
 }
 
 // TODO: Apply the `capitalize_first` function again to a slice of string
@@ -26,7 +23,6 @@ fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
 // ["hello", " ", "world"] -> "Hello World"
 fn capitalize_words_string(words: &[&str]) -> String {
     // ???
-    words.iter().map(|word| capitalize_first(word)).collect()
 }
 
 fn main() {

exercises/18_iterators/iterators3.rs

@@ -11,31 +11,21 @@ enum DivisionError {
 // TODO: Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
 // Otherwise, return a suitable error.
 fn divide(a: i64, b: i64) -> Result<i64, DivisionError> {
-    if b == 0 {
+    todo!();
-        Err(DivisionError::DivideByZero)
-    } else if b == -1 && a == i64::MIN {
-        Err(DivisionError::IntegerOverflow)
-    } else if a % b == 0 {
-        Ok(a / b)
-    } else {
-        Err(DivisionError::NotDivisible)
-    }
 }
 
 // TODO: Add the correct return type and complete the function body.
 // Desired output: `Ok([1, 11, 1426, 3])`
-fn result_with_list() -> Result<Vec<i64>, DivisionError> {
+fn result_with_list() {
     let numbers = [27, 297, 38502, 81];
     let division_results = numbers.into_iter().map(|n| divide(n, 27));
-    division_results.collect()
 }
 
 // TODO: Add the correct return type and complete the function body.
 // Desired output: `[Ok(1), Ok(11), Ok(1426), Ok(3)]`
-fn list_of_results() -> Vec<Result<i64, DivisionError>> {
+fn list_of_results() {
     let numbers = [27, 297, 38502, 81];
     let division_results = numbers.into_iter().map(|n| divide(n, 27));
-    division_results.collect()
 }
 
 fn main() {

exercises/18_iterators/iterators4.rs

@@ -10,8 +10,6 @@ fn factorial(num: u64) -> u64 {
     // - additional variables
     // For an extra challenge, don't use:
     // - recursion
-
-    (1..=num).product()
 }
 
 fn main() {

exercises/quizzes/quiz1.rs

@@ -11,18 +11,6 @@
 // TODO: Write a function that calculates the price of an order of apples given
 // the quantity bought.
 // fn calculate_price_of_apples(???) -> ??? { ??? }
-fn calculate_price_of_apples(apples: i32) -> i32 {
-    let mut cost: i32 = 2;
-
-    if apples > 40 {
-        cost = 1;
-        cost *= apples;
-        cost
-    } else {
-        cost *= apples;
-        cost
-    }
-}
 
 fn main() {
     // You can optionally experiment here.

exercises/quizzes/quiz2.rs

@@ -28,25 +28,6 @@ mod my_module {
 
     // TODO: Complete the function as described above.
     // pub fn transformer(input: ???) -> ??? { ??? }
-
-    pub fn transformer(input: Vec<(String, Command)>) -> Vec<String> {
-        let mut output = Vec::new();
-        for (s, cmd) in input {
-            let transformed = match cmd {
-                Command::Uppercase => s.to_uppercase(),
-                Command::Trim => s.trim().to_owned(),
-                Command::Append(n) => {
-                    let mut out = s;
-                    for _ in 0..n {
-                        out.push_str("bar");
-                    }
-                    out
-                }
-            };
-            output.push(transformed)
-        }
-        output
-    }
 }
 
 fn main() {
@@ -58,7 +39,6 @@ mod tests {
     // TODO: What do we need to import to have `transformer` in scope?
     // use ???;
     use super::Command;
-    use crate::my_module::transformer;
 
     #[test]
     fn it_works() {

exercises/quizzes/quiz3.rs

@@ -12,18 +12,18 @@
 // block to support alphabetical report cards in addition to numerical ones.
 
 // TODO: Adjust the struct as described above.
-struct ReportCard<T> {
+struct ReportCard {
-    grade: T,
+    grade: f32,
     student_name: String,
     student_age: u8,
 }
 
 // TODO: Adjust the impl block as described above.
-impl<T: std::fmt::Display> ReportCard<T> {
+impl ReportCard {
     fn print(&self) -> String {
         format!(
             "{} ({}) - achieved a grade of {}",
-            self.student_name, self.student_age, self.grade,
+            &self.student_name, &self.student_age, &self.grade,
         )
     }
 }