Tratti Scala e tipi strutturali: può un tratto estendere un tipo strutturale e quindi chiamare super?

Question

Mi piacerebbe avere un tratto che può a) essere mescolato in qualsiasi classe con un metodo particolare, e b) può chiamare super. Qualcosa di simile:

// A and B are from a library that I don't control. No changes allowed here. 
    class A { 
    def stuff = "a stuff" 
    } 
    class B { 
    def stuff = "b stuff" 
    } 

    // My code starts here 

    type HasStuffMethod = { 
    def stuff: String 
    } 

    // Note that this doesn't compile - gets: 
    // class type required but AnyRef{def stuff: String} found 
    trait ImplementsStuff extends HasStuffMethod { 
    override def stuff = "trait + " + super.stuff 
    } 

    val a = new A with ImplementsStuff 
    assert(a.stuff == "trait + a stuff") 

    val b = new B with ImplementsStuff 
    assert(b.stuff == "trait + b stuff") 

C'è un modo per fare questo?

Si noti che non controllo A e B; vengono da un'altra libreria che non posso modificare.

[Edit - ha aggiunto dopo aver visto le risposte]

C'è un modo per chiamare il metodo originale in qualcosa di simile?

trait ImplementsStuff { 
    this: HasStuffMethod => 
    abstract override def stuff = "foo" + "how do I call the original method here?" 
    } 

Questo non è utile, dal momento che quando si mescolano in qualcosa dà:

error: overriding method stuff in class A of type => java.lang.String; method stuff in trait ImplementsStuff of type => java.lang.String cannot override a concrete member without a third member that's overridden by both (this rule is designed to prevent ``accidental overrides'')

Ma non è un caso; si, voglio davvero che tu faccia un passo su quel metodo esistente. E poi lascia che lo chiami anche io.

Answer 1

In questo caso è necessario un abstract override.

Answer 2

Mi vengono in mente due opzioni:

l'opzione 1, utilizzando un tipo di auto annotazione e chiamando stuff da un nuovo metodo (che ho chiamato fantasiosamente callStuff) invece di rilevante esso.

trait ImplementsStuff { 
    this: HasStuffMethod => 
    def callStuff = "trait + " + this.stuff 
    } 

    val a = new A with ImplementsStuff 
    assert(a.callStuff == "trait + a stuff") 

    val b = new B with ImplementsStuff 
    assert(b.callStuff == "trait + b stuff") 

opzione 2 (dal momento che si dice di non controllare A e B) è il caro vecchio modello decoratore.

trait HasStuff { def stuff: String } 

    class DecorateStuff(decorated: HasStuffMethod) extends HasStuff { 
    def stuff = "trait + " + decorated.stuff 
    } 
    val decA = new DecorateStuff(new A) 
    assert(decA.stuff == "trait + a stuff") 

    val decB = new DecorateStuff(new B) 
    assert(decB.stuff == "trait + b stuff") 

Answer 3

Non v'è alcun modo per estendere un tipo raffinato a Scala (io non sono sicuro che questo potrebbe essere tirato fuori in modo sicuro, ma sarebbe interessante esplorare).

Ho una soluzione che è più dettagliata, ma ti avvicina al tuo obiettivo.

trait HasStuff { 
    def theirStuff: String 
} 

trait ImplementsStuff extends HasStuff { 
    def stuff = "trait + " + theirStuff 
} 

Si noti che invece di un tipo raffinato ho un tratto e lo estendo nell'implementazione. Devo aggiungere manualmente i superaccessori, lo faccio per delega. HasStuff li definisce e li implementano sul sito mixin:

val a = new A with ImplementsStuff { 
    def theirStuff = super[A].stuff 

    override def stuff = super[ImplementsStuff].stuff 
} 

val b = new B with ImplementsStuff { 
    def theirStuff = super[B].stuff 

    override def stuff = super[ImplementsStuff].stuff 
} 

Presso il sito mixin ho bisogno di implementare la funzione di accesso super (theirStuff) per trasmettere al metodo giusto ereditato. Devo anche eseguire l'override di stuff a questo livello, dal momento che ImplementsStuff non eredita un metodo stuff, pertanto non può essere impostato su override.

Calling stuff su a e b mostra è stato ignorato:

$ a.stuff 
res0: java.lang.String = trait + a stuff 

$ b.stuff 
res1: java.lang.String = trait + b stuff