Scala的Pattern Matching Anonymous Functions

参考自http://stackoverflow.com/questions/19478244/how-does-a-case-anonymous-function-really-work-in-scala

http://www.scala-lang.org/files/archive/nightly/pdfs/ScalaReference.pdf

http://docs.scala-lang.org/overviews/core/futures.html

在第三篇文档《Futures and Promises》中，讲到了Future对象有三个方法可以注册callback

import scala.util.{Success, Failure}

val f: Future[List[String]] = future {
  session.getRecentPosts
}

f onComplete {
  case Success(posts) => for (post <- posts) println(post)
  case Failure(t) => println("An error has occured: " + t.getMessage)
}

f onFailure {
  case t => println("An error has occured: " + t.getMessage)
}

f onSuccess {
  case posts => for (post <- posts) println(post)
}

传给onComplete、onFailture和onSuccess的都是

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

形式的语句，但是这三个方法接受的参数类型却是不同的。

abstract def onComplete[U](f: (Try[T]) ⇒ U)(implicit executor: ExecutionContext): Unit

def onSuccess[U](pf: PartialFunction[T, U])(implicit executor: ExecutionContext): Unit

def onFailure[U](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Unit

onCompelete的参数类型的是一个 (Try[T]) => U函数， 而onSuccess和onFailure的参数类型是偏函数。

那么，问题来了……{ case p1 => b1 ... case pn => bn } 的类型到底是啥呢？

在<The Scala Language Specification>的第8.5章给出了说明：

An anonymous function can be defined by a sequence of cases

{case p₁ =>b₁ ...case p_n =>b_n }

which appear as an expression without a prior match.
The expected type of such an expression must in part be defined. It must be either scala.Functionk[S₁, ..., S_k, R] for some k >0, or scala.PartialFunction[S₁, R], where the argument type(s) S₁, ..., S_k must
be fully determined, but the result type R may be undetermined.

也就是说{ case p1 => b1 ... case pn => bn } 这种表达式的值的类型可以有两种，要不是一个函数，要不是一个偏函数（偏函数也是一种函数）。在这个表达式的位置上需要哪种类型，编译器就会用这个表达式生成对应的类型。但是无论是生成函数还是偏函数，它们的参数的类型都必须是确定的，对于一个特定的Future对象，onComplete接受的函数的参数类型是Try[T]，而onSuccess接受的PartialFunction的参数类型是T，onFailure接受的PartialFunction的参数类型是Throwable。但是这些函数的返回类型U可以不是需要这个{ case p1 => b1 ... case pn => bn } 表达式的地方指定的。比如，这三个onXXX方法都没有指定它所接受的函数的返回值类型。

例子：

import java.io.IOException

import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.Success
import scala.util.Failure

object CallbacksOfFuture extends App {

  def getRecentPosts = {
    Thread.sleep(5000)
    "Good morning" :: "Good afternoon" :: Nil
    throw new TimeoutException("Goodbye")
  }

  val f: Future[List[String]] = future {
    val posts = getRecentPosts
    posts
  }
  f onComplete {
    case Success(posts) => posts.foreach(println)
    case Failure(e) => println("An error has occured: " + e.getMessage)
  }

  f onComplete { result =>
    result match {
      case Success(posts) => posts.foreach(println)
      case Failure(e) => println("An error has occured: " + e.getMessage)
    }
  }

  //won‘t compile

//  f onComplete{
//    case 1 => 2
//  }

  f onSuccess {
    case posts => posts foreach println
  }

  f onFailure{
    case r: IOException => println("got IOException: " + r.getMessage)
    case r: TimeoutException => println("got TimeoutException: " + r.getMessage)
    case e => println("An error has occured: " + e.getMessage)
  }

  f flatMap{ posts => future{posts}} foreach(println)
  f map (posts => posts) foreach println

  Thread.sleep(10000)
}