在Scala中如何忽略匹配词？

Question

在Scala中，你可以做

list.filter { item => 
    item match { 
     case Some(foo) => foo.bar > 0 
    } 
} 

但是你也可以做到通过省略match更快的方式：

list.filter { 
    case Some(foo) => foo.bar > 0 
} 

这是如何支持Scala呢？这是2.9的新功能吗？我一直在寻找它，我可以弄清楚是什么让这成为可能。它只是Scala编译器的一部分吗？

Answer 1

language specification解决了8.5节中的问题。的相关部分：

匿名函数可德音响通过箱子

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

如果预期的类型是scala.Functionk[S1, ..., Sk, R]，表达被认为是 的序列定义为等价于匿名功能：

(x1 : S1, ..., xk : Sk) => (x1, ..., xk) match { 
    case p1 => b1 ... case pn => bn 
} 

如果预期的类型为scala.PartialFunction[S, R]，表达取为 等同于以下实例创建表达式：

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一个Function影响表达是如何编译。

也trait PartialFunction [-A, +B] extends (A) ⇒ B所以部分功能PartialFunction[A,B]也是Function[A,B]。

Answer 2

编辑：这个答案的一部分是错误的;请参阅huynhjl's answer。

---

如果省略match，则发信号通知要定义部分功能编译器。部分函数是没有为每个输入值定义的函数。例如，您的过滤器功能仅针对Some[A]类型的值（针对您的自定义类型A）进行定义。

PartialFunction当您尝试将它们应用到未定义的位置时，会抛出MatchError。因此，当你通过PartialFunction定义的常规Function时，你应该确保你的部分函数永远不会被调用。这种机制非常有用，例如在集合中拆包元组：

val tupleSeq: Seq[(Int, Int)] = // ... 
val sums = tupleSeq.map { case (i1, i2) => i1 + i2 } 

的API，其要求的部分功能，如在集合上collect过滤器般的操作，通常把部分功能之前调用isDefinedAt。在那里，它是安全的（并且经常需要）具有不是为每个输入值定义的部分功能。

所以你看到尽管语法接近于match的语法，但它实际上是我们正在处理的完全不同的事情。

Answer 3

- 修订后 -

嗯，我不知道我看到的差异，斯卡拉2.9.1.RC3，

val f: PartialFunction[Int, Int] = { case 2 => 3 } 
f.isDefinedAt(1) // evaluates to false 
f.isDefinedAt(2) // evaluates to true 
f(1) // match error 

val g: PartialFunction[Int, Int] = x => x match { case 2 => 3 } 
g.isDefinedAt(1) // evaluates to false 
g.isDefinedAt(2) // evaluates to true 
g(1) // match error 

看来f和g行为都一模一样与PartialFunctions相同。

这里是另一个例子展示了等价：更有意思的

Seq(1, "a").collect(x => x match { case s: String => s }) // evaluates to Seq(a) 

：

// this compiles 
val g: PartialFunction[Int, Int] = (x: Int) => {x match { case 2 => 3 }} 

// this fails; found Function[Int, Int], required PartialFunction[Int, Int] 
val g: PartialFunction[Int, Int] = (x: Int) => {(); x match { case 2 => 3 }} 

所以这是在编译器级别的一些特殊套管x => x match {...}，只是{...}之间的转换。

更新。在阅读语言规范后，这对我来说似乎是一个错误。我在错误跟踪器中提交了SI-4940。