Learn Rust Coding · Aula

Conversão de erros

Implementações de From

Conversão de erros é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Por que converter erros?

Diferentes camadas do código produzem diferentes tipos de erro. Para propagá-los por uma única função, é necessário converter os erros de nível inferior em um tipo unificado. Rust faz isso por meio do trait From.

O trait From

From<T> define como construir um tipo a partir de outro. Implementá-lo para o seu tipo de erro permite converter erros de origem nele.

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

Como ? usa From

Quando você escreve expr? e o tipo do erro é diferente do erro retornado pela função, o operador chama From::from para convertê-lo. Esse é o mecanismo por trás da propagação transparente.

Um tipo de erro unificado

Defina uma enum para armazenar cada tipo de erro que sua função pode emitir.

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

Implementando From

Escreva uma implementação de From para cada erro de origem, para que ele seja convertido na variante correspondente.

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)
    }
}

Propagação automática

Com essas implementações, ? converte gratuitamente cada erro em AppError.

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 é o espelho

Implementar From<A> for B fornece automaticamente A: Into<B>. Prefira implementar From; você obterá into() gratuitamente.

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

Encapsulando objetos de trait

Para conversões rápidas, Box<dyn Error> aceita qualquer tipo de erro, pois a biblioteca padrão fornece implementações genéricas de From para ele.

use std::error::Error;

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

Crates que geram From

Escrever cada implementação de From manualmente é trabalhoso. O atributo #[from] de thiserror gera essas implementações, e anyhow converte tudo automaticamente em um único tipo.

Escolhendo uma abordagem

Resumo das estratégias de conversão:

Implementações manuais de From — controle total, mais código
thiserror #[from] — erros tipados, implementações geradas
Box<dyn Error> ou anyhow — mínimo de formalidades

Adicionando contexto durante a conversão

Uma implementação de From pode fazer mais do que encapsular: ela pode enriquecer o erro. Aqui, a conversão adiciona contexto extra para que o erro final seja mais 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)
    }
}

Verificação rápida

Qual trait o operador ? usa para converter um tipo de erro em outro?

Recapitulação

Você aprendeu sobre conversão de erros:

? converte erros por meio do trait From
Implemente From<Source> para sua enum de erro
From fornece Into e into() gratuitamente
Box<dyn Error> aceita qualquer erro
thiserror e anyhow automatizam o código repetitivo

Perguntas Frequentes

A aula “Conversão de erros” é grátis?

Sim — o texto completo de “Conversão de erros” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Conversão de erros”?

Implementações de From Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Conversão de erros”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding