Wie komme ich um das Löschen von Schriftarten auf Scala herum? Oder warum kann ich den Typparameter meiner Sammlungen nicht abrufen?

Es ist eine traurige Tatsache in Scala, dass Sie, wenn Sie eine Liste [Int] instanziieren, überprüfen können, ob Ihre Instanz eine Liste ist, und Sie können überprüfen, ob jedes einzelne Element davon eine Int ist, aber nicht, dass es eine Liste ist [ Int], wie leicht zu überprüfen ist:

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?!

Mit der Option -unchecked liegt die Schuld direkt beim Löschen des Typs:

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?!

Warum ist das so und wie komme ich darum herum?

Diese Antwort verwendet die Manifest-API, die ab Scala 2.10 veraltet ist. Weitere aktuelle Lösungen finden Sie in den Antworten unten.

Scala wurde mit Type Erasure definiert, da die Java Virtual Machine (JVM) im Gegensatz zu Java keine Generika erhielt. Dies bedeutet, dass zur Laufzeit nur die Klasse vorhanden ist, nicht ihre Typparameter. In diesem Beispiel weiß JVM, dass es eine verarbeitet scala.collection.immutable.List, aber nicht, dass diese Liste mit parametrisiert ist Int.

Glücklicherweise gibt es in Scala eine Funktion, mit der Sie das umgehen können. Es ist das Manifest . Ein Manifest ist eine Klasse, deren Instanzen Objekte sind, die Typen darstellen. Da es sich bei diesen Instanzen um Objekte handelt, können Sie sie weitergeben, speichern und im Allgemeinen Methoden für sie aufrufen. Mit der Unterstützung impliziter Parameter wird es zu einem sehr leistungsfähigen Werkzeug. Nehmen Sie zum Beispiel das folgende Beispiel:

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

Beim Speichern eines Elements speichern wir auch ein "Manifest" davon. Ein Manifest ist eine Klasse, deren Instanzen Scala-Typen darstellen. Diese Objekte enthalten mehr Informationen als JVM, sodass wir den vollständigen, parametrisierten Typ testen können.

Beachten Sie jedoch, dass sich a Manifestimmer noch weiterentwickelt. Als Beispiel für seine Einschränkungen weiß es derzeit nichts über Varianz und geht davon aus, dass alles eine Co-Variante ist. Ich gehe davon aus, dass es stabiler und solider wird, sobald die derzeit in Entwicklung befindliche Scala-Reflexionsbibliothek fertig ist.

Sie können dies mit TypeTags tun (wie Daniel bereits erwähnt, aber ich werde es nur explizit formulieren):

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

Sie können dies auch mit ClassTags tun (wodurch Sie sich nicht auf Scala-Reflect verlassen müssen):

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 können verwendet werden, solange Sie nicht erwarten, dass der Typparameter Aselbst ein generischer Typ ist.

Leider ist es etwas ausführlich und Sie benötigen die Annotation @unchecked, um eine Compiler-Warnung zu unterdrücken. Das TypeTag wird möglicherweise in Zukunft vom Compiler automatisch in die Musterübereinstimmung integriert: https://issues.scala-lang.org/browse/SI-6517

Du kannst den ... benutzen Typeable Typklasse von formlos verwenden , um das gewünschte Ergebnis zu erhalten.

Beispiel einer REPL-Sitzung,

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

Der castVorgang wird angesichts der Typeableverfügbaren In-Scope- Instanzen so genau wie möglich gelöscht .

Ich habe eine relativ einfache Lösung gefunden, die in Situationen mit eingeschränkter Verwendung ausreicht und im Wesentlichen parametrisierte Typen umschließt, die unter dem Typlöschproblem in Wrapper-Klassen leiden, die in einer Übereinstimmungsanweisung verwendet werden können.

case class StringListHolder(list:List[String])

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

Dies hat die erwartete Ausgabe und begrenzt den Inhalt unserer Fallklasse auf den gewünschten Typ, String Lists.

Weitere Details hier: http://www.scalafied.com/?p=60

Es gibt eine Möglichkeit, das Problem der Typlöschung in Scala zu lösen. Unter Überwinden der Typlöschung in Matching 1 und Überwinden der Typlöschung in Matching 2 (Varianz) finden Sie einige Erläuterungen zum Codieren einiger Helfer, um die Typen, einschließlich Varianz, für den Matching zu verpacken.

Ich habe eine etwas bessere Problemumgehung für diese Einschränkung der ansonsten fantastischen Sprache gefunden.

In Scala tritt das Problem der Typlöschung bei Arrays nicht auf. Ich denke, es ist einfacher, dies anhand eines Beispiels zu demonstrieren.

Nehmen wir an, wir haben eine Liste von (Int, String), dann gibt das Folgende eine Art Löschwarnung

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

Um dies zu umgehen, erstellen Sie zunächst eine Fallklasse:

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

dann mache im Pattern Matching so etwas wie:

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

das scheint perfekt zu funktionieren.

Dies erfordert geringfügige Änderungen in Ihrem Code, um mit Arrays anstelle von Listen zu arbeiten, sollte jedoch kein großes Problem darstellen.

Beachten Sie, dass bei Verwendung case a:Array[(Int, String)]weiterhin eine Warnung zum Löschen des Typs ausgegeben wird. Daher muss eine neue Containerklasse verwendet werden (in diesem Beispiel IntString).

Da Java den tatsächlichen Elementtyp nicht kennt, fand ich es am nützlichsten, ihn nur zu verwenden List[_]. Dann verschwindet die Warnung und der Code beschreibt die Realität - es ist eine Liste von etwas Unbekanntem.

Ich frage mich, ob dies eine geeignete Problemumgehung ist:

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

Es stimmt nicht mit dem Fall "leere Liste" überein, aber es gibt einen Kompilierungsfehler, keine Warnung!

error: type mismatch;
found:     String
requirerd: Int

Dies scheint auf der anderen Seite zu funktionieren ....

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

Ist es nicht noch besser oder verpasse ich den Punkt hier?

Keine Lösung, sondern eine Möglichkeit, damit zu leben, ohne es unter den Teppich zu kehren: Hinzufügen der @uncheckedAnmerkung. Siehe hier - http://www.scala-lang.org/api/current/index.html#scala.unchecked

Ich wollte eine Antwort hinzufügen, die das Problem verallgemeinert: Wie erhalte ich zur Laufzeit eine String-Darstellung des Typs meiner Liste?

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

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