Learn Rust Coding · Lección

Conversión de errores

Implementaciones de From

Conversión de errores es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Por qué convertir errores?

Las distintas capas del código producen diferentes tipos de errores. Para propagarlos a través de una función, debe convertir los errores de nivel inferior en un tipo unificado. Rust lo hace mediante el trait From.

El trait From

From<T> define cómo construir un tipo a partir de otro. Implementarlo para su tipo de error le permite convertir los errores de origen en ese tipo.

trait From<T> {
    fn from(value: T) -> Self;
}

¿Cómo usa From el operador ?

Cuando escribe expr? y el tipo de error difiere del error que devuelve la función, el operador llama a From::from para convertirlo. Esta es la magia que permite una propagación fluida.

Un tipo de error unificado

Defina un enum que contenga cada tipo de error que pueda emitir su función.

#[derive(Debug)]
enum AppError {
    Io(std::io::Error),
    Parse(std::num::ParseIntError),
}

Implementar From

Escriba un impl de From para cada error de origen, de modo que se convierta en la variante correspondiente.

impl From<std::io::Error> for AppError {
    fn from(e: std::io::Error) -> Self {
        AppError::Io(e)
    }
}

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

Propagación automática

Con esos impl en su lugar, ? convierte cada error en AppError automáticamente.

fn read_count(path: &str) -> Result<i32, AppError> {
    let text = std::fs::read_to_string(path)?; // io::Error -> AppError
    let n: i32 = text.trim().parse()?;          // ParseIntError -> AppError
    Ok(n)
}

Into es el reflejo

Implementar From<A> for B le proporciona automáticamente A: Into<B>. Es preferible implementar From; así obtiene into() sin coste adicional.

fn make() -> AppError {
    let e: std::io::Error = std::io::Error::other("boom");
    e.into() // uses From<io::Error> for AppError
}

Encapsular objetos trait

Para conversiones rápidas, Box<dyn Error> acepta cualquier tipo de error, ya que la biblioteca estándar proporciona impl genéricos de From hacia este tipo.

use std::error::Error;

fn run() -> Result<(), Box<dyn Error>> {
    let n: i32 = "42".parse()?; // ParseIntError -> Box<dyn Error>
    println!("{n}");
    Ok(())
}

Crates que generan From

Escribir cada impl de From manualmente resulta tedioso. El atributo #[from] de thiserror los genera, y anyhow convierte todo automáticamente en un solo tipo.

Elegir un enfoque

Resumen de las estrategias de conversión:

Impl de From manuales — control total, más código
thiserror #[from] — errores tipados, impl generados
Box<dyn Error> o anyhow — mínima configuración

Añadir contexto durante la conversión

Un impl de From puede hacer más que envolver un error: también puede enriquecerlo. Aquí, la conversión añade contexto adicional para que el error final sea más informativo.

impl From<std::num::ParseIntError> for AppError {
    fn from(e: std::num::ParseIntError) -> Self {
        // could log or annotate here before wrapping
        AppError::Parse(e)
    }
}

Comprobación rápida

¿Qué trait usa el operador ? para convertir un tipo de error en otro?

Repaso

Ha aprendido a convertir errores:

? convierte errores mediante el trait From
Implemente From<Source> para su enum de errores
From le proporciona Into e into() sin coste adicional
Box<dyn Error> acepta cualquier error
thiserror y anyhow automatizan el código repetitivo

Preguntas frecuentes

¿La lección «Conversión de errores» es gratis?

Sí — el texto completo de «Conversión de errores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Conversión de errores»?

Implementaciones de From Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Conversión de errores»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Result y el operador ?
thiserror
anyhow
Conversión de errores

← Volver a Learn Rust Coding