abstract type pattern is unchecked since it is eliminated by erasure

Question

Could someone tell me how can I avoid the warning in the code block below:

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

This results in a compiler warning:

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

It just means that the type of argument t is bounded above by T. Or in other words T is a sub-type of Bar or Bar itself. — Harshal Pandya, Oct 10 '13 at 18:41
No, it means that the type of `t` is not guaranteed to be `T` at runtime, since the JVM performs type erasure (discards the type information). — automorphic, Sep 09 '22 at 22:46

score 30 · Accepted Answer · edited Mar 27 '16 at 22:57

30

You could use ClassTag (or 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 _ => 
  }
}

edited Mar 27 '16 at 22:57

thSoft

21,755
5
88
103

answered Aug 08 '13 at 21:42

senia

37,745
4
88
129

2

What does classtag do here? – Blankman Jan 28 '17 at 00:01
1

Assuming you mean `ClassTag` in the class parameter signature, it tells the compiler to create an implicit `ClassTag[T]` parameter for the class, which is then accessed via `implicitly[ClassTag[T]]`. `abstract class Foo[T: ClassTag]` is sugar for `abstract class Foo[T](implicit tag: ClassTag[T])` – WeaponsGrade Jul 18 '18 at 19:29

score 3 · Answer 2 · answered Sep 20 '16 at 21:48

Another variation to use, especially if you desire to use a trait (as opposed to using a class or abstract class which the other solution requires), looks like this:

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
    }
}

Thanks. I needed this in a trait and couldn't quite get to the implicit version. Cheers. — AetherMass, Oct 15 '21 at 03:45

abstract type pattern is unchecked since it is eliminated by erasure

2 Answers2

Linked