javascript - 为什么幻想之地规范要求该链必须返回同一链的值？

Question

chain method

A value which has a Chain must provide a chain method. The chain method takes one argument:

m.chain(f)

1. f must be a function which returns a value
   • If f is not a function, the behaviour of chain is unspecified.
   • f must return a value of the same Chain
2. chain must return a value of the same Chain

GitHub - fantasyland

给出的是选项 monad 的简单实现:

// prototypes:
const someProto = {
  of(x) { return some(x) },
  map(f) { return some(f(this.x)) },
  ap(ftor) { return ftor.map(this.x) },
  join() { return this.x },
  chain(mf) { return this.map(mf).join() }
};

const noneProto = {
  of() { return this },
  map() { return this },
  ap() { return this },
  join() { return this },
  chain() { return this }
};

// factories:
function some(x) {
  return Object.assign(Object.create(someProto), {x: x});
}

function none() {
  return Object.assign(Object.create(noneProto), {x: null});
}

为了保证chain始终返回一个选项单子(monad)，我必须确保mf(单子(monad)函数)始终返回一个。这是不可能的，因为 mf 不是实现的一部分。相反，它是在使用 monad 时定义的:

// auxiliary function:
const sub = y => x => x - y;

let a = some(2);
let b = some(3);

a.chain(x => b.chain(y => some(sub(x)(y)))); // {x: 1}
a.chain(x => b.chain(y => sub(x)(y))); // 1 - ouch!

在第二个方法应用程序中，传递的函数不返回 monad，这导致 Monad 计算的未包装结果。我可以通过鸭子类型向 chain 或 join 添加类型检查，以解决问题 - 但这会非常难看。

为什么规范此时要求类型安全？ Javascript 是动态类型的，我更喜欢编写适当的单元测试，而不是在运行时执行类型检查。那么我会违反规范吗？

Answer 1

在第二个示例中，您应该使用 .map():

a.chain(x => b.map(y => sub(x)(y))); 

然后一切都遵循规则。

为了进行比较，这里是等效的 Haskell 签名:

fmap  :: m a -> (a ->   b)   -> m b    -- same as .map()
(>>=) :: m a -> (a -> m b)   -> m b    -- same as .chain()

因此，如果您的函数返回一元值，请使用.chain()。否则使用.map()。