Scala反射，用于在运行时从名称中解析通用特征

Question

我有两个特征及其实例对象定义如下：

package reflection

trait Monoid[T] {
  def id: T
  def op(lhs: T, rhs: T): T
}

trait ADTHelper[T]{
  type V
  def create(value: V): T
  def get(adt: T): Any
}

case class Avg(avg: Double, n: Int)

object AvgMonoid extends Monoid[Avg] with ADTHelper[Avg]{
  override def id: Avg = Avg(0, 0)

  override def op(lhs: Avg, rhs: Avg): Avg =
    Avg( (lhs.avg * lhs.n + rhs.avg * rhs.n)/(lhs.n + rhs.n), lhs.n + rhs.n)

  override type V = Double
  override def create(value: Double): Avg = Avg(value, 1)
  override def get(adt: Avg): Any = adt.avg
}

object MinMonoid extends Monoid[Double] with ADTHelper[Double]{
  override def id: Double = Double.MaxValue

  override def op(lhs: Double, rhs: Double): Double = if(lhs < rhs) lhs else rhs

  override type V = Double

  override def create(value: Double): Double = value

  override def get(adt: Double): Any = adt
}

我希望在运行时从名称中获取单类实例。例如，如果我说"min"，我想要MinMonoid对象，"avg"应该给AvgMonoid对象等等。所以我有以下设置：

object Test extends App {

  val AGGREGATORS_NAME_DICT = Map(
    "avg" -> "reflection.AvgMonoid",
    "min" -> "reflection.MinMonoid",
    "max" -> "reflection.MaxMonoid"
  )
  val AGGREGATORS_ADT_DICT = Map(
    "avg" -> "reflection.Avg",
    "min" -> "scala.Double",
    "max" -> "scala.Double"
  )

  val mirror = runtimeMirror(getClass.getClassLoader)

  def stringToTypeTag[A](name: String): TypeTag[A] = {
    val tpe = mirror.staticClass(name).selfType
    TypeTag(mirror, new api.TypeCreator {
      def apply[U <: api.Universe with Singleton](m: api.Mirror[U]) =
        if (m eq mirror) tpe.asInstanceOf[U#Type]
        else throw new IllegalArgumentException(s"Type tag defined in $mirror cannot be migrated to other mirrors.")
    })
  }

  def resolve[T](fname: String): Option[Monoid[T] with ADTHelper[T]] = for {
    monoidName <- AGGREGATORS_NAME_DICT.get(fname)
    adtName <- AGGREGATORS_ADT_DICT.get(fname)
    tag <- Option{stringToTypeTag[T](adtName)}
    instance <- Option {
      mirror
        .reflectModule(mirror.staticModule(monoidName))
        .instance
        .asInstanceOf[Monoid[T] with ADTHelper[T]]
    }
  } yield instance
}

现在的问题是:我可以：

println(resolve("min").get.op(1.0, 2.0))

但我做不到：

val monoid = resolve("min").get
println(monoid.op(1.0, 2.0))

因为后面的monoid类型是Monoid[Nothing] with ADTHelper[Nothing]。我无法使用我想出的T方法解析trait Monoid[T]和trait ADTHelper[T]的底层类型。如何修改resolve函数，使其能够使用基础类型T解决这些特性？

我知道如果我使用resolve[Double](...)进行调用，它会工作，但我希望在运行时通过AGGREGATORS_ADT_DICT解决这个问题。

Answer 1

在运行时解析T是不可能的，因为那时没有T要解决！编写resolve("min")时，编译器必须在编译期间确定其类型参数。而且，由于参数没有告诉它任何关于T的信息，而且上下文也没有提供预期的类型(例如，val monoid: Monoid[Double] = resolve("min")，它将推断Nothing。请注意，resolve的代码在这里根本不重要，只是它的类型签名。

您可以使resolve成为一个宏，从而在宏的运行时确定T，即使用此宏的程序的编译时间。但这只适用于编译时知道名称的情况(例如，它是一个文字字符串)。