scala - una - sintaxis de un programa html

¿Cómo determinar si un parámetro de tipo es un subtipo de un rasgo?

Question

Digamos que tengo los siguientes tipos

class Foo
trait Bar

¿Hay una manera de hacer un método que tome un parámetro Tipo, T, y determinar si esa T es una Barra? Por ejemplo,

def isBar[T <: Foo: Manifest] = 
  classOf[Bar].isAssignableFrom(manifest[T].erasure)

Lamentablemente, isBar[Foo with Bar] es false porque el borrado parece borrar los mixins.

Además, manifest[Foo with Bar] <:< manifest[Bar] es falso

¿Es esto posible en absoluto?

Miré esta pregunta: ¿Cómo saber si un tipo de Scala reified amplía cierta clase padre?

pero esa respuesta no funciona con rasgos combinados, ya que parecen borrarse como se evidenció anteriormente.

Answer 1

Es posible hacer esto antes de la 2.10, pero no (por lo que sé) con manifiestos:

def isBar[T <: Foo](implicit ev: T <:< Bar = null) = ev != null

Es un poco hack, pero funciona como se desea.

scala> isBar[Foo with Bar]
res0: Boolean = true

scala> isBar[Foo]
res1: Boolean = false

Answer 2

Esto se puede lograr con TypeTags (al menos 2.10M7):

scala> class Foo; trait Bar
defined class Foo
defined trait Bar

scala> import reflect.runtime.universe._
import reflect.runtime.universe._

scala> def isBar[A <: Foo : TypeTag] = typeOf[A].baseClasses.contains(typeOf[Bar].typeSymbol)
isBar: [A <: Foo](implicit evidence$1: reflect.runtime.universe.TypeTag[A])Boolean

scala> isBar[Foo]
res43: Boolean = false

scala> isBar[Foo with Bar]
res44: Boolean = true

TypeTags proporciona una traducción 1: 1 de los tipos de Scala porque representan los tipos que el compilador conoce. Por lo tanto, son mucho más poderosos que los antiguos manifiestos:

scala> val fooBar = typeTag[Foo with Bar]
fooBar: reflect.runtime.universe.TypeTag[Foo with Bar] = TypeTag[Foo with Bar]

Con el método tpe obtenemos acceso completo al nuevo Reflejo de Scalas:

scala> val tpe = fooBar.tpe // equivalent to typeOf[Foo with Bar]
tpe: reflect.runtime.universe.Type = Foo with Bar

scala> val tpe.<tab><tab> // lot of nice methods here
=:=                 asInstanceOf        asSeenFrom          baseClasses         baseType            contains            declaration         
declarations        erasure             exists              find                foreach             isInstanceOf        kind                
map                 member              members             narrow              normalize           substituteSymbols   substituteTypes     
takesTypeArgs       termSymbol          toString            typeConstructor     typeSymbol          widen  

Answer 3

Otro uso de typeclass (más genérico):

  trait SubClassGauge[A, B] {
    def A_isSubclassOf_B: Boolean
  }

  implicit class IsSubclassOps[A](a: A) {
    def isSubclassOf[B](implicit ev: SubClassGauge[A, B]): Boolean = ev.A_isSubclassOf_B
  }

  trait LowerLevelImplicits {
    implicit def defaultSubClassGauge[A, B] = new SubClassGauge[A, B] {
      override def A_isSubclassOf_B: Boolean = false
    }
  }

  object Implicits extends LowerLevelImplicits {
    implicit def subClassGauge[A <: B, B]: SubClassGauge[A, B] = new SubClassGauge[A, B] {
      override def A_isSubclassOf_B: Boolean = true
    }
  }

  trait Prime
  class NotSuper
  class Super extends Prime
  class Sub extends Super
  class NotSub

Ahora, en REPL:

@ import Implicits._ 
import Implicits._
@ (new Sub).isSubclassOf[NotSuper] 
res29: Boolean = false
@ (new Sub).isSubclassOf[Super] 
res30: Boolean = true
@ (new Sub).isSubclassOf[Prime] 
res31: Boolean = true
@ (new Super).isSubclassOf[Prime] 
res32: Boolean = true
@ (new Super).isSubclassOf[Sub] 
res33: Boolean = false
@ (new NotSub).isSubclassOf[Super] 
res34: Boolean = false

TypeTag ahora pertenece al paquete TypeTag . Uno necesita agregar dependencia adicional para usarlo.

Answer 4

Puedes resolverlo sin reflexión usando typeclasses:

trait IsBar[T] {
  def apply():Boolean
}

trait LowerLevelImplicits {
  implicit def defaultIsBar[T] = new IsBar[T]{
    def apply() = false
  }
}

object Implicits extends LowerLevelImplicits {
  implicit def isBarTrue[T <: Bar] = new IsBar[T] {
    def apply() = true
  }
}

def isBar[T<:Foo]( t: T )( implicit ib: IsBar[T] ) = ib.apply()

scala> import Implicits._

scala> isBar( new Foo )
res6: Boolean = false

scala> isBar( new Foo with Bar )
res7: Boolean = true