tipos sujeto predicado oraciones objeto ingles indirecto directo definicion con complementos complemento class scala object types implicit

class - sujeto - Obtiene el objeto compañero de clase por tipo genérico dado Scala



sujeto y predicado objeto directo e indirecto (3)

Lo que intento hacer es crear una función que tome una clase genérica y use un método estático (lo siento por el lenguaje Java, me refiero al método de su objeto complementario).

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 }

¿Algunas ideas?


Continúo golpeando esta página cuando olvido cómo hacerlo 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 tenga realmente un objeto complementario o companion.asModule lanzará una excepción de reflexión no es un módulo

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


Podría usar el reflejo para obtener la clase complementaria y su instancia, pero eso depende de las partes internas de Scala que podrían cambiar en algún futuro lejano (?). Y no hay seguridad de tipo ya que obtiene un AnyRef. Pero no hay necesidad de agregar ningún implícito 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))


Una esencia 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 se debe compilar con el -Ydependent-method-types si se usa Scala 2.9.x.