在Rust中实现依赖倒置（Dependency Inversion）的惯用方法有哪些？

依赖倒置的核心是让高层与低层模块都依赖抽象，而非互相依赖。既然你不需要运行时多态，下面是几个符合Rust惯用风格的静态多态优化方案，能解决泛型扩散和impl代码杂乱的问题：

1. 用关联类型替代多泛型参数 #

把依赖的类型定义在trait的关联类型中，让结构体只需要一个泛型参数，大幅简化代码：

trait CarSpec {
    type Wheels: WheelsTrait;
    type Seat: SeatTrait;
}

// 定义具体的组件组合
struct StandardCarSpec;
impl CarSpec for StandardCarSpec {
    type Wheels = AlloyWheels;
    type Seat = LeatherSeat;
}

// 只需要一个泛型参数的Car结构体
struct Car<C: CarSpec> {
    wheels: [C::Wheels; 4],
    seat: C::Seat,
}

// 实现方法时也只需要处理C这个泛型
impl<C: CarSpec> Car<C> {
    fn new() -> Self {
        Car {
            wheels: [C::Wheels::new(); 4],
            seat: C::Seat::new(),
        }
    }
}

2. 模块内封装泛型，对外暴露具体类型 #

如果你的组件组合在模块内是固定的，可以把泛型结构体设为私有，对外导出绑定好具体类型的别名，高层代码完全看不到泛型：

mod car_module {
    pub trait WheelsTrait { fn new() -> Self; }
    pub trait SeatTrait { fn new() -> Self; }

    pub struct AlloyWheels;
    impl WheelsTrait for AlloyWheels { fn new() -> Self { AlloyWheels } }

    pub struct LeatherSeat;
    impl SeatTrait for LeatherSeat { fn new() -> Self { LeatherSeat } }

    // 私有泛型结构体，内部保持抽象
    struct Car<W: WheelsTrait, S: SeatTrait> {
        wheels: [W;4],
        seat: S,
    }

    // 对外暴露绑定好类型的具体Car
    pub type StandardCar = Car<AlloyWheels, LeatherSeat>;

    impl StandardCar {
        pub fn new() -> Self {
            StandardCar {
                wheels: [AlloyWheels::new();4],
                seat: LeatherSeat::new(),
            }
        }
    }
}

// 外部直接用StandardCar，无需处理泛型
use car_module::StandardCar;
let my_car = StandardCar::new();

3. 用宏简化重复的trait bound声明 #

如果必须保留多泛型参数，用宏来消除impl块里重复的trait bound代码：

macro_rules! impl_car_traits {
    ($($bound:ident),*) => {
        impl<W: WheelsTrait, S: SeatTrait> Car<W, S>
        where
            $(W: $bound, S: $bound,)*
        {
            fn drive(&self) {
                // 业务逻辑实现
            }
        }
    };
}

// 一键生成带多个trait bound的impl
impl_car_traits!(Clone, Debug);

4. 利用类型推断省略显式泛型指定 #

Rust的类型推断能自动推导泛型参数，调用时不用手动指定具体类型：

impl<W: WheelsTrait, S: SeatTrait> Car<W, S> {
    fn new(wheels: [W;4], seat: S) -> Self {
        Car { wheels, seat }
    }
}

// 编译器自动推断泛型，无需写Car<AlloyWheels, LeatherSeat>
let my_car = Car::new([AlloyWheels::new();4], LeatherSeat::new());

内容的提问来源于stack exchange，提问作者jayphur