Rust 2024 Edition - Evolução do Async e Tratamento de Erros

Visão Geral do Rust 2024 Edition

O Rust 2024 Edition é a primeira atualização major de edition em 3 anos. Inclui melhorias na programação assíncrona, reforço no tratamento de erros e recursos para aumento de produtividade.

Estabilização do async trait

Agora é possível definir funções async diretamente em traits.

// Rust 2024: async trait disponível por padrão
trait HttpClient {
    async fn get(&self, url: &str) -> Result<Response, Error>;
    async fn post(&self, url: &str, body: &[u8]) -> Result<Response, Error>;
}

impl HttpClient for MyClient {
    async fn get(&self, url: &str) -> Result<Response, Error> {
        // implementação
    }

    async fn post(&self, url: &str, body: &[u8]) -> Result<Response, Error> {
        // implementação
    }
}

Anteriormente: O crate async-trait era necessário.

Mensagens de Erro Melhoradas

As mensagens de erro do compilador ficaram mais fáceis de entender.

// Código
let x: i32 = "hello";

// Mensagem de erro do Rust 2024
error[E0308]: mismatched types
 --> src/main.rs:2:18
  |
2 |     let x: i32 = "hello";
  |            ---   ^^^^^^^ expected `i32`, found `&str`
  |            |
  |            expected due to this
  |
help: consider parsing the string
  |
2 |     let x: i32 = "hello".parse().unwrap();
  |                         ++++++++++++++++

Estabilização de let chains

Pattern matching pode ser escrito de forma mais concisa.

// Rust 2024: let chains
if let Some(user) = get_user()
    && let Some(email) = user.email
    && email.ends_with("@company.com")
{
    send_internal_notification(&email);
}

// Estrutura aninhada tradicional
if let Some(user) = get_user() {
    if let Some(email) = user.email {
        if email.ends_with("@company.com") {
            send_internal_notification(&email);
        }
    }
}

Melhorias na Inferência de Tipos

A inferência de tipos para closures foi aprimorada.

// Anotações de tipo desnecessárias em mais casos
let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
let doubled = numbers.iter().map(|x| x * 2).collect::<Vec<_>>();

Novos Recursos da Biblioteca Padrão

LazyCell / LazyLock

use std::sync::LazyLock;

static CONFIG: LazyLock<Config> = LazyLock::new(|| {
    Config::load_from_file("config.toml")
});

fn main() {
    // Inicializado no primeiro acesso
    println!("{:?}", *CONFIG);
}

Iteradores Mais Convenientes

let items = vec![1, 2, 3, 4, 5];

// array_chunks: chunks de tamanho fixo
for chunk in items.array_chunks::<2>() {
    println!("{:?}", chunk); // [1, 2], [3, 4]
}

Melhorias no Cargo

Herança de Dependências do Workspace

# Cargo.toml (raiz do workspace)
[workspace.dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.0", features = ["full"] }

# member/Cargo.toml
[dependencies]
serde = { workspace = true }
tokio = { workspace = true }

Migração de Edition

# Cargo.toml
[package]
edition = "2024"

# Ferramenta de migração automática
cargo fix --edition

Resumo

O Rust 2024 Edition inclui muitas melhorias práticas como estabilização de async trait e let chains. Especialmente a experiência com programação assíncrona melhorou significativamente, tornando o desenvolvimento em Rust mais confortável.