Rust: Rust Error Handling: `Result` and the `?` Operator

// ============================================
// Use Result to simulate every step of ordering takeout
// ============================================

// Defining Possible Errors
#[derive(Debug)]
enum OrderError {
    RestaurantNotFound,
    MenuLoadFailed,
    PaymentFailed(String),
    OrderCancelled,
}

// Simulate Store Search
fn find_restaurant(name: &str) -> Result<String, OrderError> {
    let available = vec!["PizzaHouse", "SushiBar", "NoodleShop"];
    if available.contains(&name) {
        Ok(format!("Found: {}", name))
    } else {
        Err(OrderError::RestaurantNotFound)
    }
}

// Simulate the Load Menu
fn load_menu(restaurant: &str) -> Result<Vec<&str>, OrderError> {
    if restaurant.contains("Pizza") {
        Ok(vec!["Margherita", "Pepperoni", "Hawaiian"])
    } else {
        Err(OrderError::MenuLoadFailed)
    }
}

// Simulated Payment
fn process_payment(amount: f64) -> Result<String, OrderError> {
    if amount < 100.0 {
        Ok(format!("Paid: ${:.2}", amount))
    } else {
        Err(OrderError::PaymentFailed("Insufficient balance".into()))
    }
}

fn main() {
    // Go through the entire process from start to finish
    let restaurant = find_restaurant("PizzaHouse");
    match restaurant {
        Ok(msg) => println!("Step 1: {}", msg),
        Err(e) => println!("Step 1 failed: {:?}", e),
    }
}

=== match Processing ===
10 / 2 = <result>
Error: <msg>
10 / 0 = <result>
Error: <msg>

=== unwrap_or Default value ===
10 / 2 = <result1>
10 / 0 = <result2> (default)

=== unwrap_or_else Closure ===
Warning: <e>, using default
Result: <result3>
Will not reach here

// ============================================
// Use Result to handle division-by-zero errors
// ============================================

fn safe_divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    // Use match to handle both success and failure scenarios
    println!("=== match Processing ===");
    match safe_divide(10.0, 2.0) {
        Ok(result) => println!("10 / 2 = {}", result),
        Err(msg) => println!("Error: {}", msg),
    }

    match safe_divide(10.0, 0.0) {
        Ok(result) => println!("10 / 0 = {}", result),
        Err(msg) => println!("Error: {}", msg),
    }

    // Use unwrap_or to provide a default value
    println!("\n=== unwrap_or Default value ===");
    let result1 = safe_divide(10.0, 2.0).unwrap_or(0.0);
    let result2 = safe_divide(10.0, 0.0).unwrap_or(0.0);
    println!("10 / 2 = {}", result1);
    println!("10 / 0 = {} (default)", result2);

    // Use unwrap_or_else to execute a closure
    println!("\n=== unwrap_or_else Closure ===");
    let result3 = safe_divide(10.0, 2.0).unwrap_or_else(|e| {
        eprintln!("Warning: {}, using default", e);
        0.0
    });
    println!("Result: {}", result3);

    // ⚠️ unwrap will panic (Uncomment the code below to try it out)
    // let crash = safe_divide(10.0, 0.0).unwrap();
    // println!("Will not reach here");
}

=== match Processing ===
10 / 2 = 5
Error: Division by zero

=== unwrap_or Default value ===
10 / 2 = 5
10 / 0 = 0 (default)

=== unwrap_or_else Closure ===
Result: 5

--- <file> (0 bytes) ---
<&content[..content.len().min(80)]>
Failed to read '<file>': <e>

// ============================================
// ? Operators: Error propagation with Result
// Only when returning Result can only be used within the function ?
// ============================================

use std::fs::File;
use std::io::{self, Read};

// Read the entire contents of the file
// ? indicates：If File::open Failure，Return Now Err
//         If read_to_string Failure，Return Now Err
fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;          // Open the file，If it fails, return
    let mut content = String::new();
    file.read_to_string(&mut content)?;         // Read the content，If it fails, return
    Ok(content)
}

// Do not use ? An equivalent way of writing——The amount of code has doubled
fn read_file_without_question(path: &str) -> Result<String, io::Error> {
    let mut file = match File::open(path) {
        Ok(f) => f,
        Err(e) => return Err(e),
    };
    let mut content = String::new();
    match file.read_to_string(&mut content) {
        Ok(_) => Ok(content),
        Err(e) => Err(e),
    }
}

// Chain Call ?——More concise
fn read_file_chain(path: &str) -> Result<String, io::Error> {
    let mut content = String::new();
    File::open(path)?.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    // Test files that can and cannot be read, respectively
    let files = vec!["Cargo.toml", "nonexistent.txt"];

    for file in &files {
        match read_file(file) {
            Ok(content) => {
                println!("--- {} ({} bytes) ---", file, content.len());
                println!("{}", &content[..content.len().min(80)]);
            }
            Err(e) => {
                println!("Failed to read '{}': {}", file, e);
            }
        }
    }
}

--- Cargo.toml (42 bytes) ---
[package]
name = "demo"
version = "0.1.0"
edition = "2021"

Failed to read 'nonexistent.txt': The system cannot find the file specified. (os error 2)

[<description>] OK: <result>
[<description>] Error: <e>

// ============================================
// Custom Error Types：Make Your Error Messages More Informative
// To be implemented std::fmt::Display + std::fmt::Debug
// ============================================

use std::fmt;
use std::num::ParseIntError;

// Custom Error Enumeration
#[derive(Debug)]
enum AppError {
    /// Input is empty
    EmptyInput,
    /// Failed to parse the number，Includes the original string
    ParseFailed(String),
    /// The value is outside the allowed range
    OutOfRange { value: i32, min: i32, max: i32 },
    /// Division by Zero
    DivisionByZero,
}

// Implementation Display——Control the error messages users see
impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AppError::EmptyInput => {
                write!(f, "Input cannot be empty")
            }
            AppError::ParseFailed(input) => {
                write!(f, "Failed to parse '{}' as a number", input)
            }
            AppError::OutOfRange { value, min, max } => {
                write!(f, "Value {} is out of range [{}, {}]", value, min, max)
            }
            AppError::DivisionByZero => {
                write!(f, "Division by zero is not allowed")
            }
        }
    }
}

// Implement From<ParseIntError> — let ? operator convert automatically
impl From<ParseIntError> for AppError {
    fn from(_: ParseIntError) -> Self {
        AppError::ParseFailed("unknown".into())
    }
}

// Processing User Input：Analyze and Verify
fn process_input(input: &str, divisor: i32) -> Result<i32, AppError> {
    if input.is_empty() {
        return Err(AppError::EmptyInput);
    }
    let value: i32 = input.parse().map_err(|_| {
        // Manually Convert Error Types
        AppError::ParseFailed(input.to_string())
    })?;
    if value < -100 || value > 100 {
        return Err(AppError::OutOfRange {
            value,
            min: -100,
            max: 100,
        });
    }
    if divisor == 0 {
        return Err(AppError::DivisionByZero);
    }
    Ok(value / divisor)
}

fn main() {
    let test_cases = vec![
        ("42", 2,    "Normal case"),
        ("",   1,    "Empty input"),
        ("abc", 1,   "Parse error"),
        ("999", 1,   "Out of range"),
        ("50",  0,   "Division by zero"),
    ];

    for (input, divisor, description) in test_cases {
        match process_input(input, divisor) {
            Ok(result) => println!("[{}] OK: {}", description, result),
            Err(e) => println!("[{}] Error: {}", description, e),
        }
    }
}

[Normal case] OK: 21
[Empty input] Error: Input cannot be empty
[Parse error] Error: Failed to parse 'abc' as a number
[Out of range] Error: Value 999 is out of range [-100, 100]
[Division by zero] Error: Division by zero is not allowed

Default port: <get_default_port()>
sqrt(16) = <sqrt_unchecked(value)>
Parsed: <n>
Parse failed: <e>
BMI: <bmi>
BMI error: <e>
First element: <first>

// ============================================
// Demo panic! Scenarios Where Error Return Values Are Appropriate
// panic! → Unrecoverable error（Bug/Assertion Failed）
// Result → Recoverable errors（User Input/IOFailure）
// ============================================

// --- Suitable for panic! the scene ---

/// Read the port number from the configuration file
/// If the configuration file is missing，This is part of the program Bug，panic That makes sense.
fn get_default_port() -> u16 {
    // This value is hard-coded in the code.，It's impossible for the resolution to fail.
    "8080"
        .parse()
        .expect("Hardcoded port number is invalid")
}

/// A function that accepts only positive integers
/// Passing a negative number indicates that the caller has Bug，panic Quickly Identify Problems
fn sqrt_unchecked(x: i32) -> f64 {
    if x < 0 {
        panic!("sqrt_unchecked called with negative value: {}", x);
    }
    (x as f64).sqrt()
}

// --- Suitable for Result the scene ---

/// Parsing Numbers from User Input
/// It is normal for users to enter the wrong format.，Should be returned Result
fn parse_user_input(input: &str) -> Result<i32, String> {
    input
        .parse()
        .map_err(|_| format!("'{}' is not a valid integer", input))
}

/// Calculate Body Mass Index（BMI）
/// Weight is 0 A negative number may indicate a data error.，Not a program Bug
fn calculate_bmi(weight_kg: f64, height_m: f64) -> Result<f64, String> {
    if weight_kg <= 0.0 {
        return Err("Weight must be positive".to_string());
    }
    if height_m <= 0.0 {
        return Err("Height must be positive".to_string());
    }
    Ok(weight_kg / (height_m * height_m))
}

fn main() {
    // Scene 1：panic Used for unrecoverable errors
    println!("Default port: {}", get_default_port());

    // Scene 2：panic Used for assertions——Invalid parameter
    let value = 16;
    println!("sqrt({}) = {}", value, sqrt_unchecked(value));

    // Scene 3：Result Used for recoverable errors——User Input
    let inputs = vec!["42", "hello", "-5"];
    for input in inputs {
        match parse_user_input(input) {
            Ok(n) => println!("Parsed: {}", n),
            Err(e) => println!("Parse failed: {}", e),
        }
    }

    // Scene 4：Result Used for business logic validation
    let bmi_cases = vec![
        (70.0, 1.75),
        (0.0, 1.70),
        (65.0, -0.5),
    ];
    for (weight, height) in bmi_cases {
        match calculate_bmi(weight, height) {
            Ok(bmi) => println!("BMI: {:.1}", bmi),
            Err(e) => println!("BMI error: {}", e),
        }
    }

    // Scene 5: expect's panic message helps with debugging
    let numbers = vec![10, 20, 30];
    let first = numbers.first().expect("Vector should not be empty");
    println!("First element: {}", first);
}

Default port: 8080
sqrt(16) = 4
Parsed: 42
Parse failed: 'hello' is not a valid integer
Parsed: -5
BMI: 22.9
BMI error: Weight must be positive
BMI error: Height must be positive
First element: 10

// anyhow Style（Concept Examples，No execution required）
// use anyhow::{Context, Result};
//
// fn read_config() -> Result<String> {
//     let content = std::fs::read_to_string("config.toml")
//         .context("Failed to read config file")?;
//     Ok(content)
// }

// thiserror Style（Concept Examples，No execution required）
// use thiserror::Error;
//
// #[derive(Error, Debug)]
// enum MyError {
//     #[error("IO error: {0}")]
//     Io(#[from] std::io::Error),
//
//     #[error("Parse error: {0}")]
//     Parse(#[from] std::num::ParseIntError),
// }

=== User Processing Test ===
Success: <result>
Failure: <e>

=== Batch Processing (Fault-Tolerant) ===
OK: <result>
Skip: <e>
Success: 0/<inputs.len()>

// ============================================
// Comprehensive Example：Custom Errors + ? Dissemination + Recovery Strategy
// ============================================

use std::fmt;

#[derive(Debug)]
enum AppError {
    ParseError(String),
    ValidationError(String),
    NotFound(String),
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::ParseError(msg) => write!(f, "Parsing error: {}", msg),
            AppError::ValidationError(msg) => write!(f, "Validation Error: {}", msg),
            AppError::NotFound(msg) => write!(f, "Not found: {}", msg),
        }
    }
}

impl From<std::num::ParseIntError> for AppError {
    fn from(e: std::num::ParseIntError) -> Self {
        AppError::ParseError(e.to_string())
    }
}

fn parse_age(input: &str) -> Result<u8, AppError> {
    let age: u8 = input.parse().map_err(|_| AppError::ParseError(format!("'{}' Not a valid number", input)))?;
    if age > 150 {
        return Err(AppError::ValidationError(format!("Age {} Unreasonable", age)));
    }
    Ok(age)
}

fn find_user(id: u32) -> Result<String, AppError> {
    let users = [(1, "Alice"), (2, "Bob"), (3, "Charlie")];
    users.iter()
        .find(|(uid, _)| *uid == id)
        .map(|(_, name)| name.to_string())
        .ok_or_else(|| AppError::NotFound(format!("User ID={}", id)))
}

fn process_user(id_str: &str, age_str: &str) -> Result<String, AppError> {
    let id: u32 = id_str.parse().map_err(|_| AppError::ParseError(format!("Invalid ID: '{}'", id_str)))?;
    let age = parse_age(age_str)?;
    let name = find_user(id)?;
    Ok(format!("User: {}, Age: {}", name, age))
}

fn main() {
    let test_cases = [
        ("1", "30"),
        ("2", "200"),
        ("5", "25"),
        ("abc", "30"),
        ("3", "abc"),
    ];

    println!("=== User Processing Test ===");
    for (id, age) in &test_cases {
        match process_user(id, age) {
            Ok(result) => println!("Success: {}", result),
            Err(e) => println!("Failure: {}", e),
        }
    }

    println!("\n=== Batch Processing (Fault-Tolerant) ===");
    let inputs = [("1", "30"), ("5", "25"), ("2", "abc"), ("3", "20")];
    let mut success_count = 0;
    for (id, age) in &inputs {
        match process_user(id, age) {
            Ok(result) => { println!("OK: {}", result); success_count += 1; }
            Err(e) => println!("Skip: {}", e),
        }
    }
    println!("Success: {}/{}", success_count, inputs.len());
}

=== User Processing Test ===
Success: User: Alice, Age: 30
Failure: Validation Error: Age 200 Unreasonable
Failure: Not found: User ID=5
Failure: Parsing error: Invalid ID: 'abc'
Failure: Parsing error: 'abc' Not a valid number

=== Batch Processing (Fault-Tolerant) ===
OK: User: Alice, Age: 30
Skip: Not found: User ID=5
Skip: Parsing error: 'abc' Not a valid number
OK: User: Charlie, Age: 20
Success: 2/4