有趣的问题。经过一番搜索，“部分函数应用程序不是咖喱”给出了我找到的最好的解释。我不能说实际的区别对我来说特别明显，但我不是一个FP专家……

另一个看起来很有用的页面(我承认我还没有完全读完)是“用Java闭包curry和Partial Application”。

注意，这看起来确实是一对被广泛混淆的术语。

curry是将一个有n个参数的函数转换为n个每个函数都有一个参数的函数。给定以下函数:

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

咖喱后，变成:

function f(x) { lambda(y) { lambda(z) { z(x(y)); } } }

为了得到f(x,y,z)的完整应用，你需要这样做:

f(x)(y)(z);

许多函数式语言允许你写fx y z。如果你只调用fx y或f(x)(y)，那么你会得到一个部分应用的函数——返回值是lambda(z){z(x(y))}的闭包，将x和y的值传递给f(x,y)。

使用部分应用的一种方法是将函数定义为广义函数的部分应用，如fold:

function fold(combineFunction, accumulator, list) {/* ... */}
function sum     = curry(fold)(lambda(accum,e){e+accum}))(0);
function length  = curry(fold)(lambda(accum,_){1+accum})(empty-list);
function reverse = curry(fold)(lambda(accum,e){concat(e,accum)})(empty-list);

/* ... */
@list = [1, 2, 3, 4]
sum(list) //returns 10
@f = fold(lambda(accum,e){e+accum}) //f = lambda(accumulator,list) {/*...*/}
f(0,list) //returns 10
@g = f(0) //same as sum
g(list)  //returns 10

注意:本文摘自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.

我在另一个帖子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:当部分应用时，不要在lambda下求值。所以，为了让部分应用变得有趣，我们需要在局部应用和局部应用之间做出区别，并将局部应用视为在lambda下的局部应用加上求值。

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分钟 咖喱:与部分函数应用的对比

在写这篇文章时，我混淆了咖喱和不咖喱。它们是函数的逆变换。不管你怎么称呼它，只要你知道这个变换和它的逆代表什么。

不咖喱的定义不是很清楚(或者说，有“冲突”的定义都抓住了这个想法的精神)。基本上，这意味着将一个接受多个参数的函数转换为一个接受单个参数的函数。例如,

(+) :: Int -> Int -> Int

现在，你如何把它变成一个只有一个参数的函数呢?你当然作弊了!

plus :: (Int, Int) -> Int

注意，加号现在只有一个参数(由两件事组成)。超级!

这有什么意义?好吧，如果你有一个带两个参数的函数，你有一对参数，知道你可以把函数应用到参数上，并且仍然得到你想要的是很好的。事实上，这样做的管道已经存在，所以你不需要做像显式模式匹配这样的事情。你所要做的就是:

(uncurry (+)) (1,2)

什么是偏函数应用?将有两个参数的函数转换为只有一个参数的函数是另一种方法。但它的工作方式不同。同样，让我们以(+)为例。我们如何将它转换为一个以单个Int作为参数的函数?我们作弊!

((+) 0) :: Int -> Int

这是一个函数，将0加到任何Int。

((+) 1) :: Int -> Int

对任意Int值加1。等。在每一种情况下，(+)是“部分应用”。

要了解它们的不同之处，最简单的方法是考虑一个真实的例子。让我们假设我们有一个函数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个(或更多)输入。

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

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”并粘贴我的代码来查看编译后的版本，这可能(希望)更有意义。谢谢!

这里还有其他很好的答案，但我相信Java中的这个例子(根据我的理解)可能对一些人有益:

public static <A,B,X> Function< B, X > partiallyApply( BiFunction< A, B, X > aBiFunction, A aValue ){
    return b -> aBiFunction.apply( aValue, b );
}

public static <A,X> Supplier< X > partiallyApply( Function< A, X > aFunction, A aValue ){
    return () -> aFunction.apply( aValue );
}

public static <A,B,X> Function<  A, Function< B, X >  > curry( BiFunction< A, B, X > bif ){
    return a -> partiallyApply( bif, a );
}

因此curry为您提供了一个单参数函数来创建函数，而partial-application则创建一个包装器函数，该包装器函数硬编码一个或多个参数。

如果你想复制和粘贴，下面的文件比较吵闹，但是使用起来比较友好，因为类型比较宽松:

public static <A,B,X> Function< ? super B, ? extends X > partiallyApply( final BiFunction< ? super A, ? super B, X > aBiFunction, final A aValue ){
    return b -> aBiFunction.apply( aValue, b );
}

public static <A,X> Supplier< ? extends X > partiallyApply( final Function< ? super A, X > aFunction, final A aValue ){
    return () -> aFunction.apply( aValue );
}

public static <A,B,X> Function<  ? super A,  Function< ? super B, ? extends X >  > curry( final BiFunction< ? super A, ? super B, ? extends X > bif ){
    return a -> partiallyApply( bif, a );
}

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都涉及向函数提供参数，可能不是一次全部提供。一个相当典型的例子是两个数字相加。在伪代码(实际上是没有关键字的JS)中，基函数可能如下所示:

add = (x, y) => x + y

如果我想要一个“addOne”函数，我可以部分应用它或curry它:

addOneC = curry(add, 1)
addOneP = partial(add, 1)

现在使用它们是很清楚的:

addOneC(2) #=> 3
addOneP(2) #=> 3

那么有什么不同呢?好吧，这很微妙，但部分应用程序涉及提供一些参数，然后返回的函数将在下次调用时执行主函数，而curry将一直等待，直到它拥有所有必要的参数:

curriedAdd = curry(add) # notice, no args are provided
addOne = curriedAdd(1) # returns a function that can be used to provide the last argument
addOne(2) #=> returns 3, as we want

partialAdd = partial(add) # no args provided, but this still returns a function
addOne = partialAdd(1) # oops! can only use a partially applied function once, so now we're trying to add one to an undefined value (no second argument), and we get an error

简而言之，使用partial application预填充一些值，知道下次调用该方法时，它将执行，所有未提供的参数都未定义;当您希望连续多次返回部分应用的函数以实现函数签名时，请使用curry。最后一个人为的例子:

curriedAdd = curry(add)
curriedAdd()()()()()(1)(2) # ugly and dumb, but it works

partialAdd = partial(add)
partialAdd()()()()()(1)(2) # second invocation of those 7 calls fires it off with undefined parameters

希望这能有所帮助!

更新:一些语言或库实现将允许您传递一个arity(最终计算中的参数总数)到部分应用程序实现，这可能会将我的两个描述合并成令人困惑的混乱…但在这一点上，这两种技术在很大程度上是可以互换的。

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

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

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

curry是在定义函数的时候。

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

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

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

这里的很多人都没有正确地解决这个问题，也没有人谈论过重叠。

简单的答案

curry:让你调用一个函数，把它分成多个调用，每次调用提供一个参数。

部分应用:允许你调用一个函数，把它分成多个调用，每次调用提供多个参数。

两者之间的重要区别之一是调用 部分应用的函数立即返回结果，而不是另一个 沿着咖喱链;这种区别可以用例子来说明 显然，对于集度大于2的函数。

这是什么意思?这意味着对一个局部函数最多有两次调用。curry的参数和参数的数量一样多。如果curry函数只有两个参数，那么它本质上与偏函数相同。

例子

部分应用和咖喱

function bothPartialAndCurry(firstArgument) {
    return function(secondArgument) {
        return firstArgument + secondArgument;
    }
}

const partialAndCurry = bothPartialAndCurry(1);
const result = partialAndCurry(2);

部分应用程序

function partialOnly(firstArgument, secondArgument) {
    return function(thirdArgument, fourthArgument, fifthArgument) {
        return firstArgument + secondArgument + thirdArgument + fourthArgument + fifthArgument;
    }
}

const partial = partialOnly(1, 2);
const result = partial(3, 4, 5);

局部套用

function curryOnly(firstArgument) {
    return function(secondArgument) {
        return function(thirdArgument) {
            return function(fourthArgument ) {
                return function(fifthArgument) {
                    return firstArgument + secondArgument + thirdArgument + fourthArgument + fifthArgument;
                }
            }
        }
    }
}

const curryFirst = curryOnly(1);
const currySecond = curryFirst(2);
const curryThird = currySecond(3);
const curryFourth = curryThird(4);
const result = curryFourth(5);

// or...

const result = curryOnly(1)(2)(3)(4)(5);

命名约定

等我有时间再写，很快就有时间了。

局部套用

维基百科上说

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)