一文帶你瞭解Rust是如何處理錯誤的

fn main() {
    println!("程式開始執行");
    // 在 Go 裡面引發異常通過 panic 函數
    // Rust 則是通過 panic! 宏，還是挺相似的
    panic!("發生了不可恢復的錯誤");
    println!("程式不會執行到這裡");
}

fn main() {
    // 如果 assert! 裡面的布林值為真，無事發生
    // 如果為假，那麼程式會 panic 掉
    assert!(1 == 2);

    // assert!(1 == 2) 還可以寫成
    assert_eq!(1, 2);

    // 除了 assert_eq! 外，還有 assert_ne!
    assert_ne!(1, 2);

    // 不過最常用的還是 assert!
}

fn get_data() {
    unimplemented!("還沒開發完畢，by {}", "古明地覺");
}

fn main() {
    get_data()
}

fn divide_by_3(n: u32) -> u32 {
    // 找到可以滿足 3 * i 大於 n 的最小整數 i
    for i in 0 .. {
        if 3 * i > n {
            return i;
        }
    }
    // 顯然程式不可能執行到這裡
    // 因為 for 迴圈是無限進行的，最終一定會 return
    // 但 Rust 在編譯時，從語法上是判斷不出來的
    // 它只知道這個函數目前不完整，因為如果 for 迴圈結束，
    // 那麼返回值就不符合 u32 型別了，儘管我們知道 for 迴圈不可能結束

    // 為此我們可以隨便 return 一個 u32，並寫上註釋
    // "此處是為了保證函數簽名合法，但程式不會執行到這裡"
    // 而更專業的做法是使用一個宏
    unreachable!("程式不可能執行到這裡");
}

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

// 計算兩個 i32 的商
fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
    let ret: Result<i32, &'static str>;
    // 如果 b != 0，返回 Ok(a / b)
    if b != 0 {
        ret = Ok(a / b);
    } else {
        // 否則返回除零錯誤
        ret = Err("ZeroDivisionError: division by zero")
    }
    return ret;
}

fn main() {
    let a = divide(100, 20);
    println!("a = {:?}", a);

    let b = divide(100, 0);
    println!("b = {:?}", b);
    /*
    a = Ok(5)
    b = Err("ZeroDivisionError: division by zero")
    */
}

fn main() {
    // 將返回值和 5 相加，由於 a 是 Ok(i32)
    // 顯然它不能直接和 i32 相加
    let a = divide(100, 20);
    match a {
        Ok(i) => println!("a + 5 = {}", i + 5),
        Err(error) => println!("出錯啦: {}", error),
    }

    let b = divide(100, 0);
    match b {
        Ok(i) => println!("b + 5 = {}", i + 5),
        Err(error) => println!("出錯啦: {}", error),
    }
    /*
    a + 5 = 10
    出錯啦: ZeroDivisionError: division by zero
    */
}

fn external_some_func() -> Result<u32, &'static str> {
    // 外部的某個函數
    Ok(666)
}

fn call1() -> Result<f64, &'static str> {
    // 我們要呼叫 external_some_func
    match external_some_func() {
        // 型別轉化在 Rust 裡面通過 as 關鍵字
        Ok(i) => Ok((i + 1) as f64),
        Err(error) => Err(error)
    }
}

// 但是上面這種呼叫方式有點繁瑣
// 我們還可以使用問號表示式
fn call2() -> Result<f64, &'static str> {
    // 注：使用問號表示式有一個前提
    // 呼叫方和被呼叫方的返回值都要是 Result 列舉型別
    // 並且它們的錯誤型別要相同，比如這裡都是 &'static str
    let ret = external_some_func()?;
    Ok((ret + 1) as f64)
}

fn main() {
    println!("{:?}", call1());  // Ok(667.0)
    println!("{:?}", call2());  // Ok(667.0)
}

fn external_some_func() -> Result<u32, &'static str> {
    // 外部的某個函數
    Err("函數執行出錯")
}

fn call1() -> Result<f64, &'static str> {
    match external_some_func() {
        Ok(i) => Ok((i + 1) as f64),
        Err(error) => Err(error)
    }
}

fn call2() -> Result<f64, &'static str> {
    let ret = external_some_func()?;
    Ok((ret + 1) as f64)
}

fn main() {
    println!("{:?}", call1());  // Err("函數執行出錯")
    println!("{:?}", call2());  // Err("函數執行出錯")
}

struct FileNotFoundError {
    err: String,
    filename: String,
}

struct IndexError {
    err: &'static str,
    index: u32,
}

fn external_some_func1() -> Result<u32, FileNotFoundError> {
    Err(FileNotFoundError {
        err: String::from("檔案不存在"),
        filename: String::from("main.py"),
    })
}

fn external_some_func2() -> Result<i32, IndexError> {
    Err(IndexError {
        err: "索引越界了",
        index: 9,
    })
}

// 其它程式碼不變
#[derive(Debug)]
enum MyError {
    Error1(FileNotFoundError),
    Error2(IndexError)
}

// 為 MyError 實現 From trait
// 分別是 From<FileNotFoundError> 和 From<IndexError>
impl From<FileNotFoundError> for MyError {
    fn from(error: FileNotFoundError) -> MyError {
        MyError::Error1(error)
    }
}

impl From<IndexError> for MyError {
    fn from(error: IndexError) -> MyError {
        MyError::Error2(error)
    }
}

fn call1() -> Result<i32, MyError>{
    // 呼叫的兩個函數、和當前函數返回的錯誤型別都不相同
    // 但是當前函數是合法的，因為 MyError 實現了 From trait
    // 當錯誤型別是 FileNotFoundError 或 IndexError 時
    // 它們會呼叫 MyError 實現的 from 方法
    // 然後將錯誤統一轉換為 MyError 型別
    let x = external_some_func1()?;
    let y = external_some_func2()?;
    Ok(x as i32 + y)
}

fn call2() -> Result<i32, MyError>{
    let y = external_some_func2()?;
    let x = external_some_func1()?;
    Ok(x as i32 + y)
}

fn main() {
    println!("{:?}", call1());
    /*
    Err(Error1(FileNotFoundError { err: "檔案不存在", filename: "main.py" }))
    */
    println!("{:?}", call2());
    /*
    Err(Error2(IndexError { err: "索引越界了", index: 9 }))
    */
}

fn main() -> Result<(), MyError> {
    // 如果 call1() 的後面沒有加問號
    // 那麼在呼叫沒有出錯的時候，返回的就是 Ok(...)
    // 呼叫出錯的時候，返回的就是 Err(...)
    // 但不管哪一種，都是 Result<T, E> 型別
    println!("{:?}", call1());

    // 如果加了 ? 那麼就不一樣了
    // 在呼叫沒出錯的時候，會直接將 Ok(...) 裡面的值取出來
    // 呼叫出錯的時候，當前函數會中止執行，
    // 並將被呼叫方（這裡是 call2）的錯誤作為呼叫方（這裡是 main）的返回值返回
    // 此時通過問號表示式，就實現了錯誤在上下文當中傳遞
    // 所以這也要求被呼叫方返回的錯誤型別要和呼叫方相同
    println!("{:?}", call2()?);

    // 為了使函數簽名合法，這裡要返回一個值，直接返回 Ok(()) 即可
    // 但上面的 call2()? 是會報錯的，所以它下面的程式碼都不會執行
    Ok(())
}