Question

const x = (a) => b(a)与const x = b

相同

const a = () => { console.log('hi'); }
let x1 = a;
let x2 = () => a();

x1();
x2();

是什么区别..

const equalField = R.propEq('field'); // NOT WORK!

和

const equalField = (f) => R.propEq('field')(f); // WORKS!

第一个返回一个函数，第二个返回结果。

检查我的代码段...

const addingError = {
  message: '',
  errors: [ { field: "number" }, { field: "mac" } ]
}

// const equalField = R.propEq('field'); // NOT WORK!
const equalField = (f) => R.propEq('field')(f); // WORKS!

const getErrors = R.pipe(R.always(addingError), R.prop('errors'))
const anyField = R.converge(R.any, [equalField, getErrors])
const result = anyField('mac');

console.log(result);

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.23.0/ramda.js"></script>

我的目的是......

当我致电anyField('mac')

时将使用R.any

调用

R.any(equalField('mac'), getErrors('mac'))

equalField('mac')返回一个函数，这是正常的，因为R.any的第一个参数是一个函数
getErrors('mac')返回一个数组，这是正常的，因为R.any的第二个参数是一个数组。

Answer 1

这完全取决于b ...

x = (a) => b(a) 不与x = b相同

如果 b是一个只需要1个参数的函数，或者b是一个咖喱函数
如果 b是一个需要多于一个参数的函数，那么你是对的

问题变得复杂，因为Ramda有一个神奇的API，允许您与单个函数进行交互，就好像它是通过咖喱或一样。

// Ramda magic
R.propEq('a', 'b', {a: 'b'}) // true
R.propEq('a')('b', {a: 'b'}) // true
R.propEq('a', 'b')({a: 'b'}) // true
R.propEq('a')('b')({a: 'b'}) // true

这会产生一些混乱（我个人认为这很糟糕），但我们暂时忽略它

简化演示

下面：b是一个只需要1个参数的函数。 x和y按预期工作

const b = n => n + 1
const x = b
const y = n => b (n)

console.log(x(1)) // 2
console.log(y(1)) // 2

下面：b是一个需要多于1个参数的函数 - y在这种情况下是个问题

const b = (n,m) => n + m
const x = b
const y = n => b(n)

console.log(x(1,2)) // 3
console.log(y(1,2)) // NaN

下方：b是 curried 函数，需要多于1个参数 - y不再是问题

const b = n => m => n + m
const x = b
const y = n => b(n)

console.log(x(1)(2)) // 3
console.log(y(1)(2)) // 3

拉姆达魔术酱;困惑的来源

关于Ramda，具体来说，答案稍微复杂一些

下面，如果我们以咖喱形式致电x和y，我们会得到我们期待的答案 - 然而，如果我们拨打x并且{em} 两个剩余参数的y，只有x才会按预期执行; y将返回一个等待最后一个参数的函数

const b = R.propEq('a')
const x = b
const y = n => b(n)

// call in curried form, everything works as expected
console.log(x('b')({a: 'b'})) // true
console.log(y('b')({a: 'b'})) // true

// call with both args, y blows up
console.log(x('b', {a: 'b'})) // true
console.log(y('b', {a: 'b'})) // function n(r){return 0===arguments.length||b(r)?n:t.apply(this,arguments)}

错误当然是因为我们定义y

的方式

// bad, only accommodates one extra argument
// ramda super magical api would allow any number of arguments per application
const y = n => b(n)

// instead write
const y = (...args) => b(...args)

// above: which of course is stupid in a whole new way
// instead just write
const y = b

// above which is stupid, too
// instead just write
b

您的意图

我（想）我明白你在更新的帖子中想要做什么。如果是这样，以下代码段可能对您有所帮助

const fieldEq = R.propEq('field')

const errorsInclude = type => 
  R.compose (R.any(fieldEq(type)), R.prop('errors'))

const addingError = {
  message: '',
  errors: [ { field: "number" }, { field: "mac" } ]
}

errorsInclude('mac') (addingError) // true
errorsInclude('number') (addingError) // true
errorsInclude('foo') (addingError) // false

注意不要迷恋无点编程。在上面的代码中，必须以咖喱形式调用errorsInclude 。 RamdaWay®可能会建议您使用R.curry作为二元函数

const errorsInclude = R.curry((type, x) =>
  R.compose (R.any(fieldEq(type)), R.prop('errors')) (x))

// now you can call it either way
console.log(errorsInclude('mac', addingError)) // true
console.log(errorsInclude('mac')(addingError)) // true

但是！这种情况违背了R.compose的目的 - 我个人认为如果你想遵守ramda惯例，以下可能是最好的结果

const errorsInclude = R.curry((type, x) =>
  R.any(fieldEq(type), R.prop('errors', x)))

没有任何性感，但它至少是直截了当的 - 只是我的2美分。

@ScottSauyet评论说它也可以使用R.useWith来解决：

const errorsInclude = R.useWith(R.any, [R.propEq('field'), R.prop('errors')]);

为了什么值得

你的问题标题是lambda演算'eta conversion -

的核心

const g = x => f (x)  ==  f
      g(y)            ==  f(y)
      g               ==  f

当所有函数接受/期望恰好1个参数时，这仅作为定律（在lambda演算中就是这种情况）。

x =（a）=＆gt; b（a）与`x = b`不同

我的目的是......

1 个答案: