it-swarm.dev

Currying和部分应用有什么区别?

我经常在互联网上看到各种各样的抱怨,其他人的currying例子并不是currying,但实际上只是部分应用。

我没有找到关于部分应用是什么的合理解释,或者它与currying有何不同。似乎存在普遍的混淆,在某些地方将等效的例子描述为currying,在其他地方描述为部分应用。

有人可以向我提供这两个术语的定义,以及它们如何区别的细节吗?

389
SpoonMeiser

Currying将 n arguments的单个函数转换为 n functions,每个函数都有一个参数。鉴于以下功能:

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);

许多函数式语言允许你编写f x y z。如果你只调用f x 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
224
Mark Cidade

了解它们之间差异的最简单方法是考虑 实例 。假设我们有一个函数Add,它将2个数字作为输入并返回一个数字作为输出,例如Add(7, 5)返回12。在这种情况下:

  • 部分应用 函数Add带有值7将为我们提供一个新函数作为输出。该函数本身需要1个数字作为输入并输出一个数字。因此:

    Partial(Add, 7); // returns a function f2 as output
    
                     // f2 takes 1 number as input and returns a number as output
    

    所以我们可以这样做:

    f2 = Partial(Add, 7);
    f2(5); // returns 12;
           // f2(7)(5) is just a syntactic shortcut
    
  • Currying 函数Add将为我们提供一个新函数作为输出。该函数本身需要1个数字作为输入和输出另一个新函数。然后第三个函数将1个数作为输入并返回一个数作为输出。因此:

    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
    

    所以我们可以这样做:

    f2 = Curry(Add);
    f3 = f2(7);
    f3(5); // returns 12
    

换句话说,“currying”和“partial application”是两个完全不同的功能。 Currying只需1个输入,而部分应用需要2个(或更多)输入。

即使它们都返回一个函数作为输出,返回的函数也是完全不同的形式,如上所示。

146
Pacerier

注意:这取自 F#Basics 这是.NET开发人员进入函数式编程的优秀介绍性文章。

Currying意味着将具有许多参数的函数分解为一系列函数,每个函数都接受一个参数并最终产生与原始函数相同的结果。对于功能编程新手来说,Currying可能是最具挑战性的话题,特别是因为它经常与部分应用混淆。您可以在此示例中看到两者都在工作:

let multiply x y = x * y    
let double = multiply 2
let ten = double 5

您应该立即看到与大多数命令式语言不同的行为。第二个语句通过将一个参数传递给一个带两个的函数来创建一个名为double的新函数。结果是一个函数,它接受一个int参数并产生相同的输出,就好像你已经调用了multiply,x等于2,y等于那个参数。在行为方面,它与此代码相同:

let double2 z = multiply 2 z

通常,人们错误地认为乘法是形成双重的。但这只是有点真实。乘法函数是curry,但是在定义时会发生这种情况,因为默认情况下F#中的函数是curry。当创建双重函数时,更准确地说,部分应用了乘法函数。

乘法函数实际上是一系列两个函数。第一个函数接受一个int参数并返回另一个函数,有效地将x绑定到特定值。此函数还接受一个int参数,您可以将其视为绑定到y的值。在调用第二个函数之后,x和y都被绑定,因此结果是x和y的乘积,如double体中所定义。

要创建double,将计算乘法函数链中的第一个函数以部分应用乘法。结果函数的名称为double。当计算double时,它使用其参数以及部分应用的值来创建结果。

48
dodgy_coder

有趣的问题。经过一番搜索, “部分功能应用程序没有说谎” 给出了我发现的最佳解释。我不能说 practical 差异对我来说特别明显,但后来我不是FP专家......

另一个有用的页面(我承认我尚未完全阅读)是 “使用Java闭包进行Currying和部分应用程序”

看起来这看起来像是一对广泛混淆的术语,请注意。

27
Jon Skeet

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

Currying主要是理论上的兴趣:人们可以仅使用一元函数来表达计算(即 every function是一元的)。在实践中和作为副产品,如果语言具有curried功能,它是一种可以使许多有用(但不是全部)部分功能应用程序变得微不足道的技术。同样,它不是实现部分应用程序的唯一方法。因此,您可能会遇到以其他方式完成部分应用程序的情况,但人们将其误认为是Currying。

(Currying示例)

在实践中,人们不会只写

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

为了Currying。

12
Ji Han

Currying是 one argument的函数,它接受函数f并返回一个新函数h。请注意hX中获取一个参数并返回一个function,它将Y映射到Z

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

部分应用程序是 两个(或更多) arguments的函数,它接受函数f和一个或多个f的附加参数并返回一个新函数g

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

产生混淆是因为使用双参数函数时,以下等式成立:

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

双方将产生相同的单参数函数。

对于更高的arity函数,相等性不正确,因为在这种情况下currying将返回单参数函数,而部分应用程序将返回多参数函数。

差异也在于行为,而currying递归地转换整个原始函数(每个参数一次),部分应用只是一步替换。

来源: 维基百科Currying

6
Roland

通过以下JavaScript示例可以最好地说明curry和部分应用程序之间的区别:

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.更重要的是,部分应用的函数将 在调用时立即返回结果 ,而不是currying链中的另一个函数。所以,如果你看到像partial(2)(3)这样的东西,它实际上不是部分应用。

进一步阅读:

5
gsklee

简单回答

Curry: 允许你调用一个函数,将它分成多个调用,每次调用提供一个参数。

Partial: 允许你调用一个函数,将它分成多个调用,每次调用提供多个参数。


简单的提示

两者都允许你调用一个提供较少参数的函数(或者更好,累积地提供它们)。实际上它们都(在每次调用时)将特定值绑定到函数的特定参数。

当函数具有多于2个参数时,可以看到真正的差异。


简单的e(c)(样本)

(在Javascript中)

function process(context, success_callback, error_callback, subject) {...}

为什么总是传递参数,如上下文和回调,如果它们总是相同的?只需为函数绑定一些值

processSubject = _.partial(process, my_context, my_success, my_error)

并在 subject1 foobar with上调用它

processSubject('subject1');
processSubject('foobar');

舒服,不是吗? ????

使用 currying 你需要每次传递一个参数

curriedProcess = _.curry(process);
processWithBoundedContext = curriedProcess(my_context);
processWithCallbacks = processWithBoundedContext(my_success)(my_error); // note: these are two sequential calls

result1 = processWithCallbacks('subject1');
// same as: process(my_context, my_success, my_error, 'subject1');
result2 = processWithCallbacks('foobar'); 
// same as: process(my_context, my_success, my_error, 'foobar');

放弃

我跳过了所有的学术/数学解释。因为我不知道。也许它有帮助????

2
Kamafeather

我在这里可能非常错,因为我没有理论数学或函数式编程的强大背景,但是从我对FP的简短尝试来看,似乎currying倾向于将N个参数的函数转换为一个参数的N个函数,而部分应用[在实践中]使用具有不确定数量的参数的可变参数函数更好地工作。我知道以前的答案中的一些例子无法解释这个问题,但它帮助我最大限度地分离了这些概念。考虑一下这个例子(用CoffeeScript写的简洁,如果它进一步混淆我很抱歉,但如果需要,请请求澄清):

# 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

这显然是一个人为的例子,但注意到部分应用一个接受任意数量参数的函数允许我们执行一个函数但是有一些初步数据。卷曲函数是类似的,但允许我们分段执行N参数函数,直到但仅直到考虑所有N个参数。

再一次,这是我从我读过的东西中获取的。如果有人不同意,我会赞赏为什么而不是立即downvote的评论。此外,如果CoffeeScript难以阅读,请访问coffeescript.org,单击“尝试coffeescript”并粘贴我的代码以查看编译版本,这可能(希望)更有意义。谢谢!

2
sunny-mittal

我在学习的过程中经常遇到这个问题,并且多次被问到这个问题。我能描述差异的最简单方法是两者都相同:)让我解释一下......显然存在差异。

部分应用和currying都涉及为函数提供参数,也许不是一次性。一个相当规范的例子是添加两个数字。在伪代码中(实际上JS没有关键字),基本函数可能如下:

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

如果我想要一个“addOne”功能,我可以部分应用它或咖喱它:

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

现在使用它们很清楚:

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

那有什么区别?好吧,它很微妙,但部分应用程序涉及提供一些参数,然后返回的函数将 在下次调用时执行main函数 而currying将一直等待,直到它具有所需的所有参数:

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

简而言之,使用部分应用程序预先填充一些值,知道下次调用方法时,它将执行,保留未定义的所有未提供的参数;如果要根据需要连续多次返回部分应用的函数来执行函数签名,请使用currying。最后一个人为的例子:

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

希望这可以帮助!

更新:某些语言或lib实现将允许您将arity(最终评估中的参数总数)传递给部分应用程序实现,这可能会将我的两个描述混淆成混乱的混乱......但在这一点上,这两种技术是基本上可以互换.

2
sunny-mittal

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

大多数函数式语言通过返回闭包来实现currying:在部分应用时不要在lambda下求值。因此,对于有趣的部分应用,我们需要在currying和部分应用之间做出区别,并将部分应用视为curda和lambda下的评估。

2
Taoufik Dachraoui

这里有其他很好的答案,但我相信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 );
}

因此currying给你一个单参数函数来创建函数,其中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 );
}
1
ArtB

在写这篇文章时,我混淆了currying和uncurrying。它们是函数的逆变换。只要你得到转换及其逆代表的内容,你称之为什么并不重要。

没有明确定义不公开(或者更确切地说,存在“冲突”的定义,这些定义都捕捉到了这个想法的精神)。基本上,它意味着将一个带有多个参数的函数转换为一个带有单个参数的函数。例如,

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

现在,你如何把它变成一个只需要一个参数的函数?当然,你作弊!

plus :: (Int, Int) -> Int

请注意,plus现在只需要一个参数(由两件事组成)。超!

这有什么意义?好吧,如果你有一个带有两个参数的函数,并且你有一对参数,那么很高兴知道你可以将函数应用于参数,并且仍然得到你期望的结果。而且,实际上,执行它的管道已经存在,因此您不必执行显式模式匹配等操作。你所要做的就是:

(uncurry (+)) (1,2)

那么什么是部分功能应用?将两个参数中的函数转换为具有一个参数的函数是一种不同的方法。它的工作方式不同。再说一次,我们以(+)为例。我们怎样才能将它变成一个以单个Int作为参数的函数?我们作弊!

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

这是为任何Int增加零的函数。

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

为任何Int添加1。等等。在每种情况下,(+)是“部分应用的”。

0
nomen

我会假设大多数提出这个问题的人已经熟悉了基本概念,所以他们不需要谈论这个问题。重叠是令人困惑的部分。

您可能能够完全使用这些概念,但您将它们理解为这种伪原子无定形概念模糊。缺少的是知道它们之间的边界在哪里。

不是定义每个人的内容,而是更容易突出他们的差异 - 边界。

Currying 是你 定义 函数。

部分应用 当你 调用 函数。

应用程序 是数学代表调用函数。

Partial application需要调用curried函数并将函数作为返回类型。

0
Brennan Cheung