Ders 08: Hata Yönetimi

🎮 Ya Olmazsa?What If It Fails?

Oyunlarda her zaman bir şeyler ters gidebilir! Anahtar yoksa kapı açılmaz, can biterse oyun biter...

📝 Örnek 1: Hazine AramaExample 1: Treasure Hunt

🔍 hazine_ara.berk

// Belki (Option) - Ya varsa ya yoksa!
fonksiyon sandik_ac(konum: tamsayı) -> Belki[metin] {
    esle konum yap
        1 => Bazi("💎 Elmas buldun!"),
        2 => Bazi("💰 Altın buldun!"),
        3 => Bazi("🗝️ Anahtar buldun!"),
        _ => Hic,  // Boş sandık!
    son
}

fonksiyon ana() {
    yazdir("🗺️ HAZİNE AVI!\n");
    
    // 5 sandık kontrol et
    icin i in 1..6 {
        yazdir("📦 Sandık #{} açılıyor...", i);
        
        esle sandik_ac(i) yap
            Bazi(hazine) => yazdir("   ✅ {}\n", hazine),
            Hic => yazdir("   ❌ Boş sandık!\n"),
        son
    }
}

📝 Örnek 2: Boss SaldırısıExample 2: Boss Attack

👹 boss_attack.berk

// Sonuç (Result) - Ya başarılı ya başarısız!
fonksiyon saldir(oyuncu_guc: tamsayı, boss_kalkan: tamsayı) -> Sonuc[tamsayı, metin] {
    eğer oyuncu_guc <= 0 yap
        don Hata("💀 Gücün yetmiyor!");
    son
    
    eğer boss_kalkan > oyuncu_guc yap
        don Hata("🛡️ Kalkan çok güçlü!");
    son
    
    değişken hasar = oyuncu_guc - boss_kalkan;
    don Tamam(hasar);
}

fonksiyon ana() {
    yazdir("⚔️ BOSS SAVAŞI\n");
    
    // Deneme 1: Zayıf saldırı
    esle saldir(10, 20) yap
        Tamam(hasar) => yazdir("💥 {} hasar verdin!", hasar),
        Hata(mesaj) => yazdir("❌ {}", mesaj),
    son
    
    // Deneme 2: Güçlü saldırı
    esle saldir(50, 20) yap
        Tamam(hasar) => yazdir("💥 {} hasar verdin!", hasar),
        Hata(mesaj) => yazdir("❌ {}", mesaj),
    son
}

🎯 Hatırla!Remember!

Belki/Option = Var mı yok mu?Belki/Option = Is there or not?
Sonuc/Result = Başarılı mı hatalı mı?Sonuc/Result = Success or error?

📖 Option ve ResultOption and Result

BERK

// Option: Değer var veya yok
enum Option[T] {
    Some(T),   // Değer var
    None,      // Değer yok
}

// Result: İşlem başarılı veya hatalı
enum Result[T, E] {
    Ok(T),     // Başarılı + değer
    Err(E),    // Hatalı + hata bilgisi
}

📝 Örnek 1: Kullanıcı DoğrulamaExample 1: User Validation

👤 validation.berk

fonksiyon kullanici_bul(id: tamsayı) -> Belki[metin] {
    esle id yap
        1 => Bazi("Ali"),
        2 => Bazi("Ayşe"),
        3 => Bazi("Mehmet"),
        _ => Hic,
    son
}

fonksiyon yas_doğrula(yas: tamsayı) -> Sonuc[(), metin] {
    eğer yas < 0 yap
        don Hata("Yaş negatif olamaz");
    son
    eğer yas < 18 yap
        don Hata("18 yaşından küçükler giremez");
    son
    eğer yas > 120 yap
        don Hata("Geçersiz yaş");
    son
    don Tamam(());
}

fonksiyon ana() {
    // Option kullanımı
    icin id in [1, 5, 2] {
        esle kullanici_bul(id) yap
            Bazi(isim) => yazdir("✅ Kullanıcı {}: {}", id, isim),
            Hic => yazdir("❌ Kullanıcı {} bulunamadı", id),
        son
    }
    
    yazdir("");
    
    // Result kullanımı
    icin yas in [25, -5, 15, 150] {
        esle yas_doğrula(yas) yap
            Tamam(_) => yazdir("✅ Yaş {} geçerli", yas),
            Hata(msg) => yazdir("❌ Yaş {}: {}", yas, msg),
        son
    }
}

📝 Örnek 2: Dosya İşlemleriExample 2: File Operations

📁 file.berk

function read_config(path: &str) -> Result {
    // Dosya var mı kontrol et
    if !file_exists(path) {
        return Err(format!("File not found: {}", path));
    }
    
    // Dosyayı oku
    let content = match read_file(path) {
        Ok(c) => c,
        Err(e) => return Err(format!("Read error: {}", e)),
    };
    
    // Parse et
    match parse_config(&content) {
        Ok(config) => Ok(config),
        Err(e) => Err(format!("Parse error: {}", e)),
    }
}

function main() {
    // Unwrap: Panik yapar hata varsa (riskli!)
    // let config = read_config("config.json").unwrap();
    
    // Expect: Daha açıklayıcı panik
    // let config = read_config("config.json").expect("Config yüklenemedi");
    
    // Match: En güvenli yol
    match read_config("config.json") {
        Ok(config) => {
            print("✅ Config yüklendi");
            print("  Version: {}", config.version);
        },
        Err(e) => {
            print("❌ Hata: {}", e);
            print("  Varsayılan ayarlar kullanılıyor...");
        },
    }
    
    // unwrap_or: Varsayılan değer
    let value = some_option().unwrap_or(42);
    
    // unwrap_or_else: Lazy varsayılan
    let value = some_option().unwrap_or_else(|| calculate_default());
}

🎯 Advanced Error HandlingAdvanced Error Handling

Custom error types
Error propagation (?)
anyhow ve thiserror crates
Error recovery patterns

📝 Örnek 1: Custom Error TypesExample 1: Custom Error Types

BERK (thiserror)

use thiserror::Error;

#[derive(Error, Debug)]
enum AppError {
    #[error("Database error: {0}")]
    Database(#[from] DatabaseError),
    
    #[error("Network error: {source}")]
    Network {
        #[source]
        source: std::io::Error,
        url: String,
    },
    
    #[error("Validation failed: {field} - {message}")]
    Validation {
        field: String,
        message: String,
    },
    
    #[error("Not found: {0}")]
    NotFound(String),
    
    #[error("Unauthorized")]
    Unauthorized,
}

// Error conversion
impl From for AppError {
    fn from(e: serde_json::Error) -> Self {
        AppError::Validation {
            field: "json".to_string(),
            message: e.to_string(),
        }
    }
}

// Result type alias
type AppResult = Result;

function get_user(id: u64) -> AppResult {
    if id == 0 {
        return Err(AppError::NotFound(format!("User {}", id)));
    }
    
    let user = db_query(id)?;  // ? auto-converts DatabaseError
    Ok(user)
}

function main() {
    match get_user(0) {
        Ok(user) => print!("User: {:?}", user),
        Err(AppError::NotFound(msg)) => print!("404: {}", msg),
        Err(AppError::Unauthorized) => print!("401: Please login"),
        Err(e) => print!("Error: {}", e),
    }
}

📝 Örnek 2: Error RecoveryExample 2: Error Recovery

BERK (Recovery)

use anyhow::{Context, Result, bail};

// Retry pattern
async function with_retry(
    max_retries: u32,
    delay: Duration,
    mut operation: F,
) -> Result
where
    F: FnMut() -> Fut,
    Fut: Future>,
{
    let mut last_error = None;
    
    for attempt in 1..=max_retries {
        match operation().await {
            Ok(result) => return Ok(result),
            Err(e) => {
                print!("[Attempt {}/{}] Error: {}", attempt, max_retries, e);
                last_error = Some(e);
                if attempt < max_retries {
                    tokio::time::sleep(delay).await;
                }
            }
        }
    }
    
    Err(last_error.unwrap())
}

// Circuit breaker pattern
struct CircuitBreaker {
    failure_count: AtomicU32,
    threshold: u32,
    state: AtomicBool,  // true = open (blocking)
}

impl CircuitBreaker {
    function call(&self, f: F) -> Result
    where
        F: FnOnce() -> Result,
    {
        if self.state.load(Ordering::Relaxed) {
            bail!("Circuit breaker is open");
        }
        
        match f() {
            Ok(result) => {
                self.failure_count.store(0, Ordering::Relaxed);
                Ok(result)
            }
            Err(e) => {
                let count = self.failure_count.fetch_add(1, Ordering::Relaxed);
                if count + 1 >= self.threshold {
                    self.state.store(true, Ordering::Relaxed);
                }
                Err(e)
            }
        }
    }
}

async function main() -> Result<()> {
    // With context for better error messages
    let config = read_config("app.toml")
        .context("Failed to load application config")?;
    
    // Retry with backoff
    let data = with_retry(3, Duration::from_secs(1), || {
        fetch_data(&config.api_url)
    }).await.context("Failed to fetch data after 3 retries")?;
    
    print!("Data: {:?}", data);
    Ok(())
}

📌 ÖzetSummary

Option: Some(değer) veya NoneOption: Some(value) or None
Result: Ok(değer) veya Err(hata)Result: Ok(value) or Err(error)
? operatörü hata propagasyonu için? operator for error propagation