FerrousPath

Nivel 2 · Practicante· Lección 6 de 8 · 20 min

Manejo de errores en profundidad

Diseñar tipos de error, convertir con From, cadenas de errores, y cuándo recurrir a thiserror y anyhow.

El trait Error

pub trait Error: Debug + Display {
    fn source(&self) -> Option<&(dyn Error + 'static)> { None }
}

Un tipo de error debe poder imprimirse para los usuarios (Display), imprimirse para los desarrolladores (Debug) y nombrar el error de nivel inferior que lo causó (source).

Conversiones con From

? no se limita a devolver el error; devuelve From::from(error). Implementa From para cada error subyacente y una función podrá mezclar fallos libremente:

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

#[derive(Debug)]
enum AppError {
    Parse(ParseIntError),
    Negative(i64),
    Empty,
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AppError::Parse(_) => write!(f, "input is not a number"),
            AppError::Negative(n) => write!(f, "{n} is negative"),
            AppError::Empty => write!(f, "no input"),
        }
    }
}

impl std::error::Error for AppError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            AppError::Parse(e) => Some(e),
            _ => None,
        }
    }
}

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

fn sqrt_of(input: &str) -> Result<f64, AppError> {
    let input = input.trim();
    if input.is_empty() {
        return Err(AppError::Empty);
    }
    let n: i64 = input.parse()?; // ParseIntError → AppError mediante From
    if n < 0 {
        return Err(AppError::Negative(n));
    }
    Ok((n as f64).sqrt())
}

fn report(e: &dyn std::error::Error) {
    print!("error: {e}");
    let mut cause = e.source();
    while let Some(c) = cause {
        print!(" ← caused by: {c}");
        cause = c.source();
    }
    println!();
}

fn main() {
    for input in ["144", "", "-4", "12abc"] {
        match sqrt_of(input) {
            Ok(v) => println!("{v}"),
            Err(e) => report(&e),
        }
    }
}

thiserror: lo mismo sin el código repetitivo

Para las bibliotecas, el crate thiserror deriva las tres implementaciones:

// crate: thiserror
use thiserror::Error;

#[derive(Debug, Error)]
enum AppError {
    #[error("input is not a number")]
    Parse(#[from] std::num::ParseIntError),
    #[error("{0} is negative")]
    Negative(i64),
    #[error("no input")]
    Empty,
}

fn parse(s: &str) -> Result<i64, AppError> {
    if s.is_empty() {
        return Err(AppError::Empty);
    }
    let n: i64 = s.parse()?;
    if n < 0 { Err(AppError::Negative(n)) } else { Ok(n) }
}

fn main() {
    for s in ["7", "", "-1", "x"] {
        println!("{:?}", parse(s).map_err(|e| e.to_string()));
    }
}

#[from] genera la implementación de From y conecta source. El código generado es el que habrías escrito a mano, y thiserror no aparece en tu API pública.

anyhow: un único tipo de error para las aplicaciones

Una aplicación normalmente no hace match sobre las variantes de error: informa de ellas. anyhow::Error contiene cualquier error y te deja añadirle contexto a medida que sube:

// crate: anyhow
use anyhow::{bail, Context, Result};

fn load_port(path: &str) -> Result<u16> {
    let text = std::fs::read_to_string(path)
        .with_context(|| format!("could not read config file `{path}`"))?;
    let port: u16 = text.trim().parse().context("port is not a number")?;
    if port < 1024 {
        bail!("port {port} is privileged");
    }
    Ok(port)
}

fn main() {
    if let Err(e) = load_port("/no/such/file.conf") {
        println!("{e:#}"); // {:#} imprime toda la cadena en una línea
    }
}

El contexto es lo que convierte No such file or directory en un mensaje con el que alguien puede hacer algo.

Pautas

  • Bibliotecas: devuelve un enum de error concreto (a menudo mediante thiserror). Quien llama puede hacer match sobre él, y no le impones una dependencia. Márcalo con #[non_exhaustive] si puede que añadas variantes.
  • Aplicaciones: usa anyhow (o eyre) y añade contexto en cada capa.
  • No uses unwrap en código de biblioteca salvo que un invariante violado sea de verdad un bug.
  • No conviertas los errores en cadenas demasiado pronto. Result<T, String> descarta una estructura que quien llama podría necesitar.
  • Pánico ante los bugs, Err ante los fallos. Una función cuya documentación dice «entra en pánico si index >= len» está describiendo un bug de quien la llama.
  • Convierte un Option con ok_or / ok_or_else; transforma los errores con map_err; recupérate con or_else y unwrap_or_else.

Ejercicios

  1. Escribe a mano un enum ReadError { Io(std::io::Error), Parse { line: usize, source: ParseIntError } }, con Display, Error::source y From<io::Error>.
  2. Escribe fn read_numbers(path: &str) -> Result<Vec<i64>, ReadError> que informe del número de línea de la primera línea incorrecta.
  3. Reescribe ambos con thiserror, y después escribe un main que use anyhow y añada el nombre del archivo como contexto.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Cómo convierte ? un io::Error en tu propio AppError?

  2. 2.¿Qué crate está pensado para bibliotecas que exponen un enum de error preciso, sobre el que se puede hacer match?

  3. 3.¿Qué devuelve Error::source()?

¿Has terminado la lección y los ejercicios?