Question

在

trait Expr
case class Number(n: Int) extends Expr
case class Sum(e1: Expr, e2: Expr) extends Expr

object CaseExample {
  def eval(e: Expr): Int = e match {
    case Number(n) => n
    case Sum(e1, e2) => eval(e1) + eval(e2)
  }
  def main(args: Array[String]) {
    println(eval(Sum(Number(1), Number(2))))       //> 3
  }
}

还有相当多的语法糖。我得到case隐含地创建了两个对象

object Number extends Expr {
  def apply(n: Int) = new Number(n)
}
object Sum extends Expr {
  def apply(e1: Expr, e2: Expr) = new Sum(e1, e2)
}

这就是为什么我们可以写例如Sum(...)仍然通过类实例化一个对象，因为Sum(...)也是Sum.apply(...)的语法糖。

我是对的，match构造也是语法糖吗？如果是的话，怎么样 - 例如case Number(n) - 由编译器重写？

我问，因为我没有看到n中的case Number(n)在任何地方定义和/或绑定到某个值。奇怪的是，在match构造中，第一个字母的情况很重要（如果它是大写的，它将是一个常数）。这很奇怪，因为据我所知，这仅仅是match相关的构造，所以我不知道如何去除它。

Answer 1

是的，match是语法糖。它会在您的对象上调用unapply方法。 Daniel Westheide有nice blog post about it。

具体来说，当您为case class定义Number时，这是编译器实际生成的内容：

case class Number(n: scala.Int) extends scala.AnyRef with Expr with scala.Product with scala.Serializable {
  val n: scala.Int = { /* compiled code */ }
  /* omitted for brevity */
}
object Number extends scala.runtime.AbstractFunction1[scala.Int, Number] with scala.Serializable {
  def this() = { /* compiled code */ }
  final override def toString(): java.lang.String = { /* compiled code */ }
  def apply(n: scala.Int): Number = { /* compiled code */ }
  def unapply(x$0: Number): scala.Option[scala.Int] = { /* compiled code */ }
}

如您所见，Number伴随对象附带编译器生成的unapply方法。

您可以找到Scala模式匹配工具here设计的详尽说明。

- 编辑 -

如果要查看编译器生成的实际代码，请运行scalac -print Number.scala。以下是相关内容：

<synthetic> object Number extends scala.runtime.AbstractFunction1 with Serializable {
  /* ... */
  case <synthetic> def unapply(x$0: Number): Option = if (x$0.==(null))
    scala.this.None
  else
    new Some(scala.Int.box(x$0.n()));
  /* ... */
}

如果你写了一个match表达式，你可以同样运行scalac -print来查看match本身是如何被贬低的（基本上是：if和else表达式）。

Scala`match`是否构造了语法糖？如果是这样，那怎么办？

1 个答案: