Я хотел бы иметь метод, который возвращает класс определенного типа, но я хочу, чтобы метод вел себя по-разному в зависимости от того, расширяет ли класс конкретный признак следующим образом:
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
}
}
Возможно ли это, или я не ошибаюсь?
Спасибо
Вы не можете сравнивать типы напрямую, потому что сравнивать их нет (во время выполнения, из-за erasure). Вы можете работать над представлением своего класса:
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])
?
или вы можете сопоставить образец по экземплярам класса:
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))
?
Вы также можете использовать первый подход синтаксически менее навязчивым способом через манифесты класса:
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]
?
и вы можете выбрать различные виды отправки, если if/else становится wieldy:
object MyFunc {
val dispatch = Map(
classOf[TraitA] -> (() => println("A")),
classOf[TraitB] -> (() => println("B"))
)
val default = () => println("?")
def apply[T](implicit mf: ClassManifest[T]) =
dispatch.find(_._1 isAssignableFrom mf.erasure).map(_._2).getOrElse(default)()
}
scala> MyFunc[ClassA]
A
scala> MyFunc[String]
?
Обратите внимание, что любой общий код, который вы используете для этого, должен иметь доступ к манифесту класса (либо как неявный параметр, либо сокращенно, [T: ClassManifest].
"хотите, чтобы метод вел себя по-разному в зависимости от того, распространяется ли класс на конкретный признак"
Это почти каноническое описание наследования. Не можете ли вы иметь метод в каждом признаке, который инкапсулирует различное поведение, которое вы после?
Вам нужен экземпляр для проверки типа. Генерирование само по себе является просто заполнителем для типа. Вы можете сделать что-то вроде этого:
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