Why doesn’t Rust support trait object upcasting?

by

Actually, I think I got the reason. I found an elegant way to add upcasting support to any trait that desires it, and that way the programmer is able to choose whether to add that additional vtable entry to the trait, or prefer not to, which is a similar trade-off as in C++’s virtual vs. non-virtual methods: elegance and model correctness vs. performance.

The code can be implemented as follows:

trait Base: AsBase {
    // ...
}

trait AsBase {
    fn as_base(&self) -> &Base;
}

impl<T: Base> AsBase for T {
    fn as_base(&self) -> &Base {
        self
    }
}

One may add additional methods for casting a &mut pointer or a Box (that adds a requirement that T must be a 'static type), but this is a general idea. This allows for safe and simple (although not implicit) upcasting of every derived type without boilerplate for every derived type.

More Related Contents:

  1. What is an example of the Liskov Substitution Principle?
  2. Is it possible to access struct fields from within a trait?
  3. Is deriving square from rectangle a violation of Liskov’s Substitution Principle? [closed]
  4. Is it possible to extend a default method implementation of a trait in a struct?
  5. Interface vs Abstract Class (general OO)
  6. Interface vs Base class
  7. What is the difference between association, aggregation and composition?
  8. What is Inversion of Control?
  9. Mutable vs immutable objects
  10. What is the difference between loose coupling and tight coupling in the object oriented paradigm?
  11. Why is there no multiple inheritance in Java, but implementing multiple interfaces is allowed?
  12. Why do we use Interface? Is it only for Standardization? [closed]
  13. What is the use of making constructor private in a class?
  14. Is returning null bad design? [closed]
  15. OOP vs Functional Programming vs Procedural [closed]
  16. Why don’t associated types for protocols use generic type syntax in Swift?
  17. When should I use static methods in a class and what are the benefits?
  18. What is an example of the Single Responsibility Principle? [closed]
  19. Mediator Vs Observer Object-Oriented Design Patterns
  20. Do Collections.unmodifiableXXX methods violate LSP? [closed]
  21. Can’t seem to understand SOLID principles and design patterns [closed]
  22. Why not use instanceof operator in OOP design?
  23. Is it bad practice for a class to have only static fields and methods?
  24. How to create a “single dispatch, object-oriented Class” in julia that behaves like a standard Java Class with public / private fields and methods
  25. What is the difference between Composition and Association relationship?
  26. Difference between Encapsulation and Abstraction
  27. Coupling, Cohesion and the Law of Demeter
  28. When to use delegation instead of inheritance? [closed]
  29. How do you explain OO to new programmers? [closed]
  30. Aspect Oriented Programming vs. Object-Oriented Programming

Leave a Comment