Lançamento do Rust 2024 Edition - Evolução da Linguagem e Novos Recursos

O que é o Rust 2024 Edition

Em fevereiro de 2025, o Rust 2024 Edition foi lançado junto com o Rust 1.85. Esta é a primeira nova edition em 3 anos, incluindo melhorias significativas nos recursos da linguagem e aprimoramentos ergonomicos.

Referência: The Rust Edition Guide

Principais Novos Recursos

1. gen blocks (Geradores)

Permite criar iteradores de forma mais intuitiva.

// Método tradicional
fn fibonacci() -> impl Iterator<Item = u64> {
    let mut a = 0;
    let mut b = 1;
    std::iter::from_fn(move || {
        let result = a;
        (a, b) = (b, a + b);
        Some(result)
    })
}

// Rust 2024: gen blocks
fn fibonacci() -> impl Iterator<Item = u64> {
    gen {
        let mut a = 0u64;
        let mut b = 1;
        loop {
            yield a;
            (a, b) = (b, a + b);
        }
    }
}

2. async closures

Closures assíncronas agora são oficialmente suportadas.

// Workaround anterior era necessário
let fetch = |url| async move {
    reqwest::get(url).await
};

// Rust 2024: async closure nativo
let fetch = async |url: &str| {
    reqwest::get(url).await
};

// O trait AsyncFn pode ser usado
async fn process<F>(f: F)
where
    F: AsyncFn(&str) -> Result<Response, Error>
{
    f("https://example.com").await
}

Referência: Rust Async Book

3. Novo Prelude

Future e IntoFuture foram adicionados ao prelude.

// Import explícito não é mais necessário
// use std::future::Future; // Não necessário

async fn example() -> impl Future<Output = i32> {
    async { 42 }
}

4. Melhorias no RPIT (Return Position Impl Trait)

O tipo de retorno tornou-se mais flexível.

// Regras de captura de lifetime RPIT
fn process<'a>(data: &'a str) -> impl Iterator<Item = &'a str> {
    data.split(',')
}

// Rust 2024: + use<> para especificar lifetime explicitamente
fn process<'a>(data: &'a str) -> impl Iterator<Item = &str> + use<'a> {
    data.split(',')
}

Mudanças na Linguagem

1. Escopo de Variáveis Temporárias em if/while let

// Rust 2024: Escopo mais intuitivo
if let Some(guard) = lock.lock() {
    // O escopo de guard é até aqui
}
// Aqui lock já está liberado (prevenção de deadlock)

2. Explicitação de Atributos Unsafe

// Atributos inseguros requerem especificação explícita
#[unsafe(no_mangle)]
pub extern "C" fn my_function() {}

#[unsafe(link_section = ".custom")]
static DATA: [u8; 4] = [0; 4];

3. static mut Está Depreciado

// Depreciado
static mut COUNTER: u32 = 0;

// Recomendado: Use SyncUnsafeCell
use std::cell::SyncUnsafeCell;
static COUNTER: SyncUnsafeCell<u32> = SyncUnsafeCell::new(0);

Referência: Rust Reference

Melhorias no Toolchain

Melhorias no Cargo

# Cargo.toml
[package]
name = "my-project"
version = "0.1.0"
edition = "2024"  # Nova edition

# Novo recurso: dev-dependencies separadas por padrão
[dev-dependencies]
criterion = "0.5"

# Melhorias no formatter
cargo fmt -- --edition 2024

# Novos lints do Clippy
cargo clippy -- -W rust-2024-idioms

Estilo rustfmt 2024

// Novo estilo de formatação
let result = some_function(
    very_long_argument_1,
    very_long_argument_2,
);

// Melhoria na formatação de métodos encadeados
let output = input
    .iter()
    .filter(|x| x.is_valid())
    .map(|x| x.transform())
    .collect::<Vec<_>>();

Migração

Migração Automática

# Atualizar edition
cargo fix --edition

# Verificar mudanças
cargo check

# Resolver novos avisos
cargo clippy --fix

Atualização do Cargo.toml

[package]
edition = "2024"
rust-version = "1.85"

Referência: Rust Blog - Edition 2024

Melhorias de Desempenho

Tempo de Compilação

Otimizações de Runtime

// O compilador otimiza mais agressivamente
#[inline(always)]
fn hot_path(x: u32) -> u32 {
    // Código mais eficiente é gerado devido a
    // melhorias nas otimizações LLVM
    x.wrapping_mul(31).wrapping_add(17)
}

Suporte do Ecossistema

Status de Suporte de Crates Principais

Resumo

O Rust 2024 Edition melhorou significativamente a expressividade e usabilidade da linguagem.

• gen blocks: Simplificação da criação de iteradores
• async closures: Melhoria na programação assíncrona
• Reforço de segurança: Explicitação de atributos unsafe
• Toolchain: Redução do tempo de compilação

Projetos existentes podem migrar facilmente com cargo fix --edition.