currying有什么好处？

fun add(x, y) = x + y

add(3, 5)

fun add x y = x + y 
(* short for val add = fn x => fn y=> x + y *)

add 3 5

#1 楼

使用咖喱函数，您可以更加专心地重用更多抽象函数。假设您有一个加法函数

add x y = x + y

，并且您想向列表的每个成员加2。在Haskell中，您可以执行以下操作：

map (add 2) [1, 2, 3] -- gives [3, 4, 5]
-- actually one could just do: map (2+) [1, 2, 3], but that may be Haskell specific

这里的语法比必须创建函数时要轻巧。 >
，或者如果您必须创建一个匿名lambda函数：假设您有两个查找功能。一个来自键/值对列表，一个键指向值，另一个来自映射图，键与值对以及键到值，如：
>然后，您可以创建一个接受从键到值的查找功能的功能。您可以将上面的任何查找函数传递给它，分别与列表或地图部分应用：

您可以使用轻量级语法专门化/部分应用函数，然后将这些部分应用的函数传递给更高阶的函数，例如add2或map。高阶函数（将函数作为参数或将其作为结果）是函数式编程的基础，而currying和部分应用函数使高阶函数的使用更加有效和简洁。

#2 楼

实际的答案是，使用currying使创建匿名函数更加容易。即使使用最小的lambda语法，这也是一个胜利。比较：

map (add 1) [1..10]
map (\ x -> add 1 x) [1..10]

如果您使用的lambda语法很丑，那就更糟了。 （我在看JavaScript，Scheme和Python。）

随着您使用越来越多的高阶函数，它变得越来越有用。尽管在Haskell中使用的高阶函数比其他语言使用的高阶函数，但实际上发现我实际上较少使用lambda语法，因为大约三分之二的时间，lambda只是部分应用的函数。 （还有很多其他时间，我将其提取到命名函数中。）

从根本上来说，哪个版本的函数是“规范的”并不总是很明显。例如，取map。 map的类型可以用两种方式编写：

map :: (a -> b) -> [a] -> [b]
map :: (a -> b) -> ([a] -> [b])

哪个是“正确”的？实际上很难说。实际上，大多数语言都使用第一种语言-映射接受一个函数和一个列表，然后返回一个列表。但是，从根本上讲，map实际上所做的是将正常函数映射到列表函数-它接受一个函数并返回一个函数。如果map是咖喱的，那么您不必回答这个问题：它以一种非常优雅的方式完成了这两个问题。 >
此外，计算确实不是很复杂。实际上，与大多数语言使用的模型相比，它有点简化：您不需要将任何包含在您的语言中的多个参数的函数的概念表示出来。这也更紧密地反映了底层的lambda演算。

当然，ML风格的语言没有咖喱或非咖喱形式的多个参数的概念。 map语法实际上对应于将元组f(a, b, c)传入(a, b, c)，因此f仍然仅接受参数。实际上，这是我希望其他语言具有的非常有用的区别，因为它使编写类似以下内容变得很自然：

具有多个参数思想的语言就诞生了！

#3 楼

如果您有一个传递为第一类对象的函数，并且没有在代码中的某个地方收到评估它所需的所有参数，则Currying可能很有用。您可以在获得一个或多个参数时简单地应用它们，然后将结果传递给具有更多参数的另一段代码，并在那里完成评估。

实现此目的的代码比需要首先将所有参数集中在一起的代码要简单。

另外，还可以重复使用更多代码，因为带有单个参数的函数（另一个咖喱函数）不必与所有参数完全匹配。

#4 楼

（至少在最初时）进行主干的主要动机不是实践而是理论。特别是，使用currying可以有效地获取多参数函数，而无需实际为其定义语义或为产品定义语义。这导致一种更简单的语言具有与另一种更复杂的语言一样多的表现力，因此是所希望的。

#5 楼

（我将在Haskell中给出示例。）




使用函数式语言时，可以部分应用函数非常方便。就像在Haskell的(== x)中一样，如果它的参数等于给定项True，则返回x的函数：

mem :: Eq a => a -> [a] -> Bool
mem x lst = any (== x) lst

这与默认编程有关（另请参见Haskell Wiki上的Pointfree样式）。这种样式不着重于变量表示的值，而是着重于组成函数以及信息如何通过函数链流动。我们可以将示例转换为完全不使用变量的形式：从==到a。通过简单地组成它们，我们得到了结果。这一切都归功于currying。例如，假设我们要将一个列表分为两部分-小于10的元素和其余部分，然后将这两个列表连接起来。列表的拆分由a -> Bool any（在这里我们也使用curried a -> Bool）完成。结果为[a] -> Bool类型。不用将结果提取到第一部分和第二部分中并使用partition对其进行组合，我们可以通过直接使用(< 10)作为

mem x lst = any (\y -> y == x) lst

实际上，<评估为([Int],[Int])。 。这些语言虽然对实际使用没有用，但从理论上来说非常重要。
这与功能语言的基本属性有关-功能是一流的对象。如我们所见，从++到++的转换意味着后者函数的结果是(uncurry (++) . partition (< 10)) [4,12,11,1]类型。换句话说，结果是一个函数。
（Un）currying与笛卡尔封闭类别密切相关，这是查看键入的λ演算的一种分类方式。

#6 楼

我还没有看到的另一件事是，curring允许对Arity进行（有限的）抽象。

考虑Haskell库中包含的这些函数
在每种情况下，类型变量c都可以是函数类型，以便这些函数在其参数的参数列表的某些前缀上起作用。无需大惊小怪，您要么需要特殊的语言功能来抽象函数arity，要么具有专门针对不同arities的这些函数的许多不同版本。

#7 楼

咖喱不仅是语法糖！

考虑add1（未咖喱的）和add2（咖喱的）的类型签名：情况下，类型签名中的括号是可选的，但为清楚起见，我将其包括在内。） add1是一个使用int并返回另一个函数的函数，而另一个函数随后又使用int并返回int。让我们定义一个将第一个参数应用于第二个参数的函数（非咖喱函数）：现在，我们可以更清楚地看到add2和int之间的区别。 int被一个2元组调用： />

add1 : (int * int) -> int
add2 : int -> (int -> int)

编辑：currying的本质好处是您可以免费获得部分申请。假设您想要一个类型为int的函数（例如，将其添加到列表中的add1），并将其参数加5。您可以编写add2，也可以使用内联lambda进行等效操作，但是也可以更轻松地（尤其是在这种情况不那么琐碎的情况下）编写add1！

#8 楼

咖喱只是语法糖，但我认为您对糖的作用有些误解。以您的示例为例，

fun add x y = x + y

实际上是

fun add x = fn y => x + y

的语法糖，也就是说，（加x）返回一个带参数y的函数，并将x加到y。这两个功能实际上是完全不同的。

如果要在列表中的所有数字上加2：

br />
另一方面，如果要对列表中的每个元组求和，则addTuple函数非常合适。 [3,4,5]。

在部分应用有用的地方，咖喱函数非常有用-例如地图，折叠，应用，过滤器。考虑一下此函数，该函数返回提供的列表中的最大正数；如果没有正数，则返回0：

fun addTuple (x, y) = x + y

#9 楼

我有限的理解是这样的：

1）局部函数应用程序

局部函数应用程序是返回带有较少参数的函数的过程。如果您提供3个参数中的2个，它将返回一个接受3-2 = 1个参数的函数。如果您提供3个参数中的1个，它将返回一个带有3-1 = 2个参数的函数。如果需要，甚至可以部分应用3个参数中的3个，它将返回不带参数的函数。

因此，请使用以下函数： />
将1绑定到x并将其部分应用于上述函数f(x,y,z)时，您将得到：

f(x,y,z) = x + y + z;

其中：f'(y,z) = 1 + y + z;

现在，如果将y绑定到2并将z绑定到3，然后部分应用f'(y,z)，您将得到： >
现在，您可以随时选择评估f''() = 1 + 2 + 3，f或f'。所以我可以做： >另一方面，咖喱是将一个函数拆分为一个包含一个参数函数的嵌套链的过程。您永远不能提供超过1个参数，它是1或0。因此，给定相同的功能：

f(1,y,z) = f'(y,z);

如果您使用它，您将获得3个功能链：使用f''时：

f'(2,3) = f''();

您将返回一个新函数： ：

print(f''()) // and it would return 6;

返回一个新函数：

print(f'(1,1)) // and it would return 3;

最后，如果您用f'(x)调用x = 1：

f(x,y,z) = x + y + z;

您将返回g(y)。

3）关闭

最后，闭包是将功能和数据作为单个单元一起捕获的过程。函数闭包可以接受0到无数个参数，但是它也知道没有传递给它的数据。

再次使用相同的函数：

f'(x) -> f''(y) -> f'''(z)

您可以改写闭包：

f'(x) = x + f''(y);

f''(y) = y + f'''(z);

f'''(z) = z;

其中：在y = 2上关闭。这意味着h(z)可以读取z = 3内部的x值。

因此，如果要使用6调用f'： d得到一个闭包：

f'(1) = 1 + f''(y);

现在如果您用x和f'调用f：
会返回f

结论

过程，部分应用程序和闭包都有些相似，因为它们将函数分解为更多部分。

过程分解将多个参数的函数转换为单个参数的嵌套函数，这些嵌套函数返回单个参数的函数。引用一个或更少参数的函数是没有意义的，因为它没有意义。

部分应用程序将多个参数的函数分解为较小参数的函数，现在将其缺少的参数替换为

闭包将一个函数分解为一个函数和一个数据集，其中未传入函数的变量可以在数据集内查找要求值时要绑定的值。

所有这些令人困惑的是，它们可以被用来实现其他子集的一种。因此，从本质上讲，它们都是实现细节。它们都提供了相似的值，因为您不需要预先收集所有值，并且可以重用部分函数，​​因为您已经将其分解为离散的单元。

披露

我绝不是该主题的专家，我只是最近才开始学习这些知识，因此，我提供了我目前的理解，但是可能有错误，请您指出。我发现了。

#10 楼

通过Currying（部分应用程序），您可以通过固定一些参数从现有功能中创建新功能。这是词汇闭包的一种特殊情况，其中匿名函数只是一个琐碎的包装器，它将一些捕获的参数传递给另一个函数。我们也可以通过使用通用语法来进行词法闭包来做到这一点，但是部分应用程序提供了简化的语法糖。这就是为什么Lisp程序员在以函数样式工作时有时会使用库来部分化应用。

代替(lambda (x) (+ 3 x))，它给我们的函数添加了3个参数，您可以编写类似(op + 3)的内容，因此将3添加到某个列表的每个元素中将是(mapcar (op + 3) some-list)而非(mapcar (lambda (x) (+ 3 x)) some-list) 。这个op宏将为您提供一个带有x y z ...参数并调用(+ a x y z ...)的函数。在许多纯函数语言中，部分应用程序已根植于语法中，因此没有op运算符。要触发部分应用程序，您只需调用一个带有比其所需参数更少的参数的函数即可。结果不会产生"insufficient number of arguments"错误，而是其余参数的函数。

#11 楼

对于函数

fun add(x, y) = x + y

它的形式为f': 'a * 'b -> 'c

要求值将

add(3, 5)
val it = 8 : int

用于咖喱函数

fun add x y = x + y

求值会

add 3
val it = fn : int -> int

它是部分计算，特别是（3 + y），然后可以用

it 5
val it = 8 : int

完成计算。在第二种情况下，形式为f: 'a -> 'b -> 'c

这里的currying是将一个将需要两个协议的函数转换为只需要一个返回结果的函数。部分评估


为什么要这样做？


在RHS上说x不仅是常规的int，而是复杂的计算需要花一会儿时间才能完成（为了增加效果），需要两秒钟。 >
add : int * int -> int类型的

现在我们要为一系列数字计算此函数，让我们对其进行映射

x = twoSecondsComputation(z)

对于以上twoSecondsComputation的结果每一次都进行评估。这意味着需要6秒钟的计算时间。

结合使用分阶段操作和循环操作可以避免这种情况。

fun add (z:int) (y:int) : int =
    let
        val x = twoSecondsComputation(z)
    in
        x + y
    end;

现在可以执行add : int -> int -> int表格

，

val result1 = map (fn x => add (20, x)) [3, 5, 7];

twoSecondsComputation只需要评估一次。要扩大规模，请用15分钟（或任何小时）替换两秒，然后对100个数字进行映射。部分评估。其目的无法真正证明。

#12 楼

咖喱允许灵活的函数组成。

我组成了一个函数“ curry”。在这种情况下，我不在乎获得哪种记录器或它来自何处。我不在乎动作是什么或它来自哪里。我只关心处理输入。

var builder = curry(function(input, logger, action) {
     logger.log("Starting action");
     try {
         action(input);
         logger.log("Success!");
     }
     catch (err) {
         logger.logerror("Boo we failed..", err);
     }
});
var x = "My input.";
goGatherArgs(builder)(x); // Supplies action first, then logger somewhere.

builder变量是一个函数，该函数返回一个函数，该函数返回一个接受输入的函数。这是一个简单有用的示例，而不是可见的对象。

#13 楼

当您没有函数的所有参数时，使用Currying是一个优点。如果您恰好完全评估了该功能，则没有什么明显的区别。

通过固化，您可以避免提及尚不需要的参数。它更加简洁，不需要查找不会与范围内的另一个变量发生冲突的参数名称（这是我最喜欢的好处）。例如，在使用将函数用作参数时，通常会遇到需要“将3加到输入”或“将输入与变量v比较”之类的函数的情况。借助curring，可以轻松编写以下函数：add 3和(== v)。您必须使用lambda表达式，而无需进行粗略的表达：x => add 3 x和x => x == v。 lambda表达式的长度是原来的两倍，并且如果在范围上已经存在x，那么除了x之外，还有少量的忙于挑选名字。在为函数编写通用代码时，基于参数的数量，最终不会有数百种变体。例如，在C＃中，“ curry”方法将需要Func ，Func ，Func ，Func 等的变体永远。在Haskell中，Func 的等效项更像Func ，R>或Func >（和Func 更像Func ），因此所有变体都对应于单个Func 的情况。

#14 楼

我能想到的主要推理（无论如何我都不是这个主题的专家）开始显示其功能从微不足道变为非微不足道的好处。在具有这种性质的大多数概念的所有琐碎情况下，您都不会发现真正的好处。但是，大多数功能语言在处理操作中大量使用堆栈。考虑以PostScript或Lisp为例。通过使用curring，可以更有效地堆叠功能，并且随着操作的增长越来越小，这种好处变得显而易见。以咖喱的方式，命令和参数可以按顺序扔到堆栈上，并根据需要弹出，以便它们以正确的顺序运行。

#15 楼

固化至关重要（甚至是绝对）取决于返回函数的能力。

考虑此（伪造）伪代码。

var f =（m，x，b）=> ...返回某物...

我们规定调用少于三个参数的f返回一个函数。

var g = f（0，1）; //这将返回绑定到0和1（m和x）的函数，该函数接受另一个参数（b）。

var y = g（42）; //使用缺少的第三个参数调用g，对m和x使用0和1
非常有用（和DRY）。