Is it possible to extend a default method implementation of a trait in a struct?

by

This isn’t possible directly now.

However, RFC 1210: impl specialization contains various aspects that will make this sort of behaviour work, for example, something like this should work:

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

Doing a super call is explicitly mentioned as an extension to it and so won’t necessarily appear immediately, but may appear in future.

In the mean time, the approach generally used is to define a separate function for the default behaviour and call that in the default method, and then users can emulate the super::... call by just calling that function directly:

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

That said, Rust favours composition over inheritance: designs that work well in Java can’t and shouldn’t be forced 1-to-1 into Rust.

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

The qualified path syntax, Trait::method(value) is sugar for <Type as Trait>::method(value) where Type is the type of value (or, possibly, the type after dereferencing some number of times). That is, it’s calling the method on the specific type as you found out.

More Related Contents:

  1. Is it possible to access struct fields from within a trait?
  2. Why doesn’t Rust support trait object upcasting?
  3. When to use an interface instead of an abstract class and vice versa?
  4. Inheritance vs. Aggregation [closed]
  5. is it possible to call overridden method from parent struct in Golang?
  6. When to implement an interface and when to extend a superclass?
  7. Mixin vs inheritance
  8. Diamond Problem
  9. When to use delegation instead of inheritance? [closed]
  10. Interface vs Abstract Class (general OO)
  11. Interface vs Base class
  12. How do I call a parent class’s method from a child class in Python?
  13. What is an interface in Java?
  14. How to clone a struct storing a boxed trait object?
  15. Why to use Interfaces, Multiple Inheritance vs Interfaces, Benefits of Interfaces?
  16. How do I implement a trait I don’t own for a type I don’t own?
  17. Understanding prototypal inheritance in JavaScript
  18. Method chaining – why is it a good practice, or not?
  19. What makes something a “trait object”?
  20. Does functional programming replace GoF design patterns?
  21. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  22. I implemented a trait for another trait but cannot call methods from both traits
  23. What is the definition of “interface” in object oriented programming
  24. Multiple Inheritance in PHP
  25. What is the scope of the Single Responsibility Principle? [closed]
  26. When to use mixins and when to use interfaces in Dart?
  27. Define Private field Members and Inheritance in JAVASCRIPT module pattern
  28. Doctrine2 ORM does not save changes to a DateTime field
  29. Is it possible for one struct to extend an existing struct, keeping all the fields?
  30. A use for multiple inheritance?

Leave a Comment