En los lenguajes orientados a objetos tradicionales (por ejemplo, Java), es posible "extender" la funcionalidad de un método en una clase heredada llamando al método original desde la superclase en la versión anulada, por ejemplo:

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

Como puede ver, en Java, puedo llamar a la versión original de la superclase usando elsuper palabra clave. Pude obtener el comportamiento equivalente para los rasgos heredados, pero no al implementar rasgos para las estructuras.

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

Entonces, en caso de rasgos heredados, llamar a la implementación predeterminada original no es un problema, sin embargo, usar la misma sintaxis al implementar estructuras exhibe un comportamiento diferente. ¿Es este un problema dentro de Rust? ¿Hay alguna forma de evitarlo? ¿O solo me estoy perdiendo algo?