Supongamos que uno quiere construir una nueva clase genérica,Novel[A]. Esta clase contendrá muchos métodos útiles, tal vez es un tipo de colección, y por lo tanto, desea subclasificarla. Pero desea que los métodos devuelvan el tipo de la subclase, no el tipo original. En Scala 2.8, ¿cuál es la cantidad mínima de trabajo que uno tiene que hacer para que los métodos de esa clase devuelvan la subclase relevante, no la original? Por ejemplo,

class Novel[A] /* What goes here? */ {
  /* Must you have stuff here? */
  def reverse/* What goes here instead of :Novel[A]? */ = //...
  def revrev/*?*/ = reverse.reverse
}
class ShortStory[A] extends Novel[A] /* What goes here? */ {
  override def reverse: /*?*/ = //...
}
val ss = new ShortStory[String]
val ss2 = ss.revrev  // Type had better be ShortStory[String], not Novel[String]

¿Esta cantidad mínima cambia si quieres?Novel ser covariante?

(Las colecciones 2.8 hacen esto entre otras cosas, pero también juegan con los tipos de retorno de maneras más elegantes (y útiles): la pregunta es cuán poco marco puede salirse si solo quiere estos subtipos-siempre-retorno-subtipos característica.)

Editar: Suponga en el código anterior quereverse hace una copia Si se realiza una modificación en el lugar y luego se devuelve, se puede usarthis.type, pero eso no funciona porque la copia no esthis.

Arjan se vinculó a otra pregunta que sugiere la siguiente solución:

def reverse: this.type = {
  /*creation of new object*/.asInstanceOf[this.type]
}

que básicamente se basa en el sistema de tipos para obtener lo que queremos. Pero esto no es realmente una solución, porque ahora que hemos mentido al sistema de tipos, el compilador no puede ayudarnos a asegurarnos de que realmentehacer obtener unaShortStory cuando pensamos que lo hacemos (Por ejemplo, no tendríamos que anularreverse en el ejemplo anterior para hacer feliz al compilador, pero nuestros tipos no serían lo que queríamos).