Rust泛型Runner构建器：未传Config触发失败，Config为()时可选

你的核心需求是实现一个泛型Runner构建器：

• 当Poll的关联类型Config为()时，无需调用with_config即可直接执行on方法
• 当Config为其他类型时，必须传入配置，否则触发失败
• 你尝试用TypeId+unsafe的方式实现，但不确定安全性

原有unsafe代码的安全性分析 #

这段代码在**P::Config确实是()类型时是安全的**：

use std::any::TypeId;
let config: P::Config = {
    if let Some(config) = self.1 {
        config
    } else if TypeId::of::<P::Config>() == TypeId::of::<()>() {
        unsafe { std::mem::transmute_copy(&()) }
    } else {
        panic!("no config :(")
    }
};

因为()是零大小类型，和自身的内存布局完全一致，transmute_copy在这里只是复制一个空实例，不会引发内存安全问题。但它存在两个明显缺陷：

1. 仅能在运行时检查配置是否缺失，无法在编译阶段强制约束用户行为
2. 依赖TypeId的匹配逻辑，虽然类型别名（如type MyUnit = ()）也能正常工作，但属于非类型安全的运行时判断，不够优雅

更优的类型安全方案 #

推荐两种实现方式，分别对应编译时强制约束和兼容原有构建器结构的场景：

方案1：编译时强制约束（推荐） #

通过状态机模式区分Runner的状态，在编译阶段就阻止非法调用：

use std::sync::mpsc::Sender;

trait Poll {
    type Output;
    type Config: 'static;

    fn poll(cfg: Self::Config, tx: Sender<Self::Output>) -> !;
}

// 未配置状态：仅能调用with_config或（当Config为()时）调用on
struct UnconfiguredRunner<P: Poll>(P);

// 已配置状态：可直接调用on
struct ConfiguredRunner<P: Poll>(P, P::Config);

impl<P: Poll> UnconfiguredRunner<P> {
    fn run(poller: P) -> Self {
        Self(poller)
    }

    fn with_config(self, cfg: P::Config) -> ConfiguredRunner<P> {
        ConfiguredRunner(self.0, cfg)
    }
}

// 仅当Config为()时，允许未配置状态直接调用on
impl<P: Poll> UnconfiguredRunner<P>
where
    P::Config: DefaultConfig,
{
    fn on(self, tx: Sender<P::Output>) -> ! {
        P::poll(DefaultConfig::default_config(), tx)
    }
}

impl<P: Poll> ConfiguredRunner<P> {
    fn on(self, tx: Sender<P::Output>) -> ! {
        P::poll(self.1, tx)
    }
}

// 辅助trait：仅为()实现默认配置
trait DefaultConfig {
    fn default_config() -> Self;
}

impl DefaultConfig for () {
    fn default_config() -> Self {
        ()
    }
}

优势：

• 当Config不是()时，用户必须调用with_config才能得到可执行on的ConfiguredRunner，否则编译报错
• 完全避免运行时panic，约束更严格，类型安全

方案2：兼容原有构建器结构（运行时处理） #

如果不想修改原有Runner的结构，可通过TryInto trait替换unsafe代码，实现相同逻辑但更安全：

use std::sync::mpsc::Sender;

trait Poll {
    type Output;
    type Config: 'static;

    fn poll(cfg: Self::Config, tx: Sender<Self::Output>) -> !;
}

struct Runner<P: Poll>(P, Option<P::Config>);

impl<P: Poll> Runner<P> {
    fn run(poller: P) -> Self {
        Self(poller, None)
    }
    
    fn with_config(mut self, cfg: P::Config) -> Self {
        self.1 = Some(cfg);
        self
    } 
    
    fn on(self, tx: Sender<P::Output>) -> ! {
        let config = match self.1 {
            Some(cfg) => cfg,
            None => {
                // 仅当Config为()时，才能成功转换
                match TryInto::<P::Config>::try_into(()) {
                    Ok(cfg) => cfg,
                    Err(_) => panic!("必须提供Config，当前Poll的Config类型不是()"),
                }
            }
        };
        
        P::poll(config, tx);
    }
}

// 仅允许()转换为自身
impl TryInto<()> for () {
    type Error = ();
    fn try_into(self) -> Result<(), Self::Error> {
        Ok(())
    }
}

// 其他类型禁止从()转换
impl<T> TryInto<T> for ()
where
    T: ?Sized,
{
    type Error = ();
    fn try_into(self) -> Result<T, Self::Error> {
        Err(())
    }
}

优势：

• 完全兼容原有构建器的链式调用方式
• 去掉unsafe代码，用类型转换逻辑替代TypeId检查，更符合Rust的类型安全理念

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