anyhow: un solo tipo de error, con contexto, para aplicaciones

En una aplicación la pregunta cambia. Nadie va a construir lógica sobre tus errores internos; al final del día un fallo sube hasta main, se registra y el proceso termina con código distinto de cero. Enumerar cuarenta modos de fallo con un enum sería trabajo desperdiciado: no vas a escribir recuperación específica para cada uno. Lo que quieres es propagar sin fricción, añadir contexto por el camino —“esto ocurrió mientras cargaba la configuración”— y obtener al final un informe legible. Esa es exactamente la propuesta de anyhow: un único tipo de error que traga cualquier cosa, contexto de una línea y macros para abortar. Renuncia a que puedas hacer match, pero en un binario esa renuncia no cuesta nada.

anyhow::Result y el error que lo traga todo

Se declara la dependencia y se cambia el tipo de retorno:

[dependencies]
anyhow = "1"

use anyhow::{Context, Result};

fn leer_umbral(ruta: &str) -> Result<u32> {
    let texto = std::fs::read_to_string(ruta)
        .with_context(|| format!("no se pudo leer '{ruta}'"))?;
    let umbral: u32 = texto.trim().parse()
        .with_context(|| format!("'{}' no es un numero valido", texto.trim()))?;
    Ok(umbral)
}

anyhow::Result<T> no es más que un alias de Result<T, anyhow::Error>: un solo tipo de error para toda la aplicación. Y anyhow::Error es un puntero inteligente del tamaño de una palabra que envuelve cualquier tipo que sea Error + Send + Sync + 'static, capturando además un backtrace. Su implementación general de From es la que hace que los dos ? de arriba funcionen sobre errores de tipos distintos —un io::Error y un ParseIntError— sin que escribas ni una conversión. Donde thiserror te obligaba a nombrar cada fallo, anyhow te libera de nombrar ninguno.

context: la narrativa del fallo

El valor real de anyhow no es tragar errores, sino contarlos. Los métodos context y with_context envuelven un error añadiendo una frase que explica qué estabas intentando, y esa frase se convierte en un nuevo eslabón de la cadena de source que viste en la primera lección:

use anyhow::{Context, Result};

fn arrancar() -> Result<()> {
    let umbral = leer_umbral("umbral.txt")
        .context("configurando el limitador de peticiones")?;
    println!("umbral: {umbral}");
    Ok(())
}

La distinción entre las dos formas importa: context(msg) toma un mensaje ya formado; with_context(|| ...) toma una clausura que solo se ejecuta si hay error, ideal cuando construir el mensaje cuesta una asignación o un format!. Usa with_context siempre que el mensaje lleve interpolación, para no pagar el formateo en el camino feliz.

bail, ensure y anyhow: errores al vuelo

No todos los fallos vienen de otra función; muchos los detectas tú con una condición. anyhow da tres atajos para eso:

use anyhow::{anyhow, bail, ensure, Result};
use std::collections::HashMap;

fn validar(edad: i32) -> Result<()> {
    if edad < 0 {
        bail!("la edad no puede ser negativa: {edad}"); // return Err(anyhow!(...))
    }
    ensure!(edad <= 150, "edad implausible: {edad}");   // if !cond { bail!(...) }
    Ok(())
}

fn buscar(tabla: &HashMap<u32, String>, id: u32) -> Result<String> {
    tabla.get(&id)
        .cloned()
        .ok_or_else(|| anyhow!("no existe el usuario {id}")) // Option -> Result
}

• anyhow!("...") fabrica un error ad-hoc a partir de un mensaje, sin declarar ningún tipo.
• bail!(...) es azúcar de return Err(anyhow!(...)): aborta la función con ese error.
• ensure!(cond, ...) es el equivalente de assert! que devuelve Err en vez de entrar en panic!: si la condición es falsa, hace bail!.

Y ok_or_else(|| anyhow!(...)) es el puente idiomático para pasar de un Option ausente a un Result con mensaje.

Reportar desde main

El remate: si main devuelve anyhow::Result<()>, cuando algo falle Rust imprimirá el error mediante su Debug, y el Debug de anyhow despliega la cadena entera más el backtrace:

fn main() -> anyhow::Result<()> {
    let umbral = leer_umbral("umbral.txt")?;
    println!("umbral cargado: {umbral}");
    Ok(())
}

Error: no se pudo leer 'umbral.txt'

Caused by:
    No such file or directory (os error 2)

Con la variable de entorno RUST_BACKTRACE=1 se añade además la traza de la pila. Todo el informe “error … causado por …” que en la lección uno recorriste a mano con un bucle sobre source, aquí sale gratis.

flowchart TD
A[read_to_string falla con io Error] -->|with_context| B[anyhow Error con una frase de contexto]
B -->|interrogacion sube| C[La funcion propaga sin escribir From]
C --> D[main devuelve anyhow Result]
D --> E[Se imprime la cadena completa y el backtrace]
style A fill:#f38ba8,color:#11111b
style B fill:#cba6f7,color:#11111b
style D fill:#89b4fa,color:#11111b
style E fill:#a6e3a1,color:#11111b