Bölüm 11 — Konu 51: Iterable Kavramı Derinlemesine (Lazy Evaluation)

Bir önceki derste .map()'in Iterable döndürdüğünü, .toList() ile bir listeye çevirmemiz gerektiğini görmüştük. Bu derste, Iterable gerçekte nedir ve neden map/where bu tipi döndürür sorularının cevabını tam olarak vereceğiz.

#Iterable Nedir?

Iterable, Bölüm 4'te öğrendiğimiz List, Set gibi tüm "gezinebilir" koleksiyonların üst tipidir (Bölüm 7'de öğrendiğimiz kalıtım kavramını hatırla). Yani List ve Set, aslında Iterable'ın alt sınıflarıdır:

void main() {
  List<int> liste = [1, 2, 3];
  Set<int> set = {1, 2, 3};

  print(liste is Iterable); // true
  print(set is Iterable);   // true
}

Iterable, "üzerinde for-in ile gezinilebilen" anlamına gelen genel bir sözleşmedir (Bölüm 7'de öğrendiğimiz soyut sınıf/interface mantığına benzer). List, buna ek olarak indeksli erişim (liste[0]) gibi ekstra özellikler sağlar; Iterable'ın kendisi bunu garanti etmez.

#Lazy Evaluation (Tembel Değerlendirme) — Temel Kavram

.map() ve .where()'in Iterable döndürmesinin asıl sebebi budur: bu metodlar, çağrıldıkları anda hesaplamayı hemen yapmazlar — hesaplama, sonuç gerçekten kullanılana kadar ertelenir. Buna lazy evaluation (tembel değerlendirme) denir.

void main() {
  List<int> sayilar = [1, 2, 3, 4, 5];

  print("map() çağrılıyor...");
  Iterable<int> kareler = sayilar.map((sayi) {
    print("  $sayi işleniyor");
    return sayi * sayi;
  });
  print("map() çağrısı bitti, ama hiçbir 'işleniyor' yazısı GÖRMEDİK!");

  print("Şimdi toList() çağrılıyor...");
  List<int> kareListesi = kareler.toList(); // İŞTE ŞİMDİ hesaplama gerçekten çalışır
}

Çıktı:

map() çağrılıyor...
map() çağrısı bitti, ama hiçbir 'işleniyor' yazısı GÖRMEDİK!
Şimdi toList() çağrılıyor...
  1 işleniyor
  2 işleniyor
  3 işleniyor
  4 işleniyor
  5 işleniyor

Bu çok önemli bir gözlem: sayilar.map(...) satırı çalıştığında, verdiğimiz fonksiyon (print(" $sayi işleniyor") içeren) hiç çalışmadı. Sadece .toList() çağrıldığında (yani sonucun gerçekten kullanılacağı an geldiğinde), hesaplama fiilen gerçekleşti.

#Neden Lazy Evaluation Faydalıdır?

1. Gereksiz hesaplamadan kaçınma:

void main() {
  List<int> sayilar = List.generate(1000000, (i) => i); // 1 milyon eleman

  Iterable<int> ilkBesKare = sayilar.map((sayi) => sayi * sayi).take(5);
  print(ilkBesKare.toList()); // [0, 1, 4, 9, 16]
}

Burada, .map() 1 milyon elemanın hepsini işlemek yerine, .take(5) ile sadece ilk 5 sonuca ihtiyacımız olduğunu belirttik. Lazy evaluation sayesinde, Dart aslında sadece ilk 5 eleman için map fonksiyonunu çalıştırır — geri kalan 999.995 eleman hiç işlenmez. Eğer .map() "eager" (hemen, istekli) çalışsaydı, gereksiz yere milyonlarca işlem yapılırdı.

2. Zincirleme işlemler, tek bir geçişte birleşir:

void main() {
  List<int> sayilar = [1, 2, 3, 4, 5];

  var sonuc = sayilar
      .where((s) => s % 2 == 0)
      .map((s) => s * 10)
      .toList();

  print(sonuc); // [20, 40]
}

Bu zincirde, .where() ve .map(), ayrı ayrı, tam listeler oluşturarak çalışmaz (yani önce tüm liste filtrelenip yeni bir liste oluşturulmaz, sonra o listenin tamamı map edilmez). Bunun yerine, .toList() çağrıldığında, her eleman için, önce where kontrolü, hemen ardından (eleman geçtiyse) map dönüşümü art arda, o eleman üzerinde uygulanır. Bu, büyük koleksiyonlarda daha az ara bellek kullanımı anlamına gelir.

#Iterable mı List mi Döndürmeli? — Kendi Fonksiyonlarını Yazarken

// Iterable döndüren fonksiyon — çağıran taraf ne zaman "gerçekleştireceğine" karar verir
Iterable<int> ciftSayilariGetir(List<int> sayilar) {
  return sayilar.where((s) => s % 2 == 0);
}

// List döndüren fonksiyon — hesaplama hemen, burada tamamlanır
List<int> ciftSayilariGetirListe(List<int> sayilar) {
  return sayilar.where((s) => s % 2 == 0).toList();
}

Pratik tavsiye: Çoğu durumda, özellikle küçük/orta boyutlu koleksiyonlarla çalışırken, .toList() çağırıp List döndürmek daha basit ve öngörülebilirdir — çünkü sonucu birden fazla kere kullanacaksan (örneğin .length almak, sonra elemanlara erişmek), her seferinde yeniden hesaplanmasını istemezsin. Iterable'ı olduğu gibi (lazy) bırakmak, genelde sadece performans kritik, büyük veri setleriyle çalışırken veya tek seferlik bir gezinme yapacaksan tercih edilir.

#Lazy Evaluation'ın Bir Tuzağı — Her Erişimde Yeniden Hesaplama

void main() {
  int sayac = 0;
  List<int> sayilar = [1, 2, 3];

  Iterable<int> sonuc = sayilar.map((s) {
    sayac++;
    return s * 2;
  });

  print(sonuc.toList()); // sayac 3 kez artar (1, 2, 3 işlenir)
  print(sayac); // 3

  print(sonuc.toList()); // ❌ TEKRAR hesaplanır! sayac yine 3 artar
  print(sayac); // 6 — beklenmedik bir şekilde iki katına çıktı!
}

Bu, lazy evaluation'ın dikkat edilmesi gereken bir yönüdür: Iterable, sonucu saklamaz (cache'lemez) — her .toList() (veya başka bir "gerçekleştirme" işlemi) çağrıldığında, hesaplama baştan tekrar yapılır. Eğer sonucu birden fazla kere kullanacaksan, bir kere .toList() çağırıp sonucu bir değişkende saklamak çok daha güvenli ve performanslıdır:

void main() {
  List<int> sayilar = [1, 2, 3];
  List<int> sonuc = sayilar.map((s) => s * 2).toList(); // BİR KERE hesapla

  print(sonuc); // [2, 4, 6] — bu, listeden okumak, tekrar hesaplamak değil
  print(sonuc); // aynı liste, tekrar hesaplama YOK
}

#Diğer Iterable Metodları — Kısa Bir Bakış

void main() {
  List<int> sayilar = [1, 2, 3, 4, 5];

  print(sayilar.take(3));       // (1, 2, 3) — ilk 3 eleman
  print(sayilar.skip(2));       // (3, 4, 5) — ilk 2'yi atla
  print(sayilar.any((s) => s > 4)); // true — en az bir eleman koşulu sağlıyor mu?
  print(sayilar.every((s) => s > 0)); // true — TÜM elemanlar koşulu sağlıyor mu?
  print(sayilar.firstWhere((s) => s > 3)); // 4 — koşulu sağlayan ilk eleman
}

Bu metodlar da (.take(), .skip() gibi) aynı lazy evaluation prensibiyle çalışır — .any() ve .every() gibi bazıları ise sonucu doğrudan bool olarak ürettiği için "gerçekleştirme" (toList gibi) gerektirmez, doğrudan kullanılabilir.

#🎯 Bu Dersten Çıkarılması Gerekenler

• Iterable, List ve Set gibi "gezinebilir" koleksiyonların üst tipidir.
• .map(), .where() gibi metodlar lazy (tembel) çalışır — hesaplama, sonuç gerçekten kullanılana (.toList(), for-in vb.) kadar ertelenir.
• Lazy evaluation, gereksiz hesaplamalardan kaçınmayı ve zincirleme işlemlerde verimliliği sağlar.
• Sonucu birden fazla kere kullanacaksan, bir kere .toList() çağırıp sonucu saklamak gerekir — aksi halde her erişimde hesaplama tekrar yapılır.
• .take(), .skip(), .any(), .every(), .firstWhere() gibi metodlar da Iterable üzerinde çalışan, benzer prensiplere sahip yardımcı araçlardır.

#📝 Ödevler

• [ ] Bir .map() çağrısı içine bir print koyarak, .toList() çağrılmadan önce hiçbir işlemin çalışmadığını kanıtla.
• [ ] 1 milyon elemanlı bir listede .map() ve .take(5) kullanarak, sadece gerekli elemanların işlendiğini bir sayaç ile kanıtla.
• [ ] Bir Iterable sonucunu iki kere .toList() ile "gerçekleştir", bir sayaç kullanarak hesaplamanın iki kere yapıldığını göster; sonra sonucu bir değişkende saklayarak bu tekrarı önle.
• [ ] .take(), .skip(), .any(), .every() metodlarından her birini kullanan birer örnek yaz.
• [ ] Kendi cümlelerinle, "neden map() ve where() doğrudan List değil de Iterable döndürür" sorusunu, bu dersten öğrendiklerinle açıkla.

Sıradaki konu: Bölüm 11 — Konu 52: Cascade Notasyonu (..)