第9章: エラーハンドリング

fn main() {
    println!("処理を開始します...");

    // 何か致命的なことが起きたと仮定
    panic!("ここで致命的なエラーが発生しました！");

    // 以下の行は実行されません
    println!("この行は表示されません");
}

fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        // 失敗時は Err でラップして返す
        return Err(String::from("0で割ることはできません"));
    }
    // 成功時は Ok でラップして返す
    Ok(numerator / denominator)
}

fn main() {
    let inputs = vec![(10.0, 2.0), (5.0, 0.0)];

    for (num, den) in inputs {
        let result = divide(num, den);

        match result {
            Ok(val) => println!("{} / {} = {}", num, den, val),
            Err(e) => println!("エラー: {}", e),
        }
    }
}

fn main() {
    let valid_str = "100";
    let invalid_str = "hello";

    // 成功時は値を返す
    let n: i32 = valid_str.parse().unwrap();
    println!("パース成功: {}", n);

    // 失敗時は指定したメッセージと共に panic! する
    // 以下の行を実行するとクラッシュします
    let _m: i32 = invalid_str.parse().unwrap();
}

fn main() {
    let valid_str = "100";
    let invalid_str = "hello";

    // 1. 成功時は値を返す
    let n: i32 = valid_str.parse().expect("数値のパースに失敗しました");
    println!("パース成功: {}", n);

    // 2. 失敗時は指定したメッセージと共に panic! する
    // 以下の行を実行するとクラッシュします
    let _m: i32 = invalid_str.parse().expect("数値のパースに失敗しました");
}

use std::num::ParseIntError;

// 文字列を受け取り、最初の文字を切り出して数値に変換し、10倍して返す
fn get_first_digit_scaled(text: &str) -> Result<i32, String> {
    // 1. 文字列が空の場合のエラー処理
    let first_char = text.chars().next().ok_or("空の文字列です".to_string())?;

    // 2. 文字を数値にパース（失敗したらエラー伝播）
    // ParseIntError を String に変換するために map_err を使用しています
    // (?演算子はFromトレイトを使って自動変換を行いますが、ここでは単純化のため手動変換します)
    let num: i32 = first_char.to_string()
        .parse()
        .map_err(|_| format!("'{}' は数値ではありません", first_char))?;

    Ok(num * 10)
}

fn main() {
    match get_first_digit_scaled("5 apples") {
        Ok(v) => println!("計算結果: {}", v),
        Err(e) => println!("エラー発生: {}", e),
    }

    match get_first_digit_scaled("banana") {
        Ok(v) => println!("計算結果: {}", v),
        Err(e) => println!("エラー発生: {}", e),
    }
}

use std::fmt;

// 1. 独自のエラー型を定義
#[derive(Debug)]
enum MyToolError {
    IoError(String),
    ParseError(String),
    LogicError,
}

// 2. Display トレイトの実装（ユーザー向けのエラーメッセージ）
impl fmt::Display for MyToolError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            MyToolError::IoError(msg) => write!(f, "IOエラー: {}", msg),
            MyToolError::ParseError(msg) => write!(f, "解析エラー: {}", msg),
            MyToolError::LogicError => write!(f, "ロジックエラーが発生しました"),
        }
    }
}

// 3. Error トレイトの実装（これを実装することで、Rustのエラーエコシステムと統合される）
impl std::error::Error for MyToolError {}

// 使用例
fn dangerous_operation(input: i32) -> Result<String, MyToolError> {
    match input {
        0 => Err(MyToolError::IoError("ディスク書き込み失敗".into())),
        1 => Err(MyToolError::ParseError("不正なヘッダ".into())),
        2 => Err(MyToolError::LogicError),
        _ => Ok("成功！".into()),
    }
}

fn main() {
    let results = [dangerous_operation(0), dangerous_operation(3)];
    
    for res in results {
        match res {
            Ok(s) => println!("結果: {}", s),
            Err(e) => println!("失敗: {}", e), // Displayの実装が使われる
        }
    }
}

fn safe_div(a: f64, b: f64) -> Result<f64, String> {
    // ここにコードを書いてください
    
}

fn main() {
    let test_cases = vec![(10.0, 2.0), (5.0, 0.0)];

    for (a, b) in test_cases {
        match safe_div(a, b) {
            Ok(result) => println!("{} / {} = {}", a, b, result),
            Err(e) => println!("エラー: {}", e),
        }
    }
}

fn process_csv_data(csv: &str) -> Result<i32, String> {


}

fn main() {
    let inputs = ["10,20,30", "abc,20", "", "  ,50"];

    for input in inputs {
        print!("Input: {:<10} => ", format!("\"{}\"", input));
        match process_csv_data(input) {
            Ok(n) => println!("結果: {}", n),
            Err(e) => println!("エラー: {}", e),
        }
    }
}