匿名函数和部分函数有什么区别？

Question

我正在阅读有关 Scala 匿名函数的内容 here 并看到它们可以采用以下格式：

{ case p1 => b1 … case pn => bn }

但是，我认为偏函数就是这样写的。事实上，在this blog post中，作者将部分函数称为匿名函数。起初他说 collect 采用部分函数，但随后似乎将其称为匿名函数（“collect 可以处理你的匿名函数......”）。

难道只是有些匿名函数是偏函数？如果是这样，所有部分函数都是匿名的吗？或者他们只是匿名的，如果格式像 Alvin Alexander 的例子：

val divide2: PartialFunction[Int, Int] = {
    case d: Int if d != 0 => 42 / d
}

Answer 1

这是编写模式匹配部分函数的另一种方法。

val divide = new PartialFunction[Int, Int] {
    def apply(x: Int) = 42 / x
    def isDefinedAt(x: Int) = x != 0
}

本质上，部分函数是未针对一组输入定义的函数。可能就像示例中一样，除以 0 没有意义，或者您可能希望限制某些特定值。

部分函数的妙处在于它与 orElse、andThen 和 collect 具有协同作用。根据您是否在 divide 函数中输入 0，您的变量可以传递给 andThen 如果它不是 0，则可以通过 orElse 如果它是 0。最后，collect 将只应用您的部分如果在该输入上定义了函数。

创建部分函数的方式通常是通过与示例中所示的大小写匹配的模式。

最后，Scala 中的匿名函数就像 Python 中的 lambda。这只是一种无需“命名”即可创建函数的方法。

例如

val f: Int => Int = (x: Int) => x * x
collect {
    case a: Int => 1-a
}

Answer 2

匿名和部分是不同的概念。我们不会说下面的函数是匿名的

val divide2: PartialFunction[Int, Int] = {
    case d: Int if d != 0 => 42 / d
}

因为它绑定到名称 divide2，但是我们可以说 divide2 是根据匿名（函数）值

定义的

{ case d: Int if d != 0 => 42 / d }

同义x在下面的定义

中根据匿名值42来定义

val x: Int = 42

部分的正交概念是指函数的特殊子类型，而不是特定类型的值是否绑定到名称。

Answer 3

来自您链接的关于模式匹配匿名函数的文档：

If the expected type is SAM-convertible to scala.Functionk[S1,…,Sk, R], the expression is taken to be equivalent to the anonymous function:
(x1:S1,…,xk:Sk) => (x1,…,xk) match {   
    case p1 => b1 … case pn => bn 
}
Here, each xi is a fresh name. As was shown here, this anonymous function is in turn equivalent to the following instance creation expression, where T is the weak least upper bound of the types of all bi.
new scala.Functionk[S1,…,Sk, T] {   
  def apply(x1:S1,…,xk:Sk): T = (x1,…,xk) match {
    case p1 => b1 … 
    case pn => bn   
  } 
} 
If the expected type is scala.PartialFunction[S, R], the expression is taken to be equivalent to the following instance creation expression:
new scala.PartialFunction[S, T] {   
  def apply(x: S): T = x match {
    case p1 => b1 … case pn => bn   
  }   
  def isDefinedAt(x: S): Boolean = {
    case p1 => true … case pn => true
    case _ => false   
  } 
}

您的第一个代码片段是模式匹配匿名函数，但不一定是偏函数。如果将它提供给具有 PartialFunction 参数的方法或分配给类型为 PartialFunction 的变量，它只会变成 PartialFunction。

所以你是对的，只有一些（模式匹配）匿名函数是部分函数（AFAIK，用粗箭头定义的函数文字，例如 x => x，只能用于创建 FunctionN 个实例，而不是 PartialFunction 个实例）。

然而，并非所有偏函数都是匿名函数。 sugar-free 定义 PartialFunction 的方法是扩展 PartialFunction 特征（扩展 Function1）并手动覆盖 isDefinedAt 和 apply 方法。例如，divide2 也可以这样定义，使用匿名 class:

val divide2 = new PartialFunction[Int, Int] {
  override def isDefinedAt(x: Int) = x != 0
  override def apply(x: Int) = 42 / x
}

不过，您可能不会经常看到这种情况，因为仅使用模式匹配来定义 PartialFunction 会容易得多。

在您链接的 Alvin Alexander 的博客 post 中，作者将模式匹配匿名部分函数文字称为匿名函数只是因为它恰好是部分函数和一个匿名函数。您也可以像这样定义函数：


List(42, "cat").collect(new PartialFunction[Any, Int] {
  def isDefinedAt(x: Any) = x.isInstanceOf[Int]
  def apply(x: Any) = x match {
    case i: Int => i + 1
  }
})

它不再是匿名函数，尽管它仍然是匿名对象，是匿名 class 的实例。或者您可以预先定义一个单例对象，然后使用它。

object Foo extends PartialFunction[Any, Int] {
  def isDefinedAt(x: Any) = x.isInstanceOf[Int]
  def apply(x: Any) = x match {
    case i: Int => i + 1
  }
}
List(42, "cat").collect(Foo)

不管怎么定义，它都是偏函数。

匿名函数和部分函数有什么区别？

What is the difference between anonymous functions and partial functions?

scala

anonymous-function

partialfunction