Enum dan Matching Pattern

Versi Bahasa Indonesia. Baca dalam Bahasa Inggris

Enums:

Enums (kependekan dari "enumerations") adalah tipe yang memungkinkan kamu mendefinisikan sebuah nilai yang dapat berupa salah satu dari beberapa varian.

Beberapa tipe varian dalam satu enum:

enum Message {
  Quit,                       // Tanpa data
  Move { x: i32, y: i32 },    // Named fields
  Write(String),              // Single unnamed field
  ChangeColor(u8, u8, u8),    // Multiple unnamed fields
}

Matching Pattern:
- Sintaks pattern matching memungkinkan kamu membandingkan nilai dengan serangkaian pola dan mengeksekusi kode berdasarkan pola yang cocok.
- Kamu dapat mendestruktur tipe data kompleks seperti struct, enum, dan tuple dalam match.
- Kamu dapat menambahkan kondisi ke pola menggunakan if guards.
Referensi:
- Enums
- Pattern syntax

enums1.rs

#[derive(Debug)]
enum Message {
    // Define a few types of messages as used below.
    Resize,
    Move,
    Echo,
    ChangeColor,
    Quit,
}

fn main() {
    println!("{:?}", Message::Resize);
    println!("{:?}", Message::Move);
    println!("{:?}", Message::Echo);
    println!("{:?}", Message::ChangeColor);
    println!("{:?}", Message::Quit);
}

Di latihan ini kita perlu mendefinisikan tipe-tipe pesan seperti yang digunakan di fungsi main.
Jadi kita cukup menambahkan semua tipe yang tersedia di fungsi main ke dalam definisi enum.

enums2.rs

#[derive(Debug)]
struct Point {
    x: u64,
    y: u64,
}

#[derive(Debug)]
enum Message {
    // Define the different variants used below.
    Resize { width: i32, height: i32 },
    Move(Point),
    Echo(String),
    ChangeColor(i32, i32, i32),
    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();
    }
}

Kita dapat memiliki beberapa tipe varian dalam satu enum.

Dalam tugas ini kita perlu menulis 5 varian.

enum Message {
  Resize { width: i32, height: i32 }, // dengan named field data seperti struct
  Move(Point),  // memiliki data struct
  Echo(String), // memiliki data String tunggal
  ChangeColor(i32, i32, i32), // memiliki 3 data seperti tuple
  Quit, // tanpa data
}

enums3.rs

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,
    // RGB color composed of red, green and blue.
    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) {
        // TODO: Create a match expression to process the different message
        // variants using the methods defined above.
        match message {
            Message::Resize {
                width: w,
                height: h,
            } => self.resize(w, h),
            Message::Move(p) => self.move_position(p),
            Message::Echo(s) => self.echo(s),
            Message::ChangeColor(r, g, b) => self.change_color(r, g, b),
            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);
    }
}

Di latihan ini kita perlu membuat sintaks pattern matching untuk semua varian yang tersedia di enum Message dan memanggil method yang sesuai.

Untuk setiap varian yang memiliki data, kita ingin menangkap atau mendapatkan data tersebut sehingga kita dapat menggunakannya sebagai argumen saat memanggil method yang sesuai.

match message {
  // bind width -> w dan height -> h
  Message::Resize { width: w, height: h } => self.resize(w, h),
  // bind Point -> p
  Message::Move(p) => self.move_position(p),
  // bind String -> s
  Message::Echo(s) => self.echo(s),
  // bind nilai pertama -> r
  // bind nilai kedua -> g
  // bind nilai ketiga -> b
  Message::ChangeColor(r, g, b) => self.change_color(r, g, b),
  Message::Quit => self.quit(),
}

Sintaks pattern ini akan mengikat data dalam varian enum message ke dalam variabel yang telah ditentukan.