Enums and Pattern Matching in Rust

enum IpAddrKind {
    V4,
    V6,
}

let four = IpAddrKind::V4;
let six = IpAddrKind::V6;

fn route(ip_kind: IpAddrKind) {}

route(IpAddrKind::V4);
route(IpAddrKind::V6);

enum IpAddr {
    V4(String),
    V6(String),
}

let home = IpAddr::V4(String::from("127.0.0.1"));
let loopback = IpAddr::V6(String::from("::1"));

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

let home = IpAddr::V4(127, 0, 0, 1);
let loopback = IpAddr::V6(String::from("::1"));

struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

struct QuitMessage; // unit struct
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct

    impl Message {
        fn call(&self) {
            // method body would be defined here
        }
    }

    let m = Message::Write(String::from("hello"));
    m.call();

enum Option<T> {
    None,
    Some(T),
}

let some_number = Some(5);
let some_string = Some("a string");

let absent_number: Option<i32> = None;

let x: i8 = 5;
let y: Option<i8> = Some(5);

let sum = x + y;

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        },
    }
}

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        Some(i) => Some(i + 1),
    }
}

    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        other => move_player(other),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
    fn move_player(num_spaces: u8) {}

    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        _ => (), // or another actions for now do nothing
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}

    let some_u8_value = Some(0u8);
    match some_u8_value {
        Some(3) => println!("three"),
        _ => (),
    }

    if let Some(3) = some_u8_value {
        println!("three");
    }

    let mut count = 0;
    if let Coin::Quarter(state) = coin {
        println!("State quarter from {:?}!", state);
    } else {
        count += 1;
    }

// 1. 트래픽 라이트 시뮬레이터
enum TrafficLight {
    Red,
    Yellow,
    Green,
}

fn simulate_traffic_light(light: TrafficLight) {
    match light {
        TrafficLight::Red => println!("Stop"),
        TrafficLight::Yellow => println!("Caution"),
        TrafficLight::Green => println!("Go"),
    }
}

// 2. 파일 읽기 함수
use std::fs;

fn read_file(file_path: &str) -> Result<String, String> {
    match fs::read_to_string(file_path) {
        Ok(contents) => Ok(contents),
        Err(_) => Err(String::from("Failed to read the file.")),
    }
}

// 3. 동물의 소리 출력
enum Animal {
    Dog,
    Cat,
    Bird,
}

fn make_sound(animal: Animal) {
    match animal {
        Animal::Dog => println!("Woof!"),
        Animal::Cat => println!("Meow!"),
        Animal::Bird => println!("Tweet!"),
    }
}

// 4. 모양의 면적 계산
enum Shape {
    Circle(f64),
    Triangle(f64, f64),
    Rectangle(f64, f64),
}

fn calculate_area(shape: Shape) -> f64 {
    match shape {
        Shape::Circle(radius) => std::f64::consts::PI * radius * radius,
        Shape::Triangle(base, height) => 0.5 * base * height,
        Shape::Rectangle(width, height) => width * height,
    }
}

// 5. 주소 정보 출력
enum Address {
    City(String),
    State(String),
    Country(String),
}

struct Location {
    city: String,
    state: String,
    country: String,
}

fn print_city_address(address: Address) {
    match address {
        Address::City(city) => println!("City: {}", city),
        _ => (),
    }
}

// 6. 두 옵션 처리
enum OptionEnum<T> {
    Some(T),
    None,
}

fn process_option(option1: OptionEnum<i32>, option2: OptionEnum<i32>) {
    match (option1, option2) {
        (OptionEnum::Some(val1), OptionEnum::Some(val2)) => println!("Both options have values: {}, {}", val1, val2),
        _ => println!("At least one option is None."),
    }
}

// 7. 사칙연산 함수
fn calculate_operation(op: &str, num1: f64, num2: f64) -> Result<f64, String> {
    match op {
        "+" => Ok(num1 + num2),
        "-" => Ok(num1 - num2),
        "*" => Ok(num1 * num2),
        "/" => {
            if num2 == 0.0 {
                Err(String::from("Division by zero is not allowed."))
            } else {
                Ok(num1 / num2)
            }
        },
        _ => Err(String::from("Invalid operation.")),
    }
}

// 8. 계절 출력
enum Season {
    Spring,
    Summer,
    Autumn,
    Winter,
}

fn print_season_message(season: Season) {
    match season {
        Season::Spring => println!("It's spring!"),
        Season::Summer => println!("It's summer!"),
        Season::Autumn => println!("It's autumn!"),
        Season::Winter => println!("It's winter!"),
    }
}

// 9. 로그인 함수
fn login(username: &str, password: &str) -> Result<(), String> {
    if password == "correctpassword" {
        Ok(())
    } else {
        Err(String::from("Incorrect password."))
    }
}

// 10. 주문 상태 출력
enum OrderStatus {
    Pending,
    Completed,
}

fn print_order_status(status: OrderStatus) {
    match status {
        OrderStatus::Pending => println!("Your order is pending."),
        OrderStatus::Completed => println!("Your order is completed."),
    }
}