async-std

async-std, Rust programlama dili için geliştirilmiş, 'async' ve 'await' anahtar kelimeleriyle uyumlu, eşzamansız bir runtime ve "standart kütüphane" benzeri bir ekosistem sunan bir kütüphanedir. Temel amacı, Rust'ta eşzamanlı ve ağ tabanlı uygulamalar geliştirmeyi kolaylaştırmaktır.

Temel Özellikleri ve Amaçları:

1. Eşzamansız Runtime: Eşzamansız fonksiyonların (futures) çalıştırılması için bir scheduler (planlayıcı) sağlar. Bu sayede, çok sayıda I/O yoğun görevi aynı anda, işletim sistemi thread'lerinin aksine çok daha az kaynak tüketerek yönetebilir.
2. "std" Benzeri API: Rust'ın standart kütüphanesi (`std`) ile olabildiğince uyumlu bir API sunar. Örneğin, `std::fs` yerine `async_std::fs`, `std::net::TcpStream` yerine `async_std::net::TcpStream` gibi eşzamansız versiyonları bulunur. Bu, `std`'den eşzamansız programlamaya geçişi kolaylaştırır.
3. Eşzamansız I/O: Ağ (TCP, UDP), dosya sistemi (`fs`) ve zamanlayıcı (`task::sleep`) gibi I/O işlemlerinin non-blocking (bloke etmeyen) eşzamansız versiyonlarını sağlar. Bu, programın bir I/O işlemi beklerken diğer işleri yapmaya devam etmesini mümkün kılar.
4. Eşzamanlılık Primitifleri: Hafif görevler (`async_std::task::spawn` ile oluşturulan `Task`'lar), eşzamansız `Mutex`, `RwLock`, `channel` gibi eşzamanlı programlama için gerekli temel araçları sunar.
5. Minimalist Tasarım: `tokio` gibi daha kapsamlı eşzamansız runtime'lara kıyasla daha basit ve "Rust'ın ruhuna" uygun, minimalist bir yaklaşım benimser. Bu, özellikle daha az karmaşık eşzamansız uygulamalar veya öğrenme amaçlı kullanım için tercih edilebilir.
6. Trait Tabanlı Yaklaşım: Rust'ın güçlü trait sistemini kullanarak esnek ve genişletilebilir bir yapı sunar.

async-std vs. tokio:
`async-std` ve `tokio`, Rust ekosistemindeki en popüler eşzamansız runtime'lardır. `async-std` sadeliği ve `std` benzeri API'si ile öne çıkarken, `tokio` daha yüksek performans, daha zengin özellik seti (örneğin, daha gelişmiş zamanlayıcılar, `io_uring` desteği) ve daha büyük ölçekli, kurumsal ağ uygulamaları için optimizasyonlar sunar. Seçim, projenin gereksinimlerine, performans hedeflerine ve geliştiricinin tercihine bağlıdır.

```rust
// Cargo.toml dosyanıza ekleyin:
// [dependencies]
// async-std = { version = "1.12", features = ["attributes"] }
// futures = "0.3" // "await" metodu için gerekli olabilir

use async_std::prelude::*;
use async_std::{fs, task};
use std::time::Duration;

// Eşzamansız bir dosya okuma ve içerik döndürme fonksiyonu
async fn read_and_print_file(path: &str) -> Result<String, std::io::Error> {
    println!("Görev: '{}' dosyasını okumaya çalışıyor.", path);
    // fs::read_to_string eşzamansız bir dosya okuma işlemi yapar
    let contents = fs::read_to_string(path).await?;
    println!("Görev: Dosya içerikleri başarıyla okundu.");
    Ok(contents)
}

// async-std runtime'ını ana fonksiyona bağlamak için #[async_std::main] kullanılır.
#[async_std::main]
async fn main() -> Result<(), std::io::Error> {
    let file_path = "async_example.txt";

    // 1. Eşzamansız olarak bir dummy dosya oluştur
    println!("Ana: Dummy dosya oluşturuluyor...");
    // fs::write eşzamansız bir dosya yazma işlemi yapar
    fs::write(file_path, "Merhaba async-std dünyası!").await?;
    println!("Ana: Dummy dosya oluşturuldu.");

    // 2. Dosyayı okumak için eşzamansız bir görev (task) başlat
    println!("Ana: Dosya okuma görevi başlatılıyor...");
    let handle = task::spawn(read_and_print_file(file_path));

    // 3. Görev arka planda çalışırken başka işler yap
    println!("Ana: Başka işler yapılıyor...");
    // task::sleep eşzamansız bir gecikme sağlar, CPU'yu bloklamaz
    task::sleep(Duration::from_secs(1)).await;
    println!("Ana: Diğer işler tamamlandı.");

    // 4. Başlatılan görevin sonucunu bekle ve al
    println!("Ana: Dosya okuma görevinin sonucu bekleniyor...");
    match handle.await {
        Ok(contents) => {
            println!("Ana: Görevden gelen içerik: '{}'", contents);
        }
        Err(e) => {
            eprintln!("Ana: Dosya okuma hatası: {}", e);
        }
    }

    // 5. Oluşturulan dummy dosyayı temizle
    println!("Ana: Dummy dosya temizleniyor...");
    fs::remove_file(file_path).await?;
    println!("Ana: Dummy dosya kaldırıldı.");

    Ok(())
}
```