下面是泛型和最短版本的函数用n no curry的例子。的参数。

const add = a => b => b ? add(a + b) : a; 

Const add = a => b => b ?Add (a + b): a; console.log(添加(1)(2)(3)(4)());

在函数代数中，处理带有多个参数的函数(或相当于一个n元组的参数)有点不优雅——但是，正如Moses Schönfinkel(以及Haskell Curry)所证明的那样，这是不需要的:您所需要的只是带有一个参数的函数。

那么如何处理自然表示为f(x,y)的式子呢?好吧，你把它等价于f(x)(y)——f(x)，叫它g，是一个函数，你把这个函数应用到y上。换句话说，你只有带一个参数的函数——但其中一些函数返回其他函数(也带一个参数;-)。

像往常一样，维基百科对此有一个很好的总结条目，有许多有用的指针(可能包括关于你最喜欢的语言的;-)，以及稍微更严格的数学处理。

这个线程中的大多数例子都是虚构的(添加数字)。这些对于说明这个概念很有用，但当你在应用程序中实际使用咖喱时，它们就没有意义了。

下面是一个来自React (JavaScript用户界面库)的实例。这里的curry说明了闭包属性。

与大多数用户界面库中的典型情况一样，当用户单击按钮时，将调用一个函数来处理该事件。处理程序通常修改应用程序的状态并触发接口重新呈现。

项目列表是常见的用户界面组件。每个项目都可能有一个与之相关的标识符(通常与数据库记录相关)。例如，当用户单击按钮以“喜欢”列表中的某项时，处理程序需要知道单击了哪个按钮。

curry是实现id和处理程序之间绑定的一种方法。在下面的代码中，makeClickHandler是一个函数，它接受一个id，并返回一个在其作用域中包含id的处理程序函数。

内部函数的工作方式在本文中并不重要。但如果你好奇的话，它会在项目数组中搜索，通过id找到一个项目，并增加它的“喜欢”，通过设置状态触发另一次呈现。State在React中是不可变的，所以修改一个值所花费的工作比你想象的要多一些。

您可以将调用curry函数视为“剥离”外部函数以公开准备调用的内部函数。这个新的内部函数是传递给React的onClick的实际处理程序。外部函数用于循环体指定特定内部处理函数范围内的id。

const List = () => { const [items, setItems] = React.useState([ {name: "foo", likes: 0}, {name: "bar", likes: 0}, {name: "baz", likes: 0}, ].map(e => ({...e, id: crypto.randomUUID()}))); // .----------. outer func inner func // | currying | | | // `----------` V V const makeClickHandler = (id) => (event) => { setItems(prev => { const i = prev.findIndex(e => e.id === id); const cpy = {...prev[i]}; cpy.likes++; return [ ...prev.slice(0, i), cpy, ...prev.slice(i + 1) ]; }); }; return ( <ul> {items.map(({name, likes, id}) => <li key={id}> <button onClick={ /* strip off first function layer to get a click handler bound to `id` and pass it to onClick */ makeClickHandler(id) } > {name} ({likes} likes) </button> </li> )} </ul> ); }; ReactDOM.render( <List />, document.querySelector("#root") ); button { font-family: monospace; font-size: 2em; } <script src="https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/6.26.0/babel.min.js"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/react/17.0.2/umd/react.production.min.js"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/17.0.2/umd/react-dom.production.min.js"></script> <div id="root"></div>

curry函数应用于多个参数列表，而不仅仅是 一个。

这是一个常规的、非咖喱的函数，它加了两个Int 参数x和y:

scala> def plainOldSum(x: Int, y: Int) = x + y
plainOldSum: (x: Int,y: Int)Int
scala> plainOldSum(1, 2)
res4: Int = 3

这是一个类似的咖喱函数。而不是 对于一个包含两个Int形参的列表，您将此函数应用于两个包含一个Int形参的列表 Int参数each:

scala> def curriedSum(x: Int)(y: Int) = x + y
curriedSum: (x: Int)(y: Int)Intscala> second(2)
res6: Int = 3
scala> curriedSum(1)(2)
res5: Int = 3

这里发生的事情是，当您调用curriedSum时，实际上会得到两个背对背的传统函数调用。第一个函数 调用接受一个名为x的Int形参，并返回一个函数 为第二个函数。第二个函数接受Int形参 y。

这里有一个名为first的函数，它在精神上完成了第一个传统函数 函数调用curriedSum会做:

scala> def first(x: Int) = (y: Int) => x + y
first: (x: Int)(Int) => Int

对第一个函数应用1——换句话说，调用第一个函数 而传入1 -会得到第二个函数:

scala> val second = first(1)
second: (Int) => Int = <function1>

对第二个函数应用2得到的结果是:

scala> second(2)
res6: Int = 3

Curry可以简化代码。这是使用它的主要原因之一。curry是将一个接受n个参数的函数转换为n个只接受一个参数的函数的过程。

其原理是传递传递函数的参数，使用closure(闭包)属性，将它们存储在另一个函数中并将其作为返回值，这些函数形成一个链，最后的参数被传递进来完成操作。

这样做的好处是可以通过一次处理一个参数来简化参数的处理，也可以提高程序的灵活性和可读性。这也使程序更易于管理。此外，将代码分割成更小的片段将使其易于重用。

例如:

function curryMinus(x) 
{
  return function(y) 
  {
    return x - y;
  }
}

var minus5 = curryMinus(1);
minus5(3);
minus5(5);

我还可以做…

var minus7 = curryMinus(7);
minus7(3);
minus7(5);

这对于使复杂的代码变得整洁和处理非同步方法等非常有用。

curry是一种可以应用于函数的转换，允许它们比以前少接受一个参数。

例如，在f#中你可以这样定义一个函数:-

let f x y z = x + y + z

这里函数f取参数x, y和z，并将它们相加:-

f 1 2 3

返回6。

根据我们的定义，我们可以定义f的curry函数:-

let curry f = fun x -> f x

其中'fun x - >fx '是一个lambda函数，在c#中等价于x => f(x)。此函数输入您希望curry的函数，并返回一个接受单个参数的函数，并返回指定的函数，其中第一个参数设置为输入参数。

使用前面的例子，我们可以得到f的curry值:-

let curryf = curry f

然后我们可以做以下的事情:-

let f1 = curryf 1

这为我们提供了一个函数f1，它等价于f1 y z = 1 + y + z。这意味着我们可以做以下事情

f1 2 3

返回6。

这个过程经常与“部分函数应用”相混淆，可以这样定义:-

let papply f x = f x

尽管我们可以将其扩展为多个参数，即:-

let papply2 f x y = f x y
let papply3 f x y z = f x y z
etc.

部分应用程序将接受函数和形参并返回一个需要一个或多个更少形参的函数，正如前面两个示例所示，它直接在标准f#函数定义中实现，因此我们可以通过以下方式实现前面的结果

let f1 = f 1
f1 2 3

它将返回一个6的结果。

结论:-

咖喱和部分函数应用的区别是:-

curry接受一个函数，并提供一个接受单个参数的新函数，并返回指定函数，并将其第一个参数设置为该参数。这允许我们将具有多个形参的函数表示为一系列单实参函数。例子:-

let f x y z = x + y + z
let curryf = curry f
let f1 = curryf 1
let f2 = curryf 2
f1 2 3
6
f2 1 3
6

偏函数应用更直接——它接受一个函数和一个或多个参数，并返回一个函数，其中前n个参数设置为指定的n个参数。例子:-

let f x y z = x + y + z
let f1 = f 1
let f2 = f 2
f1 2 3
6
f2 1 3
6