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(oeyre) y añade contexto en cada capa. - No uses
unwrapen 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,
Errante los fallos. Una función cuya documentación dice «entra en pánico siindex >= len» está describiendo un bug de quien la llama. - Convierte un
Optionconok_or/ok_or_else; transforma los errores conmap_err; recupérate conor_elseyunwrap_or_else.
Ejercicios
- Escribe a mano un
enum ReadError { Io(std::io::Error), Parse { line: usize, source: ParseIntError } }, conDisplay,Error::sourceyFrom<io::Error>. - Escribe
fn read_numbers(path: &str) -> Result<Vec<i64>, ReadError>que informe del número de línea de la primera línea incorrecta. - Reescribe ambos con
thiserror, y después escribe unmainque useanyhowy añada el nombre del archivo como contexto.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Cómo convierte
?unio::Erroren tu propioAppError?2.¿Qué crate está pensado para bibliotecas que exponen un enum de error preciso, sobre el que se puede hacer match?
3.¿Qué devuelve
Error::source()?