Khi nào thì ghi nhớ tự động trong GHC Haskell?

Tôi không thể tìm ra lý do tại sao m1 dường như được ghi nhớ trong khi m2 không có trong như sau:

m1      = ((filter odd [1..]) !!)

m2 n    = ((filter odd [1..]) !! n)

m1 10000000 mất khoảng 1,5 giây trong lần gọi đầu tiên và một phần nhỏ trong số đó trong các lần gọi tiếp theo (có lẽ là nó vào bộ nhớ đệm danh sách), trong khi m2 10000000 luôn mất cùng một khoảng thời gian (xây dựng lại danh sách với mỗi lần gọi). Có ai biết cái gì đang xảy ra không? Có bất kỳ quy tắc chung nào về việc GHC sẽ ghi nhớ một hàm không? Cảm ơn.

GHC không ghi nhớ các chức năng.

Tuy nhiên, nó tính toán bất kỳ biểu thức nhất định nào trong mã mỗi lần mà biểu thức lambda xung quanh nó được nhập hoặc nhiều nhất một lần nếu nó ở cấp cao nhất. Việc xác định vị trí của các biểu thức lambda có thể hơi phức tạp khi bạn sử dụng cú pháp đường như trong ví dụ của mình, vì vậy hãy chuyển đổi chúng thành cú pháp gỡ bỏ tương đương:

m1' = (!!) (filter odd [1..])              -- NB: See below!
m2' = \n -> (!!) (filter odd [1..]) n

(Lưu ý: Báo cáo Haskell 98 thực sự mô tả phần toán tử bên trái (a %)tương đương với \b -> (%) a b, nhưng GHC gỡ bỏ nó thành (%) a. Các phần này khác nhau về mặt kỹ thuật vì chúng có thể được phân biệt bởi seq. Tôi nghĩ rằng tôi có thể đã gửi một phiếu GHC Trac về điều này.)

Với điều này, bạn có thể thấy rằng trong m1', biểu thức filter odd [1..]không được chứa trong bất kỳ biểu thức lambda nào, vì vậy nó sẽ chỉ được tính một lần cho mỗi lần chạy chương trình của bạn, trong khi ở trong m2', filter odd [1..]sẽ được tính mỗi khi biểu thức lambda được nhập, tức là trên mỗi cuộc gọi của m2'. Điều đó giải thích sự khác biệt về thời gian mà bạn đang thấy.

Trên thực tế, một số phiên bản của GHC, với các tùy chọn tối ưu hóa nhất định, sẽ chia sẻ nhiều giá trị hơn so với mô tả ở trên. Điều này có thể có vấn đề trong một số tình huống. Ví dụ, hãy xem xét chức năng

f = \x -> let y = [1..30000000] in foldl' (+) 0 (y ++ [x])

GHC có thể nhận thấy điều yđó không phụ thuộc vào xvà viết lại hàm thành

f = let y = [1..30000000] in \x -> foldl' (+) 0 (y ++ [x])

Trong trường hợp này, phiên bản mới kém hiệu quả hơn nhiều vì nó sẽ phải đọc khoảng 1 GB từ bộ nhớ yđược lưu trữ, trong khi phiên bản gốc sẽ chạy trong không gian không đổi và nằm gọn trong bộ nhớ đệm của bộ xử lý. Trên thực tế, theo GHC 6.12.1, hàm fnày nhanh hơn gần gấp đôi khi được biên dịch mà không cần tối ưu hóa so với khi được biên dịch cùng -O2.

m1 chỉ được tính một lần vì nó là Dạng áp dụng không đổi, trong khi m2 không phải là CAF và do đó được tính cho mỗi lần đánh giá.

Xem wiki GHC về CAF: http://www.haskell.org/haskellwiki/Constant_applicative_form

Có một sự khác biệt quan trọng giữa hai hình thức: giới hạn đơn thức áp dụng cho m1 nhưng không áp dụng cho m2, vì m2 đã cho các đối số rõ ràng. Vì vậy, loại của m2 là chung nhưng của m1 là cụ thể. Các loại chúng được chỉ định là:

m1 :: Int -> Integer
m2 :: (Integral a) => Int -> a

Hầu hết các trình biên dịch và thông dịch Haskell (tất cả đều là những cấu trúc mà tôi biết) không ghi nhớ các cấu trúc đa hình, vì vậy danh sách nội bộ của m2 được tạo lại mỗi khi nó được gọi, trong đó m1 thì không.

Tôi không chắc lắm, vì bản thân tôi cũng khá mới với Haskell, nhưng có vẻ như đó là do hàm thứ hai được tham số hóa còn hàm thứ nhất thì không. Bản chất của hàm là vậy, kết quả của nó phụ thuộc vào giá trị đầu vào và trong mô hình chức năng đặc biệt nó chỉ phụ thuộc vào đầu vào. Ngụ ý rõ ràng là một hàm không có tham số luôn trả về cùng một giá trị, bất kể điều gì.

Rõ ràng có một cơ chế tối ưu hóa trong trình biên dịch GHC khai thác thực tế này để tính toán giá trị của một hàm như vậy chỉ một lần cho toàn bộ thời gian chạy chương trình. Nó làm điều đó một cách lười biếng, chắc chắn, nhưng nó vẫn làm. Tôi tự nhận thấy điều đó khi viết hàm sau:

primes = filter isPrime [2..]
    where isPrime n = null [factor | factor <- [2..n-1], factor `divides` n]
        where f `divides` n = (n `mod` f) == 0

Sau đó, để kiểm tra nó, tôi bước vào GHCI và viết: primes !! 1000. Phải mất vài giây, nhưng cuối cùng tôi nhận được câu trả lời: 7927. Sau đó tôi gọi primes !! 1001và nhận được câu trả lời ngay lập tức. Tương tự ngay lập tức tôi nhận được kết quả take 1000 primesvì Haskell phải tính toán toàn bộ danh sách nghìn phần tử để trả về phần tử thứ 100 trước đó.

Vì vậy, nếu bạn có thể viết hàm của mình sao cho không cần tham số, bạn có thể muốn nó. ;)