quiz2 solution

exercises/quizzes/quiz2.rs

@@ -11,10 +11,11 @@
 // - 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 a 2-length tuple,
+// - The input is going to be a vector of a 2-length tuple,
 //   the first element is the string, the second one is the command.
-// - The output element is going to be a Vector of strings.
+// - The output element is going to be a vector of strings.
 
 enum Command {
     Uppercase,
@@ -25,15 +26,8 @@ enum Command {
 mod my_module {
     use super::Command;
 
-    // TODO: Complete the function signature!
-    pub fn transformer(input: ???) -> ??? {
-        // TODO: Complete the output declaration!
-        let mut output: ??? = vec![];
-        for (string, command) in input.iter() {
-            // TODO: Complete the function body. You can do it!
-        }
-        output
-    }
+    // TODO: Complete the function.
+    // pub fn transformer(input: ???) -> ??? { ??? }
 }
 
 fn main() {
@@ -43,20 +37,27 @@ fn main() {
 #[cfg(test)]
 mod tests {
     // TODO: What do we need to import to have `transformer` in scope?
-    use ???;
+    // use ???;
     use super::Command;
 
     #[test]
     fn it_works() {
-        let output = transformer(vec![
-            ("hello".into(), Command::Uppercase),
-            (" all roads lead to rome! ".into(), Command::Trim),
-            ("foo".into(), Command::Append(1)),
-            ("bar".into(), Command::Append(5)),
-        ]);
-        assert_eq!(output[0], "HELLO");
-        assert_eq!(output[1], "all roads lead to rome!");
-        assert_eq!(output[2], "foobar");
-        assert_eq!(output[3], "barbarbarbarbarbar");
+        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",
+            ]
+        );
     }
 }

solutions/quizzes/quiz2.rs

@@ -1 +1,107 @@
-// Solutions will be available before the stable release. Thank you for testing the beta version 🥰
+// This is a quiz for the following sections:
+// - Strings
+// - Vecs
+// - Move semantics
+// - Modules
+// - Enums
+//
+// 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 a 2-length tuple,
+//   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 (mut 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) => {
+                    for _ in 0..n {
+                        string += "bar";
+                    }
+                    string
+                }
+            };
+
+            // 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(|(mut string, command)| match command {
+                Command::Uppercase => string.to_uppercase(),
+                Command::Trim => string.trim().to_string(),
+                Command::Append(n) => {
+                    for _ in 0..n {
+                        string += "bar";
+                    }
+                    string
+                }
+            })
+            .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",
+                ]
+            );
+        }
+    }
+}