En Scala, ¿puedo anular un campo concreto que contiene una lista y anexarle algo en la subclase?

Question

Aquí es una simplificación de las clases que tengo:

trait RequiredThings { 
    val requiredThings: Seq[String] 
} 

class SimpleCalculator with RequiredThings { 
    val requiredThings = List("a", "b") 
} 

class ComplicatedCalculator extends SimpleCalculator with RequiredThings { 
    self: SimpleCalculator => 
    override val requiredThings:List[String] = List("c") ::: self.requiredThings 
} 

En esta versión, estoy usando una anotación de tipo auto, pero no estoy completamente seguro de que es el camino a seguir. Creo que probablemente podría hacerlo funcionar convirtiendo el requiredThings en un método completo, pero me gustaría probarlo como campo.

solución final:

trait RequiredThings { 
    def requiredThings: Seq[String] 
} 

class SimpleCalculator with RequiredThings { 
    def requiredThings = List("a", "b") 
} 

class ComplicatedCalculator extends SimpleCalculator with RequiredThings { 
    override def requiredThings:List[String] = List("c") ::: super.requiredThings 
} 

Answer 1

Sí, las supercompetentes a métodos "heredados" a través del tipo propio todavía no están implementadas. Esto cambiará (algo) pronto. Mientras tanto, debes usar la herencia en su lugar.

Answer 2

Tiene sentido tiene requiredThings como def al menos en el trait - esto le dará más flexibilidad

Answer 3

divertido lo suficiente, di un paso sobre el mismo tema ayer.

La forma en que se implementan los self types actualmente, si reemplaza un método (o valor) no hay forma de referirse al método reemplazado.

El siguiente bucle:

class A { def foo = "a" } 
trait B { self: A => override def foo = self.foo + "b" } 

(nota: no se puede llamar super.foo, el padre de B es ScalaObject, no A)

También probé con una indirecta más, pero el programa sigue bucles.

class A { def foo = "a"; def fooA = A.this.foo } 
trait B { this: A => override def foo = fooA + "b" } 

Actualmente hay trabajo en auto tipos, quizás esto cambie.