Haskell 对备忘录的函数调用（具有多个参数）

我想在具有多个不同参数的函数上使用memonization

function :: (Int, Int) -> [[Int]] -> Int

到目前为止，我尝试的是：

function :: (Int, Int) -> [[Int]] -> Int
function (s, d) matrix = inner (s, d) matrix 
  where  
    inner (i, 0) g = g !! (i-1) !! (0)
    inner (i, k) g = maximum [memo ! ((i, k-1), g)
                             ,
                              memo ! ((i-1, k), g)
                             ]
    memo = listArray bounds
                [inner (i,k) g | ((i,k), g) <- Data.Array.range bounds]
    bounds = ( ((1,1), [[1,1]]), ((n,n), [[n,n]]) )

函数：：（Int，Int）->[[Int]]->Int
函数（s，d）矩阵=内部（s，d）矩阵
哪里
内部（i，0）g=g！！（i-1）！！(0)
内部（i，k）g=最大值[memo！（（i，k-1），g）
,
备忘录！（（i-1，k），g）
]
memo=列表数组边界
[内部（i，k）g |（（i，k），g）我碰巧知道有一个软件包肯定会让整个事情变得更容易

在您的情况下，我会在这个带有类型签名的包中使用
memoize2
函数

memoize2 :: (Memoizable a, Memoizable b) => (a -> b -> v) -> a -> b -> v

使用
a=（Int，Int），b=[[Int]]
。以下实例将使您确信满足了类型约束：

Memoizable Int
Memoizable a => Memoizable [a]
(Memoizable a, Memoizable b) => Memoizable (a, b)

注意：虽然我对这个软件包印象不错，但它似乎不太便携或可靠（如果你想用它来构建真实的东西）。在它的黑客页面上可以找到以下声明：

请注意，这种风格的大多数记忆依赖于关于非严格性（如惰性）实现的假设，而这些假设并没有得到语义的保证

请您创建一个测试用例，这是一个最小的、完整的、可验证的示例，用
[[Int]]]
类型的参数记录函数是不寻常的，您尝试使用的基于数组的方法可能无法工作。错误消息告诉您不能使用
[[Int]]
作为数组的索引。也许您可以使用
数据.Map
，但我不知道在这种情况下推荐什么。使用
（！！）
可能会导致大量开销：
！！k
，在O（k）中工作，因此对于大型
k
，这将花费大量时间。请解释此代码应该做什么（伪代码、规范、示例…）。我想你实际上不想在
[[Int]]
类型的键上进行记忆。基本上，代码是：内部（I，0）g=g！！（I-1）！！（0）内部（I，k）g=maximum[内部（（I，k-1），g），内部（（i-1，k），g）]，无需记忆。我想存储：内部（（i-1，k），g/[内部（（i，k-1）的结果，g在一个数组中，使用备忘录。谢谢。幸运的是，我在没有这个包的情况下解决了这个问题。