metodos - scala introduccion

Llamando a un método en la superclase en un rasgo autodeclarado en scala

Question

Estoy tratando de crear un rasgo que, al mezclarse, reemplazará la definición predeterminada de un método con uno que llama al método original y luego manipula el resultado.

Esto es lo que estoy tratando de hacer:

class Foo {
  def bar() : String = "Foos bar"
}

trait OtherStuff {
  self : Foo =>
  def bar() : String = self.bar() + " with OtherStuff"
}

class Quux extends Foo with OtherStuff

Si esto funcionó como yo quería, entonces (new Quux).bar ahora devolvería la Foos bar with OtherStuff . Desafortunadamente, no funciona de esa manera, lo que obtengo es:

<console>:6: error: error overriding method bar in class Foo of type ()String;
 method bar in trait OtherStuff of type ()String needs `override'' modifier
       class Quux extends Foo with OtherStuff

Pero si utilizo override al definir OtherStuff , obtengo:

<console>:7: error: method bar overrides nothing
         override def bar() : String = self.bar() + " with OtherStuff"

¿Es posible anular un método en un auto-tipo usando un rasgo? Si no, cambiará OtherStuff para que sea un rasgo que extends Foo lugar de uno que tenga un tipo de Foo haga algo malo en todo el código que existe diciendo cosas como

class WhatEver extends Foo with Xyz with Pqr with OtherStuff with Abc

Estoy trabajando en scala 2.7.7 porque esta es una regla de compilación sbt, y aún no hemos actualizado nuestro proyecto sbt a las versiones 0.10.x. (Los plugins de los que dependemos todavía no están listos)

Answer 1

Necesitas una abstract override y ningún tipo de auto para eso.

trait OtherStuff extends Foo {                                
  abstract override def bar() = super.bar() + " with OtherStuff"
}

Entonces la class Quux extends Foo with OtherStuff hace lo que quieres.

Este artículo puede ser de interés.

Answer 2

O puedes hacer una sobrecarga como la siguiente

class Foo {
  def bar() : String = "Foos bar"}
trait OtherStuff {
  self : Foo =>
  def bar( s : String) : String = self.bar() + s}

class Quux extends Foo with OtherStuff
(new Quux).bar(" with other stuff")

La cosa es que, con la anotación de auto tipo, la "otra cosa" definida en OtherStuff es parte de Foo cuando el Rasgo se mezcla con Foo, en lugar de una relación de subtipo.