Могу ли я использовать макросы Scala для интернализации внешнего DSL?

Прошло некоторое время с тех пор, как на этот вопрос был дан парадигматический ответ, но я только что наткнулся на него и подумал, что его стоит расширить.

Внутренний DSL действительно должен быть действительным кодом Scala со всеми именами, определенными до раскрытия макроса, однако можно преодолеть это ограничение с помощью тщательно разработанного синтаксиса и Dynamics.

Допустим, мы хотели создать простой и глупый DSL, позволяющий классно знакомить людей. Это могло бы выглядеть так:

people {
  introduce John please
  introduce Frank and Lilly please
}

Мы хотели бы перевести (как часть компиляции) приведенный выше код в объект (класса, производного, например, от класса People), содержащий определения полей типа Person для каждого представленного человека - примерно так:

new People {
    val john: Person = new Person("John")
    val frank: Person = new Person("Frank")
    val lilly: Person = new Person("Lilly")
}

Чтобы сделать это возможным, нам нужно определить некоторые искусственные объекты и классы, имеющие две цели: определение грамматики (отчасти ...) и обман компилятора, заставив его принимать неопределенные имена (например, John или Lilly).

import scala.language.dynamics

trait AllowedAfterName

object and extends Dynamic with AllowedAfterName {
  def applyDynamic(personName: String)(arg: AllowedAfterName): AllowedAfterName = this
}

object please extends AllowedAfterName

object introduce extends Dynamic {
  def applyDynamic(personName: String)(arg: AllowedAfterName): and.type = and
}

Эти фиктивные определения делают наш код DSL законным - компилятор переводит его в приведенный ниже код, прежде чем перейти к раскрытию макроса:

people {
    introduce.applyDynamic("John")(please)
    introduce.applyDynamic("Frank")(and).applyDynamic("Lilly")(please)
}

Нужен ли нам этот уродливый и, казалось бы, лишний please? Вероятно, можно было бы придумать более приятный синтаксис, например, используя нотацию постфиксного оператора Scala (language.postfixOps), но это становится сложно из-за вывода точки с запятой (вы можете попробовать это самостоятельно в консоли REPL или в Scala Worksheet IntelliJ). Проще всего просто чередовать ключевые слова с неопределенными именами.

Поскольку мы сделали синтаксис допустимым, мы можем обработать блок с помощью макроса:

def people[A](block: A): People = macro Macros.impl[A]

class Macros(val c: whitebox.Context) {
  import c.universe._

  def impl[A](block: c.Tree) = {
    val introductions = block.children

    def getNames(t: c.Tree): List[String] = t match {
      case q"applyDynamic($name)(and).$rest" =>
        name :: getNames(q"$rest")
      case q"applyDynamic($name)(please)" =>
        List(name)
    }

    val names = introductions flatMap getNames

    val defs = names map { n =>
      val varName = TermName(n.toLowerCase())
      q"val $varName: Person = new Person($n)"
    }

    c.Expr[People](q"new People { ..$defs }")
  }
}

Макрос находит все введенные имена путем сопоставления шаблонов с расширенными динамическими вызовами и генерирует желаемый выходной код. Обратите внимание, что макрос должен быть белым ящиком, чтобы иметь возможность возвращать выражение типа, производного от того, которое было объявлено в подписи.

Я так не думаю. Выражение, которое вы передаете макросу, должно быть допустимым выражением Scala, и должны быть определены идентификаторы.