Learn Rust Coding · Aula

anyhow

Erros flexíveis de aplicações

anyhow é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 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.

Erros flexíveis para aplicações

No código de aplicações, muitas vezes você só quer propagar os erros com contexto, sem definir uma enumeração tipada para cada caso. O pacote anyhow fornece exatamente um tipo de erro simples para isso.

Adicionando anyhow

Adicione-o como dependência. Ele combina bem com thiserror: thiserror para bibliotecas e anyhow para binários.

[dependencies]
anyhow = "1.0"

O alias anyhow::Result

anyhow::Result<T> é uma abreviação de Result<T, anyhow::Error>. O tipo Error pode conter qualquer erro que implemente std::error::Error.

use anyhow::Result;

fn load() -> Result<String> {
    let text = std::fs::read_to_string("config.txt")?;
    Ok(text)
}

Conversão automática

O operador ? converte automaticamente qualquer erro padrão em anyhow::Error, permitindo combinar livremente tipos de erro.

use anyhow::Result;

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

Adicionando contexto

O método .context() anexa uma mensagem compreensível a um erro, construindo uma cadeia legível quando algo falha.

use anyhow::{Context, Result};

fn read_config(path: &str) -> Result<String> {
    let text = std::fs::read_to_string(path)
        .context("failed to read config file")?;
    Ok(text)
}

Contexto tardio

Use with_context quando construir a mensagem for caro ou exigir dados de execução; o fechamento só é executado em caso de erro.

use anyhow::{Context, Result};

fn open(path: &str) -> Result<String> {
    std::fs::read_to_string(path)
        .with_context(|| format!("could not open {path}"))
}

Criando erros ad hoc

A macro anyhow! cria um erro a partir de uma mensagem, e bail! retorna antecipadamente com um erro.

use anyhow::{anyhow, bail, Result};

fn check(age: i32) -> Result<()> {
    if age < 0 {
        bail!("age cannot be negative");
    }
    if age > 150 {
        return Err(anyhow!("age {age} is implausible"));
    }
    Ok(())
}

Usando ensure!

ensure! é semelhante a assert!, mas retorna um erro em vez de entrar em pânico.

use anyhow::{ensure, Result};

fn divide(a: i32, b: i32) -> Result<i32> {
    ensure!(b != 0, "division by zero");
    Ok(a / b)
}

anyhow em main

Retorne anyhow::Result<()> de main para que cadeias de erros bem formatadas sejam exibidas quando ocorrer uma falha.

use anyhow::Result;

fn main() -> Result<()> {
    let text = std::fs::read_to_string("data.txt")?;
    println!("{text}");
    Ok(())
}

Inspecionando a causa

Embora anyhow::Error seja opaco, ainda é possível inspecioná-lo. downcast_ref recupera um tipo de erro concreto quando é necessário tomar decisões com base nele.

use anyhow::Result;

fn report(err: anyhow::Error) {
    if let Some(io) = err.downcast_ref::<std::io::Error>() {
        println!("io error: {io}");
    } else {
        println!("other error: {err}");
    }
}

thiserror vs anyhow

Regra prática:

thiserror — bibliotecas e erros tipados que os chamadores analisam
anyhow — aplicações; basta propagar o erro com contexto

É possível converter um erro de thiserror em anyhow usando ? de forma transparente.

Verificação rápida

Qual método de anyhow adiciona uma mensagem descritiva a um erro durante a propagação?

Recapitulação

Você aprendeu sobre o crate anyhow:

anyhow::Result<T> usa um único tipo de erro flexível
? converte automaticamente qualquer erro padrão
.context() / with_context() adicionam mensagens legíveis
anyhow!, bail! e ensure! criam erros
É mais adequado para código de aplicações (binários)

Perguntas Frequentes

A aula “anyhow” é grátis?

Sim — o texto completo de “anyhow” é 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 “anyhow”?

Erros flexíveis de aplicações 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 3 de 4.

Quanto tempo leva a aula “anyhow”?

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