Rust 2024 Edition - Evolución de async y manejo de errores

Resumen de Rust 2024 Edition

Rust 2024 Edition es la primera actualización mayor de edición en 3 años. Se han añadido mejoras en programación asíncrona, fortalecimiento del manejo de errores y funciones para mejorar la productividad.

Estabilización de async trait

Ahora puedes definir funciones async directamente dentro de traits.

// Rust 2024: async trait disponible de forma estándar
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> {
        // Implementación
    }

    async fn post(&self, url: &str, body: &[u8]) -> Result<Response, Error> {
        // Implementación
    }
}

Antes: Se requería el crate async-trait.

Mensajes de error mejorados

Los mensajes de error del compilador son ahora más comprensibles.

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

// Mensaje de error en 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();
  |                         ++++++++++++++++

Estabilización de let chains

Permite escribir pattern matching de forma más 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);
}

// Estructura anidada anterior
if let Some(user) = get_user() {
    if let Some(email) = user.email {
        if email.ends_with("@company.com") {
            send_internal_notification(&email);
        }
    }
}

Mejoras en inferencia de tipos

La inferencia de tipos para closures se ha fortalecido.

// Anotaciones de tipo innecesarias en más casos
let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
let doubled = numbers.iter().map(|x| x * 2).collect::<Vec<_>>();

Nuevas funciones de la biblioteca estándar

LazyCell / LazyLock

use std::sync::LazyLock;

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

fn main() {
    // Se inicializa en el primer acceso
    println!("{:?}", *CONFIG);
}

Iteradores más convenientes

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

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

Mejoras en Cargo

Herencia de dependencias de workspace

# Cargo.toml (raíz del 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 }

Migración de edición

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

# Herramienta de migración automática
cargo fix --edition

Resumen

Rust 2024 Edition incluye muchas mejoras prácticas como la estabilización de async trait y let chains. En particular, la experiencia de programación asíncrona ha mejorado significativamente, haciendo el desarrollo en Rust más cómodo.