Rust Error Handling

// Immediately stops the thread
panic!("index out of bounds");

// Triggers automatically on bad access
let v = vec![1, 2, 3];
v[99];   // panics at runtime

// Set RUST_BACKTRACE=1 to see trace
// $ RUST_BACKTRACE=1 cargo run

// Use panic for:
// - bugs / programming errors
// - tests
// - prototype code
// - truly unrecoverable states

// The Result enum (in std prelude)
enum Result<T, E> {
    Ok(T),    // success value
    Err(E),   // error value
}

// Functions that can fail return Result
use std::fs::File;

let f = File::open("hello.txt");
// f is Result<File, std::io::Error>

// Use for:
// - I/O operations
// - parsing / conversion
// - network calls
// - any fallible operation

// Use panic! when:
// ✗ Invalid input that CAN'T happen
// ✗ Tests — unwrap() is fine
// ✗ Prototype / example code
// ✗ State is fundamentally broken

// Use Result when:
// ✓ File might not exist
// ✓ Network could fail
// ✓ User input might be invalid
// ✓ Caller should decide what to do

// Golden rule:
// Libraries → always Result
// Binaries → can panic on bad state

// unwrap — panics with generic message
let f = File::open("hi.txt").unwrap();
// panics: "called Result::unwrap() on Err"

// expect — panics with YOUR message
let f = File::open("hi.txt")
    .expect("hi.txt should exist");
// panics: "hi.txt should exist: ..."

// Use unwrap/expect only in:
// - tests
// - prototypes
// - cases you're 100% certain succeed

let res: Result<i32, &str> = Err("fail");

// Default value
res.unwrap_or(0)              // 0

// Compute default lazily
res.unwrap_or_else(|e| {
    eprintln!("Error: {e}");
    -1
})

// Default from Default trait
res.unwrap_or_default()      // 0 (i32::default)

// Check then get
if res.is_ok() {
    let val = res.unwrap();  // safe here
}

let ok: Result<i32, &str> = Ok(2);

// map — transform Ok value
ok.map(|n| n * 3)          // Ok(6)

// map_err — transform Err value
ok.map_err(|e| format!("{e}"))

// and_then — chain fallible ops
ok.and_then(|n|
    if n > 0 { Ok(n) }
    else { Err("neg") }
)

// or — use fallback Result
let err: Result<i32, &str> = Err("x");
err.or(Ok(5))              // Ok(5)

use std::fmt;

// 1. Define your error type
#[derive(Debug)]
enum AppError {
    NotFound(String),
    ParseError(std::num::ParseIntError),
    IoError(std::io::Error),
}

// 2. Implement Display
impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) ->
        fmt::Result
    {
        match self {
            AppError::NotFound(s) =>
                write!(f, "not found: {s}"),
            AppError::ParseError(e) =>
                write!(f, "parse error: {e}"),
            AppError::IoError(e) =>
                write!(f, "io error: {e}"),
        }
    }
}

// 3. Impl Error (can be empty)
impl std::error::Error for AppError {}

// Implement From so ? auto-converts
impl From<std::io::Error>
    for AppError
{
    fn from(e: std::io::Error) -> Self {
        AppError::IoError(e)
    }
}

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

// Now ? works across error types!
fn run() -> Result<(), AppError> {
    let _f = File::open("x.txt")?;   // IoError
    let _n = "abc".parse::<i32>()?; // ParseError
    Ok(())
}

// No custom type — good for binaries
type BoxError =
    Box<dyn std::error::Error>;

fn run() -> Result<(), BoxError> {
    let _f = File::open("x.txt")?;
    let _n = "abc".parse::<i32>()?;
    Ok(())
}

// type alias for cleaner signatures
type Result<T> =
    std::result::Result<T, BoxError>;

fn process() -> Result<String> {
    Ok(String::from("done"))
}

// Parse a list of strings to ints
let strings = vec!["1","2","3"];

// Fail on first error
let nums: Result<Vec<i32>, _> =
    strings.iter()
    .map(|s| s.parse::<i32>())
    .collect();
// Ok([1, 2, 3])

// Collect only successes (ignore errors)
let ok_only: Vec<i32> =
    vec!["1","x","3"]
    .iter()
    .filter_map(|s| s.parse().ok())
    .collect();
// [1, 3]

use std::num::ParseIntError;

#[derive(Debug)]
enum MyErr { Parse(ParseIntError), Neg }

fn parse_pos(s: &str) -> Result<u32, MyErr> {
    // Convert ParseIntError → MyErr::Parse
    let n: i32 = s.parse()
        .map_err(MyErr::Parse)?;

    // Check sign
    if n < 0 { return Err(MyErr::Neg); }
    Ok(n as u32)
}

use anyhow::{Context, Result};

fn load_config(path: &str) -> Result<String> {
    let mut f = File::open(path)
        // Add context to any error
        .with_context(||
            format!("opening config: {path}"))?;
    let mut s = String::new();
    f.read_to_string(&mut s)
        .context("reading config file")?;
    Ok(s)
}
// Error chain: "reading config file:
//   opening config: conf.toml:
//   No such file or directory (os error 2)"