In traditionellen objektorientierten Sprachen (z. B. Java) ist es möglich, die Funktionalität einer Methode in einer geerbten Klasse zu "erweitern", indem die ursprüngliche Methode aus der übergeordneten Klasse in der überschriebenen Version aufgerufen wird. Beispiel:

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!");
    }
}

ie Sie sehen können, kann ich in Java die Originalversion aus der Superklasse mit dem @ aufrufesuper Stichwort. Ich konnte das gleiche Verhalten für geerbte Merkmale erzielen, aber nicht, wenn ich Merkmale für Strukturen implementierte.

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"
}

So ist es bei geerbten Merkmalen kein Problem, die ursprüngliche Standardimplementierung aufzurufen. Die Verwendung derselben Syntax bei der Implementierung von Strukturen weist jedoch ein unterschiedliches Verhalten auf. Ist das ein Problem in Rust? Gibt es einen Ausweg? Oder fehlt mir nur etwas?