用特征中的抽象类型解决类型擦除问题

Question

I have a situation like this:

import scala.reflect._

trait SomeTrait {
  type T
  implicit def tag: ClassTag[T]
  def func2(x: Any) = x match {
    case x: T => "foo"
    case _ => "bar"
  }
}

case class SomeCaseClass()

class SomeClass extends SomeTrait {
  type T = SomeCaseClass
  implicit def tag = scala.reflect.classTag[SomeCaseClass]
  val x = SomeCaseClass()
  def func1() = func2(x)
}

object Main extends App {
  val someClass = new SomeClass()
  someClass.func1()
}

However, the someClass.func1() call yields,

java.lang.StackOverflowError
  at SomeClass.tag(...)
  at SomeClass.tag(...)
  at SomeClass.tag(...)
  //etc.

as if it's recursively calling itself. If I remove the ClassTag, then I have the type erasure warning, which I need to fix. Additionally, I need SomeTrait to remain a trait, thus [T : ClassTag] as a type parameter to is not an option. Does anyone know how I can avoid the type erasure warning with an abstract type in a trait?

Answer 1

See reflect api :

def classTag[T](implicit ctag: ClassTag[T]): ClassTag[T]

When you call:

implicit def tag = scala.reflect.classTag[SomeCaseClass]

your execution is:

implicit def tag = scala.reflect.classTag[SomeCaseClass](tag)

and you receive never ending loop.

Try (in object SomeCase implicit is not visible):

object SomeCase {
  val tagSomeCaseClass =  scala.reflect.classTag[SomeCaseClass]
}


class SomeClass extends SomeTrait {
  type T = SomeCaseClass
  implicit def tag = SomeCase.tagSomeCaseClass
  val x = SomeCaseClass()
  def func1() = func2(x)
}

And I checked - it works for me: scala> val someClass = new SomeClass() someClass: SomeClass = SomeClass@371a67ec

    scala> someClass.func1()
    res0: String = foo

    scala> someClass.func2(4)
    res1: String = bar

    scala> someClass.func2("String")
    res2: String = bar

    scala> someClass.func2(SomeCaseClass())
    res3: String = foo

I do not know how to suppress warning...