Problema "MyType": Devo usare tipi astratti (o generici) in Scala per restituire la classe effettiva?

Question

io non sono sicuro se c'è un modo migliore di fare questo:

trait Animal { 
    val name: String 
    val weight: Int 

    type SubAnimal <: Animal 

    def updateName(n: String) = returnMe(n, this.weight) 
    def updateWeight(w: Int) = returnMe(this.name, w) 
    // Abstract protected method 
    protected def returnMe(n: String, w: Int): SubAnimal 
} 

case class Dog(name: String, weight: Int) extends Animal { 
    type SubAnimal = Dog 
    override def returnMe(n: String, w: Int): Dog = Dog("Dog: " + name, w) 
} 
case class Cat(name: String, weight: Int) extends Animal { 
    type SubAnimal = Cat 
    override def returnMe(n: String, w: Int): Cat = Cat("Cat: " + name, w) 
} 

val fido = Dog("Fido", 11) 
println(fido) 
val fido2 = fido.updateWeight(12) 
println(fido2) 

Quando eseguo il codice ottengo questo output:

$ scala animal.scala 
Dog(Fido,11) 
Dog(Dog: Fido,12) 

voglio restituire il tipo effettivo dell'animale in questione dopo che è stato chiamato il updateName o updateWeight (ovvero non Animal). So che se si esegue l'override direttamente su updateName e updateWeight, verrà restituito il tipo corretto e non è necessario utilizzare il tipo astratto SubAnimal.

Esiste qualche modo complicato di sfuggire al tipo astratto per il caso speciale in cui il valore del tipo astratto è lo uguale alla sottoclasse?

(questo è noto come problema "MyType").

Answer 1

Alcuni recent discussion su questo argomento ... quello che stai cercando è comunemente indicato come "MyType", e il tipico codifica Scala/Java per esso utilizza i parametri di tipo ricorsive:

public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable { 
    public final int compareTo(E o) 
    // ... 
} 

Answer 2

Utilizzo della parametrizzazione del tipo?

trait Animal[A <: Animal[A]] { 
    val name: String 
    val weight: Int 

    def updateName(n: String) = returnMe(n, this.weight) 
    def updateWeight(w: Int) = returnMe(this.name, w) 
    // Abstract protected method 
    protected def returnMe(n: String, w: Int): A 
} 

case class Dog(name: String, weight: Int) extends Animal[Dog] { 
    override def returnMe(n: String, w: Int) = Dog("Dog: " + name, w) 
} 

case class Cat(name: String, weight: Int) extends Animal[Cat] { 
    override def returnMe(n: String, w: Int) = Cat("Cat: " + name, w) 
} 

Answer 3

Questo dovrebbe funzionare:

trait Animal[T] { 
    self:T => 

    val name: String 
    val weight: Int 

    def updateName(n: String): T = returnMe(n, this.weight) 
    def updateWeight(w: Int): T = returnMe(this.name, w) 
    // Abstract protected method 
    protected def returnMe(n: String, w: Int): T 
} 

case class Dog(name: String, weight: Int) extends Animal[Dog] { 
    override def returnMe(n: String, w: Int): Dog = Dog("Dog: " + name, w) 
} 

case class Cat(name: String, weight: Int) extends Animal[Cat] { 
    override def returnMe(n: String, w: Int): Cat = Cat("Cat: " + name, w) 
} 

Qualcosa di simile case class Cat(name: String, weight: Int) extends Animal[Dog] viene rifiutato dal compilatore. Codice rubato adattato da http://oldfashionedsoftware.com/2009/12/10/self-help/