ฉันจะลบประเภทใน Scala ได้อย่างไร หรือเหตุใดฉันจึงไม่สามารถรับพารามิเตอร์ type ของคอลเล็กชันของฉันได้

มันเป็นความจริงที่น่าเศร้าของชีวิตใน Scala ที่ว่าถ้าคุณยกตัวอย่าง List [Int] คุณสามารถตรวจสอบว่าอินสแตนซ์ของคุณเป็น List และคุณสามารถตรวจสอบได้ว่าองค์ประกอบใด ๆ ของมันเป็น Int แต่ไม่ใช่ว่าเป็น List 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?!

ตัวเลือก -Checked ทำให้ตำหนิอย่างเต็มที่ในการลบประเภท:

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 ถูกกำหนดด้วย Type Erasure เนื่องจาก Java Virtual Machine (JVM) ซึ่งแตกต่างจาก Java ไม่ได้รับข้อมูลทั่วไป ซึ่งหมายความว่า ณ เวลารันไทม์มีคลาสเท่านั้นไม่ใช่พารามิเตอร์ชนิด ในตัวอย่าง JVM รู้ว่ามันมีการจัดการแต่ไม่ว่ารายการนี้จะถูกแปรด้วยscala.collection.immutable.ListInt

โชคดีที่มีคุณลักษณะในสกาล่าที่ช่วยให้คุณสามารถแก้ไขได้ มันเป็นManifest Manifest เป็นคลาสที่อินสแตนซ์เป็นวัตถุที่เป็นตัวแทนประเภท เนื่องจากอินสแตนซ์เหล่านี้เป็นวัตถุคุณสามารถส่งต่อไปเก็บและโดยทั่วไปเรียกวิธีการเหล่านั้น ด้วยการสนับสนุนพารามิเตอร์โดยนัยมันจะกลายเป็นเครื่องมือที่ทรงพลังมาก ยกตัวอย่างเช่น

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

เมื่อจัดเก็บองค์ประกอบเราจะจัดเก็บ "รายการ" ด้วย Manifest เป็นคลาสที่อินสแตนซ์แสดงประเภท Scala วัตถุเหล่านี้มีข้อมูลมากกว่าที่ JVM ทำซึ่งทำให้เราสามารถทดสอบชนิดที่กำหนดพารามิเตอร์แบบเต็ม

อย่างไรก็ตามโปรดทราบว่า a Manifestยังคงเป็นคุณสมบัติที่พัฒนาขึ้น เป็นตัวอย่างของข้อ จำกัด ปัจจุบันมันไม่รู้อะไรเลยเกี่ยวกับความแปรปรวนและสมมติว่าทุกอย่างเป็นตัวแปรร่วม ฉันคาดหวังว่ามันจะมีเสถียรภาพมากขึ้นและมั่นคงเมื่อห้องสมุดสะท้อน Scala ปัจจุบันภายใต้การพัฒนาเสร็จแล้ว

คุณสามารถทำได้โดยใช้ TypeTags (ตามที่ Daniel พูดถึงแล้ว แต่ฉันจะอธิบายให้ชัดเจน):

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ตัวเองจะเป็นประเภททั่วไป

น่าเสียดายที่มันเป็น verbose เล็ก ๆ น้อย ๆ และคุณจำเป็นต้องมีคำอธิบายประกอบ @unchecked เพื่อยับยั้งการเตือนคอมไพเลอร์ TypeTag อาจรวมอยู่ในการจับคู่รูปแบบโดยอัตโนมัติโดยคอมไพเลอร์ในอนาคต: https://issues.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ดำเนินการจะถูกลบอย่างแม่นยำมากที่สุดเท่าที่เป็นไปได้เนื่องจากTypeableอินสแตนซ์ในขอบเขตพร้อมใช้งาน

ฉันคิดวิธีแก้ปัญหาง่ายๆที่พอเพียงในสถานการณ์ที่ จำกัด การใช้งานการห่อประเภทพารามิเตอร์ที่จะประสบปัญหาการลบประเภทในคลาส wrapper ที่สามารถใช้ในการจับคู่คำสั่ง

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.unchecked

ฉันต้องการเพิ่มคำตอบที่ generalises ปัญหา: ได้รับการเป็นตัวแทน String ประเภทของรายการของฉันที่ runtime

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
     }