Birisi Haskell'in notunun arkasındaki kavramı açıklayabilir mi?

(soruyu buraya yazıyorum çünkü kodlama probleminden ziyade kavramsal mekaniği ile ilgili)

Eşitliğinde bir dizi fibonacci numarası kullanan küçük bir program üzerinde çalışıyordum, ancak belirli bir sayıyı aşarsam acı verici bir şekilde yavaşladığını fark ettim, Haskell'de bir tekniğe rastladım Memoization, kodun şu şekilde çalıştığını gösterdiler:

-- Traditional implementation of fibonacci, hangs after about 30
slow_fib :: Int -> Integer
slow_fib 0 = 0
slow_fib 1 = 1
slow_fib n = slow_fib (n-2) + slow_fib (n-1)

-- Memorized variant is near instant even after 10000
memoized_fib :: Int -> Integer
memoized_fib = (map fib [0 ..] !!)
   where fib 0 = 0
         fib 1 = 1
         fib n = memoized_fib (n-2) + memoized_fib (n-1)

Yani size sorum şu: bu nasıl ya da daha doğrusu çalışıyor?

Bir şekilde hesaplama yakalanmadan önce listenin çoğunu çalıştırmayı başarıyor mu? Ancak haskell tembelse, yakalanması gereken herhangi bir hesaplama yoktur ... Peki nasıl çalışır?

Sadece gerçek hatırlamanın arkasındaki mekaniği açıklamak için,

memo_fib = (map fib [1..] !!)

"gövdelerin", değerlendirilmemiş hesaplamaların bir listesini üretir. Bunları açılmamış hediyeler gibi düşünün, onlara dokunmadığımız sürece koşmazlar.

Şimdi bir kez bir thunk'ı değerlendirirsek, bir daha asla değerlendirmeyiz. Bu aslında "normal" haskellerin tek mutasyon formudur, thunks bir kez somut değerler olarak değerlendirilir.

Kodunuza geri döndüğünüzde, bir thunks listeniz var ve yine de bu ağaç özyinelemesini yapıyorsunuz, ancak listeyi kullanarak tekrar gönderiyorsunuz ve listedeki bir öğe değerlendirildiğinde, bir daha asla hesaplanmaz. Böylece saf fib fonksiyonunda ağaç özyinelemesinden kaçınırız.

Teğetsel olarak ilginç bir not olarak, bu bir dizi fibonnaci sayısında özellikle hızlıdır, çünkü bu liste sadece bir kez değerlendirilir, yani memo_fib 10000iki kez hesaplarsanız , ikinci zamanın anlık olması gerekir. Bunun nedeni, Haskell'in işlevlere yönelik argümanları yalnızca bir kez değerlendirmesi ve lambda yerine kısmi uygulama kullanmanızdır.

TLDR: Hesaplamaları bir listede saklayarak, listenin her bir elemanı bir kez değerlendirilir, bu nedenle her fibonnacci numarası tüm program boyunca tam olarak bir kez hesaplanır.

Görselleştirme:

 [THUNK_1, THUNK_2, THUNK_3, THUNK_4, THUNK_5]
 -- Evaluating THUNK_5
 [THUNK_1, THUNK_2, THUNK_3, THUNK_4, THUNK_3 + THUNK_4]
 [THUNK_1, THUNK_2, THUNK_1 + THUNK_2, THUNK_4, THUNK_3 + THUNK_4]
 [1, 1, 1 + 1, THUNK_4, THUNK_3 + THUNK_4]
 [1, 1, 2, THUNK_4, 2 + THUNK4]
 [1, 1, 2, 1 + 2, 2 + THUNK_4]
 [1, 1, 2, 3, 2 + 3]
 [1, 1, 2, 3, 5]

Böylece THUNK_4, alt ifadeleri zaten değerlendirildiğinden değerlendirmenin nasıl daha hızlı olduğunu görebilirsiniz .

Notlama noktası asla aynı işlevi iki kez hesaplamak değildir - bu tamamen işlevsel olan, yani yan etkileri olmayan hesaplamaları hızlandırmak için son derece yararlıdır, çünkü bunlar için süreç doğruluğu etkilemeden tamamen otomatikleştirilebilir. Bu, saf bir şekilde uygulandığında ağaç özyinelemesine , yani üstel çabaya fiboyol açan gibi işlevler için özellikle gereklidir . (Fibonacci sayılarının özyineleme öğretimi için aslında çok kötü bir örnek olmasının bir nedeni budur - öğreticilerde veya kitaplarda bulduğunuz neredeyse tüm demo uygulamaları büyük giriş değerleri için kullanılamaz.)

Yürütme akışını izlerseniz, ikinci durumda, değerinin yürütüldüğünde fib xher zaman kullanılabilir olacağını ve çalışma zamanı sisteminin başka bir özyinelemeli çağrı yerine bellekten okuyabileceğini göreceksiniz. ilk çözüm, daha küçük değerler için sonuçlar elde edilmeden önce daha büyük çözümü hesaplamaya çalışır. Bunun nedeni, sonuçta yineleyicinin soldan sağa değerlendirilmesi ve bu nedenle ile başlamasıdır , ilk örnekteki özyineleme ile başlar ve ancak sonra sorar . Bu, birçok gereksiz birçok yinelenen işlev çağrısına yol açar.fib x+1[0..n]0nn-1