通过给定的泛型类型Scala获取类的伴随对象

Question

我想要做的是创建一个函数,它将采用泛型类并在其中使用静态方法(对不起Java语言,我的意思是它的伴随对象的方法).

trait Worker {def doSth: Unit}

class Base

object Base extends Worker

// this actually wouldn't work, just to show what I'm trying to achieve
def callSthStatic[T that companion object is <: Worker](implicit m: Manifest[T]) {
  // here I want to call T.doSth (on T object)
  m.getMagicallyCompanionObject.doSth
}

有任何想法吗？

Answer 1

Miles Sabin的一个要点可能会给你一个提示:

trait Companion[T] {
  type C
  def apply() : C
}

object Companion {
  implicit def companion[T](implicit comp : Companion[T]) = comp()
}

object TestCompanion {
  trait Foo

  object Foo {
    def bar = "wibble"

    // Per-companion boilerplate for access via implicit resolution
    implicit def companion = new Companion[Foo] {
      type C = Foo.type
      def apply() = Foo
    }
  }

  import Companion._

  val fc = companion[Foo]  // Type is Foo.type
  val s = fc.bar           // bar is accessible
}

-Ydependent-method-types如果使用Scala 2.9.x,则应使用该标志进行编译.

Answer 2

你可以使用反射来获取同伴类和它的实例,但是这依赖于斯卡拉内部可能在一些远(？)将来改变.你得到一个AnyRef没有类型安全.但是没有必要在类和对象中添加任何含义.

def companionOf[T : Manifest] : Option[AnyRef] = try{
  val classOfT = implicitly[Manifest[T]].erasure
  val companionClassName = classOfT.getName + "$"
  val companionClass = Class.forName(companionClassName)
  val moduleField = companionClass.getField("MODULE$")
  Some(moduleField.get(null))
} catch {
  case e => None
}

case class A(i : Int)

companionOf[A].collect{case a : A.type  => a(1)}
// res1: Option[A] = Some(A(1))

Answer 3

当我忘记如何执行此操作时，我会一直点击此页面，并且答案对我来说并不是百分百满意。这是我如何处理反射：

val thisClassCompanion = m.reflect(this).symbol.companion.asModule
val structural = m.reflectModule(thisClassCompanion)
                  .instance.asInstanceOf[{def doSth: Unit}]

您可能需要验证该类是否确实有一个伴生对象或伴生对象。asModule 将抛出一个反射异常不是模块

更新：为了清楚起见，添加了另一个示例：

    object CompanionUtil {

  import scala.reflect.runtime.{currentMirror => cm}

  def companionOf[T, CT](implicit tag: TypeTag[T]): CT = {
    Try[CT] {
      val companionModule = tag.tpe.typeSymbol.companion.asModule
      cm.reflectModule(companionModule).instance.asInstanceOf[CT]
    }
  }.getOrElse(throw new RuntimeException(s"Could not get companion object for type ${tag.tpe}"))

}