Quiz 2

// 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 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;

    // TODO: Complete the function as described above.
    // pub fn transformer(input: ???) -> ??? { ??? }
}

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    // TODO: What do we need to import to have `transformer` in scope?
    // use ???;
    use super::Command;

    #[test]
    fn it_works() {
        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",
            ]
        );
    }
}

In this quiz we are tasked to build a function called transformer that accept a tuple vector Vec<(String, Command)> and return vector Vec<String>.
We have to do string manipulation to given String based on given Command.
And return the result for each action into Vec<String>.
So we need to loop to each input, determine the action from each command using match syntax, do the action, and return the result.

We can do it by using for loop like this:

pub fn transformer(input: Vec<(String, Command)>) -> Vec<String> {
    let mut result = Vec::new();
    // loop each input
    for (s, c) in input {
        // match command
        let s: String = match c {
            Command::Trim => s.trim().to_string(),
            Command::Uppercase => s.to_uppercase(),
            Command::Append(n) => s + "bar".repeat(n).as_str(),
        };
        result.push(s);
    }
    result
}

Or by using iterator like this:

pub fn transformer(input: Vec<(String, Command)>) -> Vec<String> {
    input
        .into_iter()
        .map(|(s, c)| match c {
            Command::Trim => s.trim().to_string(),
            Command::Uppercase => s.to_uppercase(),
            Command::Append(n) => s + "bar".repeat(n).as_str(),
        })
        .collect()
}

Lastly don't forget to import the transformer function so it available in the test module:
```
use super::my_module::transformer;
```

References​

References