首页 > 代码库 > Scala的Pattern Matching Anonymous Functions
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 p1 =>b1 ...case pn =>bn }
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[S1, ..., Sk, R] for some k >0, or scala.PartialFunction[S1, R], where the argument type(s) S1, ..., Sk mustbe 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.IOExceptionimport scala.concurrent._import scala.concurrent.ExecutionContext.Implicits.globalimport scala.util.Successimport scala.util.Failureobject 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)}
Scala的Pattern Matching Anonymous Functions