javascript - 也许 javascript 解释中的 monad 示例代码

Question

我正在开始或尝试学习函数式编程 monad。

所以第一个是“也许”。我正在尝试使用 monad 转换代码。

function(fieldName, vals, fields) {
    var newValue = vals[fieldName];
    if (typeof(newValue) == 'undefined') {
        var elemFrom = fields[fieldName];
        if (elemFrom) {
            newValue = fields[fieldName]
        }
    }
    if (typeof (newValue) != 'undefined') {
        return newValue
    }
}

这里我有一堆未定义的检查，我认为这很好地利用了monay。

我的问题是我读到您将值传递给了 Maybe monad 和 map 函数。

但是就我而言，我替换了 monad 内的值。

如果我传递 null，map 方法将不会执行任何操作，因为该值未定义。

我没有使用框架，我想要简单的实现，以便我能够理解它。

我应该在也许的 monad 类(函数)中添加“else”方法吗？

我有相反的情况“如果值未定义则执行某些操作”

您能否建议如何解决该问题

谢谢

Answer 1

因此您发布的函数可以重写为

const f = (a, b, c) => b[a] === undefined ? c[a] : b[a];

我不清楚这是否需要成为一个函数，而不是在您想要使用相关对象属性的任何地方内联，但也许您正在部分应用它或其他东西，我不会判断。

对于 Maybe，(非常简单)的实现可能如下所示:

class Maybe {
  static of (value) {
    return new Maybe(value);
  }

  // Proper solution here should be recursive to handle
  // nesting properly, but I'm lazy
  static equals (a, b) {
    return a.chain(x => x) === b.chain(x => x);
  }

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

  map (f) {
    // Does not distinguish null from undefined, but YMMV. Note
    // that if the Maybe value is null or undefined we never touch
    // f, that's the null propagation thing.
    return this._value == null ? this : new Maybe(f(this._value));
  }

  chain (f) {
    const result = this._value == null ? this : f(this._value);
    console.assert(result instanceof Maybe);
    return result;
  }
}

现在我们可以测试它是否遵守 Monad 定律:

const a = 3;
const f = x => Maybe.of(x * x);
Maybe.of(a).chain(f) === f(a) // left identity
Maybe.equals(Maybe.of(5).chain(Maybe.of), Maybe.of(5)); // right identity

并且它是一个有效的仿函数

Maybe.equals(Maybe.of(3).map(x => x), Maybe.of(3)); // identity
Maybe.equals(                                       // composition
  Maybe.of(3).map(x => x + 2).map(x => x * 3), 
  Maybe.of(3).map(compose(x => x * 3, x => x + 2))
);

甜甜的。

现在，开始您的工作吧。它将被重写为

const f = (a, b, c) => {
  return b[a] === undefined ? Maybe.of(c[a]) : Maybe.of(b[a]);
}

也许你现在明白了我困惑的原因，也许在这里并没有真正为你节省多少。但如果我使用 Maybe 我会像这样重写整个事情:

const or = (a, b) => {
  return Maybe.of(a == null ? b : a);
}

然后我只需传入属性访问:

const obj1 = { a: 2, c: 3 };
const obj2 = { b: 4 };
const prop = "a"
const result = or(obj1["prop"], obj2["prop"]); // Maybe(2)

更新

感谢@Bergi 在评论中提醒我有关替代方案的信息。您可以向上面的 Maybe 类添加一个方法，如下所示:

alt (x) {
  if (!(x instanceof Maybe)) {
    throw new TypeError("Expected a Maybe");
  }
  return this.chain(x => x) == null ? x : this;
}

// semantics

Maybe.of(null).alt(Maybe.of(3)); // Maybe(3)
Maybe.of(2).alt(Maybe.of(4));    // Maybe(2)

// usage
Maybe.of(obj1[prop]).alt(Maybe.of(obj2[prop]));

请注意，这并不完全满足作为替代方案的实现(您还需要一个零/空方法)，但您可以阅读 here和 here更多细节。这可能是您发布的功能的最佳替代品。