¿Cómo puedo unir clases en una declaración de "coincidencia" de Scala?

Question

¿Cómo puedo usar una declaración de "coincidencia" para identificar el valor de una variable de clase? El siguiente es válida, y no puedo encontrar una variante aceptable - que no sea otra cosa si ... si ... si no ...

val c: Class[_] = classOf[Int] 
val what = c match { case classOf[Int] => "int!"; case classOf[Float] => "float!" } 

El compilador se queja: error: not found: type classOf

Y, por supuesto , no puedo usar Class[Int] debido a que la información se borra tipo: variantes

c match { case Class[Int] => "int!"; case Class[Float] => "float!" } 
error: type Class of type Class does not take type parameters. 

también he intentado como Int.class, todo fue en vano. (Y realmente no quiero convertir cadenas: creo que es importante que el compilador tome clases renombradas/movidas).

¿Estoy siendo denso o me he topado con un punto ciego de Scala?

Answer 1

Puede coincidir con los valores de la clase si se crea un identificador estable (es decir. Un val) para ellos,

scala> val c: Class[_] = classOf[Int] 
c: Class[_] = int 

scala> val ClassOfInt = classOf[Int] 
ClassOfInt: java.lang.Class[Int] = int 

scala> val ClassOfFloat = classOf[Float] 
ClassOfFloat: java.lang.Class[Float] = float 

scala> val what = c match { 
    |  case ClassOfInt => "int!" 
    |  case ClassOfFloat => "float!" 
    | } 
what: String = int! 

Tenga en cuenta que no puede coincidir con el tipo (es decir. Clase [Int]), porque borrado significa que los diferentes instanciaciones tipo de clase de [T] son ​​indistinguibles en tiempo de ejecución ... por lo tanto la siguiente advertencia

scala> val what = c match { 
    |  case _: Class[Int] => "int!" 
    |  case _: Class[Float] => "float!" 
    | } 
warning: there were 2 unchecked warnings; re-run with -unchecked for details 
what: java.lang.String = int! 

Answer 2

La comparación de casos detallado funciona:

val what = c match { 
    case q if q == classOf[Int] => "int!" 
    case q if q == classOf[Float] => "float!" 
} 

Por supuesto, ser un identificador minúscula, classOf no debería trabajar directamente en un comunicado el caso de todos modos. Sin embargo, tampoco lo hace un trabajo escapado

case `classOf`[Int] 

en este caso, por lo que tendrá que ir con la if cuerpo de guardia.

Answer 3

me encontré con el mismo problema y la colocación de la clase en un 'identificador estable' no era tan práctico . Encontré que la siguiente mejor opción era tener ordenadas declaraciones de 'else if'.

uso de este método:

private def is[T <: AnyRef : Manifest](implicit cls: Class[_]) = 
    cls == manifest[T].runtimeClass 

Puedo escribir:

implicit val arg = cls 
    if (is[ClassA]) ... 
    else if (is[ClassB]) ... 
    ... 
    else throw new IllegalArgumentException("Unknown class: " + cls) 

Answer 4

Considerar la herencia:

val what = c match { 
    case q if classOf[Int].isAssignableFrom(q) => "int!" 
    case q if classOf[Float].isAssignableFrom(q) => "float!" 
}