Obtener objeto compañero de clase por tipo genérico dado Scala

Question

Obtener objeto compañero de clase por tipo genérico dado Scala

Lo que estoy tratando de hacer es hacer una función que tome una clase genérica y use un método estático en ella (lo siento por el lenguaje Java, me refiero al método de su objeto compañero).

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
}

¿Alguna idea?

26

object types class scala implicit

Author: Malvolio, 2012-02-07

Source

3 answers

Un resumen de Miles Sabin puede darte una pista:

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
}

Esto debe compilarse con la bandera -Ydependent-method-types si se usa Scala 2.9.x.

21

Author: Tomasz Nurkiewicz,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2012-02-07 12:42:48

Se podría usar la reflexión para obtener la clase compañera y su instancia, pero eso depende de los internos de Scala que podrían cambiar en algún momento(?) futuro. Y no hay seguridad de tipo como usted consigue un AnyRef. Pero no hay necesidad de añadir ningún implicits a sus clases y objetos.

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

Author: MxFr,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2012-02-07 10:41:06

score 1 · Accepted Answer

Sigo golpeando esta página cuando olvido cómo hacer esto y las respuestas no son cien por ciento satisfactorias para mí. Así es como lo hago con la reflexión:

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

Es posible que deba verificar que la clase realmente tiene un objeto o compañero.asModule lanzará una excepción de reflexión no es un módulo

Actualizado: se agregó otro ejemplo para mayor claridad:

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

}