什么是 scala 的实验性虚拟模式匹配器？

Question

我见过不少 一些 提及最近出现了 scala 的新“虚拟化”模式匹配器。我错过了解释它实际上是什么的备忘录......

Answer 1

“虚拟化”模式匹配器是现有匹配器的重写。这样做的动机是支持多态嵌入式 DSL 模式匹配的虚拟化，与 2.10 无关。

正如 Iulian 在下面的评论中所说：它与 for 推导式的编译方式非常相似：它们不是直接生成代码，而是翻译为 foreach、map、 filter 等。然后，模式匹配可以转换为一系列方法调用，DSL 可以覆盖这些方法调用。默认实现将尊重当前语义，挑战是使其与当前语义一样高效。看来阿德里安已经非常接近这个目标了。 “虚拟化”实现更简单，并且修复了当前实现中的几个错误。

“多态嵌入式 DSL”是一种想法，即人们可以用 scala 编写不应该在 JVM 上运行的程序。也就是说，scalac 将产生一个描述程序正在执行的操作的输出。然后可以针对特定架构重新编译。这些事情已经在 ScalaDays 2011 上讨论过。

这个重写最终将成为标准的 scala 模式匹配器。旧的模式匹配器（据我所知）无法维护。

Answer 2

可悲的是，（唯一）现有的答案缺乏有趣的内容，而且评论上的链接也被破坏了。因此，让我尝试在这里添加一些内容，如果没有其他原因，当我真正决定将来用它做某事时，我自己的参考，因为这个答案位于我所做的每次谷歌搜索的顶部。

如前所述，虚拟化模式匹配器重写了 Scala 编译器处理模式匹配的方式。它有很多用途，其中的“虚拟化”部分意味着它是虚拟化 scala 工作的一部分。这种努力与宏有点相反：它需要在编译时“运行”的东西，然后移动到运行时。

例如，考虑到作用域中存在正确的定义，像这样的语句：

if (false) 1 else 2

而不是被编译为字节码分支和文字，甚至优化为文字“2”，实际上被编译为以下语句：

__ifThenElse(false, 1, 2)

请参阅< a href="https://github.com/TiarkRompf/scala-virtualized/wiki" rel="noreferrer">scala 虚拟化 wiki 了解更多信息和一些有用的示例。

然而，我说过，模式匹配器重写有很多用途。另一个非常重要的目标是将意大利面条式代码（即旧的模式匹配器）（完整或特殊以及极端情况和错误）转变为可以更轻松地推理、扩展和改进的代码。这次重写解决了如此多的问题，以至于人们只需浏览问题列表，运行与模式匹配器相关的问题的示例代码，并将问题标记为“已修复”。它确实有自己的新错误，但规模要小得多。

现在，关于新模式匹配器如何工作的信息很少，但基本上，它会转换为一些方法调用，这些方法调用在编译器中使用 Option monad“实现”。然后进入优化阶段，生成最佳字节码。

可以引入您自己的匹配器，尽管它被锁定在 -Xexperimental 标志后面。尝试使用从 Scala 的测试套件复制的以下代码（带或不带该标志）：

trait Intf {
 type Rep[+T]
 type M[+T] = Rep[Maybe[T]]

 val __match: Matcher
 abstract class Matcher {
   // runs the matcher on the given input
   def runOrElse[T, U](in: Rep[T])(matcher: Rep[T] => M[U]): Rep[U]

   def zero: M[Nothing]
   def one[T](x: Rep[T]): M[T]
   def guard[T](cond: Rep[Boolean], then: => Rep[T]): M[T]
   def isSuccess[T, U](x: Rep[T])(f: Rep[T] => M[U]): Rep[Boolean] // used for isDefinedAt
 }

 abstract class Maybe[+A] {
   def flatMap[B](f: Rep[A] => M[B]): M[B]
   def orElse[B >: A](alternative: => M[B]): M[B]
 }

 implicit def proxyMaybe[A](m: M[A]): Maybe[A]
 implicit def repInt(x: Int): Rep[Int]
 implicit def repBoolean(x: Boolean): Rep[Boolean]
 implicit def repString(x: String): Rep[String]

 def test = 7 match { case 5 => "foo" case _ => "bar" }
}

trait Impl extends Intf {
 type Rep[+T] = String

 object __match extends Matcher {
   def runOrElse[T, U](in: Rep[T])(matcher: Rep[T] => M[U]): Rep[U] = ("runOrElse("+ in +", ?" + matcher("?") + ")")
   def zero: M[Nothing]                                             = "zero"
   def one[T](x: Rep[T]): M[T]                                      = "one("+x.toString+")"
   def guard[T](cond: Rep[Boolean], then: => Rep[T]): M[T]          = "guard("+cond+","+then+")"
   def isSuccess[T, U](x: Rep[T])(f: Rep[T] => M[U]): Rep[Boolean]  = ("isSuccess("+x+", ?" + f("?") + ")")
 }

 implicit def proxyMaybe[A](m: M[A]): Maybe[A] = new Maybe[A] {
   def flatMap[B](f: Rep[A] => M[B]): M[B]                          = m + ".flatMap(? =>"+ f("?") +")"
   def orElse[B >: A](alternative: => M[B]): M[B]                   = m + ".orElse("+ alternative +")"
 }

 def repInt(x: Int): Rep[Int] = x.toString
 def repBoolean(x: Boolean): Rep[Boolean] = x.toString
 def repString(x: String): Rep[String] = x
}

object Test extends Impl with Intf with App {
  println(test)
}

不带标志的结果正是您所期望的：

scala> Test.main(null)
bar

但是，使用 -Xexperimental 时，会得到替代的匹配“engine”已编译：

scala> Test.main(null)
runOrElse(7, ?guard(false,?).flatMap(? =>one(foo)).orElse(one(bar)))

有关更多信息，另请参阅 PatternMatching 和 MatchMonad 接口。

免责声明：以上是从 2.10.0 之后的 master 分支上的 Scala 版本中提取并运行的，因此可能存在差异。但遗憾的是，我发现自己缺少一个纯粹的 2.10.0 或 2.10.1 环境来测试它。