abstrakcyjny typ wzoru jest zaznaczone, ponieważ jest on wyeliminowany przez skasowaniem

Question

Czy ktoś może mi powiedzieć jak mogę uniknąć ostrzeżenia w bloku kodu poniżej:

abstract class Foo[T <: Bar]{ 
    case class CaseClass[T <: Bar](t: T) 
    def method1 = { 
    case CaseClass(t: T) => println(t) 
    csse _ => 
    } 
} 

Powoduje to ostrzeżenie kompilatora:

abstract type pattern T is unchecked since it is eliminated by erasure 
case CaseClass(t: T) => println(t) 
       ^

Answer 1

można użyć ClassTag (lub TypeTag):

import scala.reflect.ClassTag 

abstract class Foo[T <: Bar : ClassTag]{ 
    ... 
    val clazz = implicitly[ClassTag[T]].runtimeClass 
    def method1 = { 
    case CaseClass(t) if clazz.isInstance(t) => println(t) // you could use `t.asInstanceOf[T]` 
    case _ => 
    } 
} 

Answer 2

Kolejna wariacja w użyciu , Zwłaszcza jeśli pragną użyć trait (w przeciwieństwie do korzystania z class lub abstract class który wymaga innego rozwiązania), wygląda następująco:

import scala.reflect.{ClassTag, classTag} 

trait Foo[B <: Bar] { 
    implicit val classTagB: ClassTag[B] = classTag[B] 
    ... 
    def operate(barDescendant: B) = 
    barDescendant match { 
     case b: Bar if classTagB.runtimeClass.isInstance(b) => 
     ... //do something with value b which will be of type B 
    } 
}