基于Proxy实现JS惰性求值时Traversable的短路问题求解

问题场景复现 #

我在JS中用Proxy模拟惰性求值（按需仅求值一次）时，遇到了Traversable相关问题（这里用mapA替代标准traverse）：

正常运行场景 #

const r = List.mapA({map: Opt.map, ap: Opt.ap, of: Opt.of})
  (x => (x & 1) === 0 ? null : x)
    (List.fromArr([1,3,5]));

Opt.map(Arr.fromList) (r); // 输出 [1,3,5]

注：Opt并非代数数据类型（ADT），而是基于null实现的可选值逻辑。此场景下r是包含thunk的弱头范式（WHNF）结构，严格的Arr.fromList会强制求值整个List，最终正常输出结果。

触发短路的错误场景 #

当传入包含偶数的列表List.fromArr([1,2,3])时，问题出现：

• Opt.map仅检查r的最外层List结构（此时为{head:1, tail: thunk}），判定为有效非空值，调用Arr.fromList处理r
• 严格的Arr.fromList会递归求值List的尾部thunk，当处理元素2时，f(2)返回null触发短路，但此时短路发生在Arr.fromList内部而非Opt.map的逻辑中，导致Arr.fromList拿到null而非预期的List结构，最终抛出错误。

核心函数实现 #

以下是问题相关的核心代码：

List.mapA = ({map, ap, of}) => {
  const liftA2_ = liftA2({map, ap}) (List.Cons);
  return f => List.foldr(x => acc =>liftA2_(f(x)) (acc)) (of(List.Nil));
};

const liftA2 = ({map, ap}) => f => tx => ty => ap(map(f) (tx)) (ty);

List.foldr = f => acc => function go(tx) { // 若f对第二个参数非严格则为 guarded rec
  return tx.run({
    nil: acc,
    cons: y => ty => f(y) (lazy(() => go(ty)))
//                         ^^^^^^^^^^^^^^^^^^ thunk（由Proxy包装的惰性占位符）
  });
};

问题根源分析 #

根据计算过程拆解，问题本质是惰性求值延迟了r从List到null的转换：

1. 构造r的过程：List.mapA基于非严格的foldr实现，遍历到元素1后就停止求值，返回{head:1, tail: thunk}的WHNF结构，此时尚未处理元素2，自然未触发短路返回null。
2. 转换为Array的过程：Opt.map仅检查最外层结构就调用严格的Arr.fromList，而Arr.fromList递归求值尾部时才触发元素2的处理，此时短路产生的null出现在List内部，而非Opt层的顶层，导致Arr.fromList无法处理。

简言之，本该由Opt函子拦截的短路信号，因为惰性求值被延迟到了下游的纯函数中，超出了Opt的处理范围。

Haskell的解决思路 #

Haskell作为惰性语言，通过两个核心机制解决这类问题：

1. 真正的Applicative ADT：Haskell的Maybe是标准ADT（data Maybe a = Nothing | Just a），而非用null模拟。Maybe的ap操作天生具备短路逻辑：

   Nothing <*> _ = Nothing
   Just f <*> Just x = Just (f x)
   

   当遍历到某个元素返回Nothing时，traverse内部的liftA2会通过ap直接返回Nothing，不会去求值后续的List尾部（因为惰性求值，第二个参数不会被计算），整个traverse的结果直接是Nothing。
2. Traversable的语义保证：Haskell的Traversable类型类要求traverse函数严格遵循Applicative的语义，一旦Applicative上下文出现失败（如Maybe的Nothing），就终止遍历并直接返回失败结果，不会继续处理后续元素。

实现修正建议 #

你的问题并非需要把List遍历改成严格，而是Opt的实现不符合Applicative的语义要求：

1. 将Opt改为ADT实现：替换null为明确的Nothing和Just结构，比如：

   const Just = value => ({ type: 'Just', value });
   const Nothing = () => ({ type: 'Nothing' });
   
   Opt.map = f => opt => 
     opt.type === 'Just' ? Just(f(opt.value)) : Nothing();
   Opt.ap = fOpt => xOpt => 
     fOpt.type === 'Just' && xOpt.type === 'Just' 
       ? Just(fOpt.value(xOpt.value)) 
       : Nothing();
   Opt.of = value => Just(value);
   

   这样Opt.ap在遇到Nothing时会直接返回Nothing，不会去求值第二个参数（即List尾部的thunk），短路信号会被正确传递到顶层，Opt.map会识别到Nothing，跳过Arr.fromList的调用，避免错误。
2. 修正List.mapA的语义：基于ADT的Opt，List.mapA的liftA2_会在f(x)返回Nothing时直接返回Nothing，终止后续遍历，整个r会是Nothing而非包含内部null的List，从根源避免下游函数处理异常结构。

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