From, ? y la estrategia: tipado en librerías, opaco en binarios

Todas las piezas del nivel encajan en una sola frase: ? convierte el error que propaga llamando a From. Ese hecho, que sembraste al estudiar las conversiones, es el mecanismo común bajo thiserror y anyhow. La macro de thiserror genera los impl From que hacen que ? estreche los errores primitivos hacia tu enum tipado; anyhow aporta una conversión general que hace que ? ensanche cualquier error hacia su tipo universal. Mismo operador, mismo trait, filosofías opuestas. Verlo así disuelve el falso dilema “thiserror o anyhow”: no son rivales, son los dos extremos naturales de una misma costura de conversión, y la pregunta de diseño no es cuál usar sino en qué capa estás.

? convierte con From: el mecanismo común

Recupera el desazucarado del operador ? sobre un error: cuando la operación falla, no devuelve el error tal cual, sino que lo pasa por From::from para adaptarlo al tipo de error de la función que lo contiene.

// v?  sobre un Result que falla equivale, grosso modo, a:
match v {
    Ok(x) => x,
    Err(e) => return Err(From::from(e)), // From adapta el error al tipo de la funcion
}

Esto significa que cada ? es una conversión de tipo en potencia, gobernada por From. Y aquí está la revelación del nivel: las dos crates que has visto no hacen otra cosa que proveer el From adecuado para que ese ? apunte a donde ellas quieren.

• thiserror, con #[from], genera un impl From<ErrorPrimitivo> for TuEnum. El ? entonces estrecha: un io::Error se convierte en una variante concreta de tu tipo cerrado.
• anyhow provee una implementación general impl<E: Error + Send + Sync + 'static> From<E> for anyhow::Error. El ? entonces ensancha: cualquier error se convierte en el único tipo universal.

Un operador, un trait, dos direcciones: hacia un tipo específico o hacia un tipo que lo absorbe todo.

thiserror y anyhow comparten la misma costura

La figura clave de todo el nivel es ver ambas capas cooperando. Abajo, una librería con error tipado; arriba, un binario que lo absorbe con contexto.

// === CAPA LIBRERIA: error tipado con thiserror ===
use thiserror::Error;

#[derive(Debug, Error)]
pub enum ErrorRepo {
    #[error("registro {0} no encontrado")]
    NoEncontrado(u64),
    #[error(transparent)]
    Io(#[from] std::io::Error),
}

pub fn leer_registro(id: u64) -> Result<String, ErrorRepo> {
    let ruta = format!("db/{id}.rec");
    let datos = std::fs::read_to_string(&ruta)?; // io::Error -> ErrorRepo por #[from]
    if datos.trim().is_empty() {
        return Err(ErrorRepo::NoEncontrado(id));
    }
    Ok(datos)
}

// === CAPA BINARIO: error opaco con anyhow ===
use anyhow::{Context, Result};

fn main() -> Result<()> {
    let reg = leer_registro(42)
        .context("cargando el registro del usuario activo")?; // ErrorRepo -> anyhow::Error
    println!("registro: {reg}");
    Ok(())
}

Sigue los dos ? con el dedo, porque cuentan toda la historia:

1. Dentro de la librería, ? convierte un io::Error en ErrorRepo: un estrechamiento hacia el vocabulario cerrado de la librería, y el impl From que lo hace posible lo generó #[from]. Quien llame a leer_registro recibe un ErrorRepo tipado y puede hacer match entre NoEncontrado e Io.
2. Dentro del binario, ? convierte ese ErrorRepo en anyhow::Error: un ensanchamiento hacia el tipo universal, más una frase de contexto. main no hace match; solo reporta.

Para que el segundo ? funcione, ErrorRepo ha de ser Send + Sync + 'static. Y lo es automáticamente, porque un error de thiserror es un enum de datos en propiedad y sus campos (u64, std::io::Error) ya lo son. Ese es el contrato silencioso que permite que las dos crates encajen sin que muevas un dedo.

La frontera: dónde tipar y dónde volverse opaco

La estrategia, dicha sin rodeos, es una pregunta sobre tu consumidor aguas abajo:

Tres matices afinan la regla:

• El criterio es la superficie pública, no si el crate es binario o librería. Un binario puede usar thiserror en un módulo interno cuya lógica sí quiere ramificar por tipo de fallo.
• Puedes cruzar de vuelta cuando, excepcionalmente, una aplicación necesita decidir: anyhow::Error recupera el tipo concreto con downcast_ref.
• Nunca al revés: anyhow::Error en la firma pública de una librería roba a tus dependientes el tipado y les impone la crate.

flowchart LR
A[io Error del sistema] -->|interrogacion con from de thiserror| B[ErrorRepo tipado y matchable]
B -->|interrogacion con context de anyhow| C[anyhow Error opaco con contexto]
C --> D[main solo informa y sale]
style A fill:#f38ba8,color:#11111b
style B fill:#a6e3a1,color:#11111b
style C fill:#cba6f7,color:#11111b
style D fill:#89b4fa,color:#11111b