我在另一个帖子https://stackoverflow.com/a/12846865/1685865中回答了这个问题。简而言之，部分函数应用是关于固定一个给定的多变量函数的一些参数，以产生另一个具有更少参数的函数，而Currying是关于将一个有N个参数的函数转换为一个返回一元函数的一元函数…[一个curry的例子显示在这篇文章的最后。]

curry主要是理论方面的兴趣:可以只用一元函数来表示计算(即每个函数都是一元函数)。在实践中，它是一种技术，可以使许多有用的(但不是全部)部分函数式应用程序变得微不足道，如果语言有咖喱函数的话。同样，它不是实现部分应用程序的唯一方法。所以你可能会遇到这样的情况，部分应用程序是用其他方式完成的，但人们会把它误认为是curry。

(以咖喱为例)

在实践中，人们不只是写

lambda x: lambda y: lambda z: x + y + z

或者等价的javascript

function (x) { return function (y){ return function (z){ return x + y + z }}}

而不是

lambda x, y, z: x + y + z

为了柯里林。

curry是一个只有一个参数的函数，它接受一个函数f，并返回一个新函数h。注意，h接受一个X的参数，并返回一个将Y映射到Z的函数:

curry(f) = h 
f: (X x Y) -> Z 
h: X -> (Y -> Z)

部分应用是一个有两个(或多个)参数的函数，它接受一个函数f和一个或多个附加参数，并返回一个新函数g:

part(f, 2) = g
f: (X x Y) -> Z 
g: Y -> Z

出现混淆是因为对于一个双参数函数，下面的等式成立:

partial(f, a) = curry(f)(a)

两边都将产生相同的单参数函数。

对于更高的函数，相等性不成立，因为在这种情况下，curry将返回一个单参数函数，而partial应用将返回一个多参数函数。

不同之处在于行为上，curry会递归地转换整个原始函数(每个参数一次)，而局部应用只是一步替换。

来源:维基百科。

局部套用

维基百科上说

curry是一种将带有多个参数的函数转换为带有单个参数的函数序列的技术。

例子

const add = (a, b) => a + b

const addC = (a) => (b) => a + b // curried function. Where C means curried

部分应用程序

文章刚刚好FP:部分应用

部分应用是将部分(而不是全部)参数应用到函数，并返回一个新函数等待其余参数。这些应用的参数存储在闭包中，并且将来对任何部分应用的返回函数仍然可用。

例子

const add = (a) => (b) => a + b

const add3 = add(3) // add3 is a partially applied function

add3(5) // 8

区别在于

咖喱是一种技术(模式) Partial application是一个带有一些预定义参数的函数(如前面示例中的add3)

注意:本文摘自f# Basics，这是一篇非常好的介绍性文章，供。net开发人员学习函数式编程。

Currying means breaking a function with many arguments into a series of functions that each take one argument and ultimately produce the same result as the original function. Currying is probably the most challenging topic for developers new to functional programming, particularly because it is often confused with partial application. You can see both at work in this example: let multiply x y = x * y let double = multiply 2 let ten = double 5 Right away, you should see behavior that is different from most imperative languages. The second statement creates a new function called double by passing one argument to a function that takes two. The result is a function that accepts one int argument and yields the same output as if you had called multiply with x equal to 2 and y equal to that argument. In terms of behavior, it’s the same as this code: let double2 z = multiply 2 z Often, people mistakenly say that multiply is curried to form double. But this is only somewhat true. The multiply function is curried, but that happens when it is defined because functions in F# are curried by default. When the double function is created, it’s more accurate to say that the multiply function is partially applied. The multiply function is really a series of two functions. The first function takes one int argument and returns another function, effectively binding x to a specific value. This function also accepts an int argument that you can think of as the value to bind to y. After calling this second function, x and y are both bound, so the result is the product of x and y as defined in the body of double. To create double, the first function in the chain of multiply functions is evaluated to partially apply multiply. The resulting function is given the name double. When double is evaluated, it uses its argument along with the partially applied value to create the result.

要了解它们的不同之处，最简单的方法是考虑一个真实的例子。让我们假设我们有一个函数Add，它接受2个数字作为输入，并返回一个数字作为输出，例如Add(7,5)返回12。在这种情况下:

Partial applying the function Add with a value 7 will give us a new function as output. That function itself takes 1 number as input and outputs a number. As such: Partial(Add, 7); // returns a function f2 as output // f2 takes 1 number as input and returns a number as output So we can do this: f2 = Partial(Add, 7); f2(5); // returns 12; // f2(7)(5) is just a syntactic shortcut Currying the function Add will give us a new function as output. That function itself takes 1 number as input and outputs yet another new function. That third function then takes 1 number as input and returns a number as output. As such: Curry(Add); // returns a function f2 as output // f2 takes 1 number as input and returns a function f3 as output // i.e. f2(number) = f3 // f3 takes 1 number as input and returns a number as output // i.e. f3(number) = number So we can do this: f2 = Curry(Add); f3 = f2(7); f3(5); // returns 12

换句话说，“套用”和“局部应用”是两种完全不同的功能。curry只需要1个输入，而partial应用程序需要2个(或更多)输入。

尽管它们都返回一个函数作为输出，但返回的函数是完全不同的形式，如上所述。

我假设大多数问这个问题的人已经熟悉了基本概念，所以他们没有必要谈论这个。重叠是令人困惑的部分。

您可能能够充分使用这些概念，但您将它们一起理解为伪原子无定形的概念模糊。现在缺少的是知道它们之间的界限在哪里。

与其定义它们是什么，不如简单地强调它们的不同之处——边界。

curry是在定义函数的时候。

部分应用程序是在调用函数时。

应用程序是调用函数的数学术语。

部分应用程序需要调用一个curry函数并获得一个函数作为返回类型。