lazy evaluation

• bir değişkenin değerinin, mecbur kalınana kadar hesaplanmadığı programlama dili özelliğidir.
  
  (bkz: haskell)
  
  bundan bihaber biz c programcıları, şöyle düşünürüz:
  int a = 5;
  int b = 2;
  int c = a / b; // 2.5, 2'ye yuvarlanir. (tamamen kucuk harf'e tesekkurler)
  int d = c * b; // 4.
  
  ama bu lazy evaluation durumunun geçerli olduğu dillerde, değişkenin değerine ihtiyaç olduğu ana kadar hesaplama yapılmaz. böylece hem performans kazanımı olur, hem de yukarıda görüldüğü gibi hatalar oluşmaz.
  örneğin c'de bu geçerli olsaydı:
  int a = 5;
  int b = 2;
  int c = a/b;
  // c, hafızada a/b ifadesi olarak işaretlenir.
  int d = c*b;
  // d, hafızada c*b olarak işaretlenir. hatta belki a/b*b, ve hatta sadeleştirilip a olabilir.
  
  (bkz: delayed evaluation) (bkz: minimal evaluation)
  tersi: (bkz: strict evaluation)
• genelde memoization ile birlikte fonksiyonel programlama dillerinde kullanilan bir evaluation teknigidir. saf fonksiyonel olmayan, ozellikle de imperatif, dillerde kullanilmasi sakattir zira o dillerde ifadelerin calistirilma sirasi sonuc uzerinde etkili olabilmektedir. dahasi fonksiyonel dillerde bu sekilde calistirilan ifadelerin sonucu memoize edilerek siradisi performans artisi saglanabilir.
• görünce "vışşşş" dediğim ve sonrasında haskell öğrenmeye tekrardan karar verdiğim zıbıdık
• (bkz: lazy ejaculation)
• and ifadesi kullanılan bir yapıda ilk operandın sonucu false ise ikinci operand işlenmeden geçilir.
  
  örrnek
  
  if bolen!=0 and bolunen%bolen==0:
  ..................
  ..................
  
  bolen eğer 0 eşit ise(false durumu) ikinci ifade artık işleme alınmaz.
• haskell'da da kullaniminda dikkatli olunmasi gereken hede.
  
  mesela su ifadeyi ele alalim: foldl (+) 0 [1..1000000]
  
  foldl her ne kadar tail recursion ile tanimlanmis bir fonksiyon olsa bile, haskell'deki lazy evaluation stratejisi yuzunden sonraki onyinelemeli fonksiyon cagrisina arguman olarak verilen degerlerin hesaplanmasi en sonra birakiliyor. (en sondan kasit base case.) yani once bir milyon sayinin birbirine eklenme expression'i olusturuluyor, bu expression sonradan hesaplaniyor:
  
  (((((((((0 + 1) + 2) + 3) + 4) + 5) + ...) + 999997) + 999998) + 999999) + 1000000
  
  boyle bir islem de buyuk bir olasilikla stack overflow'a sebebiyet veriyor. halbuki once islemi olusturup sonra degerini hesaplamak yerine foldl esnasinda toplam degerin adim adim hesaplanmasini zorunlu kilsaydik boyle bir sorunla karsilasmayacaktik. haskell'de bunun cozumu surada.
  
  ayrica (bkz: space complexity).
• (bkz: collapse of the wave function)