В традиционных объектно-ориентированных языках (например, Java) можно «расширить» функциональность метода в унаследованном классе, вызвав исходный метод из суперкласса в переопределенной версии, например:

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

Как вы можете видеть, в Java я могу вызвать исходную версию из суперкласса, используяsuper ключевое слово. Мне удалось получить эквивалентное поведение для унаследованных признаков, но не при реализации признаков для структур.

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

Таким образом, в случае унаследованных признаков вызов исходной реализации по умолчанию не представляет проблемы, однако использование одного и того же синтаксиса при реализации структур демонстрирует другое поведение. Это проблема в Rust? Есть ли способ обойти это? Или я просто что-то упустил?