Haskell在算法进行时存储数据

假设我有一个Haskell算法，通过递归，它通过一个笛卡尔平面前进，其中每个x/y坐标都有一个特定的值

位置（0,0）已知，可以通过返回原点计算彼此

例如，要看（0,3），我需要看（-1,2），（0,2）和（1,2），它们必须依次看（-2,1），（-1,1），（0,1）和（-1,1），（0,1），（1,1）和（0,1），（1,1），（2,1）

为了避免（-1,1）和（0,1）被计算两次，是否有任何方法可以创建一个数据结构，以便算法可以首先查看某个位置AH是否已经计算过，如果没有，则只进行计算

---

谢谢：）

这听起来像是m09和cdk建议的备忘录，可能是您正在寻找的。但是，如果您想要一个返回位置数组的算法，那么简单的装箱数组（意味着它们包含惰性值）和一些可以为您提供一个很好的声明性解决方案（很抱歉代码太难看）

导入数据。数组
--对于正u
平面：：Int->数组（Int，Int）Int
平面u=让我们知道诺里金=（（0,0），0）
l=否定u
otherCoords=[（x，y）|让cs=[l..u]
，x而不是显式地创建数据结构，尝试使用memonization（googlable和许多关于它的问题）。memonization听起来就在这里，特别是看看Hackage上的
memo-trys
。
import Data.Array

-- for positive u
plane :: Int -> Array (Int,Int) Int
plane u = let knownOrigin = ((0,0) , 0)
              l = negate u
              otherCoords = [ (x,y) | let cs = [l .. u] 
                                    , x <- cs , y <- cs
                                    , (x,y) /= (0,0) 
                                    ]
              a = array ((l,l),(u,u)) $
                    knownOrigin : map solution otherCoords

              -- example recursive thing, referenceing lazy values in 'a':
              solution c@(x,y) = let x' | x <0 = x+1
                                        | x >0 = x-1
                                        | x==0 = 0
                                     y' | y <0 = y+1 
                                        | y >0 = y-1
                                        | y==0 = 0
                                  in (c , a ! (x',y') + 1)
           in a