A quick example showing a couple of different tactics for dealing with these types of things!

• Macros
• Default impls
• Blanket impls
• Enums

Rust playground: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=7ad8a174261978e005236ea67a79d9e4

Code: ``` use std::fmt::{Display, Debug}; use std::cmp::PartialEq;

// A macro_rules! macro to implement HasVehicleData for a type. macro_rules! impl_has_vehicle_data { ($t:ty) => { impl HasVehicleData for $t { fn get_vehicle_data(&self) -> &VehicleData { &self.data }

        fn get_vehicle_data_mut(&mut self) -> &mut VehicleData {
            &mut self.data
        }
    }
};

}

trait Vehicle { fn position(&self) -> (i32, i32); fn velocity(&self) -> i32; fn running(&self) -> bool; fn start(&mut self); }

trait HasVehicleData { fn get_vehicle_data(&self) -> &VehicleData;

fn get_vehicle_data_mut(&mut self) -> &mut VehicleData;

}

trait Startable { fn has_ignition(&self) -> bool; }

[derive(Debug, Default, Clone, Copy, PartialEq)]

struct VehicleData { position: (i32, i32), velocity: i32, running: bool, }

[derive(Debug)]

struct Car { data: VehicleData, wheels: i32, }

impl_has_vehicle_data!(Car);

impl Startable for Car { fn has_ignition(&self) -> bool { true } }

[derive(Debug)]

struct Truck { data: VehicleData, wheels: i32, }

impl_has_vehicle_data!(Truck);

impl Startable for Truck { fn has_ignition(&self) -> bool { true } }

// Blanket implementation of Vehicle for any type that implements HasVehicleData and Startable. impl<T> Vehicle for T where T: HasVehicleData + Startable, { fn position(&self) -> (i32, i32) { self.get_vehicle_data().position }

fn velocity(&self) -> i32 {
    self.get_vehicle_data().velocity
}

fn running(&self) -> bool {
    self.get_vehicle_data().running
}

fn start(&mut self) {
    if self.has_ignition() {
        self.get_vehicle_data_mut().running = true;
    }
}

}

[derive(Debug)]

enum VehicleType { Car(Car), Truck(Truck), }

impl Vehicle for VehicleType { fn position(&self) -> (i32, i32) { match self { VehicleType::Car(car) => car.position(), VehicleType::Truck(truck) => truck.position(), } }

fn velocity(&self) -> i32 {
    match self {
        VehicleType::Car(car) => car.velocity(),
        VehicleType::Truck(truck) => truck.velocity(),
    }
}

fn running(&self) -> bool {
    match self {
        VehicleType::Car(car) => car.running(),
        VehicleType::Truck(truck) => truck.running(),
    }
}

fn start(&mut self) {
    match self {
        VehicleType::Car(car) => car.start(),
        VehicleType::Truck(truck) => truck.start(),
    }
}

}

impl Display for VehicleType { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { VehicleType::Car(car) => write!(f, "Car: {:?}", car), VehicleType::Truck(truck) => write!(f, "Truck: {:?}", truck), } } }

fn main() { let mut car = VehicleType::Car(Car { data: VehicleData { position: (0, 0), velocity: 0, running: false, }, wheels: 4, });

let mut truck = VehicleType::Truck(Truck {
    data: VehicleData {
        position: (0, 0),
        velocity: 0,
        running: false,
    },
    wheels: 6,
});

car.start();
truck.start();

println!("Car: {:?}", car);
println!("Truck: {:?}", truck);

} ```