quiz1 solution

exercises/03_if/if1.rs

@@ -1,5 +1,5 @@
-pub fn bigger(a: i32, b: i32) -> i32 {
+fn bigger(a: i32, b: i32) -> i32 {
-    // Complete this function to return the bigger number!
+    // TODO: Complete this function to return the bigger number!
     // If both numbers are equal, any of them can be returned.
     // Do not use:
     // - another function call

exercises/03_if/if2.rs

@@ -1,7 +1,5 @@
-// Step 1: Make me compile!
+// TODO: Fix the compiler error on this function.
-// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+fn foo_if_fizz(fizzish: &str) -> &str {
-
-pub fn foo_if_fizz(fizzish: &str) -> &str {
     if fizzish == "fizz" {
         "foo"
     } else {
@@ -13,23 +11,25 @@ fn main() {
     // You can optionally experiment here.
 }
 
-// No test changes needed!
+// TODO: Read the tests to understand the desired behavior.
+// Make all tests pass without changing them.
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn foo_for_fizz() {
-        assert_eq!(foo_if_fizz("fizz"), "foo")
+        // This means that calling `foo_if_fizz` with the argument "fizz" should return "foo".
+        assert_eq!(foo_if_fizz("fizz"), "foo");
     }
 
     #[test]
     fn bar_for_fuzz() {
-        assert_eq!(foo_if_fizz("fuzz"), "bar")
+        assert_eq!(foo_if_fizz("fuzz"), "bar");
     }
 
     #[test]
     fn default_to_baz() {
-        assert_eq!(foo_if_fizz("literally anything"), "baz")
+        assert_eq!(foo_if_fizz("literally anything"), "baz");
     }
 }

exercises/03_if/if3.rs

@@ -1,4 +1,5 @@
-pub fn animal_habitat(animal: &str) -> &'static str {
+fn animal_habitat(animal: &str) -> &str {
+    // TODO: Fix the compiler error in the statement below.
     let identifier = if animal == "crab" {
         1
     } else if animal == "gopher" {
@@ -9,8 +10,8 @@ pub fn animal_habitat(animal: &str) -> &'static str {
         "Unknown"
     };
 
-    // DO NOT CHANGE THIS STATEMENT BELOW
+    // Don't change the expression below!
-    let habitat = if identifier == 1 {
+    if identifier == 1 {
         "Beach"
     } else if identifier == 2 {
         "Burrow"
@@ -18,16 +19,14 @@ pub fn animal_habitat(animal: &str) -> &'static str {
         "Desert"
     } else {
         "Unknown"
-    };
+    }
-
-    habitat
 }
 
 fn main() {
     // You can optionally experiment here.
 }
 
-// No test changes needed.
+// Don't change the tests!
 #[cfg(test)]
 mod tests {
     use super::*;

exercises/04_primitive_types/primitive_types4.rs

@@ -14,6 +14,6 @@ mod tests {
 
         let nice_slice = ???
 
-        assert_eq!([2, 3, 4], nice_slice)
+        assert_eq!([2, 3, 4], nice_slice);
     }
 }

exercises/13_error_handling/errors1.rs

@@ -8,7 +8,7 @@ fn main() {
     // You can optionally experiment here.
 }
 
-pub fn generate_nametag_text(name: String) -> Option<String> {
+fn generate_nametag_text(name: String) -> Option<String> {
     if name.is_empty() {
         // Empty names aren't allowed.
         None

exercises/13_error_handling/errors2.rs

@@ -16,7 +16,7 @@
 
 use std::num::ParseIntError;
 
-pub fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
+fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
     let processing_fee = 1;
     let cost_per_item = 5;
     let qty = item_quantity.parse::<i32>();

exercises/13_error_handling/errors3.rs

@@ -18,7 +18,7 @@ fn main() {
     }
 }
 
-pub fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
+fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
     let processing_fee = 1;
     let cost_per_item = 5;
     let qty = item_quantity.parse::<i32>()?;

exercises/14_generics/generics2.rs

@@ -6,7 +6,7 @@ struct Wrapper {
 }
 
 impl Wrapper {
-    pub fn new(value: u32) -> Self {
+    fn new(value: u32) -> Self {
         Wrapper { value }
     }
 }

exercises/15_traits/traits3.rs

@@ -3,7 +3,7 @@
 //
 // Consider what you can add to the Licensed trait.
 
-pub trait Licensed {
+trait Licensed {
     fn licensing_info(&self) -> String;
 }
 

exercises/15_traits/traits4.rs

@@ -2,7 +2,7 @@
 //
 // Don't change any line other than the marked one.
 
-pub trait Licensed {
+trait Licensed {
     fn licensing_info(&self) -> String {
         "some information".to_string()
     }

exercises/15_traits/traits5.rs

@@ -2,13 +2,13 @@
 //
 // Don't change any line other than the marked one.
 
-pub trait SomeTrait {
+trait SomeTrait {
     fn some_function(&self) -> bool {
         true
     }
 }
 
-pub trait OtherTrait {
+trait OtherTrait {
     fn other_function(&self) -> bool {
         true
     }

exercises/17_tests/tests3.rs

@@ -2,7 +2,7 @@
 // the test passes. Then write a second test that tests whether we get the
 // result we expect to get when we call `is_even(5)`.
 
-pub fn is_even(num: i32) -> bool {
+fn is_even(num: i32) -> bool {
     num % 2 == 0
 }
 

exercises/17_tests/tests4.rs

@@ -7,7 +7,7 @@ struct Rectangle {
 
 impl Rectangle {
     // Only change the test functions themselves
-    pub fn new(width: i32, height: i32) -> Self {
+    fn new(width: i32, height: i32) -> Self {
         if width <= 0 || height <= 0 {
             panic!("Rectangle width and height cannot be negative!")
         }

exercises/18_iterators/iterators2.rs

@@ -4,7 +4,7 @@
 // Step 1.
 // Complete the `capitalize_first` function.
 // "hello" -> "Hello"
-pub fn capitalize_first(input: &str) -> String {
+fn capitalize_first(input: &str) -> String {
     let mut c = input.chars();
     match c.next() {
         None => String::new(),
@@ -16,7 +16,7 @@ pub fn capitalize_first(input: &str) -> String {
 // Apply the `capitalize_first` function to a slice of string slices.
 // Return a vector of strings.
 // ["hello", "world"] -> ["Hello", "World"]
-pub fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
+fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
     vec![]
 }
 
@@ -24,7 +24,7 @@ pub fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
 // Apply the `capitalize_first` function again to a slice of string slices.
 // Return a single string.
 // ["hello", " ", "world"] -> "Hello World"
-pub fn capitalize_words_string(words: &[&str]) -> String {
+fn capitalize_words_string(words: &[&str]) -> String {
     String::new()
 }
 

exercises/18_iterators/iterators3.rs

@@ -5,20 +5,20 @@
 //    list_of_results functions.
 
 #[derive(Debug, PartialEq, Eq)]
-pub enum DivisionError {
+enum DivisionError {
     NotDivisible(NotDivisibleError),
     DivideByZero,
 }
 
 #[derive(Debug, PartialEq, Eq)]
-pub struct NotDivisibleError {
+struct NotDivisibleError {
     dividend: i32,
     divisor: i32,
 }
 
 // Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
 // Otherwise, return a suitable error.
-pub fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {
+fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {
     todo!();
 }
 

exercises/18_iterators/iterators4.rs

@@ -1,4 +1,4 @@
-pub fn factorial(num: u64) -> u64 {
+fn factorial(num: u64) -> u64 {
     // Complete this function to return the factorial of num
     // Do not use:
     // - early returns (using the `return` keyword explicitly)

exercises/19_smart_pointers/box1.rs

@@ -15,7 +15,7 @@
 // Note: the tests should not be changed
 
 #[derive(PartialEq, Debug)]
-pub enum List {
+enum List {
     Cons(i32, List),
     Nil,
 }
@@ -28,11 +28,11 @@ fn main() {
     );
 }
 
-pub fn create_empty_list() -> List {
+fn create_empty_list() -> List {
     todo!()
 }
 
-pub fn create_non_empty_list() -> List {
+fn create_non_empty_list() -> List {
     todo!()
 }
 
@@ -42,11 +42,11 @@ mod tests {
 
     #[test]
     fn test_create_empty_list() {
-        assert_eq!(List::Nil, create_empty_list())
+        assert_eq!(List::Nil, create_empty_list());
     }
 
     #[test]
     fn test_create_non_empty_list() {
-        assert_ne!(create_empty_list(), create_non_empty_list())
+        assert_ne!(create_empty_list(), create_non_empty_list());
     }
 }

exercises/20_threads/threads3.rs

@@ -60,6 +60,6 @@ mod tests {
         }
 
         println!("total numbers received: {}", total_received);
-        assert_eq!(total_received, queue_length)
+        assert_eq!(total_received, queue_length);
     }
 }

exercises/quizzes/quiz1.rs

@@ -10,27 +10,22 @@
 // quantity bought.
 
 // Put your function here!
-// fn calculate_price_of_apples {
+// fn calculate_price_of_apples(???) -> ??? {
 
 fn main() {
     // You can optionally experiment here.
 }
 
+// Don't change the tests!
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    // Don't modify this test!
     #[test]
     fn verify_test() {
-        let price1 = calculate_price_of_apples(35);
+        assert_eq!(calculate_price_of_apples(35), 70);
-        let price2 = calculate_price_of_apples(40);
+        assert_eq!(calculate_price_of_apples(40), 80);
-        let price3 = calculate_price_of_apples(41);
+        assert_eq!(calculate_price_of_apples(41), 41);
-        let price4 = calculate_price_of_apples(65);
+        assert_eq!(calculate_price_of_apples(65), 65);
-
-        assert_eq!(70, price1);
-        assert_eq!(80, price2);
-        assert_eq!(41, price3);
-        assert_eq!(65, price4);
     }
 }

exercises/quizzes/quiz2.rs

@@ -16,7 +16,7 @@
 //   the first element is the string, the second one is the command.
 // - The output element is going to be a Vector of strings.
 
-pub enum Command {
+enum Command {
     Uppercase,
     Trim,
     Append(usize),

exercises/quizzes/quiz3.rs

@@ -12,14 +12,14 @@
 // to support alphabetical report cards. Change the Grade in the second test to
 // "A+" to show that your changes allow alphabetical grades.
 
-pub struct ReportCard {
+struct ReportCard {
-    pub grade: f32,
+    grade: f32,
-    pub student_name: String,
+    student_name: String,
-    pub student_age: u8,
+    student_age: u8,
 }
 
 impl ReportCard {
-    pub fn print(&self) -> String {
+    fn print(&self) -> String {
         format!(
             "{} ({}) - achieved a grade of {}",
             &self.student_name, &self.student_age, &self.grade

rustlings-macros/info.toml

@@ -200,17 +200,19 @@ Some similar examples from other languages:
 - In Python this would be:  `a if a > b else b`
 
 Remember in Rust that:
-- the `if` condition does not need to be surrounded by parentheses
+- The `if` condition does not need to be surrounded by parentheses
 - `if`/`else` conditionals are expressions
-- Each condition is followed by a `{}` block."""
+- Each condition is followed by a `{}` block"""
 
 [[exercises]]
 name = "if2"
 dir = "03_if"
 hint = """
 For that first compiler error, it's important in Rust that each conditional
-block returns the same type! To get the tests passing, you will need a couple
+block returns the same type!
-conditions checking different input values."""
+
+To get the tests passing, you will need a couple conditions checking different
+input values. Read the tests to find out what they expect."""
 
 [[exercises]]
 name = "if3"

solutions/03_if/if1.rs

@@ -1 +1,32 @@
-// Solutions will be available before the stable release. Thank you for testing the beta version 🥰
+fn bigger(a: i32, b: i32) -> i32 {
+    if a > b {
+        a
+    } else {
+        b
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+// Don't mind this for now :)
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ten_is_bigger_than_eight() {
+        assert_eq!(10, bigger(10, 8));
+    }
+
+    #[test]
+    fn fortytwo_is_bigger_than_thirtytwo() {
+        assert_eq!(42, bigger(32, 42));
+    }
+
+    #[test]
+    fn equal_numbers() {
+        assert_eq!(42, bigger(42, 42));
+    }
+}

solutions/03_if/if2.rs

@@ -1 +1,33 @@
-// Solutions will be available before the stable release. Thank you for testing the beta version 🥰
+fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else if fizzish == "fuzz" {
+        "bar"
+    } else {
+        "baz"
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo");
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar");
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz");
+    }
+}

solutions/03_if/if3.rs

@@ -1 +1,53 @@
-// Solutions will be available before the stable release. Thank you for testing the beta version 🥰
+fn animal_habitat(animal: &str) -> &str {
+    let identifier = if animal == "crab" {
+        1
+    } else if animal == "gopher" {
+        2
+    } else if animal == "snake" {
+        3
+    } else {
+        // Any unused identifier.
+        4
+    };
+
+    // Instead of such an identifier, you would use an enum in Rust.
+    // But we didn't get into enums yet.
+    if identifier == 1 {
+        "Beach"
+    } else if identifier == 2 {
+        "Burrow"
+    } else if identifier == 3 {
+        "Desert"
+    } else {
+        "Unknown"
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gopher_lives_in_burrow() {
+        assert_eq!(animal_habitat("gopher"), "Burrow")
+    }
+
+    #[test]
+    fn snake_lives_in_desert() {
+        assert_eq!(animal_habitat("snake"), "Desert")
+    }
+
+    #[test]
+    fn crab_lives_on_beach() {
+        assert_eq!(animal_habitat("crab"), "Beach")
+    }
+
+    #[test]
+    fn unknown_animal() {
+        assert_eq!(animal_habitat("dinosaur"), "Unknown")
+    }
+}

solutions/quizzes/quiz1.rs

@@ -1 +1,31 @@
-// Solutions will be available before the stable release. Thank you for testing the beta version 🥰
+// Mary is buying apples. The price of an apple is calculated as follows:
+// - An apple costs 2 rustbucks.
+// - If Mary buys more than 40 apples, each apple only costs 1 rustbuck!
+// Write a function that calculates the price of an order of apples given the
+// quantity bought.
+
+fn calculate_price_of_apples(n_apples: u64) -> u64 {
+    if n_apples > 40 {
+        n_apples
+    } else {
+        2 * n_apples
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+// Don't change the tests!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn verify_test() {
+        assert_eq!(calculate_price_of_apples(35), 70);
+        assert_eq!(calculate_price_of_apples(40), 80);
+        assert_eq!(calculate_price_of_apples(41), 41);
+        assert_eq!(calculate_price_of_apples(65), 65);
+    }
+}