记忆一个以集合为参数的函数

Question

我正在使用Data.MemoCombinators (https://hackage.haskell.org/package/data-memocombinators-0.3/docs/Data-MemoCombinators.html) 来记忆一个函数，该函数将一个集合作为其参数并返回一个集合（这是一个人为的示例，它什么都不做，但需要很长时间才能完成）：

test s = case Set.toList s of
         []     -> Set.singleton 0
         [x]    -> Set.singleton 1
         (x:xs) -> test (Set.singleton x) `Set.union` test (Set.fromList xs)

由于Data.MemoCombinators 没有实现集合表，我想自己写：

{-# LANGUAGE RankNTypes #-}

import Data.MemoCombinators (Memo)
import qualified Data.MemoCombinators as Memo
import Data.Set (Set)
import qualified Data.Set as Set

set :: Ord a => Memo a -> ((Set a) -> r) -> (Set a) -> r
set m f = Memo.list m (f . Set.fromList) . Set.toList

这是我应该记住的test：

test s = set Memo.integral test' s
    where
      test' s = case Set.toList s of
                []     -> Set.singleton 0
                [x]    -> Set.singleton 1
                (x:xs) -> test (Set.singleton x) `Set.union` test (Set.fromList xs)

没有我清楚的Data.MemoCombinators 的文档，所以基本上我不知道我在做什么。

我的问题是：

1. Memo.list 函数的第二个参数是什么？它是列表元素的记忆器吗？

2. 如何在不使用Memo.list的情况下直接为一个集合实现一个表？这里想弄清楚如何在不使用某人的库的情况下手动实现记忆。例如，使用Map。我已经看到了使用无限列表来记忆整数的示例，但是在地图的情况下，我无法弄清楚如何初始化地图以及如何将其插入。

感谢您的帮助。

Answer 1

1. Memo.list 函数的第二个参数是什么？它是列表元素的记忆器吗？

第一个参数m是列表元素的记忆器。第二个参数f 是您要应用于列表的函数（也会被记住）。

1. 如何在不使用Memo.list 的情况下直接为集合实现表？这里想弄清楚如何实现 手动记忆而不使用某人的图书馆。例如， 使用地图。我见过使用 无限列表，但在地图的情况下，我无法弄清楚如何 初始化地图以及如何插入地图。

使用与Data.MemoCombinators 相同的策略，您可以执行类似于希望他们对列表执行的操作。这种方法没有为此使用显式的数据结构，而是探索了 Haskell 将事物保存在内存中和惰性求值的方式。

set :: Ord a => Memo a -> Memo (Set a)
set m f = table (f Set.empty) (m (\x -> set m (f . (x `Set.insert`))))
  where
  table nil cons set | Set.null set = nil
                     | otherwise    = uncurry cons (Set.deleteFindMin set)

您还可以使用显式数据结构（如Map）在 Haskell 中使用 memoization。我将使用斐波那契示例来演示这一点，因为它更容易进行基准测试，但对于其他函数来说也是类似的。

让我们从简单的实现开始：

fib0 :: Integer -> Integer
fib0 0 = 0
fib0 1 = 1
fib0 x = fib0 (x-1) + fib0 (x-2)

那么Data.MemoCombinators提出这个实现：

import qualified Data.MemoCombinators as Memo

fib1 :: Integer -> Integer
fib1 = Memo.integral fib'
  where
  fib' 0 = 0
  fib' 1 = 1
  fib' x = fib1 (x-1) + fib1 (x-2)

最后，我使用Map的版本：

import Data.Map (Map)
import qualified Data.Map as Map

fib2 :: Integer -> Integer
fib2 = fst . fib' (Map.fromList [(0, 0),(1, 1)])
  where
  fib' m0 x | x `Map.member` m0 = (Map.findWithDefault 0 x m0, m0)
            | otherwise         = let (v1, m1) = fib' m0 (x-1)
                                      (v2, m2) = fib' m1 (x-2)
                                      y = v1 + v2
                                  in (y, Map.insert x y m2)

现在，让我们看看它们的表现：

fib0 40: 13.529371s
fib1 40: 0.000121s
fib2 40: 0.000048s

fib0 已经太慢了。让我们对另外两个做一个适当的测试：

fib1 400000: 6.234243s
fib2 400000: 4.022798s

fib1 500000: 8.683649s
fib2 500000: 5.781104s

在我执行的所有测试中，Map 解决方案实际上似乎优于Memo 解决方案。但我认为Data.MemoCombinators 的最大优势实际上是拥有如此出色的性能，而无需编写比天真的解决方案更多的代码。

---

更新：我改变了结论，因为我没有正确地进行基准测试。我在同一次执行中进行了多次调用，对于 500000，无论第二次调用是什么（fib1 或 fib2），都花费了太长时间。

Answer 2

test 的内容很好，尽管通常您会使用 Set 操作将 test 定义为集合上的函数。这是我所说的一个例子：

-- memoize a function on Set Int
foo = set M.integral foo'
  where foo' s | Set.null s = 0
        foo' s = let a = Set.findMin s
                     b = Set.findMax s
                     m = (a+b) `div` 2
                     (lo,found,hi) = Set.splitMember m s
                 in if a >= b
                      then 1
                      else (if found then 1 else 0) + foo lo + foo hi

这是一种计算集合中元素数量的非常低效的方法，但请注意foo' 是如何根据集合操作定义的。

关于您的其他问题：

1. Memo.list 函数的第二个参数是什么？它是列表元素的记忆器吗？

Memo.list 有签名Memo a -> Memo [a]，所以在表达式Memo.list m f 中我们有：

m :: Memo a
f :: [a] -> r    -- some type r
Memo.list m f :: [a] -> r

所以f 是您正在记忆的[a] 上的函数，而m 是采用a 类型参数的函数的记忆器。

1. 如何直接实现一个集合的表？

这取决于您所说的“直接”是什么意思。以这种方式进行记忆将涉及创建（可能是无限的）惰性数据结构。 string、integral 和 list 记忆器都使用某种形式的惰性树。这与命令式语言中的 memoization 非常不同，在命令式语言中，您显式检查哈希映射以查看您是否已经计算了某些内容并使用函数的值更新该哈希映射等。（顺便说一句 - 您可以在 ST 中进行那种记忆或 IO monads，它可能比 Data.Memocombinators 方法工作得更好 - 需要考虑。）

您通过传递给列表来记忆 Set a -> r 函数的想法是个好主意，但我会使用 to/from AscList：

set m f = Memo.list m (f . Set.fromAscList) . Set.toAscList

这样，Set.fromList [3,4,5] 集合将重复使用为记忆 Set.fromList [3,4] 的值而创建的 trie 的同一部分。