Kuis 2 | Faisal Affan

Versi Bahasa Indonesia. Baca dalam Bahasa Inggris

// 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",
            ]
        );
    }
}

Dalam kuis ini kita ditugaskan untuk membuat fungsi bernama transformer yang menerima tuple vector Vec<(String, Command)> dan mengembalikan vector Vec<String>.
Kita harus melakukan manipulasi string pada String yang diberikan berdasarkan Command yang diberikan.
Dan mengembalikan hasil untuk setiap tindakan ke dalam Vec<String>.
Jadi kita perlu melakukan loop ke setiap input, menentukan tindakan dari setiap perintah menggunakan sintaks match, melakukan tindakan, dan mengembalikan hasilnya.

Kita dapat melakukannya dengan menggunakan loop for seperti ini:

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
}

Atau dengan menggunakan iterator seperti ini:

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()
}

Terakhir jangan lupa untuk mengimpor fungsi transformer sehingga tersedia di modul test:
```
use super::my_module::transformer;
```