第11章 列挙型とmatch式.

// Coffee・Tea・Juiceの3つのバリアントを持つ列挙型Drinkを定義せよ
// {:?}で出力できるようにすること
#[derive(Debug)] 
enum Drink { 
    Coffee, 
    Tea, 
    Juice, 
} 

fn main() {
    let first = Drink::Coffee;
    let second = Drink::Tea;
    let third = Drink::Juice;

    println!("1杯目: {first:?}");
    println!("2杯目: {second:?}");
    println!("3杯目: {third:?}");
}

enum Drink {
    Coffee,
    Tea,
    Juice,
}

fn announce(drink: Drink) {
    // match式でバリアントごとに次のメッセージを出力せよ
    // Coffee → コーヒーをどうぞ
    // Tea    → 紅茶をどうぞ
    // Juice  → ジュースをどうぞ
    match drink { 
        Drink::Coffee => println!("コーヒーをどうぞ"), 
        Drink::Tea => println!("紅茶をどうぞ"), 
        Drink::Juice => println!("ジュースをどうぞ"), 
    } 
}

fn main() {
    announce(Drink::Coffee);
    announce(Drink::Juice);
    announce(Drink::Tea);
}

enum Drink {
    Coffee,
    Tea,
    Juice,
}

fn checkout(drink: Drink) {
    // match式で価格を求めてpriceに束縛せよ
    // Coffee: 500円 / Tea: 450円 / Juice: 400円
    let price = 0; 
    let price = match drink { 
        Drink::Coffee => 500, 
        Drink::Tea => 450, 
        Drink::Juice => 400, 
    }; 

    println!("お会計: {price}円");
}

fn main() {
    checkout(Drink::Coffee);
    checkout(Drink::Tea);
    checkout(Drink::Juice);
}

enum Drink {
    Coffee,
    Tea,
    Juice,
}

fn checkout(drink: Drink) {
    let price = match drink {
        Drink::Coffee => 500,
        Drink::Tea => 450,
        Drink::Juice => 400, // このアームを追加した
    };

    println!("お会計: {price}円");
}

fn main() {
    checkout(Drink::Coffee);
    checkout(Drink::Tea);
    checkout(Drink::Juice);
}

enum Order {
    Regular,
    Discounted(u32), // 割引額（円）
}

fn total(order: Order) -> u32 {
    match order {
        Order::Regular => 500,
        // Discountedのアームを追加せよ
        // 割引額を取り出し、500から引いた金額を返すこと
        Order::Discounted(amount) => 500 - amount, 
    }
}

fn main() {
    println!("通常: {}円", total(Order::Regular));
    println!("割引: {}円", total(Order::Discounted(120)));
}

enum Delivery {
    Pickup,
    Shipping { address: String, fee: u32 },
}

fn announce(delivery: Delivery) {
    match delivery {
        Delivery::Pickup => println!("店頭受け取りです"),
        // Shippingのアームを追加せよ
        // 「〇〇へ配送します（送料〇〇円）」と出力すること
        Delivery::Shipping { address, fee } => { 
            println!("{address}へ配送します（送料{fee}円）"); 
        } 
    }
}

fn main() {
    announce(Delivery::Pickup);
    announce(Delivery::Shipping {
        address: String::from("東京都渋谷区"),
        fee: 500,
    });
}

fn describe(points: u32) {
    match points {
        0 => println!("ポイントはありません"),
        1..=99 => println!("あと少しで特典です"),
        // 100以上をまとめて処理するアームを追加せよ
        // 「〇〇ポイント貯まっています」と出力すること
        other => println!("{other}ポイント貯まっています"), 
    }
}

fn is_free_drink(points: u32) {
    match points {
        100 => println!("無料ドリンク券が使えます"),
        // それ以外をまとめて処理するアームを追加せよ
        // 「無料ドリンク券は使えません」と出力すること（ポイント数は使わない）
        _ => println!("無料ドリンク券は使えません"), 
    }
}

fn main() {
    describe(0);
    describe(30);
    describe(150);

    is_free_drink(150);
    is_free_drink(100);
}

enum Drink {
    Coffee,
    Tea,
    Juice,
    Water,
}

fn serve_hot(drink: Drink) {
    match drink {
        Drink::Coffee => println!("ホットもご用意できます"), 
        Drink::Tea => println!("ホットもご用意できます"), 
        Drink::Juice => println!("冷たいドリンクのみです"), 
        Drink::Water => println!("冷たいドリンクのみです"), 
        Drink::Coffee | Drink::Tea => println!("ホットもご用意できます"), 
        Drink::Juice | Drink::Water => println!("冷たいドリンクのみです"), 
    }
}

fn main() {
    serve_hot(Drink::Coffee);
    serve_hot(Drink::Tea);
    serve_hot(Drink::Juice);
    serve_hot(Drink::Water);
}

enum Order {
    Regular,
    Discounted(u32),     // 割引額（円）
    Bulk { count: u32 }, // 個数
}

fn describe(order: Order) {
    match order {
        Order::Regular => println!("通常注文です"),
        // DiscountedとBulkのアームを追加せよ
        // Discounted → 割引注文です / Bulk → まとめ買いです
        // どちらのアームでも中の値は使わないこと
        Order::Discounted(_) => println!("割引注文です"), 
        Order::Bulk { .. } => println!("まとめ買いです"), 
    }
}

fn main() {
    describe(Order::Regular);
    describe(Order::Discounted(120));
    describe(Order::Bulk { count: 10 });
}

use std::f64::consts::PI; // 円周率

// 図形を表す列挙型Shapeを定義せよ
//   Circle    … 半径をf64で1つ持つ（タプル的バリアント）
//   Rectangle … width・heightをf64で持つ（構造体的バリアント）
//   Triangle  … base・heightをf64で持つ（構造体的バリアント）
enum Shape { 
    Circle(f64), 
    Rectangle { width: f64, height: f64 }, 
    Triangle { base: f64, height: f64 }, 
} 

// implブロックにareaとnameの2つのメソッドを定義せよ
impl Shape { 
    fn area(&self) -> f64 { 
        match self { 
            Shape::Circle(radius) => PI * radius * radius, 
            Shape::Rectangle { width, height } => width * height, 
            Shape::Triangle { base, height } => base * height / 2.0, 
        } 
    } 

    fn name(&self) -> String { 
        match self { 
            Shape::Circle(_) => String::from("円"), 
            Shape::Rectangle { .. } => String::from("長方形"), 
            Shape::Triangle { .. } => String::from("三角形"), 
        } 
    } 
} 

#[test]
fn test_circle() {
    let shape = Shape::Circle(2.0);
    assert_eq!(shape.area(), PI * 2.0 * 2.0);
    assert_eq!(shape.name(), "円");
}

#[test]
fn test_rectangle() {
    let shape = Shape::Rectangle {
        width: 3.0,
        height: 4.0,
    };
    assert_eq!(shape.area(), 12.0);
    assert_eq!(shape.name(), "長方形");
}

#[test]
fn test_triangle() {
    let shape = Shape::Triangle {
        base: 6.0,
        height: 4.0,
    };
    assert_eq!(shape.area(), 12.0);
    assert_eq!(shape.name(), "三角形");
}

#[test]
fn test_total_area() {
    let shapes = vec![
        Shape::Rectangle {
            width: 3.0,
            height: 4.0,
        },
        Shape::Triangle {
            base: 6.0,
            height: 4.0,
        },
    ];

    let mut total = 0.0;
    for shape in &shapes {
        total += shape.area();
    }

    assert_eq!(total, 24.0);
}