Enum & Pattern Matching
Sum type'lar ve exhaustive match

00 C union'dan sum type'a

C'de bir "etiketli birlik" (tagged union) elle yazılır; doğru kolu okumak tamamen programcının disiplinine kalmıştır. Rust enum'u bu kontratı tip sistemine taşır.

C'de enum aslında isimlendirilmiş bir int'tir — taşıdığı tek bilgi bir tamsayı sabitidir. Bir değer ve o değerin türünü birlikte taşımak istediğinizde, klasik C deseni bir struct içine bir enum etiket ile bir union koymaktır. Sorun şudur: etiket ile birliğin senkron kalacağına dair hiçbir garanti yoktur. Yanlış kolu okursanız, derleyici sizi uyarmaz; sonuç tanımsız davranıştır (UB).

// C: etiket + union'ı elle senkron tutmak zorundasın
enum Kind { K_INT, K_FLT };

struct Value {
    enum Kind tag;        // hangi kol geçerli?
    union { int i; float f; } data;
};

struct Value v = { .tag = K_INT, .data.i = 42 };

// Etiketi yok say, yanlış kolu oku -> derleyici susar, sonuç UB
float x = v.data.f;   // i32 bitleri float gibi yorumlanır

Rust'ta aynı kavram bir sum type olarak ifade edilir: enum varyantları doğrudan veri taşır ve etiket (discriminant) ile veriyi dil ayrılmaz biçimde birbirine bağlar. Değere yalnızca match üzerinden, doğru varyantı kanıtlayarak erişebilirsiniz. "Yanlış kolu okuma" diye bir kavram yoktur — derleyici buna izin vermez.

// Rust: etiket ve veri tek bir tip-güvenli birimde
enum Value {
    Int(i32),
    Flt(f32),
}

let v = Value::Int(42);

match v {
    Value::Int(i) => println!("int: {i}"),
    Value::Flt(f) => println!("flt: {f}"),
    // Int'i Flt gibi okumanın yolu yok
}

C: tag + union (elle senkron, UB riski)  →  Rust: enum (dil senkron tutar, UB yok)

01 Enum tanımı ve veri taşıyan varyantlar

Bir enum varyantı üç biçimden biri olabilir: birim (veri yok), tuple-benzeri (konumsal alanlar) veya struct-benzeri (isimli alanlar). Hepsi tek bir tipte birleşir.

enum Message {
    Quit,                       // birim varyant — veri yok
    Move { x: i32, y: i32 },    // struct-benzeri — isimli alanlar
    Write(String),              // tuple-benzeri — tek alan
    ChangeColor(i32, i32, i32), // tuple-benzeri — üç alan
}

let m = Message::Move { x: 10, y: 20 };

Bunu C'de yazmak için dört ayrı struct, bir union ve bir etiket enum gerekirdi. Rust tek bir bildirimle hepsini kapsar; her varyant kendi şekline (shape) sahiptir.

Bellek temsili

Bir enum'un boyutu, en büyük varyantın boyutu artı discriminant'ı tutacak kadar yerdir (hizalama dahil). Varyantların payload'ları aynı bölgeyi paylaşır (C union gibi), ancak hangi varyantın canlı olduğunu discriminant belirler.

Niche optimization

Derleyici, bir tipte "kullanılmayan" bit desenleri (niche) varsa discriminant'ı ayrı yer ayırmadan oraya gömebilir. En bilinen örnek Option<&T>: bir referans asla null olamaz, dolayısıyla None değeri tüm-sıfır bit deseniyle kodlanır. Sonuç: Option<&T> bir ham pointer ile aynı boyuttadır — ekstra etiket baytı yoktur.

use std::mem::size_of;

// Referans asla null olamaz; None = null pattern'i
assert_eq!(size_of::<&i32>(), size_of::<Option<&i32>>());

// C'de "nullable pointer + ayrı bool" iki ayrı alan olurdu

02 match temelleri ve exhaustiveness

match, C'nin switch'ine benzer ama iki temel farkla: tüm durumlar ele alınmak zorundadır ve fallthrough yoktur. Üstelik bir ifadedir — değer döndürür.

enum Dir { North, South, East, West }

fn dx(d: Dir) -> i32 {
    // match bir ifadedir; sonucu doğrudan döndürürüz
    match d {
        Dir::East => 1,
        Dir::West => -1,
        Dir::North | Dir::South => 0, // çoklu pattern
    }
}

Yukarıdaki match tüm dört varyantı kapsar. Bir varyantı unutursanız derleyici reddeder — bu, yeni bir varyant eklediğinizde ilgili tüm match'lerin "burayı da güncelle" diye sizi uyarması demektir. C'de eklediğiniz yeni bir enum sabitini güncellemeyi unuttuğunuz switch sessizce yanlış davranır.

Catch-all: _ ve bağlama

Kalan tüm durumları tek kolda toplamak için _ (değeri yoksay) veya bir değişken adı (değeri yakala) kullanılır. _ kolu yalnızca gerçekten umursamadığınız durumlar için iyidir; aksi halde exhaustiveness'in koruyuculuğunu kaybedersiniz.

let n = 7;
let s = match n {
    1 => "bir",
    2 => "iki",
    other => { // yakalanan değer 'other' olarak bağlanır
        println!("bilinmeyen: {other}");
        "diğer"
    }
};

03 Pattern türleri

Pattern, bir değerin şeklini sınamanın ve aynı anda parçalarını bağlamanın diliridir. match kolları, if let, let ve fonksiyon parametreleri hep pattern alır.

let x = 5;

match x {
    0 => println!("sıfır"),              // literal
    1 | 2 | 3 => println!("küçük"),     // çoklu (OR)
    4..=9 => println!("orta"),          // aralık (kapalı)
    n => println!("büyük: {n}"),       // değişkene bağlama
}

@ binding: sına ve aynı anda yakala

Bir aralığa uyup uymadığını test ederken eşleşen değeri de bir isme bağlamak istersiniz. @ ikisini tek kolda birleştirir.

enum Msg { Id(u32) }

match Msg::Id(5) {
    // 3..=7 aralığına uyarsa, değeri 'id' olarak da bağla
    Msg::Id(id @ 3..=7) => println!("geçerli aralık: {id}"),
    Msg::Id(id) => println!("aralık dışı: {id}"),
}

04 Destructuring

Pattern matching'in asıl gücü, bileşik bir değeri tek hamlede parçalayıp her parçasını bir isme bağlamaktır — C'de elle yapacağınız alan alan erişimin yerini alır.

// Tuple destructuring
let (a, b, c) = (1, 2, 3);

// Struct destructuring — alan adlarıyla
struct Point { x: i32, y: i32 }
let p = Point { x: 10, y: 20 };
let Point { x, y } = p;   // alan kısayolu: x, y otomatik bağlanır

let Point { x, y } = p; satırındaki "alan kısayolu" (field shorthand), x: x, y: y yazmaktan kurtarır. Yalnızca bazı alanları istiyorsanız geri kalanını .. ile atlayabilirsiniz.

İç içe (nested) destructuring

Pattern'ler iç içe geçer; bir enum varyantının içindeki struct'ın içindeki tuple'ı tek pattern ile sökebilirsiniz. Bu, "v.data.shape.color.r" gibi zincirleri tek satıra indirir ve aynı anda doğru varyantı kanıtlar.

enum Shape {
    Circle { center: (i32, i32), r: u32 },
    Rect { w: u32, h: u32 },
}

let s = Shape::Circle { center: (3, 4), r: 10 };

match s {
    // varyant + iç tuple + alan tek pattern'de sökülür
    Shape::Circle { center: (cx, cy), r } =>
        println!("daire ({cx},{cy}) yarıçap {r}"),
    Shape::Rect { w, .. } =>        // h'yi atla
        println!("dikdörtgen, w={w}"),
}

05 if let ve let else

Yalnızca tek bir varyantı umursadığınızda tam bir match abartı kaçar. if let bu durumu zarifçe ele alır; let else ise erken çıkış (guard clause) için idealdir.

let cfg: Option<u16> = Some(8080);

// Sadece Some kolu ilgilendiriyor
if let Some(port) = cfg {
    println!("port: {port}");
} else {
    println!("port tanımsız, varsayılan kullanılıyor");
}

if let, "şu pattern'e uyuyorsa içeri gir, parçalarını bağla" demektir; else dalı opsiyoneldir. Ancak if let içindeki bağlamalar yalnızca o blok içinde geçerlidir — bağlanan değeri blok sonrasında kullanmak istediğinizde sağ kenara doğru kayan (rightward drift) iç içe bloklar oluşur.

let else: başarısızlıkta erken çık

let ... else bu sorunu çözer: pattern uyarsa bağlanan değer normal akışta kalır; uymazsa else bloğu çalışır ve bu blok akışı sonlandırmak zorundadır (return, break, continue veya panic!). Bu, tam olarak C'deki "if (!x) return; ... x'i kullan" guard clause desenidir.

fn parse_port(s: &str) -> u16 {
    // Uyarsa 'port' bu noktadan sonra erişilebilir
    let Ok(port) = s.parse::<u16>() else {
        return 8080; // else mutlaka akışı bitirmeli
    };
    // rightward drift yok — port düz akışta
    port
}

06 while let

Bir değer belirli bir pattern'e uyduğu sürece dönen döngüler için while let vardır. Klasik kullanım: bir Option None dönene dek tüketmek.

let mut stack = vec![1, 2, 3];

// pop() Option döndürür; None gelene dek dön
while let Some(top) = stack.pop() {
    println!("çıkan: {top}");
}
// 3, 2, 1 yazılır; boşalınca pop() None döner, döngü biter

Bu desen C'de "while ((p = next()) != NULL)" döngüsünün doğrudan, tip-güvenli karşılığıdır. Sentinel değeri (NULL, -1) elle test etmek yerine, None varyantı pattern uymadığında döngüyü doğal olarak sonlandırır.

// Iterator'ı elle next() ile tüketmek
let mut it = [10, 20, 30].into_iter();

while let Some(x) = it.next() {
    if x == 20 { break; } // koşullu erken çıkış
    println!("{x}");
}

07 Match guards

Bir match kolunun pattern'i uyduktan sonra ekstra bir koşul daha sınamak istediğinizde guard kullanılır: => öncesine eklenen bir if ifadesi.

let x: Option<i32> = Some(-3);

match x {
    Some(n) if n > 0 => println!("pozitif: {n}"),
    Some(n) if n < 0 => println!("negatif: {n}"),
    Some(_) => println!("sıfır"),
    None => println!("yok"),
}

Guard, pattern'in ifade edemediği runtime koşullarını (aralık dışı karşılaştırma, iki bağlamanın eşitliği, harici durum) kola taşır. Pattern şekli sınar; guard değeri sınar.

Guard ile exhaustiveness ilişkisi

Kritik nokta: derleyici, guard koşulunun runtime'da ne döneceğini bilemez. Bu yüzden guard'lı bir kolu exhaustiveness sayımında "tam kapsadı" olarak kabul etmez. Yalnızca guard'lı kollarınız varsa, tüm değerleri kapsasanız bile derleyici "non-exhaustive" hatası verir; guard'sız bir catch-all kol eklemek zorunda kalırsınız.

let n = 5;

// HATA OLURDU: yalnızca guard'lı kollar -> non-exhaustive
// match n { x if x > 0 => .., x if x <= 0 => .. }

// DOĞRU: guard'sız bir catch-all gerekir
match n {
    x if x > 0 => println!("pozitif"),
    _ => println!("diğer"), // guard'sız kapsama
}

08 Option ve Result enum olarak

Rust'ta "null yok", "exception yok" derken kastedilen şey aslında basittir: bu kavramlar standart kütüphanede sıradan birer enum olarak tanımlıdır. Hepsi aynı pattern matching ile açılır.

// Std'de tam olarak böyle tanımlıdır:
enum Option<T> {
    None,
    Some(T),
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Yani Option bir "nullable" sihirli tip değil; sadece iki varyantlı bir sum type'tır. C'de "değer var mı?" sorusunu NULL pointer veya özel bir sentinel ile, "hata oldu mu?" sorusunu errno veya negatif dönüş kodu ile yanıtlarsınız — ikisi de tip dışı kanallardır. Rust bunları tipin kendisine kodlar, dolayısıyla derleyici "hata kolunu ele almayı unuttun" diyebilir.

fn bol(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        return Err("sıfıra bölme".to_string());
    }
    Ok(a / b)
}

match bol(10, 2) {
    Ok(v) => println!("sonuç: {v}"),
    Err(e) => println!("hata: {e}"),
}

// Tek kol yetiyorsa if let de olur
if let Ok(v) = bol(9, 3) {
    println!("bölüm: {v}");
}

09 Gerçek örnek: durum makinesi

Sum type'ların en güçlü olduğu yer durum makineleridir: geçersiz durumları temsil etmek imkânsız hale gelir, geçişler ise tek bir exhaustive match'te toplanır.

Bir trafik ışığını modelleyelim. C'de bunu bir int state ile yapsaydınız, hiçbir şey size 7 gibi geçersiz bir değer atamanızı engellemezdi. Rust enum'unda yalnızca tanımlı üç durum vardır — derleyici dördüncü bir durumu yazmanıza izin vermez.

// Geçersiz durum tip sistemiyle imkânsız: yalnızca bu üçü
enum Light { Red, Green, Yellow }

impl Light {
    // Geçişler tek bir exhaustive match'te
    fn next(self) -> Light {
        match self {
            Light::Red    => Light::Green,
            Light::Green  => Light::Yellow,
            Light::Yellow => Light::Red,
        }
    }

    fn duration_s(&self) -> u32 {
        match self {
            Light::Red    => 30,
            Light::Green  => 25,
            Light::Yellow => 5,
        }
    }
}

Veri taşıyan varyantlarla bunu daha da ileri götürebiliriz. Aşağıdaki basit bir bağlantı protokolü: her durum yalnızca o aşamada anlamlı olan veriyi taşır — örneğin Connected bir oturum kimliği tutar, Disconnected hiçbir şey tutmaz. Böylece "bağlı değilken oturum kimliği okumak" gibi geçersiz erişimler derleme zamanında elenir.

enum Conn {
    Disconnected,
    Connecting { retry: u8 },
    Connected { session: u32 },
}

fn step(c: Conn) -> Conn {
    match c {
        Conn::Disconnected => Conn::Connecting { retry: 0 },

        // guard + destructuring birlikte
        Conn::Connecting { retry } if retry < 3 =>
            Conn::Connecting { retry: retry + 1 },

        Conn::Connecting { .. } =>
            Conn::Connected { session: 0xABCD },

        // session yalnızca Connected içinde erişilebilir
        Conn::Connected { session } => {
            println!("oturum aktif: {session:#x}");
            Conn::Connected { session }
        }
    }
}

Disconnected → Connecting{retry:0..3} → Connected{session} → (next)