【Rust】エラーハンドリング

[profile.dev]
panic = 'abort'
 
[profile.release]
panic = 'abort'

fn main() {
    panic!("パニック！");
}

thread 'main' panicked at src/main.rs:2:5:
パニック！
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

thread 'main' panicked at src/main.rs:2:5:
パニック！
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Aborted

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn foo(x: i8) -> Result<i8, String> {
    if x == 1 {
        Err(String::from("ゼロはダメ"))
    } else {
        Ok(x)
    }
}

fn main() {
    let result = foo(0);
 
    match result {
        Ok(value) => println!("Result: {}", value),
        Err(err) => println!("Error: {}", err), // Error: ゼロはダメ
    }
 
    let result = foo(1);
 
    match result {
        Ok(value) => println!("Result: {}", value), // Result: 1
        Err(err) => println!("Error: {}", err),
    }
}

fn foo(x: i8) -> Result<i8, String> {
    if x == 0 {
        Err(String::from("ゼロはダメ"))
    } else if x == 1 {
        Err(String::from("1はダメ"))
    } else {
        Ok(x)
    }
}

fn main() {
    let result = foo(1);
    match result {
        Ok(n) => println!("Success: {}", n),
        Err(ref error) if error == "1はダメ" => panic!("パニック: {:?}", error),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    foo(0).unwrap();
}

thread 'main' panicked at src/main.rs:12:12:
called `Result::unwrap()` on an `Err` value: "ゼロはダメ"

fn main() {
    foo(0).expect("fooでエラー!");
}

thread 'main' panicked at src/main.rs:12:12:
fooでエラー!: "ゼロはダメ"

fn read_username_from_file() -> Result<String, io::Error> {
    let f = File::open("hello.txt");
 
    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),
    };
 
    let mut s = String::new();
 
    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}

fn foo(x: i8) -> Result<i8, String> {
    if x == 0 {
        Err(String::from("ゼロはダメ"))
    } else {
        Ok(x)
    }
}
 
fn f() -> Result<i8, String> {
    let result = foo(0)?;
    Ok(result)
}
 
fn main() -> Result<(), String> {
    println!("{:?}", f()?); // Error: "ゼロはダメ"
    Ok(())
}
 

fn give_adult(drink: Option<&str>) {
    match drink {
        Some("lemonade") => println!("甘い！"),
        Some(inner) => println!("{}? うまい！", inner),
        None => println!("ドリンクがない！！"),
    }
}
fn main() {
    let water = Some("water");
    let lemonade = Some("lemonade");
    let void = None;
 
    give_adult(water); // water? うまい！
    give_adult(lemonade); // 甘い！
    give_adult(void); // ドリンクがない！！
}

fn drink(drink: Option<&str>) {
    let inside = drink.unwrap();
    if inside == "lemonade" {
        panic!("ぎゃああああああ!!!!");
    }
 
    println!("I love {}s!!!!!", inside);
}
fn main() {
 
    let coffee = Some("coffee");
    let nothing = None;
 
    drink(coffee);
    drink(nothing);
}

fn f(n: Option<i32>) -> Option<i32> {
    let res = n? + 1;
    Some(res)
}
 
fn main() {
    let hoge = f(None);
    println!("{:?}", hoge); // None
}

#[derive(Debug)]
struct Peeled(Food);
 
#[derive(Debug)]
struct Cooked(Food);
 
fn peel(food: Option<Food>) -> Option<Peeled> {
    match food {
        Some(food) => Some(Peeled(food)),
        None => None,
    }
}

fn peel(food: Option<Food>) -> Option<Peeled> {
    food.map(Peeled)
}

fn peel(food: Option<Food>) -> Option<Peeled> {
    food.map(Peeled)
}
 
fn chop(peeled: Option<Peeled>) -> Option<Chopped> {
    peeled.map(|Peeled(food)| Chopped(food))
}
 
fn cook(chopped: Option<Chopped>) -> Option<Cooked> {
    chopped.map(|Chopped(food)| Cooked(food))
}
 
// 複数の`map()`をチェイン
fn process(food: Option<Food>) -> Option<Cooked> {
    food.map(Peeled)
        .map(|Peeled(f)| Chopped(f))
        .map(|Chopped(f)| Cooked(f))
}

fn have_ingredients(food: Food) -> Option<Food> {
    match food {
        Food::Sushi => None,
        _ => Some(food),
    }
}
 
fn have_recipe(food: Food) -> Option<Food> {
    match food {
        Food::Curry => None,
        _ => Some(food),
    }
}
 
// 料理を作るためには、材料とレシピの両方が必要。
// ロジックの流れを`match`のチェインで表す。
fn cookable(food: Food) -> Option<Food> {
    match have_recipe(food) {
        None => None,
        Some(food) => have_ingredients(food),
    }
}

fn cookable(food: Food) -> Option<Food> {
    have_recipe(food).map(have_ingredients).flatten()
}

fn cookable(food: Food) -> Option<Food> {
    have_recipe(food).and_then(have_ingredients)
}

#[derive(Debug)]
enum Fruit {
    Apple,
    Orange,
}
 
fn main() {
    let apple = Some(Fruit::Apple);
    let orange = Some(Fruit::Orange);
    let no_fruit: Option<Fruit> = None;
 
    let first_available_fruit = no_fruit.or(orange).or(apple);
    println!("first_available_fruit: {:?}", first_available_fruit);
}

use std::num::ParseIntError;
 
type AliasedResult<T> = Result<T, ParseIntError>;
 
fn multiply(first_number_str: &str, second_number_str: &str) -> AliasedResult<i32> {
    first_number_str.parse::<i32>().and_then(|first_number| {
        second_number_str.parse::<i32>().map(|second_number| first_number * second_number)
    })
}
 
// もう一度使用。エイリアスによって再度明記する必要性がない。
fn print(result: AliasedResult<i32>) {
    match result {
        Ok(n)  => println!("n is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}
 
fn main() {
    print(multiply("10", "2"));
    print(multiply("t", "2"));
}

use std::num::ParseIntError;
 
fn multiply(first_number_str: &str, second_number_str: &str) -> Result<i32, ParseIntError> {
    let first_number = try!(first_number_str.parse::<i32>());
    let second_number = try!(second_number_str.parse::<i32>());
 
    Ok(first_number * second_number)
}
 
fn print(result: Result<i32, ParseIntError>) {
    match result {
        Ok(n)  => println!("n is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}
 
fn main() {
    print(multiply("10", "2"));
    print(multiply("t", "2"));
}

fn double_first(vec: Vec<&str>) -> i32 {
    let first = vec.first().unwrap(); // Generate error 1
                                      // エラー１の生成
    2 * first.parse::<i32>().unwrap() // Generate error 2
                                      // エラー２の生成
}
 
fn main() {
    let numbers = vec!["42", "93", "18"];
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];
 
    println!("The first doubled is {}", double_first(numbers));
 
    println!("The first doubled is {}", double_first(empty));
    // Error 1: the input vector is empty
    // エラー１：入力が空ベクトル
 
    println!("The first doubled is {}", double_first(strings));
    // Error 2: the element doesn't parse to a number
    // エラー２：要素が数字としてパースできない
}

use std::num::ParseIntError;
 
// 一番目の要素を2倍にして返す
fn double_first(vec: Vec<&str>) -> Option<Result<i32, ParseIntError>> {
    vec.first().map(|first| first.parse::<i32>().map(|n| 2 * n))
}
 
fn main() {
    let numbers = vec!["42", "93", "18"];
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];
 
    println!("1番目の2倍は{:?}", double_first(numbers)); // 1番目の2倍はSome(Ok(84))
 
    println!("1番目の2倍は{:?}", double_first(empty)); // 1番目の2倍はNone
 
    println!("1番目の2倍は{:?}", double_first(strings));
    // 1番目の2倍はSome(Err(ParseIntError { kind: InvalidDigit }))
}

use std::num::ParseIntError;
 
fn double_first(vec: Vec<&str>) -> Result<Option<i32>, ParseIntError> {
    let opt = vec.first().map(|first| first.parse::<i32>().map(|n| 2 * n));
 
    opt.map_or(Ok(None), |r| r.map(Some))
}
 
fn main() {
    let numbers = vec!["42", "93", "18"];
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];
 
    println!("1番目の2倍は{:?}", double_first(numbers)); //1番目の2倍はOk(Some(84))
    println!("1番目の2倍は{:?}", double_first(empty)); // 1番目の2倍はOk(None)
    println!("1番目の2倍は{:?}", double_first(strings));
    // 1番目の2倍はErr(ParseIntError { kind: InvalidDigit })
}

use std::error;
use std::fmt;
 
type Result<T> = std::result::Result<T, DoubleError>;
 
#[derive(Debug, Clone)]
struct DoubleError;
 
impl fmt::Display for DoubleError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "invalid first item to double")
    }
}
 
impl error::Error for DoubleError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        None
    }
}
 
fn double_first(vec: Vec<&str>) -> Result<i32> {
    vec.first()
        .ok_or(DoubleError)
        .and_then(|s| {
            s.parse::<i32>()
                // Update to the new error type here also.
                // ここでも新たなエラー型に更新する。
                .map_err(|_| DoubleError)
                .map(|i| 2 * i)
        })
}
 
fn print(result: Result<i32>) {
    match result {
        Ok(n) => println!("1番目の要素の2倍は{}", n),
        Err(e) => println!("エラー: {}", e),
    }
}
 
fn main() {
    let numbers = vec!["42", "93", "18"];
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];
 
    print(double_first(numbers)); // 1番目の要素の2倍は84
    print(double_first(empty)); // エラー: invalid first item to double
    print(double_first(strings)); //エラー: invalid first item to double
}

use std::error;
use std::fmt;
 
// エイリアスを`Box<error::Error>`に変更する。
type Result<T> = std::result::Result<T, Box<dyn error::Error>>;
 
#[derive(Debug, Clone)]
struct EmptyVec;
 
impl fmt::Display for EmptyVec {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "invalid first item to double")
    }
}
 
impl error::Error for EmptyVec {}
 
fn double_first(vec: Vec<&str>) -> Result<i32> {
    vec.first()
        .ok_or_else(|| EmptyVec.into()) // Converts to Box
        // Boxに変換
        .and_then(|s| {
            s.parse::<i32>()
                .map_err(|e| e.into()) // Converts to Box
                // Boxに変換
                .map(|i| 2 * i)
        })
}
 
fn print(result: Result<i32>) {
    match result {
        Ok(n) => println!("1番目の要素の2倍は{}", n),
        Err(e) => println!("エラー: {}", e),
    }
}
 
fn main() {
    let numbers = vec!["42", "93", "18"]; // 1番目の要素の2倍は84
    let empty = vec![]; // エラー: invalid first item to double
    let strings = vec!["tofu", "93", "18"]; // エラー: invalid digit found in string
 
    print(double_first(numbers));
    print(double_first(empty));
    print(double_first(strings));
}

use std::error;
use std::fmt;
 
// Change the alias to `Box<dyn error::Error>`.
// エイリアスを`Box<error::Error>`に変更する。
type Result<T> = std::result::Result<T, Box<dyn error::Error>>;
 
#[derive(Debug)]
struct EmptyVec;
 
impl fmt::Display for EmptyVec {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "invalid first item to double")
    }
}
 
impl error::Error for EmptyVec {}
 
// 前と同じ構造だが、`Results`と`Option`を繋げていく代わりに、`?`で内部の値をその場で取得する。
fn double_first(vec: Vec<&str>) -> Result<i32> {
    let first = vec.first().ok_or(EmptyVec)?;
    let parsed = first.parse::<i32>()?;
    Ok(2 * parsed)
}
 
fn print(result: Result<i32>) {
    match result {
        Ok(n) => println!("1番目の要素の2倍は{}", n),
        Err(e) => println!("エラー: {}", e),
    }
}
 
fn main() {
    let numbers = vec!["42", "93", "18"];
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];
 
    print(double_first(numbers)); // 1番目の要素の2倍は84
    print(double_first(empty)); // エラー: invalid first item to double
    print(double_first(strings)); // エラー: invalid digit found in string
}

use std::error;
use std::error::Error;
use std::fmt;
use std::num::ParseIntError;
 
type Result<T> = std::result::Result<T, DoubleError>;
 
#[derive(Debug)]
enum DoubleError {
    EmptyVec,
    // パースエラーの実装まで処理を委譲します。
    // 追加の情報を提供するには、型により多くのデータを追加する必要があります。
    Parse(ParseIntError),
}
 
impl fmt::Display for DoubleError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DoubleError::EmptyVec => write!(f, "please use a vector with at least one element"),
            // ラップされたエラーは追加情報を含み、source メソッドから取り出すことができます。
            // これはラッパーなので、`fmt`での元となる型の実装に処理を任せます。
            DoubleError::Parse(..) => write!(f, "the provided string could not be parsed as int"),
        }
    }
}
 
impl error::Error for DoubleError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match *self {
            DoubleError::EmptyVec => None,
            // 元の実装のエラー型が原因。
            // `&error::Error`トレイトオブジェクトに暗にキャストされる。
            // 元となる型が`Error`トレイトをすでに実装しているため問題なく動く。
            DoubleError::Parse(ref e) => Some(e),
        }
    }
}
 
// `ParseIntError`から`DoubleError`への変換の実装。
// `ParseIntError`が`DoubleError`に変換される必要がある時、自動的に`?`から呼び出される。
impl From<ParseIntError> for DoubleError {
    fn from(err: ParseIntError) -> DoubleError {
        DoubleError::Parse(err)
    }
}
 
fn double_first(vec: Vec<&str>) -> Result<i32> {
    let first = vec.first().ok_or(DoubleError::EmptyVec)?;
    let parsed = first.parse::<i32>()?;
 
    Ok(2 * parsed)
}
 
fn print(result: Result<i32>) {
    match result {
        Ok(n) => println!("1番目の要素の2倍は{}", n),
        Err(e) => {
            println!("エラー: {}", e);
            if let Some(source) = e.source() {
                println!("  Caused by: {}", source);
            }
        }
    }
}
 
fn main() {
    let numbers = vec!["42", "93", "18"];
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];
 
    print(double_first(numbers)); // 1番目の要素の2倍は84
    print(double_first(empty));
    // エラー: please use a vector with at least one element
 
    print(double_first(strings));
    // エラー: the provided string could not be parsed as int
}