如何在泛型方法中替换实际类型参数以获得其值参数的最终类型？

Question

我有一个带有类似签名的宏

def generateSomething[A] = macro ...

也就是说，它接受一个类型参数。该类型应该是一个案例类，因此它的伴生对象中总是有相应的apply 方法。

除其他外，此宏会生成此apply 方法的调用，例如，对于此类：

case class A(x: Int, y: String)

将生成以下调用：

A.apply(someFunction[Int], someFunction[String])

我从apply签名中提取someFunction调用的参数类型。

一切都很好，除非 A 被参数化：

case class A[T](x: Int, y: T)

使用我目前的方法，为generateSomething[A[String]] 生成以下内容：

A.apply[String](someFunction[Int], someFunction[T])

这显然是无效的。

但是，在知道apply 的所有类型参数之后，我不知道如何获取它的参数。也就是说，我不知道如何确定

generateSomething[A[String]]

生成

A.apply[String](someFunction[Int], someFunction[String])

而不是上面的部分。有可能吗？

更新

我想我应该重新提出这个问题。

假设有一个类

case class A[T1, ..., Tn](x1: A1, ..., xm: Am)

其中Ai 可以依赖于Tk 的任意子集。例子：

// T1 = T
// A1 = Int, A2 = T
case class B[T](x: Int, y: T)

// T1 = U, T2 = V
// A1 = Map[U, V], A2 = List[V]
case class C[U, V](m: Map[U, V], l: List[V])

// T1 = W
// A1 = W, A2 = W
case class D[W](t: W, u: W)

// No Ts
// A1 = String, A2 = Double
case class E(v: String, w: Double)  // no type parameters at all

我需要编写一个宏，它接受类型参数 A 并扩展为带有预处理参数的 A.apply 方法调用：

myMacro[A[U1, ..., Un]]

// expands to

A.apply[U1, ..., Un](preprocess[A1], ..., preprocess[An])

Uk 这里是实际类型参数，它们被替换而不是Tk。例如（使用上面的类）：

myMacro[B[String]] -> B.apply[String](preprocess[Int], preprocess[String])

myMacro[C[Int, Double]] -> C.apply[Int, Double](preprocess[Map[Int, Double]], preprocess[List[Double]])

myMacro[D[Long]] -> D.apply[Long](preprocess[Long], preprocess[Long])

myMacro[E] -> D.apply(preprocess[String], preprocess[Double])

你看，apply 参数类型可以依赖于类型参数。虽然宏知道这些参数（因为它总是用具体类型调用），但我不知道如何将这些参数“通过”“传递”给apply 函数以使preprocess 类型参数正确.

更新 2

Here 大致就是我目前拥有的。

Answer 1

类似：

case class X[A](a: A)

object TParamMacro {
  import scala.language.experimental.macros
  import scala.reflect.macros.whitebox.Context

  def m[A](): A = macro mImpl[A]

  def mImpl[A: c.WeakTypeTag](c: Context)(): c.Expr[A] = {
    import c.universe._
    val TypeRef(pre, sym, args) = weakTypeTag[A].tpe
    val t = args.head
    val expr = 
      if (t <:< typeOf[String]) q"""X.apply[$t]("hi")"""
      else if (t <:< typeOf[Int]) q"X.apply[$t](42)"
      else q"X.apply[$t](null)"
    c.Expr[A](expr)
  }
}

object Test extends App {
  Console println TParamMacro.m[X[String]]()
}

更多示例：

object TParamMacro {
  import scala.language.experimental.macros
  import scala.reflect.macros.whitebox.Context

  def m[A](): Any = macro mImpl[A]

  def mImpl[A: c.WeakTypeTag](c: Context)() = {
    import c.universe._
    val TypeRef(pre, sym, args) = weakTypeTag[A].tpe
    val t = args.head
    val expr = if (t <:< typeOf[String]) q"""X.apply[List[$t]](List.apply[$t]("hi"))"""
      else if (t <:< typeOf[Int]) q"X.apply[List[$t]](List.apply[$t](42))"
      else q"X.apply[List[$t]](Nil)"
    expr
  }
}

在哪里

Console println TParamMacro.m[X[String]]()

产量

X(List(hi))

用修复的要点编辑：

package evaluator

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

object Evaluator {
  def preprocess[T]: T = ???

  def evaluate[A]: Any = macro evaluateImpl[A]

  def evaluateImpl[A: c.WeakTypeTag](c: Context): c.Expr[A] = {
    import c.universe._

    val tpe = weakTypeOf[A]
    val sym = tpe.typeSymbol.asClass

    require(sym.isCaseClass)

    val companionSym = sym.companion
    val companionTpe = companionSym.typeSignature
    val applyMethod = companionTpe.member(TermName("apply")).asMethod

    val paramTypes = applyMethod.paramLists.flatten.map(_.typeSignature)
    Console println s"apply($paramTypes)"

    val TypeRef(_, _, tpeTypeArgs) = tpe

    val from = applyMethod.typeParams
    val to   = tpeTypeArgs
    val arguments = paramTypes map { t =>
      val u = if (from.nonEmpty) t.substituteTypes(from, to) else t
      Console println s"param is $t, subst is $u"
      q"evaluator.Evaluator.preprocess[$u]"
    }

    c.Expr(q"$companionSym.apply[..$tpeTypeArgs](..$arguments)")
  }
}

因此，您只需将“实际类型参数”替换为方法的类型参数。在应用程序中将“参数”用于形式参数，将“参数”用于实际 arg 很有用。

示例：

package evaluator

case class A(x: Int, y: String)

case class B[T](x: Int, y: T)

case class C[U, T](x: Int, y: T, z: U)

object Test extends App {
  Evaluator.evaluate[A]
  Evaluator.evaluate[B[String]]
  Evaluator.evaluate[C[String, List[Int]]]
}

使用

-Xprint:typer

然后

A.apply(evaluator.Evaluator.preprocess[Int], evaluator.Evaluator.preprocess[String]);
B.apply[String](evaluator.Evaluator.preprocess[Int], evaluator.Evaluator.preprocess[String]);
C.apply[String, List[Int]](evaluator.Evaluator.preprocess[Int], evaluator.Evaluator.preprocess[List[Int]], evaluator.Evaluator.preprocess[String])

Answer 2

Scala macro docs 提供一些见解：

import scala.reflect.macros.blackbox.Context

class Impl(val c: Context) {
  def mono = c.literalUnit
  def poly[T: c.WeakTypeTag] = c.literal(c.weakTypeOf[T].toString)
}

object Macros {
  def mono = macro Impl.mono
  def poly[T] = macro Impl.poly[T]
}

上面的poly 方法调用c.weakTypeOf，它通过在编译时创建一个隐式来捕获已擦除的类型信息。类似的模式可能有助于具体化您的宏。

编辑以上更新：

c.WeakTypeTag 在调用站点捕获类型信息。编译器需要满足我们应用于宏参数的类型界限，应用隐式转换从您的类型中捕获此信息。

这个想法是，一旦你有了这个信息，你就可以用它来获取一个未知类型的字符串，你可以在具体化过程中使用它。

就类型参数数量的差异而言，我认为宏的参数数量必须独立于它所应用的类型才有意义，即根据你的最后一个块，我会改为做这样的事情（假设他们都有apply的两个字段）：

myMacro[B, Int, String]] -> B.apply(preprocess[Int], preprocess[String])

myMacro[C, Map[Int,Double], List[Double]] -> C.apply(preprocess[Map[Int, Double]], preprocess[List[Double]])

myMacro[D, Long, Long] -> D.apply(preprocess[Long], preprocess[Long])

myMacro[E, String, Double] -> E.apply(preprocess[String], preprocess[Double])

同样，由于这是伪代码，您的使用范围可能会有所不同，但对宏的签名应用一些统一性（并且可能应用实现）可能会对您的实现有很大帮助。