Pattern Matching

Gelişmiş eşleştirme ve değer yıkımlandırma.

Temel Match

değişken sayı = 2

eş sayı {
    1 => yazdır("bir"),
    2 => yazdır("iki"),
    3 => yazdır("üç"),
    _ => yazdır("diğer")
}

İngilizce:

match number {
    1 => print("one"),
    2 => print("two"),
    _ => print("other")
}

Match Expression

Bir değer döndürebilir:

değişken mesaj = eş sayı {
    1 => "bir",
    2 => "iki",
    3 => "üç",
    _ => "bilinmeyen"
}

Result Matching

işlev böl(a: Sayı, b: Sayı) -> Sonuç<Sayı, Yazı> {
    eğer b == 0 {
        hata dön "Sıfıra bölme"
    }
    tamam dön a / b
}

değişken sonuç = böl(10, 2)

eş sonuç {
    Tamam(değer) => yazdır("Sonuç: ", değer),
    Hata(mesaj) => yazdır("HATA: ", mesaj)
}

Option Matching

değişken değer: Seçenek<Sayı> = Bazı(42)

eş değer {
    Bazı(x) => yazdır("Değer: ", x),
    Hiç => yazdır("Değer yok")
}

Tuple Destructuring

değişken nokta = (3, 4)

eş nokta {
    (0, 0) => yazdır("Orijin"),
    (x, 0) => yazdır("X ekseni: ", x),
    (0, y) => yazdır("Y ekseni: ", y),
    (x, y) => yazdır("Nokta: (", x, ", ", y, ")")
}

List Patterns

değişken liste = [1, 2, 3]

eş liste {
    [] => yazdır("Boş liste"),
    [x] => yazdır("Tek eleman: ", x),
    [x, y] => yazdır("İki eleman: ", x, ", ", y),
    [ilk, ...geri_kalan] => {
        yazdır("İlk: ", ilk)
        yazdır("Geri kalan: ", geri_kalan)
    }
}

Struct Patterns

tür Kişi = struct {
    ad: Yazı,
    yaş: Sayı
}

değişken kişi = Kişi { ad: "Ahmet", yaş: 30 }

eş kişi {
    Kişi { ad: "Ahmet", yaş } => {
        yazdır("Ahmet, ", yaş, " yaşında")
    },
    Kişi { ad, yaş: 18..25 } => {
        yazdır(ad, " genç")
    },
    _ => yazdır("Diğer")
}

Range Patterns

değişken yaş = 25

eş yaş {
    0..12 => yazdır("Çocuk"),
    13..17 => yazdır("Genç"),
    18..64 => yazdır("Yetişkin"),
    65.. => yazdır("Yaşlı")
}

Guards (Koşullar)

değişken sayı = 15

eş sayı {
    x if x < 0 => yazdır("Negatif"),
    x if x % 2 == 0 => yazdır("Çift"),
    x if x % 2 == 1 => yazdır("Tek"),
    _ => yazdır("Bilinmeyen")
}

Multiple Patterns

eş karakter {
    'a' | 'e' | 'ı' | 'i' | 'o' | 'ö' | 'u' | 'ü' => {
        yazdır("Sesli harf")
    },
    _ => yazdır("Ünssüz harf")
}

Nested Patterns

tür Mesaj = enum {
    Metin(Yazı),
    Sayı(Sayı),
    Çoklu(Liste<Mesaj>)
}

değişken mesaj = Çoklu([Metin("hello"), Sayı(42)])

eş mesaj {
    Metin(s) => yazdır("Metin: ", s),
    Sayı(n) => yazdır("Sayı: ", n),
    Çoklu([Metin(s), Sayı(n)]) => {
        yazdır("Metin ve sayı: ", s, ", ", n)
    },
    _ => yazdır("Diğer")
}

Wildcard Patterns

// Tam wildcard
eş değer {
    _ => yazdır("Herhangi bir şey")
}

// Kısmi wildcard
eş tuple {
    (_, 0) => yazdır("Y sıfır"),
    (0, _) => yazdır("X sıfır"),
    (_, _) => yazdır("Diğer")
}

Best Practices

✅ Yapılması Gerekenler

// Exhaustive matching (tüm durumlar)
eş sonuç {
    Tamam(x) => işle(x),
    Hata(e) => hata_işle(e)
    // _ gerekli değil, tüm durumlar kapsıyor
}

// Anlamlı değişken isimleri
eş kullanıcı {
    Kişi { ad: kullanıcı_adı, yaş: kullanıcı_yaşı } => {
        // ...
    }
}

❌ Kaçınılması Gerekenler

// Çok karmaşık iç içe pattern
eş değer {
    A(B(C(D(x)))) => ...  // Okunabilir değil
}

// Gereksiz wildcard
eş x {
    _ => ...  // Tüm durumları yok sayıyor
}

Örnekler

JSON Parser

tür Json = enum {
    Null,
    Bool(Boolean),
    Number(Sayı),
    String(Yazı),
    Array(Liste<Json>),
    Object(Harita<Yazı, Json>)
}

işlev stringify(json: Json) -> Yazı {
    eş json {
        Null => "null",
        Bool(b) => b ? "true" : "false",
        Number(n) => n.to_string(),
        String(s) => "\""+s+"\"",
        Array(arr) => "[" + arr.map(stringify).join(",") + "]",
        Object(obj) => "{...}"
    }
}