Ai đó có thể giải thích khái niệm đằng sau sự ghi nhớ của Haskell không?

(lưu ý tôi đặt câu hỏi ở đây vì đó là về cơ chế khái niệm của nó, chứ không phải là vấn đề mã hóa)

Tôi đang làm việc trên một chương trình nhỏ, đó là sử dụng một chuỗi các số của Wikipedia, nhưng tôi nhận thấy rằng nếu tôi vượt qua một số nào đó, nó sẽ bị chậm một cách đau đớn, tôi loạng choạng một chút về một kỹ thuật trong Haskell được biết đến như Memoization, họ đã cho thấy mã làm việc như thế này:

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

Vì vậy, câu hỏi của tôi cho các bạn là, làm thế nào hoặc đúng hơn tại sao điều này làm việc?

Có phải vì nó bằng cách nào đó quản lý để chạy qua hầu hết danh sách trước khi tính toán bắt kịp? Nhưng nếu haskell lười biếng, thực sự không có bất kỳ tính toán nào cần theo kịp ... Vậy nó hoạt động như thế nào?

Chỉ để giải thích các cơ chế đằng sau việc ghi nhớ thực tế,

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

tạo ra một danh sách "thunks", các tính toán không được đánh giá. Hãy nghĩ về những thứ này giống như những món quà chưa mở, miễn là chúng ta không chạm vào chúng, chúng sẽ không chạy.

Bây giờ một khi chúng tôi đánh giá một thunk, chúng tôi không bao giờ đánh giá nó một lần nữa. Đây thực sự là hình thức đột biến duy nhất trong haskell "bình thường", thunks đột biến một khi được đánh giá để trở thành giá trị cụ thể.

Quay trở lại mã của bạn, bạn đã có một danh sách các thunks và bạn vẫn thực hiện đệ quy cây này, nhưng bạn sử dụng lại danh sách đó và một khi một yếu tố trong danh sách được đánh giá, nó sẽ không bao giờ được tính lại. Vì vậy, chúng tôi tránh sự đệ quy của cây trong hàm sợi ngây thơ.

Là một lưu ý thú vị, điều này đặc biệt nhanh đối với một loạt các số sợi được tính toán vì danh sách đó chỉ được đánh giá một lần, có nghĩa là nếu bạn tính toán memo_fib 10000 hai lần, thì lần thứ hai sẽ là tức thời. Điều này là do Haskell chỉ đánh giá các đối số cho các hàm một lần và bạn đang sử dụng một phần ứng dụng thay vì lambda.

TLDR: Bằng cách lưu trữ các tính toán trong một danh sách, mỗi phần tử của danh sách được ước tính một lần, do đó, mỗi số lượng sợi quang được tính chính xác một lần trong toàn bộ chương trình.

Hình dung:

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

Vì vậy, bạn có thể thấy cách đánh giá THUNK_4nhanh hơn rất nhiều vì các biểu hiện con của nó đã được đánh giá.

Điểm ghi nhớ là không bao giờ tính toán cùng một chức năng hai lần - điều này cực kỳ hữu ích để tăng tốc các tính toán hoàn toàn là chức năng, tức là không có tác dụng phụ, vì đối với những quy trình này có thể hoàn toàn tự động mà không ảnh hưởng đến tính chính xác. Điều này đặc biệt cần thiết cho các chức năng như fibo, dẫn đến đệ quy cây , tức là nỗ lực theo cấp số nhân, khi được thực hiện một cách ngây thơ. (Đây là một lý do tại sao các số Fibonacci thực sự là một ví dụ rất tệ cho việc dạy đệ quy - gần như tất cả các triển khai demo bạn tìm thấy trong hướng dẫn hoặc sách đều không sử dụng được cho các giá trị đầu vào lớn.)

Nếu bạn theo dõi luồng thực thi, bạn sẽ thấy rằng trong trường hợp thứ hai, giá trị for fib xsẽ luôn khả dụng khi fib x+1được thực thi và hệ thống thời gian chạy sẽ có thể chỉ đọc nó từ bộ nhớ thay vì thông qua một cuộc gọi đệ quy khác, trong khi giải pháp đầu tiên cố gắng tính toán giải pháp lớn hơn trước khi có kết quả cho các giá trị nhỏ hơn. Điều này cuối cùng là vì trình vòng lặp [0..n]được đánh giá từ trái sang phải và do đó sẽ bắt đầu bằng 0, trong khi đệ quy trong ví dụ đầu tiên bắt đầu bằng nvà chỉ sau đó hỏi về n-1. Đây là những gì dẫn đến nhiều, nhiều cuộc gọi chức năng trùng lặp không cần thiết.