Come aggirare la cancellazione del tipo su Scala? Oppure, perché non riesco a ottenere il parametro type delle mie raccolte?

È un fatto triste della vita su Scala che se si crea un'istanza di un Elenco [Int], è possibile verificare che la propria istanza sia un Elenco e che sia possibile verificare che ogni singolo elemento di esso sia un Int, ma non che sia un Elenco [ Int], come può essere facilmente verificato:

scala> List(1,2,3) match {
     | case l : List[String] => println("A list of strings?!")
     | case _ => println("Ok")
     | }
warning: there were unchecked warnings; re-run with -unchecked for details
A list of strings?!

L'opzione -unchecked mette esattamente la colpa sulla cancellazione del tipo:

scala>  List(1,2,3) match {
     |  case l : List[String] => println("A list of strings?!")
     |  case _ => println("Ok")
     |  }
<console>:6: warning: non variable type-argument String in type pattern is unchecked since it is eliminated by erasure
        case l : List[String] => println("A list of strings?!")
                 ^
A list of strings?!

Perché è così e come posso aggirarlo?

Questa risposta usa Manifest-API, che è obsoleto a partire da Scala 2.10. Si prega di consultare le risposte di seguito per ulteriori soluzioni attuali.

Scala è stata definita con Type Erasure perché la Java Virtual Machine (JVM), a differenza di Java, non ha ottenuto generici. Ciò significa che, in fase di esecuzione, esiste solo la classe, non i suoi parametri di tipo. Nell'esempio, JVM sa che sta gestendo un scala.collection.immutable.List, ma non che questo elenco sia parametrizzato con Int.

Fortunatamente, c'è una funzione in Scala che ti consente di aggirare questo. È il manifest . Un manifest è una classe le cui istanze sono oggetti che rappresentano i tipi. Poiché queste istanze sono oggetti, è possibile passarle in giro, archiviarle e in genere chiamare metodi su di esse. Con il supporto di parametri impliciti, diventa uno strumento molto potente. Prendi il seguente esempio, ad esempio:

object Registry {
  import scala.reflect.Manifest

  private var map= Map.empty[Any,(Manifest[_], Any)] 

  def register[T](name: Any, item: T)(implicit m: Manifest[T]) {
    map = map.updated(name, m -> item)
  }

  def get[T](key:Any)(implicit m : Manifest[T]): Option[T] = {
    map get key flatMap {
      case (om, s) => if (om <:< m) Some(s.asInstanceOf[T]) else None
    }     
  }
}

scala> Registry.register("a", List(1,2,3))

scala> Registry.get[List[Int]]("a")
res6: Option[List[Int]] = Some(List(1, 2, 3))

scala> Registry.get[List[String]]("a")
res7: Option[List[String]] = None

Quando memorizziamo un elemento, memorizziamo anche un "Manifest". Un Manifest è una classe le cui istanze rappresentano i tipi di Scala. Questi oggetti hanno più informazioni di quelle di JVM, che ci consentono di testare il tipo completo e parametrizzato.

Si noti, tuttavia, che a Manifestè ancora una funzione in evoluzione. Come esempio dei suoi limiti, al momento non sa nulla della varianza e presume che tutto sia co-variante. Mi aspetto che diventerà più stabile e solido una volta terminata la biblioteca di riflessione alla Scala, attualmente in fase di sviluppo.

Puoi farlo usando TypeTags (come già menzionato Daniel, ma lo spiegherò esplicitamente):

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!")
}

Puoi anche farlo usando ClassTags (che ti evita di dover dipendere da scala-reflection):

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!")
}

I ClassTag possono essere utilizzati purché non si preveda che il parametro type sia di Aper sé un tipo generico.

Sfortunatamente è un po 'prolisso e hai bisogno dell'annotazione @unchecked per sopprimere un avviso del compilatore. In futuro il TypeTag può essere incorporato automaticamente nella corrispondenza del modello dal compilatore: https://issues.scala-lang.org/browse/SI-6517

Puoi utilizzare la Typeableclasse type da informe per ottenere il risultato che stai cercando,

Sessione REPL di esempio,

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

L' castoperazione sarà la cancellazione più precisa possibile, date le Typeableistanze di ambito disponibili.

Ho trovato una soluzione relativamente semplice che sarebbe sufficiente in situazioni di uso limitato, essenzialmente avvolgendo i tipi con parametri che soffrirebbero del problema di cancellazione del tipo nelle classi wrapper che possono essere utilizzate in un'istruzione match.

case class StringListHolder(list:List[String])

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

Questo ha l'output previsto e limita i contenuti della nostra classe case al tipo desiderato, String Lists.

Maggiori dettagli qui: http://www.scalafied.com/?p=60

C'è un modo per superare il problema della cancellazione del tipo in Scala. In Superamento della cancellazione del tipo nella corrispondenza 1 e Superamento della cancellazione del tipo nella corrispondenza 2 (Varianza) sono riportate alcune spiegazioni su come codificare alcuni helper per avvolgere i tipi, inclusa la Varianza, per la corrispondenza.

Ho trovato una soluzione leggermente migliore per questa limitazione del linguaggio altrimenti fantastico.

In Scala, il problema della cancellazione del tipo non si verifica con le matrici. Penso che sia più facile dimostrarlo con un esempio.

Supponiamo di avere un elenco di (Int, String), quindi quanto segue fornisce un avviso di cancellazione del tipo

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

Per ovviare a questo, creare prima una classe di casi:

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

quindi nella corrispondenza del modello fai qualcosa del tipo:

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

che sembra funzionare perfettamente.

Ciò richiederà modifiche minori nel codice per funzionare con le matrici anziché con gli elenchi, ma non dovrebbe essere un grosso problema.

Si noti che l'utilizzo case a:Array[(Int, String)]fornirà comunque un avviso di cancellazione del tipo, quindi è necessario utilizzare una nuova classe contenitore (in questo esempio IntString).

Poiché Java non conosce il tipo di elemento effettivo, l'ho trovato molto utile da usare List[_]. Quindi l'avvertimento scompare e il codice descrive la realtà: è un elenco di qualcosa di sconosciuto.

Mi chiedo se questa è una soluzione alternativa adatta:

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

Non corrisponde al caso "elenco vuoto", ma genera un errore di compilazione, non un avviso!

error: type mismatch;
found:     String
requirerd: Int

Questo d'altra parte sembra funzionare ...

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

Non è forse ancora meglio o mi sto perdendo il punto qui?

Non una soluzione ma un modo di conviverci senza spazzare del tutto sotto il tappeto: aggiungere l' @uncheckedannotazione. Vedi qui - http://www.scala-lang.org/api/current/index.html#scala.unchecked

Volevo aggiungere una risposta che generalizzi il problema a: Come ottenere una rappresentazione String del tipo del mio elenco in fase di esecuzione

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

Usando la protezione della corrispondenza del modello

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