The Trait Inheritance Model

In this lesson, you will learn how to compose complex behaviors by chaining multiple smaller, focused traits to build modular systems.

The Trait Inheritance Model

In Rust, we don't have traditional class-based inheritance. Instead, we use a "Trait Inheritance Model." This allows us to define "super-traits"—a way to specify that a type must implement multiple base behaviors before it can satisfy a more complex requirement.

By breaking functionality into granular, single-responsibility traits, we avoid creating bloated interfaces. Instead, we compose smaller pieces into a cohesive whole.

Chaining Behaviors

Imagine we are building a library for game entities. We could create a Positionable trait and a Renderable trait separately. If we then need an entity that must be both, we can define a VisibleEntity trait that inherits from both.

trait Positionable {
    fn get_coords(&self) -> (i32, i32);
}

trait Renderable {
    fn render(&self);
}

// VisibleEntity inherits requirements from both traits
trait VisibleEntity: Positionable + Renderable {
    fn draw_at_location(&self) {
        let (x, y) = self.get_coords();
        println!("Drawing at {}, {}", x, y);
        self.render();
    }
}

By declaring trait VisibleEntity: Positionable + Renderable, we are telling the compiler: "Any type that implements VisibleEntity is guaranteed to also provide the methods found in Positionable and Renderable."

Why Compose?

This approach provides two major benefits:

1. Modularity: You can reuse Positionable for non-visible objects (like physics-only triggers) without dragging in Renderable code.
2. Constraint Propagation: When you write a function that takes a generic type T: VisibleEntity, you automatically know that T has access to the full suite of methods from all three traits. You are essentially building a custom contract by stacking simpler, focused interfaces.

This model keeps your code "DRY" (Don't Repeat Yourself) while ensuring that your type requirements remain explicit and granular. Instead of asking for a "God Object," you simply ask for the combination of capabilities your logic actually needs.

Key Takeaway: Use trait inheritance to compose small, focused traits into robust, high-level interfaces that precisely describe the required capabilities of your types.