a fast, functional PartialFunction implementation

runtime.AbstractPartialFunction provides a default implementation
for the new-style partial function. In principle this class is only
subclassed by compiler-generated partial functions arising from matches.

Either
 - the apply method (old-style partialfun) or
 - the applyOrElse method (current scheme)
must be overridden, and the isDefinedAt method implemented.
The applyOrElse method implementation is provided to ease the
transition from the old scheme, since starr still generates
old-style PartialFunctions, but locker's library has the
new AbstractPartialFunction.

Thus, this implementation is intended as a drop-in replacement for the
old partial function, and does not require changes to the compiler.
(compiler patches, both for old and new-style pattern matching, follow)

- runtime.AbstractPartialFunction is based on PartialFunction.WithDefault
Original version of FunctionWithDefault by Odersky
(http://article.gmane.org/gmane.comp.lang.scala.internals/4032)
- better performance for OrElse#applyOrElse, OrElse#lift, PF.cond
- new combinator methods: PF#run, PF#runWith, PF.apply

authored by @pavelpavlov, refactored by @adriaanm, review by @paulp

4 files changed, 11 insertions, 10 deletions

diff --git a/src/compiler/scala/tools/cmd/FromString.scala b/src/compiler/scala/tools/cmd/FromString.scala
index e4504702d4..3792c26c34 100644
--- a/src/compiler/scala/tools/cmd/FromString.scala
+++ b/src/compiler/scala/tools/cmd/FromString.scala
@@ -14,9 +14,9 @@ import scala.reflect.OptManifest
  *  example instances are in the companion object, but in general
  *  either IntFromString will suffice or you'll want custom transformers.
  */
-abstract class FromString[+T](implicit m: OptManifest[T]) extends scala.runtime.AbstractPartialFunction[String, T] {
+abstract class FromString[+T](implicit m: OptManifest[T]) extends PartialFunction[String, T] {
   def apply(s: String): T
-  def _isDefinedAt(s: String): Boolean = true
+  def isDefinedAt(s: String): Boolean = true
   def zero: T = apply("")
 
   def targetString: String = m.toString
@@ -30,20 +30,20 @@ object FromString {
   /** Path related stringifiers.
    */
   val ExistingFile: FromString[File] = new FromString[File] {
-    override def _isDefinedAt(s: String) = toFile(s).isFile
+    override def isDefinedAt(s: String) = toFile(s).isFile
     def apply(s: String): File =
       if (isDefinedAt(s)) toFile(s)
       else cmd.runAndExit(println("'%s' is not an existing file." format s))
   }
   val ExistingDir: FromString[Directory] = new FromString[Directory] {
-    override def _isDefinedAt(s: String) = toDir(s).isDirectory
+    override def isDefinedAt(s: String) = toDir(s).isDirectory
     def apply(s: String): Directory =
       if (isDefinedAt(s)) toDir(s)
       else cmd.runAndExit(println("'%s' is not an existing directory." format s))
   }
   def ExistingDirRelativeTo(root: Directory) = new FromString[Directory] {
     private def resolve(s: String) = toDir(s) toAbsoluteWithRoot root toDirectory
-    override def _isDefinedAt(s: String) = resolve(s).isDirectory
+    override def isDefinedAt(s: String) = resolve(s).isDirectory
     def apply(s: String): Directory =
       if (isDefinedAt(s)) resolve(s)
       else cmd.runAndExit(println("'%s' is not an existing directory." format resolve(s)))
@@ -65,7 +65,7 @@ object FromString {
   /** Implicit as the most likely to be useful as-is.
    */
   implicit val IntFromString: FromString[Int] = new FromString[Int] {
-    override def _isDefinedAt(s: String)  = safeToInt(s).isDefined
+    override def isDefinedAt(s: String)   = safeToInt(s).isDefined
     def apply(s: String)                  = safeToInt(s).get
     def safeToInt(s: String): Option[Int] = try Some(java.lang.Integer.parseInt(s)) catch { case _: NumberFormatException => None }
   }
diff --git a/src/compiler/scala/tools/nsc/interpreter/AbstractOrMissingHandler.scala b/src/compiler/scala/tools/nsc/interpreter/AbstractOrMissingHandler.scala
index 33ef4a432d..2f47685757 100644
--- a/src/compiler/scala/tools/nsc/interpreter/AbstractOrMissingHandler.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/AbstractOrMissingHandler.scala
@@ -6,8 +6,8 @@
 package scala.tools.nsc
 package interpreter
 
-class AbstractOrMissingHandler[T](onError: String => Unit, value: T) extends scala.runtime.AbstractPartialFunction[Throwable, T] {
-  def _isDefinedAt(t: Throwable) = t match {
+class AbstractOrMissingHandler[T](onError: String => Unit, value: T) extends PartialFunction[Throwable, T] {
+  def isDefinedAt(t: Throwable) = t match {
     case _: AbstractMethodError     => true
     case _: NoSuchMethodError       => true
     case _: MissingRequirementError => true
diff --git a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
index be5a9907b8..43aad9f591 100644
--- a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
+++ b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
@@ -425,7 +425,7 @@ trait ParallelMatching extends ast.TreeDSL
       // Should the given pattern join the expanded pivot in the success matrix? If so,
       // this partial function will be defined for the pattern, and the result of the apply
       // is the expanded sequence of new patterns.
-      lazy val successMatrixFn = new scala.runtime.AbstractPartialFunction[Pattern, List[Pattern]] {
+      lazy val successMatrixFn = new PartialFunction[Pattern, List[Pattern]] {
         private def seqIsDefinedAt(x: SequenceLikePattern) = (hasStar, x.hasStar) match {
           case (true, true)   => true
           case (true, false)  => pivotLen <= x.nonStarLength
@@ -433,7 +433,7 @@ trait ParallelMatching extends ast.TreeDSL
           case (false, false) => pivotLen == x.nonStarLength
         }
 
-        def _isDefinedAt(pat: Pattern) = pat match {
+        def isDefinedAt(pat: Pattern) = pat match {
           case x: SequenceLikePattern => seqIsDefinedAt(x)
           case WildcardPattern()      => true
           case _                      => false
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index e54e0289bb..0d39c040f7 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -210,6 +210,7 @@ abstract class UnCurry extends InfoTransform
      *    body = expr match { case P_i if G_i => E_i }_i=1..n
      *  to:
      *
+     //TODO: correct code template below
      *    class $anon() extends AbstractPartialFunction[T, R] with Serializable {
      *      def apply(x: T): R = (expr: @unchecked) match {
      *        case P_1 if G_1 => E_1