Tembel değerlendirme - Lazy evaluation

Değerlendirme stratejileri

İçinde programlama dili teorisi, tembel değerlendirmeveya ihtiyaca göre arama[1] bir değerlendirme stratejisi bu da bir ifade değerine ihtiyaç duyulana kadar (katı olmayan değerlendirme ) ve tekrarlanan değerlendirmelerden de kaçınan (paylaşma ).[2][3] Paylaşım, belirli işlevlerin çalışma süresini, diğer katı olmayan değerlendirme stratejilerine göre üstel bir faktörle azaltabilir, örneğin: isimle arama işlevi olup olmadığına bakılmaksızın, aynı işlevi tekrar tekrar değerlendiren ezberlenmiş.

Bununla birlikte, uzun işlemler için, kullanıcı girdilerinin işlenmesi gibi zamana duyarlı işlemlerden önce gerçekleştirilmesi daha uygun olacaktır. video oyunu.

Tembel değerlendirmenin faydaları şunları içerir:

  • Tanımlama yeteneği kontrol akışı (yapılar) ilkeller yerine soyutlamalar olarak.
  • Tanımlama yeteneği potansiyel olarak sonsuz veri yapıları. Bu, bazı algoritmaların daha kolay uygulanmasına izin verir.
  • Gereksiz hesaplamalardan kaçınarak ve bileşik ifadeleri değerlendirirken hata durumlarından kaçınarak performans artar.

Tembel değerlendirme genellikle aşağıdakilerle birleştirilir: hafızaya alma, açıklandığı gibi Jon Bentley 's Verimli Programlar Yazma.[4] Bir fonksiyonun değeri o parametre veya parametre seti için hesaplandıktan sonra, sonuç, bu parametrelerin değerleri ile indekslenen bir arama tablosunda saklanır; Fonksiyonun bir sonraki çağrılışında, bu parametre değerleri kombinasyonunun sonucunun halihazırda mevcut olup olmadığını belirlemek için tabloya başvurulur. Öyleyse, depolanan sonuç basitçe döndürülür. Değilse, işlev değerlendirilir ve yeniden kullanım için arama tablosuna başka bir giriş eklenir.

Gerektiğinde değerler oluşturulduğundan, tembel değerlendirme bellek ayak izinde azalmaya yol açabilir.[5] Ancak, tembel değerlendirmenin aşağıdaki gibi zorunlu özelliklerle birleştirilmesi zordur. istisna işleme ve giriş çıkış, çünkü işlemlerin sırası belirsiz hale gelir. Tembel değerlendirme getirebilir bellek sızıntıları.[6][7]

Tembel değerlendirmenin tersi istekli değerlendirme, bazen katı değerlendirme olarak da bilinir. Hevesli değerlendirme, çoğu ülkede kullanılan değerlendirme stratejisidir.[ölçmek ] Programlama dilleri.

Tarih

Tembel değerlendirme tanıtıldı lambda hesabı Christopher Wadsworth tarafından[8] ve tarafından istihdam Plessey Sistemi 250 bir Lambda-Calculus Meta-Machine'in kritik bir parçası olarak, yetenek sınırlı bir adres alanındaki nesnelere erişim için çözünürlük ek yükünü azaltır.[9] Programlama dilleri için bağımsız olarak Peter Henderson tarafından tanıtıldı ve James H. Morris[10] ve tarafından Daniel P. Friedman ve David S. Wise.[11][12]

Başvurular

Gecikmeli değerlendirme özellikle fonksiyonel programlama Diller. Gecikmeli değerlendirme kullanılırken, bir ifade bir değişkene bağlanır bağlanmaz değerlendirilmez, değerlendirici ifadenin değerini üretmeye zorlandığında değerlendirilir. Yani şöyle bir ifade x = ifade; (yani bir ifadenin sonucunun bir değişkene atanması) açıkça ifadenin değerlendirilmesini ve sonucun xama gerçekte ne var x bir referans yoluyla değerine ihtiyaç duyulana kadar ilgisizdir. x Sonunda hızla büyüyen bağımlılıklar ağacı, dış dünyanın görmesi için başka bir sembol yerine bir sembol üretmek üzere budanacak olsa da, değerlendirmesi ertelenebilecek sonraki bazı ifadelerde.[13]

Gecikmeli değerlendirme, sonsuz döngüler veya hesaplamayı engelleyen boyut sorunları olmadan hesaplanabilir sonsuz listeler oluşturabilme avantajına sahiptir. Örneğin, sonsuz bir liste oluşturan bir işlev oluşturulabilir (genellikle Akış ) nın-nin Fibonacci sayıları. Hesaplanması n-th Fibonacci sayısı, yalnızca o elemanın sonsuz listeden çıkarılmasıdır ve listenin yalnızca ilk n üyesinin değerlendirilmesini zorlar.[14][15]

Örneğin, Haskell programlama dili, tüm Fibonacci sayılarının listesi şu şekilde yazılabilir:[15]

 lifler = 0 : 1 : zipWith (+) lifler (kuyruk lifler)

Haskell sözdiziminde, ":"bir öğeyi listenin başına ekler, kuyruk ilk öğesi olmayan bir liste döndürür ve zipWith üçüncüyü oluşturmak için iki listenin ilgili öğelerini birleştirmek için belirli bir işlevi (bu durumda ekleme) kullanır.[14]

Programcının dikkatli olması koşuluyla, yalnızca belirli bir sonucu üretmek için gereken değerler değerlendirilir. Ancak, bazı hesaplamalar programın sonsuz sayıda öğeyi değerlendirmeye çalışmasına neden olabilir; örneğin, listenin uzunluğunu talep etmek veya listenin öğelerini bir katlama işlemi programın sonlandırılamamasına veya çalışmasına neden olabilir bellek yetersiz.

Kontrol Yapıları

Neredeyse hepsinde[ölçmek ] yaygın "istekli" diller, Eğer ifadeler tembel bir şekilde değerlendirilir.

eğer a sonra b başka bir c

(a) 'yı değerlendirir, o zaman ancak ve ancak (a) doğru olarak değerlendirirse (b)' yi değerlendirir, aksi takdirde (c) 'yi değerlendirir. Yani (b) veya (c) değerlendirilmeyecektir. Tersine, istekli bir dilde beklenen davranış şudur:

f (x, y) = 2 * xset k = f (d, e) 'yi tanımlayın

(e) f fonksiyonunda kullanılmasa bile f (d, e) 'nin değerini hesaplarken (e)' yi değerlendirecektir. Bununla birlikte, kullanıcı tanımlı kontrol yapıları tam sözdizimine bağlıdır, bu nedenle örneğin

g (a, b, c) 'yi tanımlayın = eğer a ise b ise cl = g (h, i, j)

(i) ve (j) 'nin ikisi de istekli bir dilde değerlendirilecektir. Tembel bir dilde iken

l '= eğer h ise o halde ben başka j

(i) veya (j) değerlendirilir, ancak ikisi birden asla.

Tembel değerlendirme, kontrol yapılarının ilkel veya derleme zamanı teknikleri olarak değil, normal olarak tanımlanmasına izin verir. (İ) veya (j) varsa yan etkiler veya çalışma zamanı hataları ortaya çıkarırsa, (l) ve (l ') arasındaki ince farklar karmaşık olabilir. İstekli dillerde kullanıcı tanımlı tembel kontrol yapılarını işlevler olarak tanıtmak genellikle mümkündür, ancak bunlar, istekli değerlendirme için dilin sözdiziminden ayrılabilir: Genellikle dahil edilen kod gövdelerinin ((i) ve (j) gibi) sarılması gerekir. bir işlev değeri, böylece yalnızca çağrıldığında yürütülürler.

Kısa devre değerlendirmesi Boolean denetim yapılarının adı bazen tembel.

Sonsuz veri yapılarıyla çalışmak

Birçok dil şu kavramını sunar: sonsuz veri yapıları. Bunlar, verilerin tanımlarının sonsuz aralıklar veya sonsuz özyineleme olarak verilmesine izin verir, ancak gerçek değerler yalnızca gerektiğinde hesaplanır. Örneğin Haskell'deki bu önemsiz programı ele alalım:

numberFromInfiniteList :: Int -> IntnumberFromInfiniteList n =  sonsuzluk !! n - 1    nerede sonsuzluk = [1..]ana = Yazdır $ numberFromInfiniteList 4

İşlevde numberFromInfiniteList, değeri sonsuzluk sonsuz bir aralıktır, ancak gerçek bir değere (veya daha spesifik olarak, belirli bir dizindeki belirli bir değere) ihtiyaç duyulana kadar liste değerlendirilmez ve o zaman bile yalnızca gerektiği gibi değerlendirilir (yani istenen dizine kadar. )

Başarı listesi modeli

Aşırı efordan kaçınmak

Formda bir bileşik ifade olabilir Kolayca Bilgisayarlı veya Çok iş böylece kolay kısım verirse doğru birçok işten kaçınılabilir. Örneğin, bunun bir asal sayı olup olmadığını ve bir IsPrime (N) fonksiyonu olup olmadığını belirlemek için büyük bir N sayısının kontrol edileceğini varsayalım, ancak ne yazık ki, değerlendirmek için çok fazla hesaplama gerektirebilir. Belki N = 2 veya [Mod (N, 2) ≠ 0 ve IsPrime (N)] N için keyfi değerlere sahip çok sayıda değerlendirme olması durumunda yardımcı olacaktır.

Hata koşullarından kaçınma

Formda bir bileşik ifade olabilir SafeTo Try ve İfade bu suretle eğer SafeTo Try dır-dir yanlış değerlendirme girişiminde bulunulmamalıdır. İfade sıfıra bölme veya sınır dışı indeksler vb. gibi bir çalışma zamanı hatası bildirilsin. Örneğin, aşağıdaki sözde kod, bir dizinin sıfır olmayan son elemanını bulur:

 L: = Uzunluk (A); Süre L> 0 ve Bir (L) = 0 yapmak L: = L - 1;

Dizinin tüm elemanlarının sıfır olması durumunda, döngü L = 0'a kadar çalışacaktır ve bu durumda döngü, mevcut olmayan dizinin sıfır elemanına başvurmadan sonlandırılmalıdır.

Diğer kullanımlar

Bilgisayarda pencereleme sistemleri, bilginin ekrana boyanması, olayları açığa çıkarmak ekran kodunu mümkün olan en son anda çalıştıran. Bunu yaparak, pencereleme sistemleri gereksiz görüntü içeriği güncellemelerini hesaplamaktan kaçınır.[16]

Modern bilgisayar sistemlerindeki bir başka tembellik örneği yazma üzerine kopyalama sayfa ayırma veya çağrı isteği, burada belleğin yalnızca o bellekte saklanan bir değer değiştirildiğinde tahsis edilir.[16]

Tembellik, yüksek performans senaryoları için faydalı olabilir. Bir örnek Unix'tir mmap sağlayan işlev talebe dayalı sayfaların diskten yüklenmesi, böylece sadece gerçekten dokunulan sayfalar belleğe yüklenir ve gereksiz bellek tahsis edilmez.

MATLAB uygular düzenleme üzerine kopyala, kopyalanan dizilerin gerçek bellek depolama alanlarının yalnızca içerikleri değiştirildiğinde çoğaltıldığı, muhtemelen bir bellek yetersiz kopyalama işlemi sırasında değil, daha sonra bir öğeyi güncellerken hata.[17]

Uygulama

Bazı programlama dilleri varsayılan olarak ifadelerin değerlendirilmesini geciktirir, bazıları ise fonksiyonlar veya özel sözdizimi değerlendirmeyi geciktirmek. İçinde Miranda ve Haskell işlev bağımsız değişkenlerinin değerlendirilmesi varsayılan olarak geciktirilir. Diğer birçok dilde, özel sözdizimi kullanarak hesaplamayı açıkça askıya alarak değerlendirme geciktirilebilir ( Şema "gecikme" ve "güç" ve OCaml 's "tembel" ve "Tembel kuvvet") veya daha genel olarak ifadeyi bir thunk. Böyle açıkça gecikmiş bir değerlendirmeyi temsil eden nesneye tembel gelecek. Raku listelerin tembel değerlendirmesini kullanır, böylece kişi değişkenlere sonsuz listeler atayabilir ve bunları işlevler için bağımsız değişken olarak kullanabilir, ancak Haskell ve Miranda'dan farklı olarak Raku, aritmetik işleçlerin ve işlevlerin tembel değerlendirmesini varsayılan olarak kullanmaz.[13]

Tembellik ve heves

Tembel dillerde hevesi kontrol etme

Haskell gibi tembel programlama dillerinde, varsayılan, ifadeleri yalnızca talep edildiğinde değerlendirmek olsa da, bazı durumlarda kodu daha istekli yapmak veya tam tersi, daha istekli hale getirildikten sonra tekrar daha tembel hale getirmek mümkündür. Bu, değerlendirmeyi zorlayan (kodu daha istekli hale getiren) bir şeyi açıkça kodlayarak veya bu tür kodlardan kaçınarak (kodu daha tembel hale getirebilir) yapılabilir. Katı değerlendirme genellikle isteklilik anlamına gelir, ancak bunlar teknik olarak farklı kavramlardır.

Ancak, bazı derleyicilerde uygulanan bir optimizasyon vardır. sıkılık analizi, bazı durumlarda derleyicinin bir değerin her zaman kullanılacağı sonucuna varmasına izin verir. Bu gibi durumlarda, programcının belirli bir değeri zorlayıp zorlamama seçimini alakasız hale getirebilir, çünkü katılık analizi katı değerlendirmeyi zorlayacaktır.

Haskell'de yapıcı alanlarının katı olarak işaretlenmesi, değerlerinin her zaman hemen talep edileceği anlamına gelir. sıra işlev, hemen bir değer talep etmek ve sonra onu iletmek için de kullanılabilir; bu, bir yapıcı alanının genellikle tembel olması gerekiyorsa yararlıdır. Bununla birlikte, bu tekniklerin hiçbiri yinelemeli katılık — bunun için adı verilen bir işlev deepSeq icat edildi.

Ayrıca, desen eşleştirme Haskell 98'de varsayılan olarak katıdır, bu nedenle ~ niteleyici, onu tembel hale getirmek için kullanılmalıdır.[18]

Hevesli dillerde tembellik simülasyonu

Java

İçinde Java, değere ihtiyaç duyulduğunda onları değerlendirmek için bir yöntemi olan nesneler kullanılarak tembel değerlendirme yapılabilir. Bu yöntemin gövdesi, bu değerlendirmeyi gerçekleştirmek için gereken kodu içermelidir. Girişinden beri lambda ifadeleri Java SE8'de, Java bunun için kompakt bir gösterimi desteklemiştir. Aşağıdaki örnek genel arabirim, tembel değerlendirme için bir çerçeve sağlar:[19][20]

arayüz Tembel<T> {    T değerlendirme();}

Tembel ile arayüz eval () yöntem eşdeğerdir Tedarikçi ile arayüz almak() yöntem java.util.function kütüphane.[21]

Uygulayan her sınıf Tembel arayüz sağlamalıdır değerlendirme yöntem ve sınıfın örnekleri, yöntemin tembel değerlendirmeyi gerçekleştirmek için ihtiyaç duyduğu değerleri taşıyabilir. Örneğin, tembel olarak hesaplamak ve yazdırmak için aşağıdaki kodu göz önünde bulundurun 210:

Tembel<Tamsayı> a = ()-> 1;için (int ben = 1; ben <= 10; ben++) {    final Tembel<Tamsayı> b = a;    a = ()-> b.değerlendirme() + b.değerlendirme();}Sistemi.dışarı.println( "a =" + a.değerlendirme() );

Yukarıda değişken a başlangıçta lambda ifadesi tarafından oluşturulan tembel bir tam sayı nesnesini ifade eder ()->1. Bu lambda ifadesinin değerlendirilmesi, uygulayan anonim bir sınıfın yeni bir örneğini oluşturmaya eşdeğerdir Tembel bir ile değerlendirme geri dönen yöntem 1.

Döngü bağlantılarının her yinelemesi a döngü içindeki lambda ifadesinin değerlendirilmesiyle oluşturulan yeni bir nesneye. Bu nesnelerin her biri, başka bir tembel nesneye bir referans tutar, bve bir değerlendirme çağıran yöntem b.eval () iki kez ve toplamı döndürür. Değişken b Java'nın lambda ifadesi içinde referans verilen değişkenlerin nihai olması gerekliliğini karşılamak için burada gereklidir.

Bu verimsiz bir programdır çünkü tembel tam sayıların bu uygulaması hatırlamak önceki çağrıların sonucu değerlendirme. Aynı zamanda önemli otomatik kutulama ve kutudan çıkarma. Açık olmayabilecek şey, döngünün sonunda programın bir bağlantılı liste 11 nesneden oluştuğunu ve sonucun hesaplanmasında yer alan tüm gerçek eklemelerin, çağrıya yanıt olarak yapıldığını a.eval () kodun son satırında. Bu çağrı tekrarlı gerekli eklemeleri gerçekleştirmek için listeyi dolaşır.

Tembel nesneleri aşağıdaki gibi hatırlayan bir Java sınıfı oluşturabiliriz:[19][20]

sınıf Not<T> uygular Tembel<T> {    özel Tembel<T> tembel;  // tembel bir ifade, eval onu boş olarak ayarlar    özel T not = boş; // önceki değerin muhtırası    halka açık Not( Tembel<T> tembel ) { // yapıcı        bu.tembel = tembel;    }    halka açık T değerlendirme() {        Eğer (tembel == boş) dönüş not;        not = tembel.değerlendirme();        tembel = boş;        dönüş not;    }}

Bu, önceki örneğin çok daha verimli olması için yeniden yazılmasına izin verir. Orijinalin yineleme sayısında zaman içinde üstel olarak çalıştığı yerde, ezberlenmiş sürüm doğrusal zamanda çalışır:

Tembel<Tamsayı> a = ()-> 1;için (int ben = 1; ben <= 10; ben++) {    final Tembel<Tamsayı> b = a;    a = yeni Not<Tamsayı>( ()-> b.değerlendirme() + b.değerlendirme() );}Sistemi.dışarı.println( "a =" + a.değerlendirme() );

Java'nın lambda ifadelerinin yalnızca Sözdizimsel şeker. Bir lambda ifadesiyle yazabileceğiniz her şey, anonim bir örnek oluşturmak için bir çağrı olarak yeniden yazılabilir. iç sınıf arabirimi uygulamak ve anonim bir iç sınıfın herhangi bir kullanımı, adlandırılmış bir iç sınıf kullanılarak yeniden yazılabilir ve adlandırılmış herhangi bir iç sınıf, en dıştaki yuvalama düzeyine taşınabilir.

Python

İçinde Python 2.x Aralık() işlevi[22] tamsayıların bir listesini hesaplar. İlk atama ifadesi değerlendirildiğinde listenin tamamı bellekte saklanır, bu nedenle bu, istekli veya anlık değerlendirme örneğidir:

>>> r = Aralık(10)>>> Yazdır r[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>>> Yazdır r[3]3

Python 3.x'te Aralık() işlevi[23] istek üzerine listenin öğelerini hesaplayan özel bir aralık nesnesi döndürür. Aralık nesnesinin öğeleri yalnızca ihtiyaç duyulduğunda oluşturulur (ör. baskı (r [3]) aşağıdaki örnekte değerlendirilmiştir), bu nedenle bu tembel veya ertelenmiş bir değerlendirme örneğidir:

>>> r = Aralık(10)>>> Yazdır(r)aralık (0, 10)>>> Yazdır(r[3])3
Tembel değerlendirmeye yapılan bu değişiklik, hiçbir zaman tam olarak başvurulamayacak büyük aralıklar için yürütme süresinden ve herhangi bir zamanda yalnızca bir veya birkaç öğenin gerekli olduğu geniş aralıklar için bellek kullanımından tasarruf sağlar.

Python 2.x'te, adı verilen bir işlevi kullanmak mümkündür xrange () talep üzerine aralıktaki sayıları üreten bir nesne döndürür. Avantajı xrange üretilen nesnenin her zaman aynı miktarda bellek almasıdır.

>>> r = xrange(10)>>> Yazdır(r)xrange (10)>>> lst = [x için x içinde r]>>> Yazdır(lst)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Sürüm 2.2'den itibaren, Python, tuple veya list dizilerinin aksine yineleyiciler (tembel diziler) uygulayarak tembel bir değerlendirme sunar. Örneğin (Python 2):

>>> sayılar = Aralık(10)>>> yineleyici = tekrar(sayılar)>>> Yazdır sayılar[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>>> Yazdır yineleyici<listiterator object at 0xf7e8dd4c>>>> Yazdır yineleyici.Sonraki()0
Yukarıdaki örnek, listelerin çağrıldığında değerlendirildiğini, ancak yineleyici durumunda, ihtiyaç duyulduğunda ilk öğe '0' yazdırıldığını göstermektedir.

.NET Framework

İçinde .NET Framework sınıfı kullanarak tembel değerlendirme yapmak mümkündür Sistemi.Tembel<T>.[24] Sınıf, içinde kolayca kullanılabilir F # kullanmak tembel anahtar kelime, güç yöntem değerlendirmeyi zorlayacaktır. Gibi özel koleksiyonlar da var Microsoft.FSharp.Koleksiyonlar.Sıra tembel değerlendirme için yerleşik destek sağlayan. 

İzin Vermek fibonacci = Sıra.açılmak (eğlence (x, y) -> Biraz(x, (y, x + y))) (0I,1I)fibonacci |> Sıra.n. 1000

C # ve VB.NET'te sınıf Sistemi.Tembel<T> doğrudan kullanılır. 

halka açık int Toplam(){    int a = 0;    int b = 0;     Tembel<int> x = yeni Tembel<int>(() => a + b);    a = 3;    b = 5;    dönüş x.Değer; // 8 döndürür}

Veya daha pratik bir örnekle: 

// n'inci fibonacci sayısının yinelemeli hesaplamasıhalka açık int Fib(int n){   dönüş (n == 1)? 1 : (n == 2)? 1 : Fib(n-1) + Fib(n-2);}halka açık geçersiz Ana(){    Konsol.Yazı çizgisi("Hangi Fibonacci sayısını hesaplamak istiyorsunuz?");    int n = Int32.Ayrıştır(Konsol.ReadLine());     Tembel<int> uydurmak = yeni Tembel<int>(() => Fib(n)); // işlev hazırlandı, ancak çalıştırılmadı    bool yürütmek;     Eğer (n > 100)    {        Konsol.Yazı çizgisi("Bu biraz zaman alabilir. Bu büyük sayıyı gerçekten hesaplamak istiyor musunuz? [Y / n]");        yürütmek = (Konsol.ReadLine() == "y");     }    Başka yürütmek = yanlış;        Eğer (yürütmek) Konsol.Yazı çizgisi(uydurmak.Değer); // sayı yalnızca gerekirse hesaplanır}

Başka bir yol da Yol ver anahtar kelime: 

// hevesli değerlendirme halka açık IEnumerable<int> Fibonacci(int x){    IList<int> lifler = yeni Liste<int>();    int önceki = -1;    int Sonraki = 1;    için (int ben = 0; ben < x; ben++)    {        int toplam = önceki + Sonraki;        önceki = Sonraki;        Sonraki = toplam;        lifler.Ekle(toplam);     }    dönüş lifler;}// tembel değerlendirme halka açık IEnumerable<int> LazyFibonacci(int x){    int önceki = -1;    int Sonraki = 1;    için (int ben = 0; ben < x; ben++)    {        int toplam = önceki + Sonraki;        önceki = Sonraki;        Sonraki = toplam;        Yol ver dönüş toplam;    }}
Ana makale: Thunk

Ayrıca bakınız

Referanslar

  1. ^ Hudak 1989, s. 384
  2. ^ David Anthony Watt; William Findlay (2004). Programlama dili tasarım kavramları. John Wiley and Sons. sayfa 367–368. ISBN  978-0-470-85320-7. Alındı 30 Aralık 2010.
  3. ^ Reynolds 1998, s. 307
  4. ^ Bentley, Jon Louis. Verimli Programlar Yazmak. Prentice-Hall, 1985. ISBN  978-0139702440
  5. ^ Chris Smith (22 Ekim 2009). Programlama F #. O'Reilly Media, Inc. s. 79. ISBN  978-0-596-15364-9. Alındı 31 Aralık 2010.
  6. ^ Launchbury 1993.
  7. ^ Edward Z. Yang. "Uzay sızıntısı hayvanat bahçesi".
  8. ^ Wadsworth 1971
  9. ^ Hamer-Hodges, Kenneth (1 Ocak 2020). Civilizing Cyberspace: The Fight for Digital Democracy. s. 410. ISBN  978-1-95-163044-7. Alındı 29 Şubat 2020.
  10. ^ Henderson ve Morris 1976
  11. ^ Friedman ve Wise 1976
  12. ^ Reynolds 1998, s. 312
  13. ^ a b Philip Wadler (2006). İşlevsel ve mantıksal programlama: 8. uluslararası sempozyum, FLOPS 2006, Fuji-Susono, Japonya, 24-26 Nisan 2006: bildiriler. Springer. s. 149. ISBN  978-3-540-33438-5. Alındı 14 Ocak 2011.
  14. ^ a b Daniel Le Métayer (2002). Programlama dilleri ve sistemleri: 11. Avrupa Programlama Sempozyumu, ESOP 2002, Ortak Avrupa Yazılım Teorisi ve Pratiği Konferanslarının bir parçası olarak düzenlenmiştir, ETAPS 2002, Grenoble, Fransa, 8-12 Nisan 2002: bildiriler. Springer. s. 129–132. ISBN  978-3-540-43363-7. Alındı 14 Ocak 2011.
  15. ^ a b Bilgi İşlem Makinaları Derneği; ACM Programlama Dilleri Özel İlgi Grubu (1 Ocak 2002). 2002 ACM SIGPLAN Haskell Çalıştayı Bildirileri (Haskell '02): Pittsburgh, Pennsylvania, ABD; 3 Ekim 2002. Bilgi İşlem Makineleri Derneği. s. 40. ISBN  978-1-58113-605-0. Alındı 14 Ocak 2011.
  16. ^ a b Tembel ve Spekülatif Yürütme Butler Lampson Microsoft Araştırma OPODIS, Bordeaux, Fransa 12 Aralık 2006
  17. ^ "Mevcut dizilere değer atarken bellek yetersiz mi? - MATLAB Answers - MATLAB Central".
  18. ^ "Tembel kalıp eşleşmesi - HaskellWiki".
  19. ^ a b Grzegorz Piwowarek, Java'da Tembel Değerlendirme için Lambda İfadelerinden Yararlanma, 4 Anlama, 25 Temmuz 2018.
  20. ^ a b Douglas W. Jones, CS: 2820 Notlar, Ders 14, Erişim tarihi: Ekim 2020.
  21. ^ Arayüz Desteği , Erişim tarihi: Ekim 2020.
  22. ^ "2. Yerleşik İşlevler - Python 2.7.11 belgeleri".
  23. ^ "2. Yerleşik İşlevler - Python 3.5.1 belgeleri".
  24. ^ "Tembel (T) Sınıf (Sistem)". Microsoft.

daha fazla okuma

Dış bağlantılar