隐式参数vs TypeTag何时使用以及为什么

Question

Scala suffers type erasure , but it also introduces TypeTag to overcome type erasure problem.

Sometimes we can use implicit parameters (or even value paramters are enough) to solve the same problem that we countered.

For exammple:

// implicit paramters
def getKindName[T](implicit x: T): String = {
      x match {
        case _: People => "Mammals"
        case _: Sparrow => "Birds"
        case _: Shark => "Fishes"
        case _: Crocodile => "Reptiles"
        case _ => ???
      }
}

// TypeTag
def getKindName[T: TypeTag]: String = {
    typeOf[T] match {
      case t if t =:= typeOf[People] => "Mammals"
      case t if t =:= typeOf[Sparrow] => "Birds"
      case t if t =:= typeOf[Shark] => "Fishes"
      case t if t =:= typeOf[Crocodile] => "Reptiles"
      case _ => ???
    }
}

So my question are:

• why and when use Type Tag and implicit paramters ?
• what are the differences of perfomance between Type Tag and implicit paramters?

If you could give me a link of doc in scala to prove your opinion, it is perfect. Thank you in advance.

Answer 1

1. TypeTag s are nearly always used as implicit parameters. If you aren't aware, getKindName[T: TypeTag] means getKindName[T](implicit tag: TypeTag[T]) . The exception would be when you store a TypeTag which you got as an implicit parameter somewhere. So "implicit parameters vs TypeTag " doesn't make sense to begin with.

2. The two snippets do not behave at all similarly, so they can't be solving the same problem, whatever that problem is. Eg you can define

    implicit val x: Animal = new People getKindName1[Sparrow] // returns "Mammals" 

   or without any extra implicits being defined, getKindName1[Sparrow] will not compile at all (and it isn't clear why you would have eg an implicit Sparrow in the first place).