Posso eseguire la corrispondenza su un parametro di tipo in Scala per vedere se implementa un tratto?

Question

Vorrei avere un metodo che restituisce una classe di un certo tipo, ma voglio il metodo di comportarsi in modo diverso a seconda se la classe estende un determinato tratto come segue:

 

case class ClassA extends TraitA 
case class ClassB extends TraitB 
case class ClassC extends TraitA 
... 
def myfunc[T]():T = { 
    T match { 
    case TraitA => // return new T in a particular way 
    case TraitB => // ditto 
    } 
} 
 

Questo è possibile o sto andando su di esso nel modo sbagliato?

Grazie

Answer 1

Non è possibile confrontare i tipi direttamente, perché non c'è nulla da confrontare (in fase di esecuzione, a causa di erasure). Si potrebbe lavorare su una rappresentazione della classe:

trait TraitA { } 
trait TraitB { } 
class ClassA extends TraitA { } 
class ClassB extends TraitB { } 

def myFunc[T](clazz: Class[T]) = { 
    if (classOf[TraitA] isAssignableFrom clazz) println("A") 
    else if (classOf[TraitB] isAssignableFrom clazz) println("B") 
    else println("?") 
} 

scala> myFunc(classOf[ClassA]) 
A 

scala> myFunc(classOf[String]) 
? 

oppure si può abbinare modello sul istanze della classe:

def myFunc2[T](t: T) = t match { 
    case _: TraitA => println("A") 
    case _: TraitB => println("B") 
    case _ => println("?") 
} 

scala> myFunc2(new ClassA) 
A 

scala> myFunc2(Some(5)) 
? 

È anche possibile utilizzare il primo approccio in modo sintatticamente meno invadente via classe manifesta:

def myFunc3[T](implicit mf: ClassManifest[T]) = { 
    val clazz = mf.erasure 
    if (classOf[TraitA] isAssignableFrom clazz) println("A") 
    else if (classOf[TraitB] isAssignableFrom clazz) println("B") 
    else println("?") 
} 

scala> myFunc3[ClassA] 
A 

scala> myFunc3[String] 
? 

ed è possibile scegliere diversi tipi di spedizione anche se il if/else diventa wieldy:

Si noti che qualsiasi codice generico che si utilizza da questo dovrà avere un manifest di classe disponibile (sia come parametro implicito o in stenografia, [T: ClassManifest].

Answer 2

È necessaria un'istanza per verificare il tipo. Un generico di per sé è solo un segnaposto per un tipo. Si potrebbe fare qualcosa di simile:

trait bTrait //common base trait 
trait TraitA extends bTrait 
trait TraitB extends bTrait 

class ClassA extends TraitA 
class ClassB extends TraitB 

def myFunc[T <: bTrait](t:T) : String = //passing explicitly an instance of type T 
{ 
    t match { 
    case _ : TraitA => "TraitA" 
    case _ : TraitB => "TraitB" 
    } 
} 

println(myFunc(new ClassA)) //prints TraitA 

Answer 3

"vogliono il metodo di comportarsi in modo diverso a seconda se la classe estende un tratto particolare"

Questo è quasi una descrizione canonica di eredità. Non puoi avere un metodo in ogni tratto che incapsula il diverso comportamento che stai cercando?