Error Handling

fn page_slice(pages: &[u32], start: usize, len: usize) -> &[u32] {
    assert!(len > 0, "len must be positive, got {len}");   // assert! panics if false
    &pages[start..start + len]                              // panics if out of bounds
}

fn main() {
    let pages = [10, 20, 30];
    println!("{:?}", page_slice(&pages, 1, 2));
    let result = std::panic::catch_unwind(|| page_slice(&pages, 2, 5).len());
    println!("caught a panic: {}", result.is_err()); // true -- for illustration only
}

use std::error::Error;
use std::fmt;
use std::num::ParseIntError;

#[derive(Debug)]
pub enum ImportError {
    Io(std::io::Error),
    BadYear { line: usize, source: ParseIntError },
    MissingTitle { line: usize },
}

impl fmt::Display for ImportError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ImportError::Io(_) => write!(f, "could not read the import file"),
            ImportError::BadYear { line, .. } => write!(f, "invalid year on line {line}"),
            ImportError::MissingTitle { line } => write!(f, "missing title on line {line}"),
        }
    }
}

impl Error for ImportError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            ImportError::Io(e) => Some(e),
            ImportError::BadYear { source, .. } => Some(source),
            ImportError::MissingTitle { .. } => None,
        }
    }
}

// From impls let `?` convert automatically.
impl From<std::io::Error> for ImportError {
    fn from(e: std::io::Error) -> Self {
        ImportError::Io(e)
    }
}

fn parse_line(n: usize, line: &str) -> Result<(String, u16), ImportError> {
    let (title, year) = line.split_once(';').ok_or(ImportError::MissingTitle { line: n })?;
    let year = year.trim().parse().map_err(|source| ImportError::BadYear { line: n, source })?;
    Ok((title.trim().to_owned(), year))
}

fn import(path: &str) -> Result<Vec<(String, u16)>, ImportError> {
    let text = std::fs::read_to_string(path)?; // io::Error -> ImportError via From
    text.lines().enumerate().map(|(i, l)| parse_line(i + 1, l)).collect()
}

fn report(err: &dyn Error) {
    eprint!("error: {err}");
    let mut cause = err.source();
    while let Some(c) = cause {
        eprint!(": {c}");
        cause = c.source();
    }
    eprintln!();
}

fn main() {
    if let Err(e) = parse_line(3, "Dune; 19x5") {
        report(&e); // error: invalid year on line 3: invalid digit found in string
    }
    if let Err(e) = import("/no/such/file.csv") {
        report(&e); // error: could not read the import file: No such file or directory (os error 2)
    }
}

use std::error::Error;

type BoxError = Box<dyn Error + Send + Sync + 'static>;

fn load_limit(text: &str) -> Result<u8, BoxError> {
    let n: u8 = text.trim().parse()?;          // ParseIntError -> BoxError
    if n == 0 {
        return Err("limit must be positive".into()); // &str -> BoxError
    }
    Ok(n)
}

fn main() {
    println!("{:?}", load_limit("5"));
    match load_limit("0") {
        Ok(_) => {}
        Err(e) => println!("error: {e}"),
    }
}

use thiserror::Error;

#[derive(Debug, Error)]
pub enum ImportError {
    #[error("could not read the import file")]
    Io(#[from] std::io::Error),                       // #[from] generates From and source()
    #[error("invalid year on line {line}")]
    BadYear { line: usize, #[source] source: std::num::ParseIntError },
    #[error("missing title on line {line}")]
    MissingTitle { line: usize },
    #[error(transparent)]                              // forward Display and source() to the inner error
    Catalog(#[from] shelf_core::CatalogError),
}

fn main() {
    let e = ImportError::MissingTitle { line: 4 };
    println!("{e}"); // missing title on line 4
}

use anyhow::{Context, Result, bail, ensure};

fn read_config(path: &str) -> Result<u16> {
    let text = std::fs::read_to_string(path).with_context(|| format!("reading config {path}"))?;
    let port: u16 = text.trim().parse().context("config must contain a port number")?;
    ensure!(port >= 1024, "port {port} is privileged");
    if port == 8443 {
        bail!("port 8443 is reserved for the admin console");
    }
    Ok(port)
}

fn main() {
    match read_config("/etc/shelf/port.conf") {
        Ok(port) => println!("listening on {port}"),
        Err(e) => eprintln!("error: {e:#}"),
        // error: reading config /etc/shelf/port.conf: No such file or directory (os error 2)
    }
}

use std::process::ExitCode;

fn run() -> anyhow::Result<()> {
    let args: Vec<String> = std::env::args().collect();
    anyhow::ensure!(args.len() <= 3, "usage: shelf <command> [arg]");
    println!("ok");
    Ok(())
}

fn main() -> ExitCode {
    match run() {
        Ok(()) => ExitCode::SUCCESS,
        Err(e) => {
            eprintln!("error: {e:#}");  // Display with the chain, not Debug
            ExitCode::from(2)
        }
    }
}