Adakah yang bisa menjelaskan konsep di balik memoisasi Haskell?

(perhatikan saya mengajukan pertanyaan di sini karena ini tentang mekanisme konseptualnya, daripada masalah pengkodean)

Saya sedang mengerjakan sebuah program kecil, yang menggunakan urutan angka-angka fibonacci dalam persamaannya, tetapi saya perhatikan bahwa jika saya mendapatkan lebih dari jumlah tertentu ia menjadi sangat lambat, mencari-cari sedikit, saya menemukan sebuah teknik di Haskell yang dikenal sebagai Memoization, mereka menunjukkan kode berfungsi seperti ini:

-- 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)

Jadi pertanyaan saya kepada kalian adalah, bagaimana atau lebih tepatnya mengapa ini bekerja?

Apakah karena entah bagaimana berhasil melewati sebagian besar daftar sebelum perhitungannya tercapai? Tetapi jika haskell malas, sebenarnya tidak ada perhitungan yang perlu mengejar ... Jadi bagaimana cara kerjanya?

Hanya untuk menjelaskan mekanisme di balik memoisasi yang sebenarnya,

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

menghasilkan daftar "thunks", perhitungan yang tidak dievaluasi. Pikirkan ini seperti hadiah yang belum dibuka, selama kita tidak menyentuh mereka, mereka tidak akan lari.

Sekarang setelah kami mengevaluasi seorang pencuri, kami tidak pernah mengevaluasinya lagi. Ini sebenarnya satu-satunya bentuk mutasi dalam haskell "normal", thunks bermutasi setelah dievaluasi menjadi nilai konkret.

Jadi kembali ke kode Anda, Anda punya daftar thunks, dan Anda masih melakukan rekursi pohon ini, tetapi Anda berulang menggunakan daftar, dan sekali elemen dalam daftar dievaluasi, itu tidak akan pernah dihitung lagi. Dengan demikian, kita menghindari rekursi pohon dalam fungsi fib naif.

Sebagai catatan yang menarik secara tangensial, ini terutama cepat pada serangkaian bilangan fibonnaci yang dihitung karena daftar itu hanya dievaluasi satu kali, yang berarti bahwa jika Anda menghitung memo_fib 10000dua kali, yang kedua harus instan. Ini karena Haskell hanya mengevaluasi argumen untuk fungsi sekali dan Anda menggunakan aplikasi parsial bukan lambda.

TLDR: Dengan menyimpan perhitungan dalam daftar, setiap elemen daftar dievaluasi satu kali, oleh karena itu, setiap nomor fibonnacci dihitung tepat sekali di seluruh program.

Visualisasi:

 [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]

Jadi, Anda dapat melihat bagaimana mengevaluasi THUNK_4jauh lebih cepat karena subekspresi sudah dievaluasi.

Titik memoisasi tidak pernah menghitung fungsi yang sama dua kali - ini sangat berguna untuk mempercepat perhitungan yang murni fungsional, yaitu tanpa efek samping, karena bagi mereka proses tersebut dapat sepenuhnya otomatis tanpa mempengaruhi kebenaran. Ini terutama diperlukan untuk fungsi seperti fibo, yang mengarah pada rekursi pohon , yaitu upaya eksponensial, ketika diterapkan secara naif. (Ini adalah salah satu alasan mengapa angka-angka Fibonacci sebenarnya adalah contoh yang sangat buruk untuk pengajaran rekursi - hampir semua implementasi demo yang Anda temukan dalam tutorial atau buku tidak dapat digunakan untuk nilai input besar.)

Jika Anda melacak aliran eksekusi, Anda akan melihat bahwa dalam kasus kedua, nilai untuk fib xakan selalu tersedia ketika fib x+1dieksekusi, dan sistem runtime akan dapat dengan mudah membacanya dari memori daripada melalui panggilan rekursif lain, sedangkan solusi pertama mencoba untuk menghitung solusi yang lebih besar sebelum hasil untuk nilai yang lebih kecil tersedia. Ini pada akhirnya karena iterator [0..n]dievaluasi dari kiri ke kanan dan karena itu akan mulai dengan 0, sedangkan rekursi dalam contoh pertama dimulai dengan ndan hanya kemudian bertanya tentang n-1. Inilah yang menyebabkan banyak, banyak panggilan fungsi duplikat yang tidak perlu.