lodash curry 不适用于 flow 返回的函数； lodash FP 够 FP 吗？

Question

lodash 流函数是真正的 compose 函数，还是看起来像一个，但经过优化以快速运行并牺牲了我期望的灵活性？我希望 flow 能够返回一个我可以 curry 的函数，但它却返回了一个使用 Javascript 的 arguments 关键字的函数。所以 curry 无法判断有待处理的参数，它会立即被调用。

足够直观地工作：

var add = function(x, y) { 
    return x + y 
};
var exclam = function(x) { 
    return x.toString() + "!"; 
}
exclam(1) // "1!"
add(1,2) // 3
var add1 = FP.curry(add)(1);
add1(4) // 5
var add1AndExclam = FP.flow([add1, exclam])
add1AndExclam(2) // "3!"

非直观结果：

addAndExclam = FP.flow([add, exclam])
/*
function(){
    var t=arguments,e=t[0];
    if(i&&1==t.length&&yi(e)&&e.length>=200)return i.plant(e).value();
    for(var u=0,t=r?n[u].apply(this,t):e;++u<r;)t=n[u].call(this,t);
    return t
}
*/
addAndExclam(1,2) // "3!"
add1AndExclamV2 = FP.curry(addAndExclam)(1) // "NaN!"`

寻找另一个库来帮助函数式编程范式是不是有点矫枉过正？我应该自己做曲子吗？我使用了 lodash，因为它已经在我的项目中了。文档使它看起来像 flow 应该是 lodash 的 compose。

我还发现很难在 lodash 的 each 中使用 data 参数（我想要一个类似 eachMyArrayName 快捷方式的东西）。无论我使用 curryRight 还是 lodash 对象占位符约定。

lodash FP 是否只是为了让 lodash 函数可以自动 curriable？还是我做错了什么，它可以用作主要的函数式编程助手？

编辑：

如果我愿意，我可以像这样包装函数，但它似乎违背了元编程的目的，让代码看起来像样板。

add1AndExclamV2 = FP.curry(function(x, y) { 
    return addAndExclam(x, y) 
})(1)
add1AndExclamV2(2)

“3！”`

Answer 1

这只是基本的功能组合。 Lodash “flow” 和 Rambda “pipe” 可能发现很难命名这些函数，因为它们不适合通用。它们不是“真实的”，就像您在短语“真正的撰写功能”中使用单词 real 一样。

您可以使用comp2 将二元函数与一元函数组合在一起——关键是，“二元”函数必须采用柯里化形式，而不是采用元组

let f = x => y => ... 

而不是

let f = (x,y) => ...

回想一下，函数式编程起源于the lambda calculus，那里没有像函数这样的东西，它只接受一个参数。

const curry = f => x => y => f (x,y)
const comp = f => g => x => f (g (x))
const comp2 = comp (comp) (comp)

var add = function(x, y) { return x + y };
var exclam = function(x) { return x.toString() + "!"; }

console.log(exclam (1)) // "1!"
console.log(add (1,2)) // 3

var add1 = curry (add) (1)
console.log(add1 (4)) // 5

var addAndExclam = comp2 (exclam) (curry (add))
console.log(addAndExclam (1) (2)) // "3!"

我鼓励您使用 substitution model 来查看表达式的计算结果

---

将类型放在所有内容上有助于您更有效地推理程序

// curry :: ((a,b) -> c) -> a -> b -> c
const curry = f => x => y => f (x,y)

// comp :: (b -> c) -> (a -> b) -> (a -> c)
const comp = f => g => x => f (g (x))

// comp2 :: (c -> d) -> (a -> b -> c) -> (a -> b -> d)
const comp2 = comp (comp) (comp)

// add :: (Number,Number) -> Number
var add = function(x, y) { return x + y };

// exclam :: Number -> String
var exclam = function(x) { return x.toString() + "!"; }

console.log(exclam (1)) // "1!"
console.log(add (1,2)) // 3

// add1 :: Number -> Number
var add1 = curry (add) (1)
console.log(add1 (4)) // 5

// addAndExlam :: Number -> Number -> String
var addAndExclam = comp2 (exclam) (curry (add))
console.log(addAndExclam (1) (2)) // "3!"

---

关于您的评论：

我想如果我想编写一个特殊函数，其中一个嵌套函数需要两个参数，我会写出来

好主意。如果您发现自己四处寻找一个内置过程（由您的语言或某个库提供），那应该已经表明您应该先尝试将其写出来。至少与自己确认您正确理解了自己的需求。

这是完全可以接受的

const addAndExclam = (x,y) => exclam (add (x,y))

这也是

const addAndExclam = x => y => exclam (add (x,y))

如果你后来了解comp2，发现它可以更好地描述代码，那么你可以在那个时候实现它

const addAndExclam = comp2 (exclam) (curry (add))

Answer 2

var myAdd = function(x, y) { return x + y; }; var exclam = function(x) { return x.toString() + '!'; }; var addSclam = pipe(myAdd, exclam); addSclam(1,2); // "3!" var add1Sclam = curry( addSclam )(1); add1Sclam(500); // "501!"

看起来 ramda 做了对我来说很直观的事情。它为我的项目增加了 1.2mb，但我想它可以或多或少地用于替换 lodash。