d2

.rustlings-state.txt

@@ -1,6 +1,6 @@
 DON'T EDIT THIS FILE!
 
-move_semantics5
+errors4
 
 intro1
 intro2
@@ -30,4 +30,28 @@ vecs2
 move_semantics1
 move_semantics2
 move_semantics3
-move_semantics4
+move_semantics4
+move_semantics5
+structs1
+structs2
+structs3
+enums1
+enums2
+enums3
+strings1
+strings2
+strings3
+strings4
+modules1
+modules2
+modules3
+hashmaps1
+hashmaps2
+hashmaps3
+quiz2
+options1
+options2
+options3
+errors1
+errors2
+errors3

exercises/07_structs/structs1.rs

@@ -1,9 +1,13 @@
 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: u64,
+    green: u64,
+    blue: u64,
 }
 
-struct ColorTupleStruct(/* TODO: Add the fields that the test `tuple_structs` expects */);
+// struct ColorTupleStruct(/* TODO: Add the fields that the test `tuple_structs` expects */);
+struct ColorTupleStruct(i32, i32, i32);
 
 #[derive(Debug)]
 struct UnitStruct;
@@ -19,7 +23,11 @@ mod tests {
     #[test]
     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);
@@ -29,7 +37,7 @@ mod tests {
     #[test]
     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);
@@ -39,7 +47,7 @@ mod tests {
     #[test]
     fn unit_structs() {
         // TODO: Instantiate a unit struct.
-        // let unit_struct =
+        let unit_struct = UnitStruct;
         let message = format!("{unit_struct:?}s are fun!");
 
         assert_eq!(message, "UnitStructs are fun!");

exercises/07_structs/structs2.rs

@@ -34,7 +34,11 @@ mod tests {
         let order_template = create_order_template();
 
         // TODO: Create your own order using the update syntax and template above!
-        // let your_order =
+        let your_order = Order {
+            name: String::from("Hacker in Rust"),
+            count: 1,
+            ..order_template
+        };
 
         assert_eq!(your_order.name, "Hacker in Rust");
         assert_eq!(your_order.year, order_template.year);

exercises/07_structs/structs3.rs

@@ -24,14 +24,16 @@ impl Package {
     }
 
     // TODO: Add the correct return type to the function signature.
-    fn is_international(&self) {
+    fn is_international(&self) -> bool {
         // TODO: Read the tests that use this method to find out when a package
         // is considered international.
+        self.recipient_country != self.sender_country
     }
 
     // TODO: Add the correct return type to the function signature.
-    fn get_fees(&self, cents_per_gram: u32) {
+    fn get_fees(&self, cents_per_gram: u32) -> u32 {
         // TODO: Calculate the package's fees.
+        self.weight_in_grams * cents_per_gram
     }
 }
 

exercises/08_enums/enums1.rs

@@ -1,6 +1,11 @@
 #[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,6 +7,11 @@ struct Point {
 #[derive(Debug)]
 enum Message {
     // TODO: Define the different variants used below.
+    Resize { width: u32, height: u32 },
+    Move(Point),
+    Echo(String),
+    ChangeColor(u8, u8, u8),
+    Quit,
 }
 
 impl Message {

exercises/08_enums/enums3.rs

@@ -46,6 +46,14 @@ 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(p) => self.move_position(p),
+            Message::Echo(msg) => self.echo(msg),
+            Message::ChangeColor(r, g, b) => self.change_color(r, g, b),
+            Message::Quit => self.quit(),
+            _ => println!("JSR"),
+        }
     }
 }
 

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"
+    String::from("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,13 +1,16 @@
 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.
+    String::from(input) + " world!"
 }
 
 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,25 +13,25 @@ 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() {
-    placeholder("blue");
+    string_slice("blue");
 
-    placeholder("red".to_string());
+    string("red".to_string());
 
-    placeholder(String::from("hi"));
+    string(String::from("hi"));
 
-    placeholder("rust is fun!".to_owned());
+    string("rust is fun!".to_owned());
 
-    placeholder("nice weather".into());
+    string_slice("nice weather".into());
 
-    placeholder(format!("Interpolation {}", "Station"));
+    string(format!("Interpolation {}", "Station"));
 
     // WARNING: This is byte indexing, not character indexing.
     // Character indexing can be done using `s.chars().nth(INDEX)`.
-    placeholder(&String::from("abc")[0..1]);
+    string_slice(&String::from("abc")[0..1]);
 
-    placeholder("  hello there ".trim());
+    string_slice("  hello there ".trim());
 
-    placeholder("Happy Monday!".replace("Mon", "Tues"));
+    string("Happy Monday!".replace("Mon", "Tues"));
 
-    placeholder("mY sHiFt KeY iS sTiCkY".to_lowercase());
+    string("mY sHiFt KeY iS sTiCkY".to_lowercase());
 }

exercises/10_modules/modules1.rs

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

exercises/10_modules/modules2.rs

@@ -3,8 +3,8 @@
 
 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

@@ -3,7 +3,8 @@
 
 // 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

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

exercises/11_hashmaps/hashmaps2.rs

@@ -32,6 +32,7 @@ fn fruit_basket(basket: &mut HashMap<Fruit, u32>) {
         // 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.entry(fruit).or_insert(4);
     }
 }
 

exercises/11_hashmaps/hashmaps3.rs

@@ -31,6 +31,27 @@ fn build_scores_table(results: &str) -> HashMap<&str, TeamScores> {
         // 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
         // number of goals conceded by team 1.
+
+        scores
+            .entry(team_1_name)
+            .and_modify(|e| {
+                e.goals_conceded += team_2_score;
+                e.goals_scored += team_1_score;
+            })
+            .or_insert(TeamScores {
+                goals_scored: team_1_score,
+                goals_conceded: team_2_score,
+            });
+        scores
+            .entry(team_2_name)
+            .and_modify(|e| {
+                e.goals_conceded += team_1_score;
+                e.goals_scored += team_2_score;
+            })
+            .or_insert(TeamScores {
+                goals_scored: team_2_score,
+                goals_conceded: team_1_score,
+            });
     }
 
     scores

exercises/12_options/options1.rs

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

exercises/12_options/options2.rs

@@ -10,7 +10,10 @@ 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);
+        // }
+        if let Some(word) = optional_target {
             assert_eq!(word, target);
         }
     }
@@ -29,8 +32,9 @@ 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() {
+        while let Some(Some(integer)) = optional_integers.pop() {
             assert_eq!(integer, cursor);
+            println!("JSR");
             cursor -= 1;
         }
 

exercises/12_options/options3.rs

@@ -9,7 +9,7 @@ fn main() {
 
     // TODO: Fix the compiler error by adding something to this match statement.
     match optional_point {
-        Some(p) => println!("Co-ordinates are {},{}", p.x, p.y),
+        Some(ref p) => println!("Co-ordinates 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) -> Option<String> {
+fn generate_nametag_text(name: String) -> Result<String, String> {
     if name.is_empty() {
         // Empty names aren't allowed
-        None
+        Err("Empty names aren't allowed".to_string())
     } else {
-        Some(format!("Hi! My name is {name}"))
+        Ok(format!("Hi! My name is {name}"))
     }
 }
 

exercises/13_error_handling/errors2.rs

@@ -21,7 +21,16 @@ 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>();
+
+    // Added `?` to propagate the error.
+    // let qty = item_quantity.parse::<i32>()?;
+    //                                    ^ added
+
+    // Equivalent to this verbose version:
+    let qty = match item_quantity.parse::<i32>() {
+        Ok(v) => v,
+        Err(e) => return Err(e),
+    };
 
     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() {
+fn main() -> Result<(), ParseIntError> {
     let mut tokens = 100;
     let pretend_user_input = "8";
 
@@ -28,4 +28,5 @@ fn main() {
         tokens -= cost;
         println!("You now have {tokens} tokens.");
     }
+    Ok(())
 }

exercises/quizzes/quiz2.rs

@@ -28,6 +28,25 @@ 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<String> = vec![];
+        for mut elem in input {
+            let updated_element: String = match elem.1 {
+                Command::Trim => elem.0.trim().to_string(),
+                Command::Uppercase => elem.0.to_uppercase(),
+                Command::Append(n) => {
+                    let mut count = n;
+                    while count != 0 {
+                        elem.0 += "bar";
+                        count -= 1;
+                    }
+                    elem.0
+                }
+            };
+            output.push(updated_element);
+        }
+        output
+    }
 }
 
 fn main() {
@@ -37,7 +56,7 @@ fn main() {
 #[cfg(test)]
 mod tests {
     // TODO: What do we need to import to have `transformer` in scope?
-    // use ???;
+    use super::my_module::transformer;
     use super::Command;
 
     #[test]

solutions/07_structs/structs1.rs

@@ -1,4 +1,49 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+struct ColorRegularStruct {
+    red: u8,
+    green: u8,
+    blue: u8,
+}
+
+struct ColorTupleStruct(u8, u8, u8);
+
+#[derive(Debug)]
+struct UnitStruct;
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn regular_structs() {
+        let green = ColorRegularStruct {
+            red: 0,
+            green: 255,
+            blue: 0,
+        };
+
+        assert_eq!(green.red, 0);
+        assert_eq!(green.green, 255);
+        assert_eq!(green.blue, 0);
+    }
+
+    #[test]
+    fn tuple_structs() {
+        let green = ColorTupleStruct(0, 255, 0);
+
+        assert_eq!(green.0, 0);
+        assert_eq!(green.1, 255);
+        assert_eq!(green.2, 0);
+    }
+
+    #[test]
+    fn unit_structs() {
+        let unit_struct = UnitStruct;
+        let message = format!("{unit_struct:?}s are fun!");
+
+        assert_eq!(message, "UnitStructs are fun!");
+    }
 }

solutions/07_structs/structs2.rs

@@ -1,4 +1,51 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+#[derive(Debug)]
+struct Order {
+    name: String,
+    year: u32,
+    made_by_phone: bool,
+    made_by_mobile: bool,
+    made_by_email: bool,
+    item_number: u32,
+    count: u32,
+}
+
+fn create_order_template() -> Order {
+    Order {
+        name: String::from("Bob"),
+        year: 2019,
+        made_by_phone: false,
+        made_by_mobile: false,
+        made_by_email: true,
+        item_number: 123,
+        count: 0,
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn your_order() {
+        let order_template = create_order_template();
+
+        let your_order = Order {
+            name: String::from("Hacker in Rust"),
+            count: 1,
+            // Struct update syntax
+            ..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);
+        assert_eq!(your_order.made_by_mobile, order_template.made_by_mobile);
+        assert_eq!(your_order.made_by_email, order_template.made_by_email);
+        assert_eq!(your_order.item_number, order_template.item_number);
+        assert_eq!(your_order.count, 1);
+    }
 }

solutions/07_structs/structs3.rs

@@ -1,4 +1,83 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+#[derive(Debug)]
+struct Package {
+    sender_country: String,
+    recipient_country: String,
+    weight_in_grams: u32,
+}
+
+impl Package {
+    fn new(sender_country: String, recipient_country: String, weight_in_grams: u32) -> Self {
+        if weight_in_grams < 10 {
+            // This isn't how you should handle errors in Rust, but we will
+            // learn about error handling later.
+            panic!("Can't ship a package with weight below 10 grams");
+        }
+
+        Self {
+            sender_country,
+            recipient_country,
+            weight_in_grams,
+        }
+    }
+
+    fn is_international(&self) -> bool {
+        //                     ^^^^^^^ added
+        self.sender_country != self.recipient_country
+    }
+
+    fn get_fees(&self, cents_per_gram: u32) -> u32 {
+        //                                  ^^^^^^ added
+        self.weight_in_grams * cents_per_gram
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn fail_creating_weightless_package() {
+        let sender_country = String::from("Spain");
+        let recipient_country = String::from("Austria");
+
+        Package::new(sender_country, recipient_country, 5);
+    }
+
+    #[test]
+    fn create_international_package() {
+        let sender_country = String::from("Spain");
+        let recipient_country = String::from("Russia");
+
+        let package = Package::new(sender_country, recipient_country, 1200);
+
+        assert!(package.is_international());
+    }
+
+    #[test]
+    fn create_local_package() {
+        let sender_country = String::from("Canada");
+        let recipient_country = sender_country.clone();
+
+        let package = Package::new(sender_country, recipient_country, 1200);
+
+        assert!(!package.is_international());
+    }
+
+    #[test]
+    fn calculate_transport_fees() {
+        let sender_country = String::from("Spain");
+        let recipient_country = String::from("Spain");
+
+        let cents_per_gram = 3;
+
+        let package = Package::new(sender_country, recipient_country, 1500);
+
+        assert_eq!(package.get_fees(cents_per_gram), 4500);
+        assert_eq!(package.get_fees(cents_per_gram * 2), 9000);
+    }
 }

solutions/08_enums/enums1.rs

@@ -1,4 +1,16 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+#[derive(Debug)]
+enum Message {
+    Resize,
+    Move,
+    Echo,
+    ChangeColor,
+    Quit,
+}
+
+fn main() {
+    println!("{:?}", Message::Resize);
+    println!("{:?}", Message::Move);
+    println!("{:?}", Message::Echo);
+    println!("{:?}", Message::ChangeColor);
+    println!("{:?}", Message::Quit);
 }

solutions/08_enums/enums2.rs

@@ -1,4 +1,37 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+#[derive(Debug)]
+struct Point {
+    x: u64,
+    y: u64,
+}
+
+#[derive(Debug)]
+enum Message {
+    Resize { width: u64, height: u64 },
+    Move(Point),
+    Echo(String),
+    ChangeColor(u8, u8, u8),
+    Quit,
+}
+
+impl Message {
+    fn call(&self) {
+        println!("{self:?}");
+    }
+}
+
+fn main() {
+    let messages = [
+        Message::Resize {
+            width: 10,
+            height: 30,
+        },
+        Message::Move(Point { x: 10, y: 15 }),
+        Message::Echo(String::from("hello world")),
+        Message::ChangeColor(200, 255, 255),
+        Message::Quit,
+    ];
+
+    for message in &messages {
+        message.call();
+    }
 }

solutions/08_enums/enums3.rs

@@ -1,4 +1,92 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+struct Point {
+    x: u64,
+    y: u64,
+}
+
+enum Message {
+    Resize { width: u64, height: u64 },
+    Move(Point),
+    Echo(String),
+    ChangeColor(u8, u8, u8),
+    Quit,
+}
+
+struct State {
+    width: u64,
+    height: u64,
+    position: Point,
+    message: String,
+    color: (u8, u8, u8),
+    quit: bool,
+}
+
+impl State {
+    fn resize(&mut self, width: u64, height: u64) {
+        self.width = width;
+        self.height = height;
+    }
+
+    fn move_position(&mut self, point: Point) {
+        self.position = point;
+    }
+
+    fn echo(&mut self, s: String) {
+        self.message = s;
+    }
+
+    fn change_color(&mut self, red: u8, green: u8, blue: u8) {
+        self.color = (red, green, blue);
+    }
+
+    fn quit(&mut self) {
+        self.quit = true;
+    }
+
+    fn process(&mut self, message: Message) {
+        match message {
+            Message::Resize { width, height } => self.resize(width, height),
+            Message::Move(point) => self.move_position(point),
+            Message::Echo(string) => self.echo(string),
+            Message::ChangeColor(red, green, blue) => self.change_color(red, green, blue),
+            Message::Quit => self.quit(),
+        }
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_match_message_call() {
+        let mut state = State {
+            width: 0,
+            height: 0,
+            position: Point { x: 0, y: 0 },
+            message: String::from("hello world"),
+            color: (0, 0, 0),
+            quit: false,
+        };
+
+        state.process(Message::Resize {
+            width: 10,
+            height: 30,
+        });
+        state.process(Message::Move(Point { x: 10, y: 15 }));
+        state.process(Message::Echo(String::from("Hello world!")));
+        state.process(Message::ChangeColor(255, 0, 255));
+        state.process(Message::Quit);
+
+        assert_eq!(state.width, 10);
+        assert_eq!(state.height, 30);
+        assert_eq!(state.position.x, 10);
+        assert_eq!(state.position.y, 15);
+        assert_eq!(state.message, "Hello world!");
+        assert_eq!(state.color, (255, 0, 255));
+        assert!(state.quit);
+    }
 }

solutions/09_strings/strings1.rs

@@ -1,4 +1,9 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+fn current_favorite_color() -> String {
+    // Equivalent to `String::from("blue")`
+    "blue".to_string()
+}
+
+fn main() {
+    let answer = current_favorite_color();
+    println!("My current favorite color is {answer}");
 }

solutions/09_strings/strings2.rs

@@ -1,4 +1,15 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+fn is_a_color_word(attempt: &str) -> bool {
+    attempt == "green" || attempt == "blue" || attempt == "red"
+}
+
+fn main() {
+    let word = String::from("green");
+
+    if is_a_color_word(&word) {
+        //             ^ added to have `&String` which is automatically
+        //               coerced to `&str` by the compiler.
+        println!("That is a color word I know!");
+    } else {
+        println!("That is not a color word I know.");
+    }
 }

solutions/09_strings/strings3.rs

@@ -1,4 +1,48 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+fn trim_me(input: &str) -> &str {
+    input.trim()
+}
+
+fn compose_me(input: &str) -> String {
+    // The macro `format!` has the same syntax as `println!`, but it returns a
+    // string instead of printing it to the terminal.
+    // Equivalent to `input.to_string() + " world!"`
+    format!("{input} world!")
+}
+
+fn replace_me(input: &str) -> String {
+    input.replace("cars", "balloons")
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn trim_a_string() {
+        assert_eq!(trim_me("Hello!     "), "Hello!");
+        assert_eq!(trim_me("  What's up!"), "What's up!");
+        assert_eq!(trim_me("   Hola!  "), "Hola!");
+    }
+
+    #[test]
+    fn compose_a_string() {
+        assert_eq!(compose_me("Hello"), "Hello world!");
+        assert_eq!(compose_me("Goodbye"), "Goodbye world!");
+    }
+
+    #[test]
+    fn replace_a_string() {
+        assert_eq!(
+            replace_me("I think cars are cool"),
+            "I think balloons are cool",
+        );
+        assert_eq!(
+            replace_me("I love to look at cars"),
+            "I love to look at balloons",
+        );
+    }
 }

solutions/09_strings/strings4.rs

@@ -1,4 +1,38 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+fn string_slice(arg: &str) {
+    println!("{arg}");
+}
+
+fn string(arg: String) {
+    println!("{arg}");
+}
+
+fn main() {
+    string_slice("blue");
+
+    string("red".to_string());
+
+    string(String::from("hi"));
+
+    string("rust is fun!".to_owned());
+
+    // Here, both answers work.
+    // `.into()` converts a type into an expected type.
+    // If it is called where `String` is expected, it will convert `&str` to `String`.
+    string("nice weather".into());
+    // But if it is called where `&str` is expected, then `&str` is kept `&str` since no conversion is needed.
+    // If you remove the `#[allow(…)]` line, then Clippy will tell you to remove `.into()` below since it is a useless conversion.
+    #[allow(clippy::useless_conversion)]
+    string_slice("nice weather".into());
+
+    string(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]);
+
+    string_slice("  hello there ".trim());
+
+    string("Happy Monday!".replace("Mon", "Tues"));
+
+    string("mY sHiFt KeY iS sTiCkY".to_lowercase());
 }

solutions/10_modules/modules1.rs

@@ -1,4 +1,15 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+mod sausage_factory {
+    fn get_secret_recipe() -> String {
+        String::from("Ginger")
+    }
+
+    // Added `pub` before `fn` to make the function accessible outside the module.
+    pub fn make_sausage() {
+        get_secret_recipe();
+        println!("sausage!");
+    }
+}
+
+fn main() {
+    sausage_factory::make_sausage();
 }

solutions/10_modules/modules2.rs

@@ -1,4 +1,23 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+mod delicious_snacks {
+    // Added `pub` and used the expected alias after `as`.
+    pub use self::fruits::PEAR as fruit;
+    pub use self::veggies::CUCUMBER as veggie;
+
+    mod fruits {
+        pub const PEAR: &str = "Pear";
+        pub const APPLE: &str = "Apple";
+    }
+
+    mod veggies {
+        pub const CUCUMBER: &str = "Cucumber";
+        pub const CARROT: &str = "Carrot";
+    }
+}
+
+fn main() {
+    println!(
+        "favorite snacks: {} and {}",
+        delicious_snacks::fruit,
+        delicious_snacks::veggie,
+    );
 }

solutions/10_modules/modules3.rs

@@ -1,4 +1,8 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    match SystemTime::now().duration_since(UNIX_EPOCH) {
+        Ok(n) => println!("1970-01-01 00:00:00 UTC was {} seconds ago!", n.as_secs()),
+        Err(_) => panic!("SystemTime before UNIX EPOCH!"),
+    }
 }

solutions/11_hashmaps/hashmaps1.rs

@@ -1,4 +1,42 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+// A basket of fruits in the form of a hash map needs to be defined. The key
+// represents the name of the fruit and the value represents how many of that
+// particular fruit is in the basket. You have to put at least 3 different
+// types of fruits (e.g apple, banana, mango) in the basket and the total count
+// of all the fruits should be at least 5.
+
+use std::collections::HashMap;
+
+fn fruit_basket() -> HashMap<String, u32> {
+    // Declare the hash map.
+    let mut basket = HashMap::new();
+
+    // Two bananas are already given for you :)
+    basket.insert(String::from("banana"), 2);
+
+    // Put more fruits in your basket.
+    basket.insert(String::from("apple"), 3);
+    basket.insert(String::from("mango"), 1);
+
+    basket
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn at_least_three_types_of_fruits() {
+        let basket = fruit_basket();
+        assert!(basket.len() >= 3);
+    }
+
+    #[test]
+    fn at_least_five_fruits() {
+        let basket = fruit_basket();
+        assert!(basket.values().sum::<u32>() >= 5);
+    }
 }

solutions/11_hashmaps/hashmaps2.rs

@@ -1,4 +1,96 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+// We're collecting different fruits to bake a delicious fruit cake. For this,
+// we have a basket, which we'll represent in the form of a hash map. The key
+// represents the name of each fruit we collect and the value represents how
+// many of that particular fruit we have collected. Three types of fruits -
+// Apple (4), Mango (2) and Lychee (5) are already in the basket hash map. You
+// must add fruit to the basket so that there is at least one of each kind and
+// more than 11 in total - we have a lot of mouths to feed. You are not allowed
+// to insert any more of the fruits that are already in the basket (Apple,
+// Mango, and Lychee).
+
+use std::collections::HashMap;
+
+#[derive(Hash, PartialEq, Eq, Debug)]
+enum Fruit {
+    Apple,
+    Banana,
+    Mango,
+    Lychee,
+    Pineapple,
+}
+
+fn fruit_basket(basket: &mut HashMap<Fruit, u32>) {
+    let fruit_kinds = [
+        Fruit::Apple,
+        Fruit::Banana,
+        Fruit::Mango,
+        Fruit::Lychee,
+        Fruit::Pineapple,
+    ];
+
+    for fruit in fruit_kinds {
+        // If fruit doesn't exist, insert it with some value.
+        basket.entry(fruit).or_insert(5);
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Don't modify this function!
+    fn get_fruit_basket() -> HashMap<Fruit, u32> {
+        let content = [(Fruit::Apple, 4), (Fruit::Mango, 2), (Fruit::Lychee, 5)];
+        HashMap::from_iter(content)
+    }
+
+    #[test]
+    fn test_given_fruits_are_not_modified() {
+        let mut basket = get_fruit_basket();
+        fruit_basket(&mut basket);
+        assert_eq!(*basket.get(&Fruit::Apple).unwrap(), 4);
+        assert_eq!(*basket.get(&Fruit::Mango).unwrap(), 2);
+        assert_eq!(*basket.get(&Fruit::Lychee).unwrap(), 5);
+    }
+
+    #[test]
+    fn at_least_five_types_of_fruits() {
+        let mut basket = get_fruit_basket();
+        fruit_basket(&mut basket);
+        let count_fruit_kinds = basket.len();
+        assert!(count_fruit_kinds >= 5);
+    }
+
+    #[test]
+    fn greater_than_eleven_fruits() {
+        let mut basket = get_fruit_basket();
+        fruit_basket(&mut basket);
+        let count = basket.values().sum::<u32>();
+        assert!(count > 11);
+    }
+
+    #[test]
+    fn all_fruit_types_in_basket() {
+        let fruit_kinds = [
+            Fruit::Apple,
+            Fruit::Banana,
+            Fruit::Mango,
+            Fruit::Lychee,
+            Fruit::Pineapple,
+        ];
+
+        let mut basket = get_fruit_basket();
+        fruit_basket(&mut basket);
+
+        for fruit_kind in fruit_kinds {
+            let Some(amount) = basket.get(&fruit_kind) else {
+                panic!("Fruit kind {fruit_kind:?} was not found in basket");
+            };
+            assert!(*amount > 0);
+        }
+    }
 }

solutions/11_hashmaps/hashmaps3.rs

@@ -1,4 +1,83 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+// A list of scores (one per line) of a soccer match is given. Each line is of
+// the form "<team_1_name>,<team_2_name>,<team_1_goals>,<team_2_goals>"
+// Example: "England,France,4,2" (England scored 4 goals, France 2).
+//
+// You have to build a scores table containing the name of the team, the total
+// number of goals the team scored, and the total number of goals the team
+// conceded.
+
+use std::collections::HashMap;
+
+// A structure to store the goal details of a team.
+#[derive(Default)]
+struct TeamScores {
+    goals_scored: u8,
+    goals_conceded: u8,
+}
+
+fn build_scores_table(results: &str) -> HashMap<&str, TeamScores> {
+    // The name of the team is the key and its associated struct is the value.
+    let mut scores = HashMap::<&str, TeamScores>::new();
+
+    for line in results.lines() {
+        let mut split_iterator = line.split(',');
+        // NOTE: We use `unwrap` because we didn't deal with error handling yet.
+        let team_1_name = split_iterator.next().unwrap();
+        let team_2_name = split_iterator.next().unwrap();
+        let team_1_score: u8 = split_iterator.next().unwrap().parse().unwrap();
+        let team_2_score: u8 = split_iterator.next().unwrap().parse().unwrap();
+
+        // Insert the default with zeros if a team doesn't exist yet.
+        let team_1 = scores.entry(team_1_name).or_default();
+        // Update the values.
+        team_1.goals_scored += team_1_score;
+        team_1.goals_conceded += team_2_score;
+
+        // Similarly for the second team.
+        let team_2 = scores.entry(team_2_name).or_default();
+        team_2.goals_scored += team_2_score;
+        team_2.goals_conceded += team_1_score;
+    }
+
+    scores
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const RESULTS: &str = "England,France,4,2
+France,Italy,3,1
+Poland,Spain,2,0
+Germany,England,2,1
+England,Spain,1,0";
+
+    #[test]
+    fn build_scores() {
+        let scores = build_scores_table(RESULTS);
+
+        assert!(["England", "France", "Germany", "Italy", "Poland", "Spain"]
+            .into_iter()
+            .all(|team_name| scores.contains_key(team_name)));
+    }
+
+    #[test]
+    fn validate_team_score_1() {
+        let scores = build_scores_table(RESULTS);
+        let team = scores.get("England").unwrap();
+        assert_eq!(team.goals_scored, 6);
+        assert_eq!(team.goals_conceded, 4);
+    }
+
+    #[test]
+    fn validate_team_score_2() {
+        let scores = build_scores_table(RESULTS);
+        let team = scores.get("Spain").unwrap();
+        assert_eq!(team.goals_scored, 0);
+        assert_eq!(team.goals_conceded, 3);
+    }
 }

solutions/12_options/options1.rs

@@ -1,4 +1,39 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+// This function returns how much icecream there is left in the fridge.
+// If it's before 22:00 (24-hour system), then 5 scoops are left. At 22:00,
+// someone eats it all, so no icecream is left (value 0). Return `None` if
+// `hour_of_day` is higher than 23.
+fn maybe_icecream(hour_of_day: u16) -> Option<u16> {
+    match hour_of_day {
+        0..=21 => Some(5),
+        22..=23 => Some(0),
+        _ => None,
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn raw_value() {
+        // Using `unwrap` is fine in a test.
+        let icecreams = maybe_icecream(12).unwrap();
+
+        assert_eq!(icecreams, 5);
+    }
+
+    #[test]
+    fn check_icecream() {
+        assert_eq!(maybe_icecream(0), Some(5));
+        assert_eq!(maybe_icecream(9), Some(5));
+        assert_eq!(maybe_icecream(18), Some(5));
+        assert_eq!(maybe_icecream(22), Some(0));
+        assert_eq!(maybe_icecream(23), Some(0));
+        assert_eq!(maybe_icecream(24), None);
+        assert_eq!(maybe_icecream(25), None);
+    }
 }

solutions/12_options/options2.rs

@@ -1,4 +1,37 @@
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn simple_option() {
+        let target = "rustlings";
+        let optional_target = Some(target);
+
+        // if-let
+        if let Some(word) = optional_target {
+            assert_eq!(word, target);
+        }
+    }
+
+    #[test]
+    fn layered_option() {
+        let range = 10;
+        let mut optional_integers: Vec<Option<i8>> = vec![None];
+
+        for i in 1..=range {
+            optional_integers.push(Some(i));
+        }
+
+        let mut cursor = range;
+
+        // while-let with nested pattern matching
+        while let Some(Some(integer)) = optional_integers.pop() {
+            assert_eq!(integer, cursor);
+            cursor -= 1;
+        }
+
+        assert_eq!(cursor, 0);
+    }
 }

solutions/12_options/options3.rs

@@ -1,4 +1,26 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+#[derive(Debug)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {
+    let optional_point = Some(Point { x: 100, y: 200 });
+
+    // Solution 1: Matching over the `Option` (not `&Option`) but without moving
+    // out of the `Some` variant.
+    match optional_point {
+        Some(ref p) => println!("Co-ordinates are {},{}", p.x, p.y),
+        //   ^^^ added
+        _ => panic!("No match!"),
+    }
+
+    // Solution 2: Matching over a reference (`&Option`) by added `&` before
+    // `optional_point`.
+    match &optional_point {
+        Some(p) => println!("Co-ordinates are {},{}", p.x, p.y),
+        _ => panic!("No match!"),
+    }
+
+    println!("{optional_point:?}");
 }

solutions/13_error_handling/errors1.rs

@@ -1,4 +1,37 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+fn generate_nametag_text(name: String) -> Result<String, String> {
+    //                                    ^^^^^^         ^^^^^^
+    if name.is_empty() {
+        // `Err(String)` instead of `None`.
+        Err("Empty names aren't allowed".to_string())
+    } else {
+        // `Ok` instead of `Some`.
+        Ok(format!("Hi! My name is {name}"))
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn generates_nametag_text_for_a_nonempty_name() {
+        assert_eq!(
+            generate_nametag_text("Beyoncé".to_string()).as_deref(),
+            Ok("Hi! My name is Beyoncé"),
+        );
+    }
+
+    #[test]
+    fn explains_why_generating_nametag_text_fails() {
+        assert_eq!(
+            generate_nametag_text(String::new())
+                .as_ref()
+                .map_err(|e| e.as_str()),
+            Err("Empty names aren't allowed"),
+        );
+    }
 }

solutions/13_error_handling/errors2.rs

@@ -1,4 +1,58 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+// Say we're writing a game where you can buy items with tokens. All items cost
+// 5 tokens, and whenever you purchase items there is a processing fee of 1
+// token. A player of the game will type in how many items they want to buy, and
+// the `total_cost` function will calculate the total cost of the items. Since
+// the player typed in the quantity, we get it as a string. They might have
+// typed anything, not just numbers!
+//
+// Right now, this function isn't handling the error case at all. What we want
+// to do is: If we call the `total_cost` function on a string that is not a
+// number, that function will return a `ParseIntError`. In that case, we want to
+// immediately return that error from our function and not try to multiply and
+// add.
+//
+// There are at least two ways to implement this that are both correct. But one
+// is a lot shorter!
+
+use std::num::ParseIntError;
+
+#[allow(unused_variables)]
+fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
+    let processing_fee = 1;
+    let cost_per_item = 5;
+
+    // Added `?` to propagate the error.
+    let qty = item_quantity.parse::<i32>()?;
+    //                                    ^ added
+
+    // Equivalent to this verbose version:
+    let qty = match item_quantity.parse::<i32>() {
+        Ok(v) => v,
+        Err(e) => return Err(e),
+    };
+
+    Ok(qty * cost_per_item + processing_fee)
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::num::IntErrorKind;
+
+    #[test]
+    fn item_quantity_is_a_valid_number() {
+        assert_eq!(total_cost("34"), Ok(171));
+    }
+
+    #[test]
+    fn item_quantity_is_an_invalid_number() {
+        assert_eq!(
+            total_cost("beep boop").unwrap_err().kind(),
+            &IntErrorKind::InvalidDigit,
+        );
+    }
 }

solutions/13_error_handling/errors3.rs

@@ -1,4 +1,32 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+// This is a program that is trying to use a completed version of the
+// `total_cost` function from the previous exercise. It's not working though!
+// Why not? What should we do to fix it?
+
+use std::num::ParseIntError;
+
+// Don't change this function.
+fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
+    let processing_fee = 1;
+    let cost_per_item = 5;
+    let qty = item_quantity.parse::<i32>()?;
+
+    Ok(qty * cost_per_item + processing_fee)
+}
+
+fn main() -> Result<(), ParseIntError> {
+    //    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ added
+    let mut tokens = 100;
+    let pretend_user_input = "8";
+
+    let cost = total_cost(pretend_user_input)?;
+
+    if cost > tokens {
+        println!("You can't afford that many!");
+    } else {
+        tokens -= cost;
+        println!("You now have {tokens} tokens.");
+    }
+
+    // Added this line to return the `Ok` variant of the expected `Result`.
+    Ok(())
 }

solutions/quizzes/quiz2.rs

@@ -1,4 +1,90 @@
-fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+// Let's build a little machine in the form of a function. As input, we're going
+// to give a list of strings and commands. These commands determine what action
+// is going to be applied to the string. It can either be:
+// - Uppercase the string
+// - Trim the string
+// - Append "bar" to the string a specified amount of times
+//
+// The exact form of this will be:
+// - The input is going to be a vector of 2-length tuples,
+//   the first element is the string, the second one is the command.
+// - The output element is going to be a vector of strings.
+
+enum Command {
+    Uppercase,
+    Trim,
+    Append(usize),
+}
+
+mod my_module {
+    use super::Command;
+
+    // The solution with a loop. Check out `transformer_iter` for a version
+    // with iterators.
+    pub fn transformer(input: Vec<(String, Command)>) -> Vec<String> {
+        let mut output = Vec::new();
+
+        for (string, command) in input {
+            // Create the new string.
+            let new_string = match command {
+                Command::Uppercase => string.to_uppercase(),
+                Command::Trim => string.trim().to_string(),
+                Command::Append(n) => string + &"bar".repeat(n),
+            };
+
+            // Push the new string to the output vector.
+            output.push(new_string);
+        }
+
+        output
+    }
+
+    // Equivalent to `transform` but uses an iterator instead of a loop for
+    // comparison. Don't worry, we will practice iterators later ;)
+    pub fn transformer_iter(input: Vec<(String, Command)>) -> Vec<String> {
+        input
+            .into_iter()
+            .map(|(string, command)| match command {
+                Command::Uppercase => string.to_uppercase(),
+                Command::Trim => string.trim().to_string(),
+                Command::Append(n) => string + &"bar".repeat(n),
+            })
+            .collect()
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    // Import `transformer`.
+    use super::my_module::transformer;
+
+    use super::my_module::transformer_iter;
+    use super::Command;
+
+    #[test]
+    fn it_works() {
+        for transformer in [transformer, transformer_iter] {
+            let input = vec![
+                ("hello".to_string(), Command::Uppercase),
+                (" all roads lead to rome! ".to_string(), Command::Trim),
+                ("foo".to_string(), Command::Append(1)),
+                ("bar".to_string(), Command::Append(5)),
+            ];
+            let output = transformer(input);
+
+            assert_eq!(
+                output,
+                [
+                    "HELLO",
+                    "all roads lead to rome!",
+                    "foobar",
+                    "barbarbarbarbarbar",
+                ]
+            );
+        }
+    }
 }