Scala 宏:使用 Scala 中的类的字段制作地图 [英] Scala Macros: Making a Map out of fields of a class in Scala
问题描述
假设我有很多类似的数据类.这是一个示例类 User，其定义如下:
Let's say that I have a lot of similar data classes. Here's an example class User which is defined as follows:
case class User (name: String, age: Int, posts: List[String]) {
val numPosts: Int = posts.length
...
def foo = "bar"
...
}
我对自动创建一个方法(在编译时)感兴趣，该方法返回一个 Map ，每个字段名称在调用时都映射到它的值在运行时.对于上面的示例，假设我的方法名为 toMap:
I am interested in automatically creating a method (at compile time) that returns a Map in a way that each field name is mapped to its value when it is called in runtime. For the example above, let's say that my method is called toMap:
val myUser = User("Foo", 25, List("Lorem", "Ipsum"))
myUser.toMap
应该返回
Map("name" -> "Foo", "age" -> 25, "posts" -> List("Lorem", "Ipsum"), "numPosts" -> 2)
你会如何用宏来做到这一点?
How would you do this with macros?
这是我所做的:首先，我创建了一个 Model 类作为我所有数据类的超类，并在其中实现了这样的方法:
Here's what I have done: First, I created a Model class as a superclass for all of my data classes and implemented the method in there like this:
abstract class Model {
def toMap[T]: Map[String, Any] = macro toMap_impl[T]
}
class User(...) extends Model {
...
}
然后我在一个单独的 Macros 对象中定义了一个宏实现:
Then I defined a macro implementation in a separate Macros object:
object Macros {
import scala.language.experimental.macros
import scala.reflect.macros.Context
def getMap_impl[T: c.WeakTypeTag](c: Context): c.Expr[Map[String, Any]] = {
import c.universe._
val tpe = weakTypeOf[T]
// Filter members that start with "value", which are val fields
val members = tpe.members.toList.filter(m => !m.isMethod && m.toString.startsWith("value"))
// Create ("fieldName", field) tuples to construct a map from field names to fields themselves
val tuples =
for {
m <- members
val fieldString = Literal(Constant(m.toString.replace("value ", "")))
val field = Ident(m)
} yield (fieldString, field)
val mappings = tuples.toMap
/* Parse the string version of the map [i.e. Map("posts" -> (posts), "age" -> (age), "name" -> (name))] to get the AST
* for the map, which is generated as:
*
* Apply(Ident(newTermName("Map")),
* List(
* Apply(Select(Literal(Constant("posts")), newTermName("$minus$greater")), List(Ident(newTermName("posts")))),
* Apply(Select(Literal(Constant("age")), newTermName("$minus$greater")), List(Ident(newTermName("age")))),
* Apply(Select(Literal(Constant("name")), newTermName("$minus$greater")), List(Ident(newTermName("name"))))
* )
* )
*
* which is equivalent to Map("posts".$minus$greater(posts), "age".$minus$greater(age), "name".$minus$greater(name))
*/
c.Expr[Map[String, Any]](c.parse(mappings.toString))
}
}
但是当我尝试编译它时，我从 sbt 得到这个错误:
Yet I get this error from sbt when I try to compile it:
[error] /Users/emre/workspace/DynamoReflection/core/src/main/scala/dynamo/Main.scala:9: not found: value posts
[error] foo.getMap[User]
[error] ^
Macros.scala 首先被编译.这是我的 Build.scala 的片段:
Macros.scala is being compiled first. Here is the snippet from my Build.scala:
lazy val root: Project = Project(
"root",
file("core"),
settings = buildSettings
) aggregate(macros, core)
lazy val macros: Project = Project(
"macros",
file("macros"),
settings = buildSettings ++ Seq(
libraryDependencies <+= (scalaVersion)("org.scala-lang" % "scala-reflect" % _))
)
lazy val core: Project = Project(
"core",
file("core"),
settings = buildSettings
) dependsOn(macros)
我做错了什么?我认为编译器在创建表达式时也会尝试评估字段标识符，但我不知道如何在表达式中正确返回它们.你能告诉我怎么做吗?
What am I doing wrong? I think that the compiler tries to evaluate the field identifiers too when it creates the expression, but I don't know how to return them properly in the expression. Could you show me how to do that?
非常感谢.
推荐答案
请注意，这可以在没有 toString/c.parse 业务的情况下更优雅地完成:
Note that this can be done much more elegantly without the toString / c.parse business:
import scala.language.experimental.macros
abstract class Model {
def toMap[T]: Map[String, Any] = macro Macros.toMap_impl[T]
}
object Macros {
import scala.reflect.macros.Context
def toMap_impl[T: c.WeakTypeTag](c: Context) = {
import c.universe._
val mapApply = Select(reify(Map).tree, newTermName("apply"))
val pairs = weakTypeOf[T].declarations.collect {
case m: MethodSymbol if m.isCaseAccessor =>
val name = c.literal(m.name.decoded)
val value = c.Expr(Select(c.resetAllAttrs(c.prefix.tree), m.name))
reify(name.splice -> value.splice).tree
}
c.Expr[Map[String, Any]](Apply(mapApply, pairs.toList))
}
}
另请注意，如果您希望能够编写以下内容，则需要 c.resetAllAttrs 位:
Note also that you need the c.resetAllAttrs bit if you want to be able to write the following:
User("a", 1, Nil).toMap[User]
如果没有它，在这种情况下你会得到一个令人困惑的 ClassCastException.
Without it you'll get a confusing ClassCastException in this situation.
顺便说一句，这是我用来避免额外类型参数的一个技巧，例如user.toMap[User] 写这样的宏时:
By the way, here's a trick that I've used to avoid the extra type parameter in e.g. user.toMap[User] when writing macros like this:
import scala.language.experimental.macros
trait Model
object Model {
implicit class Mappable[M <: Model](val model: M) extends AnyVal {
def asMap: Map[String, Any] = macro Macros.asMap_impl[M]
}
private object Macros {
import scala.reflect.macros.Context
def asMap_impl[T: c.WeakTypeTag](c: Context) = {
import c.universe._
val mapApply = Select(reify(Map).tree, newTermName("apply"))
val model = Select(c.prefix.tree, newTermName("model"))
val pairs = weakTypeOf[T].declarations.collect {
case m: MethodSymbol if m.isCaseAccessor =>
val name = c.literal(m.name.decoded)
val value = c.Expr(Select(model, m.name))
reify(name.splice -> value.splice).tree
}
c.Expr[Map[String, Any]](Apply(mapApply, pairs.toList))
}
}
}
现在我们可以写如下:
scala> println(User("a", 1, Nil).asMap)
Map(name -> a, age -> 1, posts -> List())
并且不需要指定我们正在谈论的是 User.
And don't need to specify that we're talking about a User.
这篇关于Scala 宏:使用 Scala 中的类的字段制作地图的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
