Hata Yönetimi
Exception yok, panik son çare

// fopen NULL dönebilir; kontrol etmeyi unutmak derlenir, çalışır, çöker.
FILE *f = fopen("yok.txt", "r");
fread(buf, 1, 64, f);   // f == NULL → segfault, errno hiç okunmadı

enum Option<T> {
    None,        // değer yok — C'deki NULL'ın güvenli karşılığı
    Some(T),     // değer var, içinde T taşıyor
}

let v = mut; // (örnek için) vec![10, 20, 30]
let v = vec![10, 20, 30];

// get: indeks taşarsa None döner — C'de v[99] UB iken burada güvenli
let a: Option<&i32> = v.get(1);    // Some(&20)
let b: Option<&i32> = v.get(99);   // None

// iterator find: koşulu sağlayan ilk eleman ya da None
let c = v.iter().find(|&&x| x > 15);  // Some(&20)

// HashMap::get da Option döner
use std::collections::HashMap;
let mut m = HashMap::new();
m.insert("k", 1);
let d = m.get("yok");             // None — anahtar yoksa çökmez

// std'deki tanım; #[must_use] sonucu yok saymayı uyarıya çevirir.
#[must_use]
enum Result<T, E> {
    Ok(T),     // başarı: T değeri
    Err(E),    // hata: E tipinde sebep
}

use std::fs::File;

fn main() {
    File::create("log.txt");   // warning: unused `Result` that must be used
}

use std::fs;

fn oku(yol: &str) {
    match fs::read_to_string(yol) {
        Ok(icerik) => println!("{} bayt okundu", icerik.len()),
        Err(e)      => eprintln!("okunamadı: {e}"),
    }
    // İki kolu da yazmazsan: error[E0004] non-exhaustive patterns
}

fn ilk_kelime(s: &str) -> &str {
    match s.split_whitespace().next() {
        Some(k) => k,
        None    => "",   // boş girdi durumu açıkça ele alındı
    }
}

// if let: yalnızca tek kola ilgileniyorsan match'in kısası
if let Some(k) = "merhaba dünya".split_whitespace().next() {
    println!("ilk: {k}");
}

use std::fs::File;
use std::io::{self, Read};

// Önce: elle match — gürültülü
fn oku_uzun(yol: &str) -> Result<String, io::Error> {
    let mut f = match File::open(yol) {
        Ok(f)  => f,
        Err(e) => return Err(e),
    };
    let mut s = String::new();
    match f.read_to_string(&mut s) {
        Ok(_)  => Ok(s),
        Err(e) => Err(e),
    }
}

// Sonra: ? ile aynı mantık, dört satır
fn oku_kisa(yol: &str) -> Result<String, io::Error> {
    let mut f = File::open(yol)?;       // Err ise hemen return Err(...)
    let mut s = String::new();
    f.read_to_string(&mut s)?;            // Err ise hemen return Err(...)
    Ok(s)
}

// Option üzerinde ?: None ise erken None döner
fn ilk_harf(s: &str) -> Option<char> {
    let kelime = s.split_whitespace().next()?;  // None → return None
    kelime.chars().next()                       // Option<char>
}

let n: i32 = "42".parse().unwrap();
// parse başarısızsa: panicked at 'called `Result::unwrap()` on an `Err` value: ...'

let n: i32 = "42".parse()
    .expect("yapılandırma sayısı geçerli olmalı");
// expect aynı işi yapar ama panik mesajı senin bağlamını taşır

// "Gerçekten imkânsız" durumda gerekçeli expect:
let re = Regex::new(r"^\d+$")
    .expect("sabit literal regex; derleme zamanı doğru");

// unwrap_or: panik yerine varsayılan — çoğu zaman daha iyi seçim
let port: u16 = std::env::var("PORT")
    .ok()
    .and_then(|s| s.parse().ok())
    .unwrap_or(8080);

let v = vec![1, 2, 3];
let x = v[99];        // panic: index out of bounds — C'de UB, burada kontrollü çökme

let a: i32 = 1;
let b: i32 = 0;
let c = a / b;        // panic: attempt to divide by zero

fn hesapla(adim: u32) {
    if adim == 0 {
        panic!("adim sıfır olamaz — çağıran tarafta hata var");
    }
    // ... invariant artık garanti
}

[profile.release]
panic = "abort"    # anında sonlandır; unwind kodu üretilmez
# panic = "unwind"  (varsayılan): stack geri sarılır, Drop'lar çalışır

use std::num::ParseIntError;
use std::io;

// Tüm hataları toplayan kendi enum'umuz
enum UygHata {
    Io(io::Error),
    Parse(ParseIntError),
}

// From impl'leri ?'un dönüşümü için gereken köprü
impl From<io::Error> for UygHata {
    fn from(e: io::Error) -> Self { UygHata::Io(e) }
}
impl From<ParseIntError> for UygHata {
    fn from(e: ParseIntError) -> Self { UygHata::Parse(e) }
}

fn oku_sayi(yol: &str) -> Result<i32, UygHata> {
    let s = std::fs::read_to_string(yol)?;  // io::Error → UygHata
    let n = s.trim().parse::<i32>()?;        // ParseIntError → UygHata
    Ok(n)
}

use std::error::Error;

// Box<dyn Error>: "Error uygulayan herhangi bir hata" — type erasure
fn oku_sayi(yol: &str) -> Result<i32, Box<dyn Error>> {
    let s = std::fs::read_to_string(yol)?;  // io::Error → Box<dyn Error>
    let n = s.trim().parse::<i32>()?;        // ParseIntError → Box<dyn Error>
    Ok(n)
}

// "  42 " → 84; her adım önceki Ok'a uygulanır, ilk Err zinciri keser
fn iki_kati(s: &str) -> Result<i32, String> {
    s.trim()
        .parse::<i32>()                       // Result<i32, ParseIntError>
        .map(|n| n * 2)                       // Ok değerini ikiye katla
        .map_err(|e| format!("geçersiz: {e}"))  // hata tipini String'e çevir
}

// Option zinciri: config map'inden oku, yoksa varsayılan
fn port(cfg: &std::collections::HashMap<String, String>) -> u16 {
    cfg.get("port")                  // Option<&String>
        .and_then(|s| s.parse().ok())  // Option<u16> (parse hatası → None)
        .unwrap_or(8080)               // yoksa 8080
}

// ok_or: yokluğu anlamlı bir hataya çevir, sonra ? ile yay
fn ilk(v: &[i32]) -> Result<i32, String> {
    let &x = v.first().ok_or("boş dilim".to_string())?;
    Ok(x)
}

use std::error::Error;
use std::fs;

// sayilar.txt: her satırda bir tam sayı. Toplamlarını döndürür.
fn dosyadan_topla(yol: &str) -> Result<i64, Box<dyn Error>> {
    let icerik = fs::read_to_string(yol)?;   // io::Error yayılır

    let mut toplam: i64 = 0;
    for (i, satir) in icerik.lines().enumerate() {
        let t = satir.trim();
        if t.is_empty() { continue; }     // boş satırları atla

        // parse hatasını satır numarasıyla zenginleştir, sonra ? ile yay
        let n: i64 = t.parse()
            .map_err(|e| format!("satır {}: '{}' sayı değil ({e})", i + 1, t))?;
        toplam += n;
    }
    Ok(toplam)
}

// main de Result döner → fonksiyon gövdesinde ? serbest
fn main() -> Result<(), Box<dyn Error>> {
    let toplam = dosyadan_topla("sayilar.txt")?;
    println!("toplam = {toplam}");
    Ok(())   // başarı; main Err dönerse süreç != 0 ile çıkar ve hatayı basar
}