对于我来说，部分应用程序必须创建一个新函数，其中使用的参数完全集成到结果函数中。

大多数函数式语言通过返回一个闭包来实现curry:当部分应用时，不要在lambda下求值。所以，为了让部分应用变得有趣，我们需要在局部应用和局部应用之间做出区别，并将局部应用视为在lambda下的局部应用加上求值。

I could be very wrong here, as I don't have a strong background in theoretical mathematics or functional programming, but from my brief foray into FP, it seems that currying tends to turn a function of N arguments into N functions of one argument, whereas partial application [in practice] works better with variadic functions with an indeterminate number of arguments. I know some of the examples in previous answers defy this explanation, but it has helped me the most to separate the concepts. Consider this example (written in CoffeeScript for succinctness, my apologies if it confuses further, but please ask for clarification, if needed):

# partial application
partial_apply = (func) ->
  args = [].slice.call arguments, 1
  -> func.apply null, args.concat [].slice.call arguments

sum_variadic = -> [].reduce.call arguments, (acc, num) -> acc + num

add_to_7_and_5 = partial_apply sum_variadic, 7, 5

add_to_7_and_5 10 # returns 22
add_to_7_and_5 10, 11, 12 # returns 45

# currying
curry = (func) ->
  num_args = func.length
  helper = (prev) ->
    ->
      args = prev.concat [].slice.call arguments
      return if args.length < num_args then helper args else func.apply null, args
  helper []

sum_of_three = (x, y, z) -> x + y + z
curried_sum_of_three = curry sum_of_three
curried_sum_of_three 4 # returns a function expecting more arguments
curried_sum_of_three(4)(5) # still returns a function expecting more arguments
curried_sum_of_three(4)(5)(6) # returns 15
curried_sum_of_three 4, 5, 6 # returns 15

这显然是一个人为的例子，但请注意，部分应用一个接受任意数量参数的函数允许我们使用一些初步数据来执行函数。curry函数与此类似，但允许我们分批执行N个参数的函数，直到，但只是直到，所有N个参数都被考虑。

再说一次，这是我从我读过的东西中得出的结论。如果有人不同意，我希望能就原因发表评论，而不是立即投反对票。另外，如果CoffeeScript很难阅读，请访问coffeescript.org，点击“尝试CoffeeScript”并粘贴我的代码来查看编译后的版本，这可能(希望)更有意义。谢谢!

curry和partial application之间的区别可以通过下面的JavaScript示例来最好地说明:

function f(x, y, z) {
    return x + y + z;
}

var partial = f.bind(null, 1);

6 === partial(2, 3);

局部应用的结果是一个更小的函数;在上面的例子中，f的arity是3，而partial的arity只有2。更重要的是，部分应用的函数将在被调用时立即返回结果，而不是沿着curry链向下的另一个函数。所以如果你看到的是偏(2)偏(3)，实际上这不是偏应用。

进一步阅读:

函数式编程5分钟 咖喱:与部分函数应用的对比

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会递归地转换整个原始函数(每个参数一次)，而局部应用只是一步替换。

来源:维基百科。

要了解它们的不同之处，最简单的方法是考虑一个真实的例子。让我们假设我们有一个函数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是一种将带有多个参数的函数转换为带有单个参数的函数序列的技术。

例子

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)