Типизированный построитель: обход инвариантов во время выполнения

Я хотел бы определить, есть ли способ следовать шаблону состояния типа, но разрешить инварианты, если есть альтернатива.

Предположим, у меня есть шаблон построения структуры-обертки вокруг признака.

trait Trait {
}

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

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 = inner;
        self
    }

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

Builder::build возвращает Option<Wrapper<T>>, где Option::None означает, что сборка не удалась; сборка была снабжена инвариантами, то есть недопустимыми аргументами.

Я могу использовать шаблон типизированного построителя, чтобы предотвратить время компиляции инвариантов вместо времени выполнения.

struct Invariant;

struct TypedBuilder<T> {
    inner: T
}

impl<T: Trait> Wrapper<T> {
    fn typed_builder() -> TypedBuilder<Invariant> {
        TypedBuilder {
            inner: Invariant
        }
    }
}

impl<T> TypedBuilder<T> {
    fn with_inner<T2: Trait>(self, inner: T2) -> TypedBuilder<T2> {
        TypedBuilder {
            inner: inner
        }
    }
}
impl<T: Trait> TypedBuilder<T> {
    fn build(self) -> Wrapper<T> { // infallible
        Wrapper {
            inner: self.inner,
        }
    }
}

В этом примере я бы хотел, чтобы TypeBuilderinner имело значение по умолчанию T, если оно доступно по умолчанию.

Таким образом, инварианты будут:

• None если T: !Default

Я не знаю, возможен ли такой шаблон проектирования без ночных функций, таких как специализация черт.