È possibile estendere un'implementazione di metodo predefinita di un tratto in una struttura?

Question

Nei linguaggi orientati agli oggetti tradizionali (ad esempio Java), è possibile "estendere" la funzionalità di un metodo in una classe ereditata chiamando il metodo originale dalla super classe nella versione sostituita, ad esempio:

class A { 
    public void method() { 
     System.out.println("I am doing some serious stuff!"); 
    } 
} 

class B extends A { 
    @Override 
    public void method() { 
     super.method(); // here we call the original version 
     System.out.println("And I'm doing something more!"); 
    } 
} 

Come potete vedere, in Java, sono in grado di chiamare la versione originale della super classe usando la parola chiave super. Sono stato in grado di ottenere il comportamento equivalente per i tratti ereditati, ma non quando si implementano i tratti per le strutture.

trait Foo { 
    fn method(&self) { 
     println!("default implementation"); 
    } 
} 

trait Boo: Foo { 
    fn method(&self) { 
     // this is overriding the default implementation 
     Foo::method(self); // here, we successfully call the original 
          // this is tested to work properly 
     println!("I am doing something more."); 
    } 
} 

struct Bar; 

impl Foo for Bar { 
    fn method(&self) { 
     // this is overriding the default implementation as well 
     Foo::method(self); // this apparently calls this overridden 
          // version, because it overflows the stack 
     println!("Hey, I'm doing something entirely different!"); 
     println!("Actually, I never get to this point, 'cause I crash."); 
    } 
} 

fn main() { 
    let b = Bar; 
    b.method();  // results in "thread '<main>' has overflowed its stack" 
} 

Così, in caso di tratti ereditari, chiamando l'implementazione di default originale non è un problema, tuttavia, utilizzando la stessa sintassi in sede di attuazione struct presenta un comportamento diverso. È un problema all'interno di Rust? C'è un modo per aggirarlo? O mi manca qualcosa?

Answer 1

Questo non è possibile ora direttamente.

Tuttavia, RFC 1210: impl specialization contiene vari aspetti che renderanno questo tipo di lavoro comportamenti, per esempio, qualcosa come questo dovrebbe funzionare:

trait Foo { 
    fn method(&self) { println!("default implementation"); } 
} 
trait Bar: Foo { ... } 

partial impl<T: Bar> Foo for T { 
    default fn method(&self) { println!("Bar default"); } 
} 

Fare una chiamata super è esplicitamente menzionato come an extension ad esso e così ha vinto' t appare necessariamente immediatamente, ma potrebbe apparire in futuro.

Nel frattempo, l'approccio generalmente utilizzato è quello di definire una funzione separata per il comportamento predefinito e chiamare che nel metodo predefinito, e quindi gli utenti possono emulare la chiamata super::... semplicemente chiamando direttamente che funzione:

trait Foo { 
    fn method(&self) { do_method(self) } 
} 

fn do_method<T: Foo>(_x: &T) { 
    println!("default implementation"); 
} 

impl Foo for Bar { 
    fn method(&self) { 
     do_method(self); 
     println!("more"); 
    } 
} 

Detto questo, Rust preferisce la composizione all'ereditarietà: i progetti che funzionano bene in Java non possono e non devono essere forzati 1-a-1 in Rust.

Foo::method(self); // this apparently calls this overridden 
         // version, because it overflows the stack 

La sintassi percorso qualificato, è Trait::method(value) zucchero per <Type as Trait>::method(value) dove Type è il tipo di value (o, eventualmente, del tipo dopo dereferencing un numero di volte). Cioè, chiama il metodo sul tipo specifico come l'hai scoperto.

Answer 2

Si tratta di un problema all'interno di Rust?

No, questo sta funzionando come previsto

Esiste un modo intorno ad esso?

È possibile spostare il metodo su una funzione libera e quindi chiamarlo direttamente, una volta dal metodo predefinito e una volta dal metodo "sovrascritto".

fn the_default() { 
    println!("default implementation"); 
} 

trait Foo { 
    fn method(&self) { 
     the_default()  
    } 
} 

struct Bar; 

impl Foo for Bar { 
    fn method(&self) { 
     the_default(); 
     println!("Hey, I'm doing something entirely different!"); 
    } 
} 

fn main() { 
    let b = Bar; 
    b.method(); 
} 

O sono solo perdendo qualcosa?

ruggine non è un linguaggio orientato agli oggetti, ruggine può essere un linguaggio orientato agli oggetti, ma non tutti i linguaggi OO sono creati uguali. La ruggine potrebbe non adattarsi perfettamente ai paradigmi tradizionali che ti aspetti.

Vale a dire, i tratti non esistono in fase di esecuzione. Solo quando vengono applicati e utilizzati con una struct viene generato il codice che è richiamabile. Quando crei la tua implementazione di un metodo, questo sostituisce l'implementazione predefinita; non esiste da nessuna parte l'implementazione del metodo di default.

Spesso il tuo codice può essere scritto in modo diverso. Forse il codice veramente condiviso dovrebbe essere estratto come metodo su una nuova struttura, o forse si fornisce una chiusura a un metodo per personalizzare il comportamento.