Làm thế nào để tôi có được xung quanh loại tẩy trên Scala? Hoặc, tại sao tôi không thể có được tham số loại của các bộ sưu tập của mình?

Một thực tế đáng buồn của Scala là nếu bạn khởi tạo Danh sách [Int], bạn có thể xác minh rằng cá thể của bạn là Danh sách và bạn có thể xác minh rằng bất kỳ yếu tố riêng lẻ nào của nó là Int, nhưng không phải là Danh sách [ Int], như có thể dễ dàng xác minh:

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

Tùy chọn -unchecked đặt sự đổ lỗi thẳng vào loại tẩy:

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

Tại sao vậy, và làm thế nào để tôi có được xung quanh nó?

Câu trả lời này sử dụng Manifest-API, không được dùng trong Scala 2.10. Xin vui lòng xem câu trả lời dưới đây để biết thêm các giải pháp hiện tại.

Scala được định nghĩa với Loại xóa vì Máy ảo Java (JVM), không giống như Java, không nhận được tổng quát. Điều này có nghĩa là, trong thời gian chạy, chỉ có lớp tồn tại, không phải là tham số loại của nó. Trong ví dụ này, JVM biết nó đang xử lý a scala.collection.immutable.List, nhưng không phải danh sách này được tham số hóa vớiInt .

May mắn thay, có một tính năng trong Scala cho phép bạn khắc phục điều đó. Đó là biểu hiện . Một Manifest là lớp có các thể hiện là các đối tượng đại diện cho các loại. Vì các thể hiện này là các đối tượng, bạn có thể chuyển chúng xung quanh, lưu trữ chúng và thường gọi các phương thức trên chúng. Với sự hỗ trợ của các tham số ngầm, nó trở thành một công cụ rất mạnh. Lấy ví dụ sau đây, ví dụ:

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

Khi lưu trữ một phần tử, chúng tôi cũng lưu trữ "Bản kê khai" của phần tử đó. Manifest là một lớp có các thể hiện đại diện cho các kiểu Scala. Các đối tượng này có nhiều thông tin hơn JVM, cho phép chúng tôi kiểm tra loại đầy đủ, tham số hóa.

Lưu ý, tuy nhiên, a Manifestvẫn là một tính năng đang phát triển. Như một ví dụ về những hạn chế của nó, hiện tại nó không biết gì về phương sai và cho rằng mọi thứ đều là đồng biến thể. Tôi hy vọng nó sẽ ổn định và vững chắc hơn một khi thư viện phản chiếu Scala, hiện đang được phát triển, hoàn thành.

Bạn có thể thực hiện việc này bằng TypeTags (như Daniel đã đề cập, nhưng tôi sẽ chỉ đánh vần rõ ràng):

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

Bạn cũng có thể thực hiện việc này bằng ClassTags (giúp bạn không phải phụ thuộc vào phản xạ scala):

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 có thể được sử dụng miễn là bạn không mong đợi tham số loại A chính nó là một loại chung.

Thật không may, nó hơi dài dòng và bạn cần chú thích @unchecked để chặn cảnh báo của trình biên dịch. TypeTag có thể được trình biên dịch tự động kết hợp vào mẫu phù hợp trong tương lai: https://issues.scala-lang.org/browse/SI-6517

Bạn có thể sử dụng Typeablelớp loại từ hình dạng để có được kết quả mà bạn theo sau,

Phiên REPL mẫu,

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

Các casthoạt động sẽ được xóa càng chính xác càng tốt với các Typeabletrường hợp trong phạm vi có sẵn.

Tôi đã đưa ra một giải pháp tương đối đơn giản, đủ cho các tình huống sử dụng hạn chế, về cơ bản là bọc các kiểu tham số hóa sẽ gặp phải vấn đề xóa kiểu trong các lớp bao bọc có thể được sử dụng trong câu lệnh khớp.

case class StringListHolder(list:List[String])

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

Điều này có đầu ra dự kiến ​​và giới hạn nội dung của lớp trường hợp của chúng tôi ở loại mong muốn, Danh sách chuỗi.

Thêm chi tiết tại đây: http://www.scalafied.com/?p=60

Có một cách để khắc phục vấn đề xóa kiểu trong Scala. Trong Khắc phục Loại xóa trong Kết hợp 1 và Khắc phục Loại khắc phục trong Kết hợp 2 (Phương sai) là một số giải thích về cách mã hóa một số người trợ giúp để bọc các loại, bao gồm cả Phương sai, cho phù hợp.

Tôi tìm thấy một cách giải quyết tốt hơn một chút cho giới hạn của ngôn ngữ tuyệt vời này.

Trong Scala, vấn đề xóa kiểu không xảy ra với mảng. Tôi nghĩ rằng nó dễ dàng hơn để chứng minh điều này với một ví dụ.

Hãy để chúng tôi nói rằng chúng tôi có một danh sách (Int, String), sau đó đưa ra một cảnh báo xóa

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

Để giải quyết vấn đề này, trước tiên hãy tạo một lớp trường hợp:

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

sau đó trong khớp mẫu làm một cái gì đó như:

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

mà dường như làm việc hoàn hảo.

Điều này sẽ yêu cầu các thay đổi nhỏ trong mã của bạn để làm việc với các mảng thay vì danh sách, nhưng không phải là một vấn đề lớn.

Lưu ý rằng việc sử dụng case a:Array[(Int, String)]vẫn sẽ đưa ra cảnh báo xóa kiểu, do đó cần phải sử dụng lớp container mới (trong ví dụ này IntString).

Vì Java không biết loại phần tử thực tế, tôi thấy nó hữu ích nhất khi chỉ sử dụng List[_]. Sau đó, cảnh báo biến mất và mã mô tả thực tế - đó là một danh sách của một cái gì đó chưa biết.

Tôi tự hỏi nếu đây là một cách giải quyết phù hợp:

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

Nó không khớp với trường hợp "danh sách trống", nhưng nó đưa ra một lỗi biên dịch, không phải là một cảnh báo!

error: type mismatch;
found:     String
requirerd: Int

Mặt khác, nó có vẻ hoạt động ....

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

Không phải là nó thậm chí còn tốt hơn hay tôi đang thiếu điểm ở đây?

Không phải là một giải pháp mà là một cách để sống với nó mà không quét nó dưới tấm thảm hoàn toàn: Thêm @uncheckedchú thích. Xem tại đây - http://www.scala-lang.org/api/civerse/index.html#scala.unchecked

Tôi muốn thêm một câu trả lời khái quát vấn đề vào: Làm thế nào để có được một chuỗi đại diện cho loại danh sách của tôi khi chạy

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

Sử dụng mô hình bảo vệ khớp

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