Rust 1.85 ve 2024 Edition: Async Closures, gen Blocks ve Modern Async Ergonomi Rehberi (2026)

Rust 2024 Edition Nedir? (What is Rust 2024 Edition?)

Rust dilinin edition kavramı, geriye dönük uyumluluğu (backward compatibility) bozmadan dile büyük değişiklikler getirmek için kullanılan bir mekanizma. Üç edition var şu ana kadar: 2015, 2018, 2021. Şubat 2025'te Rust 2024 Edition stable oldu — son 3 yılın en kapsamlı sürümü (most significant in 3 years).

Önemli not: Edition yeni dil özelliği eklemez, mevcut özelliklerin syntax'ını veya davranışını değiştirebilir. Her crate kendi edition'ını seçer (edition = "2024" Cargo.toml'da). 2015 edition crate'i, 2024 edition crate'i ile sorunsuz çalışır.

Async Closures: Beklenen Özellik (Long-Awaited Feature)

Yıllardır Rust ekosisteminde async kod yazarken karşılaştığımız büyük bir gap vardı: async closures. Şimdiye kadar FnMut, FnOnce traitler async fonksiyonları temiz şekilde destekleyemiyordu. Rust 1.85 ile bu çözüldü.

// ÖNCEDEN (Rust 2021): Workaround gerekiyordu
async fn process_items<F>(items: Vec<i32>, f: F)
where
    F: Fn(i32) -> Pin<Box<dyn Future<Output = i32> + Send>>,
{
    for item in items {
        let result = f(item).await;
        println!("{}", result);
    }
}

// ŞİMDİ (Rust 2024): Native syntax
async fn process_items<F>(items: Vec<i32>, f: F)
where
    F: AsyncFn(i32) -> i32,
{
    for item in items {
        let result = f(item).await;
        println!("{}", result);
    }
}

// Kullanım: async closure ile
process_items(vec![1, 2, 3], async |x| x * 2).await;

Yeni traitler:

• ✅ AsyncFn — async closure'lar için
• ✅ AsyncFnMut — mutable state ile async closures
• ✅ AsyncFnOnce — bir kere çağrılabilir async closures

Bu traitler local environment'tan değer capture edebilir, lifetime'lar düzgün çıkarılabilir (lifetimes properly inferred).

gen Blocks: İteratör Üretimi Kolay Hale Geldi (Easy Iterator Creation)

Python'da yield, JavaScript'te function* kullanarak iterator yazmak çok kolaydır. Rust'ta ise iterator implement etmek için Iterator trait'ini implement etmek, next() metodunu yazmak, state machine'i elle kurmak gerekiyordu. Rust 2024 Edition ile gen blocks bu sorunu çözüyor.

// ÖNCEDEN: Iterator trait implementation
struct Fibonacci { a: u64, b: u64 }

impl Iterator for Fibonacci {
    type Item = u64;
    fn next(&mut self) -> Option<Self::Item> {
        let result = self.a;
        let next = self.a + self.b;
        self.a = self.b;
        self.b = next;
        Some(result)
    }
}

// ŞİMDİ (gen block ile)
fn fibonacci() -> impl Iterator<Item = u64> {
    gen {
        let (mut a, mut b) = (0u64, 1u64);
        loop {
            yield a;
            let next = a + b;
            a = b;
            b = next;
        }
    }
}

// Kullanım
let fib: Vec<u64> = fibonacci().take(10).collect();
// [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

gen block'ların avantajları:

• ✅ Daha az boilerplate: State machine'i compiler yazıyor
• ✅ Lazy evaluation: Sadece next() çağrıldığında çalışır
• ✅ Anonymous types: Trait implementation gerekmez
• ✅ Async gen blocks: Yakında geliyor (preview)

Alesta Web notu: gen block'lar özellikle recursive iterator, state machine veya complex traversal gerektiren algoritmalarda inanılmaz işe yarıyor. Tree traversal yazarken hayat kurtarıyor.

Future ve IntoFuture Prelude'a Eklendi (Added to Prelude)

Rust 2024 Edition öncesinde async kod yazarken sık sık use std::future::Future; ve use std::future::IntoFuture; import etmek gerekiyordu. 2024 Edition ile bu traitler prelude'a (default import) eklendi.

// Rust 2021
use std::future::Future;
use std::future::IntoFuture;

async fn fetch<T: IntoFuture<Output = String>>(req: T) -> String {
    req.await
}

// Rust 2024 - import gerek yok!
async fn fetch<T: IntoFuture<Output = String>>(req: T) -> String {
    req.await
}

Bu küçük gibi görünen değişiklik aslında büyük kalite-yaşam (quality-of-life) iyileştirmesi. Async kod yazarken use satırlarının kalabalığı azalıyor.

Style Editions ve Formatting Özelleştirmesi (Style Editions)

Rust 2024 Edition ile birlikte style editions kavramı tanıtıldı. Bu, formatting kurallarını edition'dan bağımsız olarak özelleştirme imkanı veriyor. Yani edition = "2024" kullansanız bile, formatting için style_edition = "2021" tercih edebilirsiniz.

# Edition: dilin syntax kuralları
edition = "2024"

# Style: rustfmt'nin formatting kuralları (2024'te değişiklik var)
style_edition = "2024"

# Veya geriye uyumlu kalmak için
# style_edition = "2021"

Hangi formatting değişiklikleri var?

• 📝 Tail expression formatlama daha kompakt
• 📝 Match arm body'leri farklı indent
• 📝 Generic parametrelerin wrap'i daha agresif
• 📝 Closure body'leri yeniden düzenlendi

Alesta Web önerisi: Büyük codebase'lerde style edition'ı edition geçişinden ayrı yapın. Önce edition'a geçin, formatting'i bir sonraki PR'da değiştirin. CR (code review) yükünü azaltır.

rust-version Aware Dependency Resolution (Smarter Cargo Resolution)

Cargo artık Cargo.toml'daki rust-version alanını dependency resolution sırasında dikkate alıyor. Eğer bir crate sizden daha yeni Rust sürümü gerektiriyorsa, Cargo otomatik olarak uyumlu bir eski sürümü seçiyor.

[package]
name = "my-app"
version = "0.1.0"
edition = "2024"
rust-version = "1.82"  # En düşük desteklenen Rust sürümü

[dependencies]
serde = "1.0"  # Cargo, 1.82 ile uyumlu en yeni sürümü seçer
tokio = { version = "1", features = ["full"] }

Bu özellik özellikle library yazarları için kritik. MSRV (Minimum Supported Rust Version) garanti edebiliyorsunuz, kullanıcılarınız onlara uyumlu sürümleri otomatik alıyor.