Вы можете сделать это, используя 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 (что избавляет вас от необходимости зависеть от 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 можно использовать до тех пор, пока вы не ожидаете, что параметр типа Aсам по себе является универсальным типом.

К сожалению, это немного многословно, и вам нужна аннотация @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Операция будет столь же точным WRT стирания , насколько это возможно , учитывая в области видимости Typeableэкземпляры доступны.

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

case class StringListHolder(list:List[String])

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

Это имеет ожидаемый результат и ограничивает содержимое нашего класса case желаемым типом, String Lists.

Подробнее здесь: http://www.scalafied.com/?p=60

В Scala есть способ преодолеть проблему стирания типов. В книге «Преодоление стирания типов при сопоставлении 1» и « Преодоление стирания типов при сопоставлении 2» (дисперсия) приводятся некоторые объяснения того, как закодировать некоторые помощники для переноса типов, включая дисперсию, для сопоставления.

Я нашел немного лучший обходной путь для этого ограничения в остальном отличном языке.

В Scala проблема стирания типов не возникает с массивами. Я думаю, что это легче продемонстрировать на примере.

Допустим, у нас есть список (Int, String), тогда следующее выдает предупреждение об удалении типа

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

Чтобы обойти это, сначала создайте класс case:

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

Я хотел добавить ответ, который обобщает проблему: Как получить представление типа String типа моего списка во время выполнения

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
     }