查看Ramda.js源代码，特别是“lift”函数。
下面是给出的示例:
var madd3 = R.lift(R.curry((a, b, c) => a + b + c));
madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]
因此，结果的第一个数字很容易确定，a、b和c都是每个数组的第一个元素。对我来说，第二个数字就不那么容易理解了。这些参数是每个数组的第二个值（2、2、undefined），还是第一个数组的第二个值和第二个和第三个数组的第一个值？
即使忽略这里发生的顺序，我也真的看不到它的价值。如果我在没有先进行lift操作的情况下执行此操作，我最终会得到将数组作为字符串连接起来的结果。这似乎有点像flatMap，但我似乎无法理解其背后的逻辑。
Bergi的回答很好。但是考虑这个问题的另一种方式是变得更具体一些。Ramda文档中真正需要包含一个非列表示例，因为列表并不能真正捕捉这个问题。
让我们来看一个简单的函数：
var add3 = (a, b, c) => a + b + c;
这个操作作用于三个数字。但是，如果你有一些包含数字的容器呢？也许我们有一些Maybe。我们不能简单地将它们相加：
const Just = Maybe.Just, Nothing = Maybe.Nothing;
add3(Just(10), Just(15), Just(17)); //=> ERROR!
（好的，这是 JavaScript，它实际上不会在此处引发错误，只是尝试连接它不应该连接的内容...但它肯定不会做你想要的！）
如果我们可以将该函数提升到容器级别，那么我们的生活将更加轻松。Bergi指出的lift3在Ramda中使用liftN(3, fn)实现，还有一个简单使用所提供函数的参数个数的 lift(fn)。因此，我们可以这样做：
const madd3 = R.lift(add3);
madd3(Just(10), Just(15), Just(17)); //=> Just(42)
madd3(Just(10), Nothing(), Just(17)); //=> Nothing()
但这个提升的函数并不知道我们的容器的具体信息，只知道它们实现了ap。Ramda通过类似将函数应用于列表的元组交叉积的方式来为列表实现ap，所以我们也可以这样做：
madd3([100, 200], [30, 40], [5, 6, 7]);
//=> [135, 136, 137, 145, 146, 147, 235, 236, 237, 245, 246, 247]
这就是我对 lift 的理解。它接受一个在某些值的层次上工作的函数，并将其提升为一个在这些值的容器层次上工作的函数。
.ap来“学习”如何使用容器。我还在ramda-fantasy存储库中看到了Just.prototype.ap = function(m) { return m.map(this.value); };。ap是典型的函数式编程东西吗？还是这只是Ramda / JavaScript处理lift的方式？ - diplosaurusap或类似的东西是很常见的。根据这些FantasyLand规范定义的函数实现lift意味着它将与任何符合FL规范的Applicative类型一起工作。这是一个不错的胜利。 - Scott Sauyetmadd3示例结果的确切过程：var madd3 = R.lift((a, b, c) => a + b + c);
madd3([3, 7], [9, 5], [4, 6]); 这将产生以下结果：_[16, 18, 12, 14, 20, 22, 16, 18]_，计算如下：
3 + 9 + 4，3 + 9 + 6，3 + 5 + 4，3 + 5 + 6，7 + 9 + 4，7 + 9 + 6，7 + 5 + 4，7 + 5 + 6 - hsrobvar madd3 = R.lift((a, b, c) => a + b + c);
madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]
Apply规范（我将其称为Apply）以及Apply#ap的作用R.ap实现以及Array与Apply规范有什么关系R.lift中扮演了什么角色Apply规范ap方法时，它实现了Apply规范（该对象还必须通过定义map方法来实现Functor规范）。
ap方法具有以下签名：ap :: Apply f => f a ~> f (a -> b) -> f b
=> 声明类型约束，因此上面标记中的 f 指的是类型 Apply~> 声明方法声明，所以 ap 应该是在 Apply 上声明的函数，它围绕我们称之为 a 的值进行封装（我们将在下面的示例中看到，一些fantasy-land的实现的ap与此签名不一致，但思想是相同的）假设我们有两个对象 v 和 u （v = f a; u = f (a -> b)），因此这个表达式是有效的 v.ap(u)，这里需要注意一些事情：
v和u都实现了Apply。 v保存一个值，u保存一个函数，但它们具有相同的Apply“接口”（这将有助于理解下面的下一节，当涉及到R.ap和Array时）a和函数a -> b对Apply一无所知，函数只是转换值a。正是Apply将值和函数放在容器中，而ap则将它们提取出来，在值上调用函数，然后再放回去。Ramda的R.apR.ap的签名有两种情况：
应用 f => f (a → b) → f a → f b: 这与上一节中 Apply#ap 的签名非常相似，区别在于如何调用 ap（Apply#ap vs. R.ap）和参数的顺序。[a → b] → [a] → [b]: 如果我们将 Apply f 替换为 Array，请记住，在上一节中，值和函数必须包装在同一个容器中。这就是为什么当使用 R.ap 与 Array 时，第一个参数是函数列表，即使你只想应用一个函数，也要将它放入一个数组中。让我们来看一个例子，我正在使用ramda-fantasy中的Maybe，它实现了Apply。这里存在一个不一致之处，即Maybe#ap的签名是：ap :: Apply f => f (a -> b) ~> f a -> f b。似乎一些其他的fantasy-land实现也遵循这种方式，但这不应影响我们的理解：
const R = require('ramda');
const Maybe = require('ramda-fantasy').Maybe;
const a = Maybe.of(2);
const plus3 = Maybe.of(x => x + 3);
const b = plus3.ap(a); // invoke Apply#ap
const b2 = R.ap(plus3, a); // invoke R.ap
console.log(b); // Just { value: 5 }
console.log(b2); // Just { value: 5 }
R.lift的例子在R.lift使用数组的例子中，一个具有3个参数的函数被传递给了R.lift: var madd3 = R.lift((a, b, c) => a + b + c);，它如何与三个数组[1, 2, 3], [1, 2, 3], [1]一起工作呢？请注意，它不是柯里化的。
实际上，在R.liftN的源代码中（R.lift委托给它），传入的函数是自动柯里化的，然后它遍历值（在我们的例子中，是三个数组），将其缩减为结果：在每次迭代中，它使用柯里化的函数和一个值（在我们的例子中，是一个数组）调用ap。很难用语言解释清楚，让我们看看等价的代码：
const R = require('ramda');
const madd3 = (x, y, z) => x + y + z;
// example from R.lift
const result = R.lift(madd3)([1, 2, 3], [1, 2, 3], [1]);
// this is equivalent of the calculation of 'result' above,
// R.liftN uses reduce, but the idea is the same
const result2 = R.ap(R.ap(R.ap([R.curry(madd3)], [1, 2, 3]), [1, 2, 3]), [1]);
console.log(result); // [ 3, 4, 5, 4, 5, 6, 5, 6, 7 ]
console.log(result2); // [ 3, 4, 5, 4, 5, 6, 5, 6, 7 ]
result2的表达式，这个例子就会变得清晰明了。R.lift在Apply上：const R = require('ramda');
const Maybe = require('ramda-fantasy').Maybe;
const madd3 = (x, y, z) => x + y + z;
const madd3Curried = Maybe.of(R.curry(madd3));
const a = Maybe.of(1);
const b = Maybe.of(2);
const c = Maybe.of(3);
const sumResult = madd3Curried.ap(a).ap(b).ap(c); // invoke #ap on Apply
const sumResult2 = R.ap(R.ap(R.ap(madd3Curried, a), b), c); // invoke R.ap
const sumResult3 = R.lift(madd3)(a, b, c); // invoke R.lift, madd3 is auto-curried
console.log(sumResult); // Just { value: 6 }
console.log(sumResult2); // Just { value: 6 }
console.log(sumResult3); // Just { value: 6 }
在评论中，Scott Sauyet提出了一个更好的例子（他提供了很多见解，建议你阅读），这个例子更容易理解，至少它指向了一个方向，即R.lift计算Array的笛卡尔积。
var madd3 = R.lift((a, b, c) => a + b + c);
madd3([100, 200], [30, 40, 50], [6, 7]); //=> [136, 137, 146, 147, 156, 157, 236, 237, 246, 247, 256, 257]
madd3([100, 200], [30, 40, 50], [6, 7]); //=> [136, 137, 146, 147, 156, 157, 236, 237, 246, 247, 256, 257] 。（欢迎提交PR以修复文档）。 - Scott SauyetMaybe#ap 的签名与 FantasyLand 规范所需的相同。本质上，ap 是类型为 f a 的对象的 方法。Ramda 的 ap 函数接受一个 (a -> b) 转换和一个 ApplyX a，并为某个名为 ApplyX 的 Apply 实现返回一个 ApplyX b。（这可能比签名中使用的 f 更清晰。）在许多情况下，Ramda 的函数将委托给该对象的方法。 - Scott SauyetApply和Array似乎是不同的情况，但这并不完全正确。更清晰的思考方式是，Array可以被视为Apply（以及Functor等等），但由于它们没有内置的ap方法，Ramda会为它们提供一个。Ramda还为Array提供了一个适当的map函数，因为Array.prototype中的一个不遵循适当的规则。在各种地方，Ramda也为Object和Function做出类似的事情。 - Scott Sauyetap只处理一个参数。如果我们从像(x) => (y) => (z) => x + y + z这样的函数开始，这将是不必要的。 - Scott Sauyetlift和liftN的示例。 - Dapeng Lilift/liftN将一个普通的函数提升到Applicative上下文。
// lift1 :: (a -> b) -> f a -> f b
// lift1 :: (a -> b) -> [a] -> [b]
function lift1(fn) {
return function(a_x) {
return R.ap([fn], a_x);
}
}
ap的类型（f (a->b) -> f a -> f b）也不容易理解，但列表示例应该是可以理解的。// lift2 :: (a -> b -> c) -> f a -> f b -> f c
// lift2 :: (a -> b -> c) -> [a] -> [b] -> [c]
function lift2(fn) {
return function(a_x, a_y) {
return R.ap(R.ap([fn], a_x), a_y);
}
}
而你在示例中隐式使用的 lift3 也是同样的 - 现在它是这样的 ap(ap(ap([fn], a_x), a_y), a_z)。
liftжӣҙеҠ зӣҙи§ӮгҖӮSanctuaryжҸҗдҫӣдәҶliftпјҢlift2е’Ңlift3гҖӮ - davidchambersap并理解Applicative上下文是什么意思（我假设是https://github.com/fantasyland/fantasy-land#applicative）。 - diplosaurus