Question

我希望在Scala中设计一个具有最少语法可能性的DSL。它意味着由不了解Scala的用户使用，但可以利用Scala类型系统进行验证和错误检查。在我看来，DSL看起来像这样：

outer {
    inner(id = "asdf") {
        value("v1")
        value("v2")
    }
}

这个剪辑应该产生这样的值：

Outer(Inner("asdf", Value("v1") :: Value("v2") :: Nil))

给定数据结构

case class Outer(inner: Inner)
case class Inner(values: List[Value])
case class Value(value: String)

这个想法是inner函数仅在outer之后的闭包中可用，value函数仅在inner之后的闭包时可用，等等。以下内容不会编译：{{1}}。

我该如何实现这样的东西？最后，数据结构不需要是不可变的，只要它是强类型的，它就可以是任何东西。

我对Scala宏不熟悉，但是我可以用宏来解决这个问题吗？

我到目前为止最接近的是以下实现：

outer { value("1") }

如何摆脱匿名函数注释（即object DSL extends App { def outer = new Outer() class Outer(val values: mutable.MutableList[Inner] = mutable.MutableList.empty) { def inner(id: String): Inner = { val inner = new Inner(id) values += inner inner } def apply(func: Outer => Unit): Outer = { func(this) this } override def toString: String = s"Outer [${values.mkString(", ")}]" } class Inner(val id: String, val values: mutable.MutableList[Value] = mutable.MutableList.empty) { def value(v: String): Value = { val value = new Value(v) values += value value } def apply(func: Inner => Unit): Unit = func(this) override def toString: String = s"Inner (${values.mkString(", ")})" } class Value(val str: String) { override def toString: String = s"Value<$str>" } val value = outer { o => o.inner(id = "some_id") { i => i.value("value1") i.value("value2") } } println(value)和o =>等）？

或者有一种方法可以将o.视为outer（在这种情况下，以下代码块将被视为构造函数，我将能够调用成员函数）？

Answer 1

正如您所注意到的那样归结为

有没有办法将outer视为new Outer

不幸的是答案是否定的。我认为这在实验性的Scala-Virtualized fork中是可行的。就个人而言，我认为new关键字在Scala中也非常烦人。

我看到的解决方案只有两种。

使用宏或编译器插件
使用全局可变构建器对象

我知道有两个项目可以通过第一种方法为您完成这项工作：

我尝试过前者。我克隆了存储库并将scalaVersion中的project/build.scala更改为"2.11.6"（而不是快照）。您可以使用sbt sandbox/console进入REPL。

我们的想法是定义带有标记为@Implicit的参数的函数，这样你就可以“粘合”＃34; DSL树的外部和内部在一起：

import org.dslparadise.annotations._
import scala.collection.mutable.Builder

case class Outer(inner: Inner)
case class Inner(id: String, values: List[Value])
case class Value(value: String)

def outer(i: Inner) = Outer(i)  // nothing special here

def inner(id: String)
         (body: (Builder[Value, List[Value]] @Implicit) => Unit): Inner = {
  val b = List.newBuilder[Value]  // to "build" the contents of inner
  body(b)
  Inner(id, b.result)
}

def value(x: String)(implicit b: Builder[Value, List[Value]]): Value = {
  val v = Value(x)
  b += v   // side-effect: populate the builder
  v
}

示例：

scala> outer {
     |   inner(id = "asdf") {
     |     value("v1")
     |     value("v2")
     |   }
     | }
res1: Outer = Outer(Inner(asdf,List(Value(v1), Value(v2))))

瞧！

没有插件/宏的解决方案是设置例如ThreadLocal构建器，但是你没有编译时安全性：

val values = new ThreadLocal[Builder[Value, List[Value]]]

def inner(id: String)(body: => Unit): Inner = { 
  val prev = values.get()
  values.set(List.newBuilder[Value])
  body
  val v = values.get().result
  values.set(prev)
  Inner(id, v)
}

def value(x: String): Value = { 
  val v = Value(x)
  values.get() += v
  v
}

示例：

scala> inner(id = "asdf") { value("v1"); value("v2") }
res1: Inner = Inner(asdf,List(Value(v1), Value(v2)))

Scala - 用最少的语法设计DSL

1 个答案: