Scala提取器unapply调用了两次

Question

我刚刚发现由于某种原因，我的提取器中的unapply被调用了两次。有人知道为什么，以及如何避免吗？

val data = List("a","b","c","d","e")

object Uap {
  def unapply( s:String ) = {
    println("S: "+s)
    Some(s+"!")
  }             
}

println( data.collect{ case Uap(x) => x } )

这将产生输出：

S: a
S: a
S: b
S: b
S: c
S: c
S: d
S: d
S: e
S: e
List(a!, b!, c!, d!, e!)

最终的结果是好的，但在我的实际程序中，unapply不是微不足道的，所以我当然不想调用它两次！

Answer 1

collect接受PartialFunction作为输入。PartialFunction定义了两个关键成员：isDefinedAt和apply。当apply运行你的函数时，它会运行一次提取器，以确定你的函数是否收集了一些特定的输入，如果是，它就会作为collect的一部分再次运行提取器来提取值。

如果有一种简单的方法可以正确地实现isDefinedAt，那么您可以通过显式地实现自己的PartialFunction来实现它，而不是使用case语法。或者您可以在集合上执行filter，然后使用map函数(这实际上就是collect通过调用isDefinedAt，然后调用apply)所做的事情。

另一种选择是将分部函数转换为lift函数。PartialFunction定义了lift，它将PartialFunction[A,B]转换为A=>Option[B]。您可以使用这个提升的函数(称为fun)来执行以下操作：data.map(fun).collect { case Some(x) => x }

Answer 2

实际上，这在2.11中作为一个性能错误得到了解决：

$ skala
Welcome to Scala version 2.11.0-20130423-194141-5ec9dbd6a9 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_06).
Type in expressions to have them evaluated.
Type :help for more information.

scala> val data = List("a","b","c","d","e")
data: List[String] = List(a, b, c, d, e)

scala> 

scala> object Uap {
     |   def unapply( s:String ) = {
     |     println("S: "+s)
     |     Some(s+"!")
     |   }             
     | }
defined object Uap

scala> 

scala> println( data.collect{ case Uap(x) => x } )
S: a
S: b
S: c
S: d
S: e
List(a!, b!, c!, d!, e!)

请参阅applyOrElse上的效率说明。

这是2.10的一个版本，这个问题很容易通过扩展来解决：

object Test extends App {
  import scala.collection.TraversableLike
  import scala.collection.generic.CanBuildFrom
  import scala.collection.immutable.StringLike

  implicit class Collector[A, Repr, C <: TraversableLike[A, Repr]](val c: C) extends AnyVal {
    def collecting[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
      val b = bf(c.repr)
      c.foreach(pf.runWith(b += _))
      b.result
    }
  }

  val data = List("a","b","c","d","e")

  object Uap {
    def unapply( s:String ) = {
      println("S: "+s)
      s match {
        case "foo" => None
        case _     => Some(s+"!")
      }
    }
  }
  val c = Collector[String, List[String], List[String]](data)
  Console println c.collecting { case Uap(x) => x }
}

结果：

$ scalac -version
Scala compiler version 2.10.1 -- Copyright 2002-2013, LAMP/EPFL

apm@halyard ~/tmp
$ scalac applyorelse.scala ; scala applyorelse.Test
S: a
S: b
S: c
S: d
S: e
List(a!, b!, c!, d!, e!)

请注意，此版本的Uap是局部的：

scala> val data = List("a","b","c","d","e", "foo")
data: List[String] = List(a, b, c, d, e, foo)

scala> data.map{ case Uap(x) => x }
S: a
S: b
S: c
S: d
S: e
S: foo
scala.MatchError: foo (of class java.lang.String)

我认为如果用例是PF，那么代码应该是部分的。

Answer 3

除了@stew之外，collect还实现为：

def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
val b = bf(repr)
for (x <- this) if (pf.isDefinedAt(x)) b += pf(x)
b.result
}

它使用pf.isDefinedAt(x)。执行scalac -Xprint:typer check.scala (check.scala包含您的代码)。它打印：

....
final def isDefinedAt(x1: String): Boolean = ((x1.asInstanceOf[String]:String): String @unchecked) match {
      case check.this.Uap.unapply(<unapply-selector>) <unapply> ((x @ _)) => true
      case (defaultCase$ @ _) => false
    }

如你所见，它在这里再次调用unapply。这就解释了为什么它会打印两次，即一次检查是否定义了它，然后在` `pf(x)中已经调用它时再打印一次。

@som snytt是对的。从Scala2.11开始，TraversableLike中的collect函数更改为：

def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
val b = bf(repr)
foreach(pf.runWith(b += _))
b.result
}

它只打印一次的原因是，在内部，它调用applyOrElse来检查是否定义了它。如果是，则应用函数本身(在上面的例子中为(b += _))。因此，它只打印一次。