Bölüm 13 — Konu 59: Dart 3 Pattern Matching — Records, Destructuring, Sealed Classes, Exhaustive Switch

Bölüm 13'e — gerçek uzmanlık bölümüne — hoş geldin. Bu, Dart 3 ile gelen, dilin en modern ve güçlü özelliklerinden biri: pattern matching (örüntü eşleştirme).

#Records (Kayıtlar) — Anonim, Yapılandırılmış Veri

Bölüm 6'da sınıflar öğrendik — birden fazla değeri bir arada tutmak için bir class tanımlıyorduk. Ama bazen, sadece geçici olarak birkaç değeri bir arada döndürmek istersin, tam bir class yazmak "fazla" gelir. İşte record, bunun için var:

void main() {
  var kisi = (isim: "Ahmet", yas: 25); // named field'lı bir record
  print(kisi.isim); // Ahmet
  print(kisi.yas);  // 25
  print(kisi);       // (isim: Ahmet, yas: 25)
}

Positional (isimsiz) record da mümkündür:

void main() {
  var koordinat = (10, 20); // positional record
  print(koordinat.$1); // 10 — ilk eleman
  print(koordinat.$2); // 20 — ikinci eleman
}

#Bir Fonksiyondan Birden Fazla Değer Döndürme

Bölüm 5'te fonksiyonların tek bir değer döndürdüğünü öğrenmiştik. Eğer birden fazla değer döndürmek istiyorsan, önceden ya bir class yazman ya da bir Map/List kullanman gerekiyordu. Artık record ile doğrudan birden fazla değer döndürebilirsin:

(double, double) minMaxBul(List<double> sayilar) {
  double min = sayilar[0];
  double max = sayilar[0];
  for (var sayi in sayilar) {
    if (sayi < min) min = sayi;
    if (sayi > max) max = sayi;
  }
  return (min, max); // record döndürüyoruz
}

void main() {
  var sonuc = minMaxBul([5, 2, 8, 1, 9]);
  print("Min: ${sonuc.$1}, Max: ${sonuc.$2}"); // Min: 1.0, Max: 9.0
}

Named field'larla daha okunabilir:

({double min, double max}) minMaxBulV2(List<double> sayilar) {
  double min = sayilar[0];
  double max = sayilar[0];
  for (var sayi in sayilar) {
    if (sayi < min) min = sayi;
    if (sayi > max) max = sayi;
  }
  return (min: min, max: max);
}

void main() {
  var sonuc = minMaxBulV2([5, 2, 8, 1, 9]);
  print("Min: ${sonuc.min}, Max: ${sonuc.max}"); // Min: 1.0, Max: 9.0
}

#Destructuring — Record'u Ayrı Değişkenlere Ayırma

Bölüm 4'te collection'larla çalışırken hep "önce bütünü al, sonra parçalarına eriş" yaptık. Destructuring, bir record'u (veya başka yapıları) tek bir satırda, doğrudan ayrı değişkenlere ayırmanı sağlar:

(double, double) minMaxBul(List<double> sayilar) {
  // ... (yukarıdaki gibi)
  return (1.0, 9.0);
}

void main() {
  var (min, max) = minMaxBul([5, 2, 8, 1, 9]); // DESTRUCTURING
  print("Min: $min, Max: $max"); // Min: 1.0, Max: 9.0
}

var (min, max) = ... satırı, record'un $1 ve $2 elemanlarını doğrudan min ve max adında iki ayrı değişkene atıyor — .min/.max veya .$1/.$2 yazmana gerek kalmıyor. Bu, Bölüm 6'daki this.x constructor kısayoluna benzer bir "sözdizimsel şeker" (syntactic sugar) — kodu daha kısa ve okunabilir kılıyor.

Named record'larda destructuring:

void main() {
  var kisi = (isim: "Ahmet", yas: 25);
  var (isim: i, yas: y) = kisi;
  print("$i, $y"); // Ahmet, 25
}

Listelerde de destructuring çalışır:

void main() {
  List<int> sayilar = [1, 2, 3];
  var [birinci, ikinci, ucuncu] = sayilar;
  print("$birinci, $ikinci, $ucuncu"); // 1, 2, 3
}

#Sealed Classes — "Kapalı" Kalıtım Hiyerarşisi

Bölüm 7'de abstract class öğrenmiştik — soyut sınıflar, alt sınıfların belirli metodları implemente etmesini zorunlu kılıyordu. sealed class, bunun bir adım ötesine geçer: hangi sınıfların bu sınıftan türeyebileceğini de sınırlar — sadece aynı dosyada tanımlanan sınıflar türeyebilir.

sealed class Sekil {}

class Daire extends Sekil {
  final double yaricap;
  Daire(this.yaricap);
}

class Kare extends Sekil {
  final double kenar;
  Kare(this.kenar);
}

class Ucgen extends Sekil {
  final double taban, yukseklik;
  Ucgen(this.taban, this.yukseklik);
}

Bu üç sınıf (Daire, Kare, Ucgen), Sekil'in bilinen, sabit tüm alt tipleridir — başka bir dosyadan gelip Sekil'i extend eden dördüncü bir sınıf olamaz (Dart bunu engeller). Bu, önemli bir garanti sağlıyor: Dart derleyicisi, Sekil'in tam olarak kaç ve hangi alt tipi olduğunu bilir.

#Sealed Class + Exhaustive Switch — Asıl Güç Burada

Bölüm 3'te ve Bölüm 7'de enum'larla exhaustiveness kontrolünü görmüştük. Sealed class'lar, bunu enum'un ötesine, tam class hiyerarşilerine taşır:

double alanHesapla(Sekil sekil) {
  return switch (sekil) {
    Daire(:var yaricap) => 3.14159 * yaricap * yaricap,
    Kare(:var kenar) => kenar * kenar,
    Ucgen(:var taban, :var yukseklik) => 0.5 * taban * yukseklik,
  };
}

void main() {
  print(alanHesapla(Daire(5)));      // 78.53975
  print(alanHesapla(Kare(4)));       // 16.0
  print(alanHesapla(Ucgen(6, 8)));   // 24.0
}

default (_) yazmadık ve Dart buna izin verdi — çünkü Sekil, sealed olduğu için, Dart kesin olarak bilir ki sadece Daire, Kare, Ucgen olabilir. Eğer birisi ileride Sekil'e dördüncü bir alt sınıf (örneğin Besgen) eklerse, ama bu switch'i güncellemeyi unutursa, Dart derleyicisi anında hata verir: "bu switch artık eksik (non-exhaustive)."

Bu, Bölüm 7'de öğrendiğimiz abstract class'ın sağladığı garantiden çok daha güçlüdür — abstract class, sadece "her alt sınıf şu metodu implemente etmeli" der; sealed class + switch, "kod tabanının her yerinde, bu tipin tüm olasılıkları ele alınmalı" garantisini verir.

#Daire(:var yaricap) — Object Pattern (Nesne Örüntüsü)

Yukarıdaki switch örneğinde gördüğün Daire(:var yaricap) sözdizimi, bir object pattern'dir — "eğer bu değer bir Daire ise, onun yaricap alanını doğrudan yaricap adında bir değişkene ata" anlamına gelir. Bu, is operatörü (Bölüm 3) ile tip kontrolü yapıp sonra .yaricap ile erişmenin birleştirilmiş, kısa halidir:

// Object pattern OLMADAN, klasik yöntem
double alanHesaplaEski(Sekil sekil) {
  if (sekil is Daire) {
    double yaricap = sekil.yaricap;
    return 3.14159 * yaricap * yaricap;
  } else if (sekil is Kare) {
    double kenar = sekil.kenar;
    return kenar * kenar;
  }
  // ...
  return 0;
}

Pattern matching versiyonu, bu tip kontrolü + destructuring işlemini tek bir satırda, çok daha okunabilir şekilde birleştiriyor.

#switch İçinde Guard (when) — Ek Koşul

String sekilYorumu(Sekil sekil) {
  return switch (sekil) {
    Daire(:var yaricap) when yaricap > 10 => "Büyük bir daire",
    Daire() => "Küçük bir daire",
    Kare() => "Bir kare",
    Ucgen() => "Bir üçgen",
  };
}

when, bir pattern'e ek bir koşul eklemeni sağlar — "bu bir Daire ise VE yarıçapı 10'dan büyükse" gibi daha spesifik durumları ayırt etmeni sağlıyor.

#Neden Bu Kadar Önemli? — Gerçek Dünya Kullanımı

Sealed class + pattern matching, özellikle "durum" (state) modellemede çok güçlüdür — örneğin bir API çağrısının sonucunu modellemek için:

sealed class ApiSonucu<T> {}

class Basarili<T> extends ApiSonucu<T> {
  final T veri;
  Basarili(this.veri);
}

class Basarisiz<T> extends ApiSonucu<T> {
  final String hataMesaji;
  Basarisiz(this.hataMesaji);
}

class Yukleniyor<T> extends ApiSonucu<T> {}

String sonucGoster(ApiSonucu<String> sonuc) {
  return switch (sonuc) {
    Basarili(:var veri) => "Veri: $veri",
    Basarisiz(:var hataMesaji) => "Hata: $hataMesaji",
    Yukleniyor() => "Yükleniyor...",
  };
}

Bu kalıp, Flutter'da state management (Bölüm 6, Flutter müfredatında) yaparken son derece yaygın hale geldi — Riverpod gibi modern state management çözümleri, bu tarz sealed class + pattern matching yapılarını yoğun şekilde kullanıyor. Bu dersten öğrendiğin temel, Flutter'a geçtiğinde doğrudan işine yarayacak.

#🎯 Bu Dersten Çıkarılması Gerekenler

• Record'lar, birden fazla değeri geçici olarak bir arada tutan, hafif ve yapılandırılmış veri türleridir ((a, b) veya (isim: a, yas: b)).
• Destructuring, bir record'u (veya liste/map'i) tek satırda ayrı değişkenlere ayırmayı sağlar (var (a, b) = ...).
• sealed class, bir sınıfın alt tiplerini aynı dosyayla sınırlar — bu, Dart'ın tüm olası alt tipleri bilmesini sağlar.
• Sealed class + switch expression, default olmadan tam kapsayıcı (exhaustive) kontrol sağlar; yeni bir alt tip eklenip switch güncellenmezse, derleyici hata verir.
• Object pattern (Daire(:var yaricap)), tip kontrolü ve destructuring'i tek adımda birleştirir.
• when guard'ı, bir pattern'e ek koşul ekler.

#📝 Ödevler

• [ ] Positional ve named iki farklı record oluştur, her ikisinin elemanlarına farklı yollarla eriş.
• [ ] Birden fazla değer döndüren bir fonksiyon yaz (örn. bir listenin ortalamasını ve medyanını döndüren), destructuring ile sonuçları ayrı değişkenlere ata.
• [ ] Sealed class ile bir Sekil hiyerarşisi tanımla (en az 3 alt sınıf), exhaustive switch expression ile her şeklin çevresini hesapla.
• [ ] Sealed class'a dördüncü bir alt sınıf ekle ama switch'i güncelleme, derleyicinin seni nasıl uyardığını gözlemle.
• [ ] when guard'ı kullanarak, bir pattern'e ek bir koşul ekleyen bir örnek yaz.

Sıradaki konu: Bölüm 13 — Konu 60: Never Tipi, covariant ve Generic Variance Detayları