Extracción de tipo en Scala

Question

Soy bastante nuevo en Scala y en lenguajes de programación avanzados. Intento resolver el siguiente problema.

que han conseguido:

val s: Seq[SomeMutableType[_]] 

que asumen que todos los elementos de la secuencia son del mismo tipo (pero no sabe cuál en este punto).

¿En qué puedo llamar:

def proc[T](v0: SomeMutableType[T], v1: SomeMutableType[T]) { /* ... */ } 

con algo como

proc(s(0), s(1)) 

El compilador se queja:

• coincidencia de tipos; found: SomeMutableType [_ $ 351] donde type _ $ 351 required: SomeMutableType [Any] Nota: _ $ 351 <: Cualquiera, pero la clase SomeMutableType es invariable en el tipo T. Es posible que desee definir T como + T. (SLS 4,5)

pensé en esa cosa covariante, pero no creo que tiene sentido en mi caso. Solo quiero que el compilador me crea cuando digo que s (0) y s (1) son del mismo tipo. Normalmente hago esto a través de un casting, pero no puedo convertir a SomeMutableType [T] aquí ya que T es desconocido debido a borrado. Por supuesto, no puedo cambiar la definición de proc.

Answer 1

Soy nuevo en Scala, pero por lo que puedo ver su problema es el uso de un parámetro de tipo comodín cuando se declara s:

val s: Seq[SomeMutableType[_]] 

Por lo que yo entiendo, el tipo de borrado sucederá siempre y lo que realmente quiere aquí es un tipo parametrizado vinculado a donde s se inicializa.

Por ejemplo:

scala> class Erased(val s: List[_]) 
defined class Erased 

scala> new Erased(List(1,2,3)).s.head 
res21: Any = 1 

Si en lugar de utilizar

scala> class Kept[T](val s: List[T]) 
defined class Kept 

scala> new Kept(List(1,2,3)).s.head 
res22: Int = 1 

A continuación, el contenido de s mantienen su información de tipo al que le obligan a T. Es decir, este es exactamente como se indica al compilador "que s (0) y s (1) son del mismo tipo".

Answer 2

El problema es que realmente no puede hacer esa garantía. Por ejemplo:

scala> import scala.collection.mutable.Buffer 
import scala.collection.mutable.Buffer 

scala> val s: Seq[Buffer[_]] = Seq(Buffer(1), Buffer("a")) 
s: Seq[scala.collection.mutable.Buffer[_]] = List(ArrayBuffer(1), ArrayBuffer(a)) 

Ver? Usted no sabe sabe que s(0) y s(1) son del mismo tipo, porque pueden no ser del mismo tipo.

En este punto, debe hacer una pregunta acerca de lo que quiere lograr, en lugar de preguntar cómo resolver un problema en cómo desea lograrlo. La forma en que tomaste no funcionará. Retroceda, piense qué problema estaba tratando de resolver con este enfoque y pregúntele cómo resolver ese problema.

Por ejemplo, dicen:

Asumo que todos los elementos de la secuencia son del mismo tipo (pero no saben lo que uno en este punto).

Es posible que lo que quiera hacer sea parametrizar una clase o método, y use su parámetro de tipo al declarar s. O, tal vez, no tener un s en absoluto.