scala scala-macros shapeless scala-quasiquotes

scala - ¿Cómo usar Shapeless en un cuasiquote?



scala-macros scala-quasiquotes (1)

Estoy tratando de llamar a una macro sin forma desde dentro de una quasiquote con Scala y no obtengo lo que me gustaría obtener.

Mi macro no devuelve ningún error, pero no expande Witness(fieldName) en Witness.Lt[String]

val implicits = schema.fields.map { field => val fieldName:String = field.name val fieldType = TypeName(field.valueType.fullName) val in = TermName("implicitField"+fieldName) val tn = TermName(fieldName) val cc = TermName("cc") q"""implicit val $in = Field.apply[$className,$fieldType](Witness($fieldName), ($cc: $className) => $cc.$tn)""" }

Aquí está mi definición de Field :

sealed abstract class Field[CC, FieldName] { val fieldName: String type fieldType // How to extract this field def get(cc : CC) : fieldType } object Field { // fieldType is existencial in Field but parametric in Fied.Aux // used to explict constraints on fieldType type Aux[CC, FieldName, fieldType_] = Field[CC, FieldName] { type fieldType = fieldType_ } def apply[CC, fieldType_](fieldWitness : Witness.Lt[String], ext : CC => fieldType_) : Field.Aux[CC, fieldWitness.T, fieldType_] = new Field[CC, fieldWitness.T] { val fieldName : String = fieldWitness.value type fieldType = fieldType_ def get(cc : CC) : fieldType = ext(cc) } }

En este caso, el implícito que genero se ve así:

implicit val implicitFieldname : Field[MyCaseClass, fieldWitness.`type`#T]{ override type fieldType = java.lang.String }

Si se hubiera definido fuera de una quasiquote , generaría algo como:

implicit val implicitFieldname : Field.Aux[MyCaseClass, Witness.Lt[String]#T, String] = ...

¿Hay algo que se pueda hacer?


Esta es mi solución de trabajo usando anotaciones macro de estilo antiguo.

import scala.language.experimental.macros import scala.reflect.macros.blackbox.Context import scala.annotation.StaticAnnotation class fieldable extends StaticAnnotation { def macroTransform(annottees: Any*): Any = macro fieldableMacro.impl } object fieldableMacro { def impl(c: Context)(annottees: c.Expr[Any]*): c.Tree = { import c.universe._ annottees.map(_.tree) match { case (param @ q"case class $className(..$fields)") :: Nil => { val implicits = fields.collect { case field @ q"$mods val $tname: $tpt" => q""" implicit val $tname = Field.apply[$className,$tpt]( Witness(${tname.decodedName.toString}), _.$tname )""" }; q"$param; object ${className.toTermName} {..$implicits}" } } } }

Sin duda, se puede mejorar utilizando mejores cuasiquotes, pero mi objetivo era mostrar algo lo más limpio posible.

Se puede usar como:

@fieldable case class MyCaseClass(foo: String, bar: Int)

Esto produce un objeto complementario MyCaseClass que requiere Fields implícitos:

implicit val foo = Field.apply[MyCaseClass, String](Witness("foo"), ((x$1) => x$1.foo)); implicit val bar = Field.apply[MyCaseClass, Int](Witness("bar"), ((x$2) => x$2.bar));

Como ya se señaló, sin un ejemplo de trabajo completo, es bastante difícil escribir una respuesta exhaustiva.