¿Cómo usar Shapeless en un cuasiquote?

Estoy tratando de llamar a una Shapelessmacro desde dentro de un quasiquotecon Scalay no obtengo lo que me gustaría obtener.

Mi macro no devuelve ningún error pero no se expande Witness(fieldName)enWitness.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 Fielddefinición:

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 un quasiquote, generaría algo como:

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

¿Hay algo que se pueda hacer?

scala scala-macros shapeless scala-quasiquotes Roch
fuente

¿Estás usando esto en una macro anotación? ¿Has intentado proporcionar una anotación de tipo para $in(que creo que requerirá usar ConstantType)?

Travis Brown

@TravisBrown sí, estoy construyendo esto usando una macro anotación (Macro Paradise). He intentado proporcionar un tipo como este:

q"""implicit val $in : Field.Aux[$className, Witness.Lt[String]#T, String]  = Field.apply[$className,$fieldType](Witness($fieldName), ($cc:   $className) => $cc.$tn)"""

Roch

Sin embargo, necesitará el nombre de campo específico en la anotación de tipo (consulte, por ejemplo, mi antigua publicación de blog anterior a Shapeless 2.0 aquí para ver un ejemplo de uso ConstantType). ¿Tienes un ejemplo de trabajo completo?

Travis Brown

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 MyCaseClassobjeto complementario que requiere Fieldsimplicits:

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.

Federico Pellegatta
fuente

¿Cómo usar Shapeless en un cuasiquote?

Respuestas: