Scala'da nasıl silinir? Ya da neden koleksiyonlarımın type parametresini alamıyorum?

Scala'da yaşamın üzücü bir gerçeği, bir Liste [Int] başlatırsanız, örneğinizin bir Liste olduğunu doğrulayabilir ve bunun herhangi bir öğesinin Int olduğunu doğrulayabilirsiniz, ancak bir Liste olmadığını doğrulayabilirsiniz [ Int], kolayca doğrulanabilir:

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

-Konuklanmış seçenek suçu düzgün bir şekilde silme işlemine sokar:

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

Bu neden ve nasıl dolaşırım?

Bu cevapta ManifestScala 2.10'dan itibaren kullanımdan kaldırılmış olan -API kullanılmıştır. Daha güncel çözümler için lütfen aşağıdaki yanıtlara bakın.

Scala, Type Erasure ile tanımlandı çünkü Java'nın aksine Java Sanal Makinesi (JVM) jenerikler alamadı. Bu, çalışma zamanında tür sınıflarının değil, yalnızca sınıfın var olduğu anlamına gelir. Örnekte, JVM, a'nın işlediğini biliyor scala.collection.immutable.List, ancak bu listeninInt .

Neyse ki, Scala'da bunun üstesinden gelmenizi sağlayan bir özellik var. Bu Manifest . Bir Manifest, örnekleri türleri temsil eden nesnelerdir. Bu örnekler nesne olduğundan, bunları etrafa aktarabilir, depolayabilir ve genellikle bunlara yöntem çağırabilirsiniz. Örtük parametrelerin desteği ile çok güçlü bir araç haline gelir. Örneğin aşağıdaki örneği ele alalım:

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

Bir öğeyi saklarken, onun bir "Bildirisi" de saklarız. Manifest, örnekleri Scala tiplerini temsil eden bir sınıftır. Bu nesneler, tam, parametrelenmiş türü test etmemizi sağlayan JVM'den daha fazla bilgiye sahiptir.

Ancak Manifesta'nın hala gelişen bir özellik olduğuna dikkat edin . Sınırlamalarının bir örneği olarak, şu anda varyans hakkında hiçbir şey bilmiyor ve her şeyin birlikte varyant olduğunu varsayıyor. Halen geliştirme aşamasında olan Scala yansıma kütüphanesi bittikten sonra daha istikrarlı ve sağlam hale gelmesini bekliyorum.

Bunu TypeTags kullanarak yapabilirsiniz (Daniel'in belirttiği gibi, ancak açıkça açıkça söyleyeceğim):

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

Bunu ClassTags kullanarak da yapabilirsiniz (bu sizi scala-yansıtmaya bağımlı olmaktan kurtarır):

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, type parametresinin Akendisinin genel bir tür olmasını beklemediğiniz sürece kullanılabilir .

Ne yazık ki biraz ayrıntılı ve derleyici uyarısını bastırmak için @eckecked ek açıklamaya ihtiyacınız var. TypeTag gelecekte derleyici tarafından otomatik olarak kalıp eşleşmesine dahil edilebilir: https://issues.scala-lang.org/browse/SI-6517

Sen kullanabilirsiniz Typeablegelen tip sınıfını shapeless peşinde olduğunuz sonuç almak için,

Örnek REPL oturumu,

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

Mevcut castkapsam içi Typeabledurumlar göz önüne alındığında, işlem mümkün olduğunca hassas bir şekilde silinecektir .

Sınırlı kullanım durumlarında yeterli olacak nispeten basit bir çözüm buldum, aslında bir eşleşme ifadesinde kullanılabilecek sarıcı sınıflarında tür silme probleminden muzdarip olacak parametrelenmiş türleri sarma.

case class StringListHolder(list:List[String])

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

Bu beklenen çıktıya sahiptir ve vaka sınıfımızın içeriğini istenen Dize Listeleri türüyle sınırlar.

Daha fazla ayrıntı burada: http://www.scalafied.com/?p=60

Scala'da tip silme sorununun üstesinden gelmenin bir yolu var. Gelen eşleştirme 1'de Üstesinden Tip Erasure'in ve Matching Üstesinden Tip Erasure'in 2 (Varyans) koduna bazı yardımcıları eşleştirme için, Varyans dahil türlerini sarmak için nasıl bir açıklaması vardır.

Aksi takdirde harika dilin bu sınırlaması için biraz daha iyi bir çözüm buldum.

Scala'da türlerde silme sorunu dizilerde görülmez. Bunu bir örnekle göstermenin daha kolay olduğunu düşünüyorum.

Diyelim ki bir listemiz var (Int, String), sonra aşağıdakiler bir tür silme uyarısı veriyor

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

Bu sorunu çözmek için önce bir vaka sınıfı oluşturun:

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

daha sonra desen eşleşmesinde şöyle bir şey yapın:

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

ki bu mükemmel çalışıyor.

Bu, listeler yerine dizilerle çalışmak için kodunuzda küçük değişiklikler gerektirir, ancak büyük bir sorun olmamalıdır.

Kullanmanın case a:Array[(Int, String)]yine de bir tür silme uyarısı vereceğini unutmayın , bu nedenle yeni bir kapsayıcı sınıfı kullanmak gerekir (bu örnekte IntString).

Java gerçek eleman türünü bilmediğinden, sadece kullanmak için en kullanışlı buldum List[_]. Sonra uyarı kaybolur ve kod gerçeği tanımlar - bilinmeyen bir şeyin listesidir.

Bunun uygun bir çözüm olup olmadığını merak ediyorum:

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

"Boş liste" durumu ile eşleşmiyor, ancak uyarı değil derleme hatası veriyor!

error: type mismatch;
found:     String
requirerd: Int

Bu da işe yarıyor gibi görünüyor ....

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

Biraz daha iyi değil mi yoksa buradaki noktayı kaçırıyor muyum?

Bir çözüm değil, halıyı tamamen süpürmeden onunla yaşamak için bir yol: @uncheckedEk açıklama eklemek . Buraya bakın - http://www.scala-lang.org/api/current/index.html#scala.unchecked

Sorunu genelleştiren bir cevap eklemek istedim: Nasıl bir çalışma zamanında benim liste türü bir dize temsili almak

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

Desen eşleştirme korumasını kullanma

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