如何在纯函数式编程（如Haskell）中实现带缓存计算的类型？

问题背景 #

我们需要实现一个类型P，它包含两个关联字段A和B：构造时仅能提供其中一个字段的值，另一个可通过转换函数从已有字段计算得出。由于转换开销较高，要求延迟计算——仅当实际需要该字段时才执行转换，且计算结果需缓存避免重复计算。对应的OOP实现如下：

class P{
  private A a;
  private B b;
 
  public P(A a'){
     this.a=a';
     this.b=null;
  }
 
 public P(B b'){
     this.a = null;
     this.b = b';
 }

 public A getA(){ 
    if(this.a==null){
       // 从b计算a的逻辑
       this.a = result;
    }
   return this.a
 } 

 public B getB(){ 
    if(this.b==null){
       // 从a计算b的逻辑
       this.b = result;
    }
   return this.b
 }
}

原有方案的问题 #

最初考虑用Maybe记录实现：

data P = P {a:: Maybe A, b:: Maybe B} 

makePA :: A -> P 
makePA a = P (Just a) Nothing

makePB :: B -> P 
makePB b = P Nothing (Just b)

但该方案存在明显缺陷：

• 使用时需手动处理Maybe类型的空值判断，代码繁琐
• 每次获取未计算的字段时，需手动执行转换并返回新的P记录，状态管理冗余

更优解决方案：利用Haskell的惰性求值 #

Haskell的惰性求值特性天然支持延迟计算与自动缓存，我们可以直接封装计算逻辑，无需手动管理状态：

1. 定义核心转换函数 #

首先明确双向转换的纯函数（这是业务逻辑的核心）：

-- 从B计算出A的函数
aFromB :: B -> A
aFromB b = -- 具体转换逻辑

-- 从A计算出B的函数
bFromA :: A -> B
bFromA a = -- 具体转换逻辑

2. 定义P类型与构造函数 #

直接定义P类型为包含A和B的记录，利用惰性求值延迟计算未提供的字段：

data P = P { getA :: A, getB :: B }

-- 从A构造P，B字段延迟计算
makePA :: A -> P
makePA a = P a (bFromA a)

-- 从B构造P，A字段延迟计算
makePB :: B -> P
makePB b = P (aFromB b) b

方案优势 #

• 无空值处理：getA和getB直接返回确定的A/B类型，无需处理Maybe的空值情况
• 自动延迟计算：未提供的字段只有在首次调用对应的get方法时才会执行转换
• 自动缓存结果：由于Haskell的惰性求值是按需求计算且值不可变，字段一旦计算完成，后续调用会直接返回缓存的结果，避免重复计算
• 代码简洁：构造函数逻辑清晰，无需手动管理状态更新

示例场景（多边形） #

假设：

• A是点列表[Point]
• B是凸包的边列表[Edge]
• bFromA是计算凸包的函数（如Graham扫描法）
• aFromB是从边列表提取顶点的函数

使用时：

-- 从点列表构造P，凸包边列表延迟计算
myPoly :: P
myPoly = makePA [Point 0 0, Point 1 0, Point 0 1]

-- 首次调用getB时才计算凸包，后续调用直接返回缓存结果
polyEdges :: [Edge]
polyEdges = getB myPoly

内容的提问来源于stack exchange，提问作者Rooxo