85

在 Scala 中，可以编写（咖喱？）这样的函数

def curriedFunc(arg1: Int) (arg2: String) = { ... }

curriedFunc上述带有两个参数列表的函数定义与在单个参数列表中带有多个参数的函数有什么区别：

def curriedFunc(arg1: Int, arg2: String) = { ... }

从数学的角度来看，这是(curriedFunc(x))(y)，curriedFunc(x,y)但我可以写def sum(x) (y) = x + y，同样会是def sum2(x, y) = x + y

我只知道一个区别 - 这是部分应用的功能。但两种方式对我来说都是等价的。

还有其他区别吗？

4

4 回答 4

88

严格来说，这不是一个柯里化函数，而是一个具有多个参数列表的方法，尽管不可否认它看起来像一个函数。

正如您所说，多个参数列表允许使用该方法代替部分应用的函数。（对不起，我使用的一般愚蠢的例子）

object NonCurr {
  def tabulate[A](n: Int, fun: Int => A) = IndexedSeq.tabulate(n)(fun)
}

NonCurr.tabulate[Double](10, _)            // not possible
val x = IndexedSeq.tabulate[Double](10) _  // possible. x is Function1 now
x(math.exp(_))                             // complete the application

另一个好处是，如果第二个参数列表由单个函数或 thunk 组成，您可以使用花括号代替括号，这看起来不错。例如

NonCurr.tabulate(10, { i => val j = util.Random.nextInt(i + 1); i - i % 2 })

相对

IndexedSeq.tabulate(10) { i =>
  val j = util.Random.nextInt(i + 1)
  i - i % 2
}

或者对于重击：

IndexedSeq.fill(10) {
  println("debug: operating the random number generator")
  util.Random.nextInt(99)
}

另一个优点是，您可以参考先前参数列表的参数来定义默认参数值（尽管您也可以说在单个列表中不能这样做是一个缺点：）

// again I'm not very creative with the example, so forgive me
def doSomething(f: java.io.File)(modDate: Long = f.lastModified) = ???

最后，在相关帖子的回答中还有其他三个应用程序为什么 Scala 同时提供多个参数列表和每个列表的多个参数？. 我将在这里复制它们，但功劳归于 Knut Arne Vedaa、Kevin Wright 和即兴的。

第一：你可以有多个 var args：

def foo(as: Int*)(bs: Int*)(cs: Int*) = as.sum * bs.sum * cs.sum

...这在单个参数列表中是不可能的。

其次，它有助于类型推断：

def foo[T](a: T, b: T)(op: (T,T) => T) = op(a, b)
foo(1, 2){_ + _}   // compiler can infer the type of the op function

def foo2[T](a: T, b: T, op: (T,T) => T) = op(a, b)
foo2(1, 2, _ + _)  // compiler too stupid, unfortunately

最后，这是拥有隐式和非隐式参数的唯一方法，implicit整个参数列表的修饰符也是如此：

def gaga [A](x: A)(implicit mf: Manifest[A]) = ???   // ok
def gaga2[A](x: A, implicit mf: Manifest[A]) = ???   // not possible
于 2011-07-23T23:21:14.203 回答
42

0__ 的出色答案没有涵盖另一个差异：默认参数。当计算另一个参数列表中的默认值时，可以使用一个参数列表中的参数，但不能在同一个参数列表中使用。

例如：

def f(x: Int, y: Int = x * 2) = x + y // not valid
def g(x: Int)(y: Int = x * 2) = x + y // valid
于 2011-07-26T02:57:22.027 回答
20

这就是重点，咖喱和非咖喱形式是等价的！正如其他人所指出的那样，根据情况，使用一种或另一种形式在语法上更方便，这是首选其中一种形式的唯一原因。

重要的是要理解，即使 Scala 没有用于声明柯里化函数的特殊语法，您仍然可以构造它们；一旦您有能力创建返回函数的函数，这只是数学上的必然性。

为了证明这一点，假设def foo(a)(b)(c) = {...}语法不存在。然后你仍然可以像这样实现完全相同的事情：def foo(a) = (b) => (c) => {...}.

就像 Scala 中的许多特性一样，这只是一种语法上的便利，可以做一些无论如何都是可能的事情，但稍微冗长一些。

于 2011-07-23T23:18:36.400 回答
4

这两种形式是同构的。主要区别在于柯里化函数更容易部分应用，而非柯里化函数的语法稍好一些，至少在 Scala 中是这样。

于 2011-07-23T20:55:54.910 回答