PhantomData 是零大小类型（ZST），编译器在释放优化后完全消除它。这意味着两种实现在内存中占用空间完全相同，但类型状态版本没有任何运行时检查指令。

LLVM IR 层面的证明

对于上面的 checksum() 方法，使用类型状态模式编译后生成的 IR 直接是内存操作和算术运算，没有条件分支。而运行时版本会有一个 icmp 和 br 指令对状态进行比较。

在 hot path 上，少一个分支意味着：

• 没有分支预测失败惩罚
• 没有指令缓存压力
• 更好的指令级并行

四、实战进阶：多维度状态与复合类型机

真实系统的状态往往不是单维度的。你可能需要追踪连接状态、认证状态、加密状态等多重独立维度。类型状态模式可以优雅地处理这种情况：

mod conn_state {
    pub trait State {}
    pub struct Disconnected;
    pub struct Connected;
    pub struct Authenticated;
    pub struct Encrypted;
    pub struct EncryptedAuthenticated;
    impl State for Disconnected {}
    impl State for Connected {}
    impl State for Authenticated {}
    impl State for Encrypted {}
    impl State for EncryptedAuthenticated {}
}

mod auth_state {
    pub trait State {}
    pub struct Anonymous;
    pub struct Authenticated;
    impl State for Anonymous {}
    impl State for Authenticated {}
}

// 二维状态机
struct Connection {
    socket: TcpStream,
    buffer: Vec,
    _cs: PhantomData,
    _as: PhantomData,
}

impl Connection {
    fn connect(addr: &str) -> io::Result> {
        let socket = TcpStream::connect(addr)?;
        Ok(Connection {
            socket,
            buffer: Vec::new(),
            _cs: PhantomData,
            _as: PhantomData,
        })
    }
}

impl Connection {
    fn enable_tls(self) -> Result, Error> {
        // TLS 握手逻辑
        Ok(Connection {
            socket: self.socket, // 实际中会被 TLS stream 替换
            buffer: self.buffer,
            _cs: PhantomData,
            _as: PhantomData,
        })
    }
    
    fn authenticate(self, token: &str) -> Result, Error> {
        // 认证逻辑
        Ok(Connection {
            socket: self.socket,
            buffer: self.buffer,
            _cs: PhantomData,
            _as: PhantomData,
        })
    }
}

impl Connection {
    fn send_encrypted_secure(&mut self, data: &[u8]) -> io::Result {
        // 只有同时处于加密+认证状态才能调用
        self.socket.write(data)
    }
}

这种设计防止了"先发送再加密"或"未认证就发送敏感数据"等逻辑错误——不是靠文档约定，而是靠编译器强制执行。

五、工业级实践：文件描述符与资源管理的类型安全

Linux 系统编程中，文件描述符的状态管理是类型状态模式的天然应用场景：

mod fd_state {
    pub trait State {}
    pub struct Open;
    pub struct Sealed;
    pub struct Closed;
    impl State for Open {}
    impl State for Sealed {}
    impl State for Closed {}
}

struct TypedFd {
    fd: RawFd,
    _state: PhantomData,
}

impl TypedFd {
    fn open(path: &str) -> io::Result {
        let fd = unsafe { libc::open(path.as_ptr() as *const c_char, O_RDWR) };
        if fd < 0 { return Err(io::Error::last_os_error()); }
        Ok(Self { fd, _state: PhantomData })
    }
    
    fn read(&self, buf: &mut [u8]) -> io::Result {
        let n = unsafe { libc::read(self.fd, buf.as_mut_ptr() as *mut c_void, buf.len()) };
        if n < 0 { return Err(io::Error::last_os_error()); }
        Ok(n as usize)
    }
    
    fn seal(mut self) -> Result, Error> {
        // fcntl 设置 seals
        let ret = unsafe { libc::fcntl(self.fd, F_ADD_SEALS, SEAL_SEAL | SEAL_SHRINK | SEAL_GROW | SEAL_WRITE) };
        if ret < 0 { return Err(Error::from(io::Error::last_os_error())); }
        let fd = self.fd;
        // 防止 Drop 关闭 fd（此处简化示意）
        std::mem::forget(self); // 实际应使用 ManuallyDrop 模式
        Ok(TypedFd { fd, _state: PhantomData })
    }
    
    fn close(self) -> TypedFd {
        unsafe { libc::close(self.fd); }
        TypedFd { fd: -1, _state: PhantomData }
    }
}

impl TypedFd {
    fn read_only(&self, buf: &mut [u8]) -> io::Result {
        // 已封 sealed 的文件只能读取
        let n = unsafe { libc::read(self.fd, buf.as_mut_ptr() as *mut c_void, buf.len()) };
        if n < 0 { return Err(io::Error::last_os_error()); }
        Ok(n as usize)
    }
    
    // 没有 write() 方法！sealed 文件不可写
    // 没有 seal() 方法！已经 sealed 了
}

struct HttpClientBuilder {
    url: Option>,
    timeout: Option>,
    retries: Option>,
}

struct Set;
struct Unset;

impl HttpClientBuilder {
    fn new() -> Self {
        Self { url: None, timeout: None, retries: None }
    }
}

impl HttpClientBuilder {
    fn with_url(self, url: &str) -> HttpClientBuilder {
        HttpClientBuilder { url: Some(PhantomData), timeout: self.timeout, retries: self.retries }
    }
}

impl HttpClientBuilder {
    fn with_timeout(self, ms: u64) -> HttpClientBuilder {
        HttpClientBuilder { url: self.url, timeout: Some(PhantomData), retries: self.retries }
    }
}

impl HttpClientBuilder {
    fn with_retries(self, n: u32) -> HttpClientBuilder {
        HttpClientBuilder { url: self.url, timeout: self.timeout, retries: Some(PhantomData) }
    }
}

// 只有所有必填字段都 Set 才能 build
impl HttpClientBuilder {
    fn build(self) -> HttpClient {
        HttpClient { url: "...".to_string() } // 简化
    }
}

/// 已认证的连接
pub type ReadyConnection = Connection;