Як мені подолати стирання типу Scala? Або чому я не можу отримати параметр типу моїх колекцій?

Сумний факт життя Scala - це те, що якщо ви створюєте список [Int], ви можете переконатися, що ваш екземпляр є списком, і ви можете перевірити, що будь-який окремий його елемент є Int, але не що це список [ Int], як легко перевірити:

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

Опція, що не використовується, покладає звинувачення прямо на стирання типу:

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

Чому це так, і як я його обходжу?

У цій відповіді використовується Manifest-API, який застаріло, як у Scala 2.10. Будь ласка, дивіться відповіді нижче для більш сучасних рішень.

Scala був визначений за допомогою типу Erasure, оскільки віртуальна машина Java (JVM), на відміну від Java, не отримала загальної інформації. Це означає, що під час виконання існує лише клас, а не його параметри типу. У прикладі JVM знає, що це обробка а scala.collection.immutable.List, але не те, що цей список параметризований Int.

На щастя, у Scala є функція, яка дозволяє вам обійтись. Це маніфест . Маніфест - клас, екземпляри якого є об'єктами, що представляють типи. Оскільки ці екземпляри є об'єктами, ви можете передавати їх, зберігати їх і, як правило, викликати на них методи. За підтримки неявних параметрів він стає дуже потужним інструментом. Візьмемо, наприклад, такий приклад:

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

Зберігаючи елемент, ми також зберігаємо його "Маніфест". Маніфест - клас, екземпляри якого представляють типи Scala. Ці об'єкти мають більше інформації, ніж JVM, що дозволяє нам протестувати на повний параметризований тип.

Зауважте, проте, що a Manifestвсе ще розвивається. Як приклад своїх обмежень, він наразі нічого не знає про варіацію, і припускає, що все є ко-варіантом. Я очікую, що вона стане стабільнішою та міцнішою, коли бібліотека роздумів Scala, яка зараз знаходиться в стадії розробки, закінчиться.

Це можна зробити за допомогою TypeTags (як вже згадує Даніель, але я просто чітко це проговорюю):

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

Ви також можете зробити це за допомогою ClassTags (що позбавить вас від необхідності залежати від масштабування):

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 можна використовувати до тих пір, поки ви не очікуєте, що параметр типу Aсам по собі буде загальним типом.

На жаль, це трохи дослівно, і вам потрібно @uncked анотація, щоб придушити попередження компілятора. Компілятор TypeTag може бути включений у відповідність шаблонів автоматично в майбутньому компілятором: https://isissue.scala-lang.org/browse/SI-6517

Ви можете використовувати Typeableтип типу з безформних, щоб отримати результат, якого ви хочете,

Зразок сеансу 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))

castОперація буде настільки ж точним WRT стирання , наскільки це можливо , враховуючи в області видимості Typeableекземпляри доступні.

Я придумав відносно просте рішення, якого було б достатньо в ситуаціях з обмеженим використанням, по суті, обгортаючи параметризовані типи, які страждатимуть від проблеми стирання типів у класах обгортки, які можна використовувати в заяві відповідності.

case class StringListHolder(list:List[String])

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

Це має очікуваний вихід і обмежує вміст нашого класу випадків потрібним типом, списками рядків.

Детальніше тут: http://www.scalafied.com/?p=60

Існує спосіб подолати проблему стирання типу Scala. У розділі " Подолання стирання типу" у зіставленні 1 та " Подолання стирання типу" у "Збігу 2" (Варіант) є деякі пояснення того, як кодувати деякі помічники для обгортання типів, включаючи Варіант, для відповідності.

Я знайшов дещо кращий спосіб вирішити це обмеження інакше приголомшливої ​​мови.

У Scala питання стирання типу не виникає з масивами. Я думаю, що простіше продемонструвати це на прикладі.

Скажімо, у нас є список (Int, String), а далі наведено попередження про стирання типу

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

Щоб вирішити це, спочатку створіть клас корпусу:

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

то в узгодженні шаблону робіть щось на кшталт:

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

який, здається, працює чудово.

Це потребує незначних змін у вашому коді для роботи з масивами замість списків, але це не повинно бути головною проблемою.

Зауважте, що використання case a:Array[(Int, String)]все ще надасть попередження про стирання типу, тому необхідно використовувати новий клас контейнерів (у цьому прикладі IntString).

Оскільки Java не знає фактичного типу елементів, я вважаю найкориснішим просто використовувати List[_]. Тоді попередження відходить і код описує реальність - це список чогось невідомого.

Мені цікаво, чи це підходящий спосіб вирішення:

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

Він не відповідає випадку "порожнього списку", але він дає помилку компіляції, а не попередження!

error: type mismatch;
found:     String
requirerd: Int

З іншого боку, це, здається, працює ...

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

Хіба це нічим не краще, чи я тут пропускаю суть?

Не рішення, а спосіб жити з ним, не засуваючи його під килим: Додавання @uncheckedанотації. Дивіться тут - http://www.scala-lang.org/api/current/index.html#scala.uncked

Я хотів додати відповідь, яка узагальнює проблему: Як отримати рядкове представлення типу мого списку під час виконання

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

Використовуючи захист відповідності шаблону

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