web-dev-qa-db-ja.com

与えられたジェネリック型によってクラスのコンパニオンオブジェクトを取得するScala

私がやろうとしているのは、ジェネリッククラスを取り、その中で静的メソッドを使用する関数を作成することです（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
}

何か案は？

classscalaobjecttypesimplicit
27
Wojtek Erbetowski

これを行う方法を忘れて、答えが100％満足できないとき、私はこのページを押し続けます。これが私がリフレクションで行う方法です：

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

}
2
Miquel

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
}

Scala 2.9.xを使用する場合、これは-Ydependent-method-typesフラグを使用してコンパイルする必要があります。

24
Eugene Yokota

リフレクションを使用してコンパニオンクラスとそのインスタンスを取得することもできますが、それはScala内部的には遠い（？）将来変更される可能性があります。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))
8
MxFr