Typescript中Maybe Monad的chain方法的正确实现是什么？

Question

我在 Typescript 中创建一个简单的 Monad 库只是为了好玩，遵循 https://github.com/fantasyland/fantasy-land 的精彩规范。

在这里，创作者提出了三个一元法则：

1. M.of(a).chain(f) 等价于 f(a) (左身份)
2. m.chain(M.of) 等价于m（正确的身份）
3. m.chain(f).chain(g) 等价于 m.chain(x => f(x).chain(g)) (关联性)

所以我实施了法律测试和这个经典实施。

import { setoid, functor, apply } from './common';

const isEmpty = (value: any) => value === null || value === undefined;

const chain = function<T, U>(fn: (val: T) => IMonad<U>) {  
  return this.isNone() ? this : fn(this.lift());
};

class Some<T> implements IMonad<T> {
  private _value: T;

  constructor(value: T) {
    this._value = value;
  }

  lift = () => this._value;
  of = (value: T) => new Some(value);
  map = functor;
  ap = apply;
  flatMap = chain;
  equals = setoid;
  isSome = () => true
  isNone = () => false
}

class None implements IMonad<any> {
  constructor() {}

  lift = () => { throw "Cannot get a value from None" };
  of = (value: any) => new None();
  map = functor;
  ap = apply;
  flatMap = chain;
  equals = setoid;
  isSome = () => false;
  isNone = () => true;
}


class MaybeStatic implements IMonadStatic<any> {
  of = (value:any) => !isEmpty(value) ? new Some(value) : new None();
}

const maybeStatic = new MaybeStatic();

export { maybeStatic as Maybe, Some, None, MaybeStatic };

运行测试我看到在None 的情况下Maybe monad left identity 规则没有通过测试。事实上：

Maybe.of(null).chain(x => Some(x+2)) !== (null + 2)

在这种情况下，Js/Ts 允许操作 null + 2 的事实似乎打破了第一条单子规则（其他语言可能不允许此操作）。我检查了很多 Maybe monad 的 javascript 和 typescript 实现，他们似乎完全忽略了这个问题。

所以问题：

• 为什么会这样？
• 我错过了什么吗？
• x => Some(x+2) 是 None 的有效参数还是应该只接受返回 None 的函数？
• 如何纠正？
• 我是否也应该考虑NaN（这也可以扩展除以零和其他奇怪情况（如undefined + 2）的可能效率？

编辑

• 这种异常似乎也出现在面向函数的语言中。我尝试使用原生 Option 类型在 Scala here 中实现类似的案例。

Answer 1

Maybe<T> 类型（或任何泛型类型）应避免检查其包含的值，并且应仅基于构造函数定义的结构（在本例中为 None<T> 和 Some<T> 类）进行操作。

您的isSome 函数通过检查null 和undefined 违反了这一原则。为了遵守 monad 法则，您的 of 函数应始终返回 Some 的实例，而您的 chain 函数应仅检查 this 是 Some 或 None 的实例。

在您的chain 函数中，Some 实例可以使用其内部值无条件地调用延续函数。 None<T> 实例总是返回 None，因此根本不需要包含值。

将这些放在一起，您的实现将如下所示：

class Some<T> implements IMonad<T> {
  private _value: T;

  constructor(value: T) {
    this._value = value;
  }

  of = (value: any) => new Some(value);
  chain = function<U>(fn: T => IMonad<U>) { return fn(this._value); };
  isSome = () => true;
  isNone = () => false;
}

class None<T> implements IMonad<T> {
  chain = function<U>(fn: T => IMonad<U>) { return new None<U>(); };
  isSome = () => false;
  isNone = () => true;
}

class MaybeStatic implements IMonadStatic<any> {
    of =(value:any) => new Some(value);
}

Answer 2

如果您正在做这个项目来了解 monad，那么 javascript 可能会导致与它的动态类型的额外混淆。如果你这样做是因为你想使用 monad 来编写软件，那么你可能会过度思考 monad 法则。在任何情况下，等价物的定义都没有 javascript 的 == 严格。这是可能在 ts 中的一个（不完整）实现：

class MaybeInstance<T> {
    private isSome: boolean;
    private val: T;
    constructor(isSome: boolean, val: T) {
        this.isSome = isSome;
        this.val = val;
    }
    orJust(t: T) {
        return this.isSome
            ? this.val
            : t;
    }
    map<U>(fn: (t: T) => U): Maybe<U> {
        return new MaybeInstance<U>(this.isSome,
            this.isSome
                ? fn(this.val)
                : null);
    }
    chain<U>(fn: (t: T) => Maybe<U>): Maybe<U> {
        return this.isSome
            ? fn(this.val)
            : new MaybeInstance<U>(false, null);
    }
    isEquivalent<U>(mU: Maybe<U>) {
        return this.isSome === mU.isSome
            && typeof this.val === typeof mU.val;
    }
}

export type Maybe<T> = MaybeInstance<T>;

export module Maybe {

    export const some: <T>(val: T) => Maybe<T> =
        (val) => new MaybeInstance(true, val);

    export const none: () => Maybe<any> =
        () => new MaybeInstance(false, null);

    export const fromUndef: <T>(val: T | undefined) => Maybe<T> =
        (val) => !!val && (val as any) !== NaN
            ? some(val)
            : none();

}

const a = 1;
const f = (x: number) => Maybe.fromUndef(100 / x);
const g = (x: number) => Maybe.fromUndef(x).map(String);

const mA = Maybe.some(a);

console.log(
    // M.of(a).chain(f) is equivalent to f(a) (left identity)
    mA.chain(f).isEquivalent(f(a)),
    // m.chain(M.of) is equivalent to m (right identity)
    mA.chain(Maybe.some).isEquivalent(mA),
    // m.chain(f).chain(g) is equivalent to m.chain(x => f(x).chain(g)) (associativity)
    mA.chain(f).chain(g).isEquivalent(mA.chain((x) => f(x).chain(g))),
);

ts 编译器不喜欢这个带有严格空值检查的代码（但可能不是一个足够严格的空值检查吗？）并且它缺少很多函数，如 ap、concat 等，但它表明在ts 很简单。