拉姆达的咖喱和部分功能有什么不同？

Question

似乎咖喱和部分功能完全相同.(也许唯一的区别是参数的数量)

这只是为了方便,或者有充分的理由让两个函数做类似的事情.

Answer 1

来自更广泛的FP社区的许多答案可能会引导你一点点错误.在我看来,Ramda的cur is风格将ML风格的语言融入Javascript,但并不完全相同.

部分应用可能在Ramda中是相当标准的.(免责声明:我是Ramda的作者之一.)描述起来也容易得多.Ramda的partial函数接受一个n参数函数和一个参数列表k(对于某些人0 < k < n),并返回一个新的n - k参数函数,它将用你的新参数和原始函数调用原始函数:

const f = (a, b, c, d, e) => a + b + c + d + e;
// f :: a -> b -> c -> d -> e -> a + b + c + d + e

const g = partial(f, [1, 2]);
g.length; //=> 3
g(3, 4, 5); //=> 15
g(3); //=> NaN ? 1 + 2 + 3 + undefined + undefined)
// g :: (c, d, e) -> 1 + 2 + c + d + e

返回的函数只是其余参数的一个简单函数.如果你用太少的东西来调用它,它就好像你用太少的东西调用原始函数一样.

Currying是一个略有不同的故事.在许多语言中,curry函数会将n参数函数转换为嵌套的1参数函数序列,以便(a, b, c) => f(a, b, c)转换为a => (b => (c => f(a, b, c))可以不加混淆地编写的函数a => b => c => f(a, b, c).在Ramda中,我们更灵活一点,允许您在一次调用时提供尽可能多的参数,每次返回一个函数,直到您提供足够的总参数来满足原始函数,此时我们调用它并返回该值.通过示例解释可能更容易:

const f = (a, b, c, d, e) => a + b + c + d + e;
// f :: a -> b -> c -> d -> e -> a + b + c + d + e

const h5 = curry(f);
h5.length; //=> 5

const h3 = h5(1, 2);
h3.length; //=> 3
h3(3, 4, 5); //=> 15

const h2a = h3(3);
h2a.length; //=> 2
h2a(4, 5); //=> 15

const h2b = h5(1, 2, 3);
h2b.length; //=> 2
h2b(4, 5); //=> 15

const h2c = h5(1)(2, 3);
h2c.length; //=> 2
h2c(4, 5); //=> 15

const h2d = h5(1)(2)(3);
h2d.length; //=> 2
h2d(4, 5); //=> 15

const h1a = h3(3, 4);
h1a.length; //=> 1
h1a(5); //=> 15

const h1b = h2a(4);
h1b.length; //=> 1
h1b(5); //=> 15

// h5 :: (a, b, c, d, e) -> a + b + c + d + e
//    :: (a, b, c, d) -> e -> a + b + c + d + e
//    :: (a, b, c) -> (d, e) -> a + b + c + d + e
//    :: (a, b, c) -> d -> e -> a + b + c + d + e
//    :: (a, b) -> (c, d, e) -> a + b + c + d + e
//    :: (a, b) -> (c, d) -> e -> a + b + c + d + e
//    :: (a, b) -> c -> (d, e) -> a + b + c + d + e
//    :: (a, b) -> c -> d -> e -> a + b + c + d + e
//    :: a -> (b, c, d, e) -> a + b + c + d + e
//    :: a -> (b, c, d) -> e -> a + b + c + d + e
//    :: a -> (b, c) -> (d, e) -> a + b + c + d + e
//    :: a -> (b, c) -> d -> e -> a + b + c + d + e
//    :: a -> b -> (c, d, e) -> a + b + c + d + e
//    :: a -> b -> (c, d) -> e -> a + b + c + d + e
//    :: a -> b -> c -> (d, e) -> a + b + c + d + e
//    :: a -> b -> c -> d -> e -> a + b + c + d + e

因为curry它更灵活,我很少使用partial自己.但有些人谁是,啊哈,分给它.