Scala的sealed关键字
缘起
今天在学习Akka的监控策咯过程中看到了下面一段代码：
def supervisorStrategy(): SupervisorStrategy = OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 10 seconds) {
case _: ArithmeticException => Resume
case _: IllegalArgumentException => Restart
case _: NullPointerException => Stop
case _: Exception => Escalate
}
当时有点好奇，就想去看看Resume, Restart等的实现，于是就看到了下面的代码：
object SupervisorStrategy extends SupervisorStrategyLowPriorityImplicits {
sealed trait Directive
/**
* Resumes message processing for the failed Actor
*/
case object Resume extends Directive
/**
* Discards the old Actor instance and replaces it with a new,
* then resumes message processing.
*/
case object Restart extends Directive
/**
* Stops the Actor
*/
case object Stop extends Directive
/**
* Escalates the failure to the supervisor of the supervisor,
* by rethrowing the cause of the failure.
*/
case object Escalate extends Directive
// ....
}
刚刚Scala不久，不太清楚这里的sealed关键字的作用，本文下面就详细的描述一下这个关键字的作用吧。
模式匹配
模式匹配pattern matching在scala里面是一个重量级的功能，依赖于模式匹配可以优雅地实现很多功能。大致格式如下：
selector match {
pattern1 => <body1>
pattern2 => <body2>
...
}
pattern总结起来大约以下几类：
- Wildcard patterns // _ 统配
- Constant patterns // 常量
- Variable patterns // 变量
- Constructor patterns // 构造函数
- Sequence patterns // 比如List(,). 如果需要匹配剩余的话使用List(0,_*)
- Tuple patterns // (a,b,c)
- Typed patterns // 使用类型匹配 case a:Map[,]
- asInstanceOf[]
- isInstanceOf[]
- note(dirlt):这里需要注意容器类型擦除.Array例外因为这个是java内置类型
实际上我们还能够使用pattern完成下面事情：
Patterns in variable definitions // val (a,b) = ("123","345");
-
Case sequences as partial functions
- 直接使用pattern来构造函数.以参数为match对象，在body里面直接编写case.
- Each case is an entry point to the function, and the parameters are specified with the pattern. The body of each entry point is the right-hand side of the case.
-
Patterns in for expressions // for ((country, city) <- capitals)
// case sequences as partial function.
val foo : Option[String] => String = {
case Some(e) => e
case None => "???"
} val a = Option[String]("hello")
println(foo(a))
val b = None
println(foo(b))
pattern matching过程中还有下面几个问题需要注意：
- Patterns are tried in the order in which they are written.
- Variable binding // 有时候我们希望匹配的变量包含外层结构
- A(1,B(x)) => handle(B(x))
- A(1, p @ B(_)) => handle(p) # p绑定了B(x)这个匹配
- A(1, p @ B()) => handle(p) # B是可以包含unapply从type(p) => Boolean的类，做条件判断
- Pattern guards // 有时候我们希望对pattern做一些限制性条件
- A(1,e,e) 比如希望后面两个元素相等，但是这个在pm里面没有办法表达
- A(1,x,y) if x == y => // 通过guard来完成
scala为了方便扩展模式匹配对象的case, 提供case class这个概念。case class和普通class大致相同，不过有以下三个区别，定义上只需要在class之前加上case即可：
提供factory method来方便构造object
class parameter隐含val prefix
-
自带toString,hashCode,equals实现
case class A(x:Int) {} // implicit val x:Int
val a = A(1); // factory method.
println(a.x);
println(a); // toString = A(1)
case class最大就是可以很方便地用来做pattern matching.
如果我们能够知道某个selector所有可能的pattern的话，那么就能够在编译期做一些安全性检查。但是selector这个过于宽泛，如果将selector限制在类层次上的话，那么还是可以实现的。举例如下：
abstract class A; // sealed abstract class A
case class B(a:Int) extends A;
case class C(a:Int) extends A;
case class D(a:Int) extends A;
val a:A = B(1);
a match {
case e @ B(_) => println(e)
case e @ C(_) => println(e)
}
在match a这个过程中，实际上我们可能存在B，C，D三种子类，但是因为我们这里缺少检查。使用sealed关键字可以完成这个工作。sealed class必须和subclass在同一个文件内。A sealed class cannot have any new subclasses added except the ones in the same file. 如果上面增加sealed的话，那么编译会出现如下警告，说明我们没有枚举所有可能的情况。
/Users/dirlt/scala/Hello.scala:8: warning: match may not be exhaustive.
It would fail on the following input: D(_)
a match {
^
one warning found
有三个方式可以解决这个问题，一个是加上对D的处理，一个是使用unchecked annotation, 一个则是在最后用wildcard匹配
(a : @unchecked) match {
case e @ B(_) => println(e)
case e @ C(_) => println(e)
}
a match {
case e @ B(_) => println(e)
case e @ C(_) => println(e)
case _ => throw new RuntimeException("??");
}
sealed
从上面的描述我们可以知道，sealed 关键字主要有2个作用：
- 其修饰的trait，class只能在当前文件里面被继承
- 用sealed修饰这样做的目的是告诉scala编译器在检查模式匹配的时候，让scala知道这些case的所有情况，scala就能够在编译的时候进行检查，看你写的代码是否有没有漏掉什么没case到，减少编程的错误。