Jak obejść Typ erasure na Scali? Albo dlaczego nie mogę uzyskać parametru typ moich kolekcji?

Możesz to zrobić za pomocą TypeTags (jak już wspomina Daniel, ale po prostu przeliteruję to wprost):

import scala.reflect.runtime.universe._
def matchList[A: TypeTag](list: List[A]) = list match {
  case strlist: List[String @unchecked] if typeOf[A] =:= typeOf[String] => println("A list of strings!")
  case intlist: List[Int @unchecked] if typeOf[A] =:= typeOf[Int] => println("A list of ints!")
}

Możesz to również zrobić używając ClassTags (co oszczędza Ci konieczności polegania na scala-reflect):

import scala.reflect.{ClassTag, classTag}
def matchList2[A : ClassTag](list: List[A]) = list match {
  case strlist: List[String @unchecked] if classTag[A] == classTag[String] => println("A List of strings!")
  case intlist: List[Int @unchecked] if classTag[A] == classTag[Int] => println("A list of ints!")
}

ClassTags mogą być używane tak długo, jak długo nie oczekujesz, że parametr type A będzie typem generycznym.

Niestety jest to trochę gadatliwe i potrzebujesz adnotacji @ unchecked, aby stłumić Ostrzeżenie kompilatora. TypeTag może być włączony do wzorzec dopasowuje się automatycznie przez kompilator w przyszłości: https://issues.scala-lang.org/browse/SI-6517

Możesz użyć Typeable klasy typu z shapeless aby uzyskać wynik,

Przykładowa sesja REPL,

scala> import shapeless.syntax.typeable._
import shapeless.syntax.typeable._

scala> val l1 : Any = List(1,2,3)
l1: Any = List(1, 2, 3)

scala> l1.cast[List[String]]
res0: Option[List[String]] = None

scala> l1.cast[List[Int]]
res1: Option[List[Int]] = Some(List(1, 2, 3))

Operacja cast będzie jak najdokładniejszym usunięciem wrt, biorąc pod uwagę dostępne przypadki w zakresie Typeable.

Wymyśliłem stosunkowo proste rozwiązanie, które wystarczyłoby w sytuacjach o ograniczonym użyciu, zasadniczo owijając parametryzowane typy, które cierpiałyby z powodu problemu usuwania typów w klasach owijania, które mogą być używane w instrukcji match.

case class StringListHolder(list:List[String])

StringListHolder(List("str1","str2")) match {
    case holder: StringListHolder => holder.list foreach println
}

To ma oczekiwane wyjście i ogranicza zawartość naszej klasy case do żądanego typu, List łańcuchowych.

Więcej szczegółów tutaj: http://www.scalafied.com/?p=60

Istnieje sposób na przezwyciężenie problemu usuwania typu w Scali. W przezwyciężenie wymazywania typu w dopasowaniu 1 oraz przezwyciężenie wymazywania typu w dopasowaniu 2 (wariancja) są jakieś wyjaśnienia, jak kodować niektóre helpery do zawijania typów, w tym wariancji, do dopasowania.

Znalazłem nieco lepsze obejście tego ograniczenia w inny sposób niesamowitego języka.

W Scali problem typu erasure nie występuje w przypadku tablic. Myślę, że łatwiej jest to zademonstrować na przykładzie.

Powiedzmy, że mamy listę (Int, String), wtedy poniżej podano Ostrzeżenie typu erasure

x match {
  case l:List[(Int, String)] => 
  ...
}

Aby to obejść, najpierw Utwórz klasę case:

case class IntString(i:Int, s:String)

Następnie w dopasowaniu wzorca zrób coś takiego:

x match {
  case a:Array[IntString] => 
  ...
}

Który wydaje się działać doskonale.

Wymaga to niewielkich zmian w kodzie do pracy z tablicami zamiast listami, ale nie powinno to stanowić większego problemu.

Zauważ, że użycie case a:Array[(Int, String)] nadal wyświetli ostrzeżenie o usunięciu typu, dlatego konieczne jest użycie nowej klasy kontenera(w tym przykładzie IntString).

Ponieważ Java nie zna rzeczywistego typu elementu, najbardziej przydatne okazało się użycie List[_]. Wtedy Ostrzeżenie odchodzi, a kod opisuje rzeczywistość - jest to lista czegoś nieznanego.

Zastanawiam się, czy jest to odpowiednie obejście:

scala> List(1,2,3) match {
     |    case List(_: String, _*) => println("A list of strings?!")
     |    case _ => println("Ok")
     | }

Nie pasuje do przypadku "pusta lista" , ale daje błąd kompilacji, a nie Ostrzeżenie!

error: type mismatch;
found:     String
requirerd: Int

scala> List(1,2,3) match {
     |    case List(_: Int, _*) => println("A list of ints")
     |    case _ => println("Ok")
     | }

Nie jest to rozwiązanie, ale sposób na życie bez zamiatania go pod dywan: Dodawanie adnotacji @unchecked. Zobacz tutaj - http://www.scala-lang.org/api/current/index.html#scala.unchecked

Chciałem dodać odpowiedź, która uogólnia problem do: jak uzyskać reprezentację String typu mojej listy w czasie wykonywania

import scala.reflect.runtime.universe._

def whatListAmI[A : TypeTag](list : List[A]) = {
    if (typeTag[A] == typeTag[java.lang.String]) // note that typeTag[String] does not match due to type alias being a different type
        println("its a String")
    else if (typeTag[A] == typeTag[Int])
        println("its a Int")

    s"A List of ${typeTag[A].tpe.toString}"
}

val listInt = List(1,2,3)
val listString = List("a", "b", "c")

println(whatListAmI(listInt))
println(whatListAmI(listString))

Użycie pattern match guard

    list match  {
        case x:List if x.isInstanceOf(List[String]) => do sth
        case x:List if x.isInstanceOf(List[Int]) => do sth else
     }