第6章: 列挙型（Enum）とパターンマッチ

#[derive(Debug)]
enum IpAddr {
    V4(u8, u8, u8, u8), // 4つのu8を持つ
    V6(String),         // Stringを持つ
}

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

    println!("Home: {:?}", home);
    println!("Loopback: {:?}", loopback);
}

#[derive(Debug)]
enum Message {
    Quit,                       // データなし
    Move { x: i32, y: i32 },    // 名前付きフィールド（構造体風）
    Write(String),              // 単一のString（タプル風）
    ChangeColor(i32, i32, i32), // 3つのi32（タプル風）
}

impl Message {
    // Enumにもメソッドを定義できる
    fn call(&self) {
        println!("メッセージを処理します: {:?}", self);
    }
}

fn main() {
    let m1 = Message::Write(String::from("hello"));
    let m2 = Message::Move { x: 10, y: 20 };
    let m3 = Message::Quit;

    m1.call();
    m2.call();
    m3.call();
}

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

    // Noneの場合は型推論できないため、明示的に型を指定する必要がある
    let absent_number: Option<i32> = None;

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

    // 以下の行はコンパイルエラーになります。
    // i8 と Option<i8> は足し算できません。
    // let sum = x + y; 

    println!("x: {}", x);
    // 値を取り出すには明示的な処理が必要（後述のmatchなどを使う）
    println!("y is: {:?}", y);
    println!("absent is: {:?}", absent_number);
}

enum Shape {
    Circle(f64),             // 半径
    Rectangle(f64, f64),     // 幅, 高さ
    Triangle(f64, f64, f64), // 3辺の長さ（簡略化のためヘロンの公式用）
}

fn calculate_area(shape: Shape) -> f64 {
    match shape {
        // パターンマッチで中のデータを取り出す（バインディング）
        Shape::Circle(radius) => {
            std::f64::consts::PI * radius * radius
        },
        Shape::Rectangle(w, h) => {
            w * h
        },
        Shape::Triangle(a, b, c) => {
            let s = (a + b + c) / 2.0;
            (s * (s - a) * (s - b) * (s - c)).sqrt()
        }
    }
}

fn main() {
    let c = Shape::Circle(10.0);
    let r = Shape::Rectangle(3.0, 4.0);

    println!("円の面積: {:.2}", calculate_area(c));
    println!("長方形の面積: {:.2}", calculate_area(r));
}

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

fn main() {
    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);

    println!("Five: {:?}", five);
    println!("Six: {:?}", six);
    println!("None: {:?}", none);
}

fn main() {
    let config = Some("config_value");
    let missing: Option<&str> = None;

    // 「もし config が Some(val) というパターンにマッチするならブロックを実行」
    if let Some(val) = config {
        println!("設定値があります: {}", val);
    }

    // else も使えます
    if let Some(val) = missing {
        println!("設定値: {}", val);
    } else {
        println!("設定値がありません");
    }
}

// UsState, Coin, value_in_cents を作成してください

fn main() {
    let coin1 = Coin::Penny;
    let coin2 = Coin::Quarter(UsState::California);

    println!("Coin1 value: {}", value_in_cents(coin1));
    println!("Coin2 value: {}", value_in_cents(coin2));
}

// Operation enum と calculate 関数を実装してください

fn main() {
    let add = Operation::Add(5, 3);
    let subtract = Operation::Subtract(10, 4);
    let multiply = Operation::Multiply(6, 7);
    let divide = Operation::Divide(20, 4);
    let divide_by_zero = Operation::Divide(10, 0);

    println!("5 + 3 = {:?}", calculate(add));
    println!("10 - 4 = {:?}", calculate(subtract));
    println!("6 * 7 = {:?}", calculate(multiply));
    println!("20 / 4 = {:?}", calculate(divide));
    println!("10 / 0 = {:?}", calculate(divide_by_zero));
}