12

ケースクラスのインスタンスを引数として取るScalaマクロをプログラムしたいと思います。マクロに渡すことができるすべてのオブジェクトは、特定のマーカー特性を実装する必要があります。

次のスニペットは、マーカー特性とそれを実装する2つのケースクラスの例を示しています。

trait Domain
case class Country( id: String, name: String ) extends Domain
case class Town( id: String, longitude: Double, latitude: Double ) extends Domain

ここで、実行時の反映の重さとそのスレッドの安全性を回避するために、マクロを使用して次のコードを記述したいと思います。

object Test extends App {

  // instantiate example domain object
  val myCountry = Country( "CH", "Switzerland" )

  // this is a macro call
  logDomain( myCountry )
}

マクロlogDomainは別のプロジェクトに実装されており、次のようになります。

object Macros {
  def logDomain( domain: Domain ): Unit = macro logDomainMacroImpl

  def logDomainMacroImpl( c: Context )( domain: c.Expr[Domain] ): c.Expr[Unit] = {
    // Here I would like to introspect the argument object but do not know how?
    // I would like to generate code that prints out all val's with their values
  }
}

マクロの目的は、実行時に、指定されたオブジェクトのすべての値（idおよび）を出力し、次に示すようにそれらを出力するコードを生成することです。name

id (String) : CH
name (String) : Switzerland

これを実現するには、渡された型引数を動的に検査し、そのメンバー（vals）を決定する必要があります。次に、ログ出力を作成するコードを表すASTを生成する必要があります。マクロは、マーカー特性「ドメイン」を実装する特定のオブジェクトがマクロに渡されるかどうかに関係なく機能する必要があります。

この時点で私は迷子になっています。誰かが私に出発点を教えてくれたり、いくつかのドキュメントを教えてくれたら幸いです。私はScalaに比較的慣れていないので、ScalaAPIドキュメントまたはマクロガイドで解決策を見つけられませんでした。

4

2 に答える 2

14

ケースクラスのアクセサーを一覧表示することは、マクロを操作しているときに非常に一般的な操作であるため、次のようなメソッドを保持する傾向があります。

def accessors[A: u.WeakTypeTag](u: scala.reflect.api.Universe) = {
  import u._

  u.weakTypeOf[A].declarations.collect {
    case acc: MethodSymbol if acc.isCaseAccessor => acc
  }.toList
}

これにより、のすべてのケースクラスアクセサーメソッドシンボルが提供されますA（存在する場合）。ここでは一般的なリフレクションAPIを使用していることに注意してください。これをマクロ固有にする必要はまだありません。

このメソッドを他の便利なものでまとめることができます。

trait ReflectionUtils {
  import scala.reflect.api.Universe

  def accessors[A: u.WeakTypeTag](u: Universe) = {
    import u._

    u.weakTypeOf[A].declarations.collect {
      case acc: MethodSymbol if acc.isCaseAccessor => acc
    }.toList
  }

  def printfTree(u: Universe)(format: String, trees: u.Tree*) = {
    import u._

    Apply(
      Select(reify(Predef).tree, "printf"),
      Literal(Constant(format)) :: trees.toList
    )
  }
}

そして今、私たちは実際のマクロコードをかなり簡潔に書くことができます：

trait Domain

object Macros extends ReflectionUtils {
  import scala.language.experimental.macros
  import scala.reflect.macros.Context

  def log[D <: Domain](domain: D): Unit = macro log_impl[D]
  def log_impl[D <: Domain: c.WeakTypeTag](c: Context)(domain: c.Expr[D]) = {
    import c.universe._

    if (!weakTypeOf[D].typeSymbol.asClass.isCaseClass) c.abort(
      c.enclosingPosition,
      "Need something typed as a case class!"
    ) else c.Expr(
      Block(
        accessors[D](c.universe).map(acc =>
          printfTree(c.universe)(
            "%s (%s) : %%s\n".format(
              acc.name.decoded,
              acc.typeSignature.typeSymbol.name.decoded
            ),
            Select(domain.tree.duplicate, acc.name)
          )
        ),
        c.literalUnit.tree
      )
    )
  }
}

処理している特定のケースクラスタイプを追跡する必要があることに注意してください。ただし、型推論は呼び出しサイトでそれを処理します。typeパラメータを明示的に指定する必要はありません。

これで、REPLを開き、ケースクラス定義を貼り付けて、次のように記述できます。

scala> Macros.log(Town("Washington, D.C.", 38.89, 77.03))
id (String) : Washington, D.C.
longitude (Double) : 38.89
latitude (Double) : 77.03

または：

scala> Macros.log(Country("CH", "Switzerland"))
id (String) : CH
name (String) : Switzerland

望んだ通りに。

于 2013-01-14T22:44:53.060 に答える
7

私が見ることができることから、2つの問題を解決する必要があります：1）マクロ引数から必要な情報を取得します。2）必要なコードを表すツリーを生成します。

Scala 2.10では、これらのことはリフレクションAPIを使用して行われます。フォローScala2.10のリフレクションAPIに関するチュートリアルはまだありますか？利用可能なドキュメントを確認します。

import scala.reflect.macros.Context
import language.experimental.macros

trait Domain
case class Country(id: String, name: String) extends Domain
case class Town(id: String, longitude: Double, latitude: Double) extends Domain

object Macros {
  def logDomain(domain: Domain): Unit = macro logDomainMacroImpl

  def logDomainMacroImpl(c: Context)(domain: c.Expr[Domain]): c.Expr[Unit] = {
    import c.universe._

    // problem 1: getting the list of all declared vals and their types
    //   * declarations return declared, but not inherited members
    //   * collect filters out non-methods
    //   * isCaseAccessor only leaves accessors of case class vals
    //   * typeSignature is how you get types of members
    //     (for generic members you might need to use typeSignatureIn)
    val vals = typeOf[Country].declarations.toList.collect{ case sym if sym.isMethod => sym.asMethod }.filter(_.isCaseAccessor)
    val types = vals map (_.typeSignature)

    // problem 2: generating the code which would print:
    // id (String) : CH
    // name (String) : Switzerland
    //
    // usually reify is of limited usefulness
    // (see https://stackoverflow.com/questions/13795490/how-to-use-type-calculated-in-scala-macro-in-a-reify-clause)
    // but here it's perfectly suitable
    // a subtle detail: `domain` will be possibly used multiple times
    // therefore we need to duplicate it
    val stmts = vals.map(v => c.universe.reify(println(
      c.literal(v.name.toString).splice +
      "(" + c.literal(v.returnType.toString).splice + ")" +
      " : " + c.Expr[Any](Select(domain.tree.duplicate, v)).splice)).tree)

    c.Expr[Unit](Block(stmts, Literal(Constant(()))))
  }
}
于 2013-01-14T22:49:28.950 に答える