第12章 OptionとResult.

fn show_stock(stock: Option<u32>) {
    // 次のように出力せよ
    // 在庫数が設定されている  → 在庫は〇〇個です
    // 在庫数が設定されていない → 在庫が分かりません
    match stock { 
        Some(count) => println!("在庫は{count}個です"), 
        None => println!("在庫が分かりません"), 
    } 
}

fn main() {
    show_stock(Some(3));
    show_stock(None);
}

fn main() {
    let stock: Option<u32> = Some(3);

    let total = stock + 2; 
    let total = match stock { 
        Some(count) => count + 2, 
        None => 0 + 2, // 在庫が分からない場合は0個として扱う
    }; 

    println!("合計: {total}個");
}

// メニューから価格を探す関数find_priceを定義せよ
//   引数  : 商品名（&str）
//   戻り値: 見つかればSome(価格)、見つからなければNone
//   メニュー: コーヒー 500円 / 紅茶 450円 / ジュース 400円
fn find_price(name: &str) -> Option<u32> { 
    match name { 
        "コーヒー" => Some(500), 
        "紅茶" => Some(450), 
        "ジュース" => Some(400), 
        _ => None, 
    } 
} 

#[test]
fn test_found() {
    assert_eq!(find_price("コーヒー"), Some(500));
    assert_eq!(find_price("紅茶"), Some(450));
    assert_eq!(find_price("ジュース"), Some(400));
}

#[test]
fn test_not_found() {
    assert_eq!(find_price("ビール"), None);
}

fn show_stock(stock: Option<u32>) {
    // if let式を使い、Someのときだけ「在庫は〇〇個です」と出力せよ
    // Noneのときは何も出力しないこと
    if let Some(count) = stock { 
        println!("在庫は{count}個です"); 
    } 
}

fn main() {
    show_stock(Some(3));
    show_stock(None);
    show_stock(Some(10));
}

fn show_coupon(coupon: Option<u32>) {
    // if let ... elseで次のように出力せよ
    // Some(amount) → 〇〇円引きのクーポンがあります
    // None         → クーポンはありません
    if let Some(amount) = coupon { 
        println!("{amount}円引きのクーポンがあります"); 
    } else { 
        println!("クーポンはありません"); 
    } 
}

fn main() {
    show_coupon(Some(300));
    show_coupon(None);
}

fn print_total(stock: Option<u32>) {
    // let-else文でstockからcountを取り出せ
    // Noneの場合は「在庫が分かりません」と出力して処理を打ち切ること
    let Some(count) = stock else { 
        println!("在庫が分かりません"); 
        return; 
    }; 

    println!("在庫{count}個、合計{}円です", count * 500);
}

fn main() {
    print_total(Some(3));
    print_total(None);
}

fn show(result: Result<u32, String>) {
    // match式で次のように出力せよ
    // 成功時 → 1人あたり〇〇円です
    // 失敗時 → エラー: 〇〇
    match result { 
        Ok(amount) => println!("1人あたり{amount}円です"), 
        Err(reason) => println!("エラー: {reason}"), 
    } 
}

fn main() {
    show(Ok(750));
    show(Err(String::from("人数が0人です")));
}

// 在庫stockからcount個を出荷する関数shipを定義せよ
//   在庫が足りていれば、出荷後の残り在庫数をOkで返す
//   足りなければ「在庫が足りません（在庫〇〇個）」というErrを返す
fn ship(stock: u32, count: u32) -> Result<u32, String> { 
    if count > stock { 
        return Err(format!("在庫が足りません（在庫{stock}個）")); 
    } 

    Ok(stock - count) 
} 

#[test]
fn test_ship_ok() {
    assert_eq!(ship(10, 3), Ok(7));
    assert_eq!(ship(5, 5), Ok(0));
}

#[test]
fn test_ship_error() {
    assert_eq!(ship(2, 5), Err(String::from("在庫が足りません（在庫2個）")));
    assert_eq!(ship(0, 1), Err(String::from("在庫が足りません（在庫0個）")));
}

fn ship(stock: u32, count: u32) -> Result<u32, String> {
    if count > stock {
        return Err(format!("在庫が足りません（在庫{stock}個）"));
    }

    Ok(stock - count)
}

fn ship_twice(stock: u32, first: u32, second: u32) -> Result<u32, String> {
    // 次のmatchの入れ子を?演算子で書き換えよ（動作は変えないこと）
    match ship(stock, first) { 
        Ok(rest) => match ship(rest, second) { 
            Ok(last) => Ok(last), 
            Err(reason) => Err(reason), 
        }, 
        Err(reason) => Err(reason), 
    } 
    let rest = ship(stock, first)?; 
    let last = ship(rest, second)?; 

    Ok(last) 
}

fn main() {
    match ship_twice(10, 3, 2) {
        Ok(rest) => println!("残り{rest}個"),
        Err(reason) => println!("エラー: {reason}"),
    }

    match ship_twice(10, 8, 5) {
        Ok(rest) => println!("残り{rest}個"),
        Err(reason) => println!("エラー: {reason}"),
    }
}

fn main() {
    let coffee: Option<u32> = Some(3);
    let tea: Option<u32> = None;

    // 次の2つのmatchをunwrap_orで書き換えよ（動作は変えないこと）
    let coffee_stock = match coffee { 
        Some(count) => count, 
        None => 0, 
    }; 
    let coffee_stock = coffee.unwrap_or(0); 
    let tea_stock = match tea { 
        Some(count) => count, 
        None => 0, 
    }; 
    let tea_stock = tea.unwrap_or(0); 

    println!("コーヒーの在庫は{coffee_stock}個です");
    println!("紅茶の在庫は{tea_stock}個です");
}

fn ship(stock: u32, count: u32) -> Result<u32, String> {
    if count > stock {
        return Err(format!("在庫が足りません（在庫{stock}個）"));
    }

    Ok(stock - count)
}

fn main() {
    // 2つのunwrapを、失敗した理由が伝わるexpectへ書き換えよ
    let rest = ship(10, 3).unwrap(); 
    let rest = ship(10, 3).expect("在庫は足りているはず"); 
    println!("1回目の出荷後: 残り{rest}個");

    let rest = ship(rest, 9).unwrap(); 
    let rest = ship(rest, 9).expect("在庫は足りているはず"); 
    println!("2回目の出荷後: 残り{rest}個");
}

fn find_price(name: &str) -> Option<u32> {
    match name {
        "コーヒー" => Some(500),
        "紅茶" => Some(450),
        "ジュース" => Some(400),
        _ => None,
    }
}

fn main() {
    // メニューにある商品なので、必ず見つかる
    let coffee = find_price("コーヒー").unwrap(); 
    let coffee = find_price("コーヒー").expect("メニューにある商品なので必ず見つかるはず"); 
    println!("コーヒー: {coffee}円");

    // 客が注文した商品名。メニューにないこともある
    // 見つからない場合は「〇〇は取り扱いがありません」と出力すること
    let ordered = "ビール";
    let price = find_price(ordered).unwrap(); 
    println!("{ordered}: {price}円"); 
    if let Some(price) = find_price(ordered) { 
        println!("{ordered}: {price}円"); 
    } else { 
        println!("{ordered}は取り扱いがありません"); 
    } 
}

// 商品を表す構造体Itemを定義せよ（name: String / price: u32 / stock: u32）
struct Item { 
    name: String, 
    price: u32, 
    stock: u32, 
} 

// 購入の失敗理由を表す列挙型StockErrorを定義せよ
//   NotFound                 … 商品が見つからない
//   OutOfStock { stock: u32 } … 在庫不足（現在の在庫数を持つ）
// テストのassert_eq!で比較するため #[derive(Debug, PartialEq)] を付けること
#[derive(Debug, PartialEq)] 
enum StockError { 
    NotFound, 
    OutOfStock { stock: u32 }, 
} 

// 在庫全体を表す構造体Inventoryを定義せよ（items: Vec<Item>）
struct Inventory { 
    items: Vec<Item>, 
} 

// Inventoryのimplブロックにnew・add・find_price・buyを定義せよ
impl Inventory { 
    fn new() -> Self { 
        Inventory { items: Vec::new() } 
    } 

    fn add(&mut self, name: &str, price: u32, stock: u32) { 
        self.items.push(Item { 
            name: String::from(name), 
            price, 
            stock, 
        }); 
    } 

    fn find_price(&self, name: &str) -> Option<u32> { 
        for item in &self.items { 
            if item.name == name { 
                return Some(item.price); 
            } 
        } 

        None
    } 

    fn buy(&mut self, name: &str, count: u32) -> Result<u32, StockError> { 
        for item in &mut self.items { 
            if item.name == name { 
                if item.stock < count { 
                    return Err(StockError::OutOfStock { stock: item.stock }); 
                } 

                item.stock -= count; 
                return Ok(item.price * count); 
            } 
        } 

        Err(StockError::NotFound) 
    } 
} 

fn sample() -> Inventory {
    let mut inventory = Inventory::new();
    inventory.add("コーヒー豆", 1200, 3);
    inventory.add("マグカップ", 800, 10);
    inventory
}

#[test]
fn test_find_price() {
    let inventory = sample();
    assert_eq!(inventory.find_price("コーヒー豆"), Some(1200));
    assert_eq!(inventory.find_price("マグカップ"), Some(800));
    assert_eq!(inventory.find_price("ビール"), None);
}

#[test]
fn test_buy() {
    let mut inventory = sample();
    assert_eq!(inventory.buy("コーヒー豆", 2), Ok(2400));
    assert_eq!(inventory.buy("コーヒー豆", 1), Ok(1200));
    // 在庫を使い切ったので次は失敗する
    assert_eq!(
        inventory.buy("コーヒー豆", 1),
        Err(StockError::OutOfStock { stock: 0 })
    );
}

#[test]
fn test_buy_not_found() {
    let mut inventory = sample();
    assert_eq!(inventory.buy("ビール", 1), Err(StockError::NotFound));
}

#[test]
fn test_buy_out_of_stock() {
    let mut inventory = sample();
    assert_eq!(
        inventory.buy("コーヒー豆", 5),
        Err(StockError::OutOfStock { stock: 3 })
    );
    // 失敗したときは在庫を減らさない
    assert_eq!(inventory.buy("コーヒー豆", 3), Ok(3600));
}