Bir Quasiquote içinde Shapeless nasıl kullanılır?

Question

Shapeless makrosunu quasiquote içinden Scala ile aramaya çalışıyorum ve almak istediklerimi alamıyorum.

My makro hataları dönmez ama burada 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)""" 
} 

benim Field tanımıdır içine Witness(fieldName) genişletmek değildir:

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) 
    } 
} 

ben gibi görünüyor oluşturmak örtük Bu durumda :

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

n bu gibi bir şey üretecek bir quasiquote dışında tanımlanmış:

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

yapılabilecek bir şey var mı?

Answer 1

Bu, eski stil makro ek açıklamalarını kullanan çalışma çözümümdür.

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}" 
     } 
    } 
    } 
} 

Herhalde, daha iyi quasiquotes kullanılarak geliştirilmiş, olabilir, ama amacım mümkün olduğunca temizleyici olarak bir şeyler göstermekti.

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

Bu MyCaseClass refakatçi nesne Fields implicits gerekli olan üretir: Zaten işaret edildiği gibi

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)); 

tam çalışma olmadan olarak

Bu kullanılabilmektedir Örneğin, kapsamlı bir cevap yazmak oldukça zordur.