类型化构建器模式：无Nightly特性下兼容默认值与不变量

问题背景 #

我们需要基于类型状态模式实现TypedBuilder，核心需求是：

• 当泛型参数T实现Default trait时，允许直接调用build()生成Wrapper<T>，自动使用T::default()作为内部值
• 当T未实现Default时，必须显式调用with_inner()传入有效值后才能调用build()，否则触发编译错误
  同时要求不使用Rust Nightly独有的特性（如trait specialization）。

解决方案 #

通过标记类型区分初始状态+条件trait实现，可以在稳定版Rust中满足需求。核心思路是用不同的标记类型表示构建器的状态，再根据T是否实现Default提供对应的初始状态和方法集。

以下是完整的实现代码（保留原有的运行时Builder，替换原TypedBuilder部分）：

trait Trait {}

struct Wrapper<T: Trait> {
    inner: T,
}

// --- 原运行时Builder实现（保留）---
struct Builder<T: Trait> {
    inner: Option<T>,
}

impl<T: Trait> Wrapper<T> {
    fn builder() -> Builder<T> {
        Builder { inner: None }
    }
}

impl<T: Trait> Builder<T> {
    fn with_inner(mut self, inner: T) -> Self {
        self.inner = Some(inner);
        self
    }

    fn build(self) -> Option<Wrapper<T>> {
        Some(Wrapper {
            inner: self.inner?,
        })
    }
}

// --- 改进后的类型安全TypedBuilder实现 ---
// 标记类型：未设置值的初始状态（用于未实现Default的T）
struct Unset;
// 标记类型：可使用默认值的初始状态（用于实现了Default的T）
struct Defaultable;

struct TypedBuilder<State> {
    inner: State,
}

// 为不同情况的T提供对应的初始构建器
impl<T: Trait> Wrapper<T> {
    // 当T未实现Default时，返回Unset状态的构建器
    fn typed_builder() -> TypedBuilder<Unset>
    where
        T: !Default, // 稳定版Rust 1.27+支持负向 trait bound
    {
        TypedBuilder { inner: Unset }
    }
}

impl<T: Trait + Default> Wrapper<T> {
    // 当T实现Default时，返回Defaultable状态的构建器
    fn typed_builder() -> TypedBuilder<Defaultable> {
        TypedBuilder { inner: Defaultable }
    }
}

// Unset状态的构建器：只能调用with_inner转换到已设置状态
impl TypedBuilder<Unset> {
    fn with_inner<T2: Trait>(self, inner: T2) -> TypedBuilder<T2> {
        TypedBuilder { inner }
    }
}

// Defaultable状态的构建器：可以直接build用默认值，也可以调用with_inner覆盖
impl TypedBuilder<Defaultable> {
    fn with_inner<T2: Trait + Default>(self, inner: T2) -> TypedBuilder<T2> {
        TypedBuilder { inner }
    }

    fn build<T: Trait + Default>(self) -> Wrapper<T> {
        Wrapper {
            inner: T::default(),
        }
    }
}

// 已设置值的状态（持有T实例）：直接build
impl<T: Trait> TypedBuilder<T> {
    fn build(self) -> Wrapper<T> {
        Wrapper { inner: self.inner }
    }
}

// --- 测试用例 ---
// 实现Trait的类型：未实现Default
struct NoDefaultType;
impl Trait for NoDefaultType {}

// 实现Trait+Default的类型
struct WithDefaultType;
impl Trait for WithDefaultType {}
impl Default for WithDefaultType {
    fn default() -> Self {
        WithDefaultType
    }
}

fn main() {
    // 场景1：T未实现Default，必须调用with_inner
    let wrapper1 = Wrapper::<NoDefaultType>::typed_builder()
        .with_inner(NoDefaultType)
        .build();

    // 场景2：T实现Default，可以直接build
    let wrapper2 = Wrapper::<WithDefaultType>::typed_builder().build();

    // 场景3：T实现Default，也可以用with_inner覆盖默认值
    let wrapper3 = Wrapper::<WithDefaultType>::typed_builder()
        .with_inner(WithDefaultType)
        .build();
}

关键实现细节 #

1. 负向Trait Bound：利用稳定版Rust支持的!Default约束，确保当T未实现Default时，只能获取Unset状态的构建器，避免方法冲突。
2. 类型状态控制：通过Unset/Defaultable标记类型，在编译期限制不同状态下可调用的方法：
   • Unset状态仅提供with_inner方法，强制用户设置值
   • Defaultable状态同时提供build和with_inner方法，允许自动填充默认值或手动覆盖
3. 无额外运行时开销：所有状态检查和默认值填充都在编译期完成，运行时性能与直接构造Wrapper完全一致。

编译验证 #

• 如果尝试直接为NoDefaultType调用build()：

  // 编译报错：`TypedBuilder<Unset>`没有`build`方法
  let wrapper = Wrapper::<NoDefaultType>::typed_builder().build();
  

• 只有调用with_inner后才能正常编译，完全符合不变量约束。

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