1143 字
6 分钟
Rust的Typestate思想

Typestate(类型状态)模式是Rust中一种强大的编译期状态机实现方式,它将对象的运行时状态编码进类型系统中,从而让编译器在代码运行前就帮你拒绝所有非法的状态转换。


让非法状态“不可表示”#

Typestate的核心原则可以概括为三点:

  1. 每个状态都是一个独立的类型:例如,一个网络连接会有 Handshaking、Authenticated、Closed 等不同的类型。

  2. 状态转换会“消耗”旧状态,“产生”新状态:转换方法会拿走旧状态的所有权(self),并返回一个新状态的实例。

  3. 非法操作在编译期就会失败:因为方法只定义在特定状态类型上,对错误的状态调用该方法会直接导致编译错误,而不是运行时错误。

实现#

反例#

常规的状态都是使用enum的变体表示。 举个简单的例子,假设需要构建一个简单的Builder:

// 此处有两种状态,一个是构造中,一个是构造完成
enum BuilderState {
Building,
Ready,
}
struct Data;
/// 假设此处的两个option都必须在Builder时期由用户选择
struct Builder {
data1: Option<Data>,
data2: Option<Data>,
state: BuilderState,
}
impl Builder {
fn new() -> Builder {
Self {
data1: None,
data2: None,
state: BuilderState::Building,
}
}
fn set_data1(&mut self, d: Data) {
self.data1 = Some(d)
}
fn set_data2(&mut self, d: Data) {
self.data2 = Some(Data)
}
/// 此处的build必须要data1和data2都有设置才能运行,但是使用if语句检查是运行时检查,失去了rust类型检查系统的优势,并且还需要额外处理错误分支
fn build(&mut self) {
//....Do Some Thing
if self.data1.is_some() && self.data2.is_some() {
self.state = BuilderState::Ready;
unimplemented!()
}
else{
unimplemented!()
// 额外处理错误
}
}
}

这样是最常用的写法,状态使用enum方便且易于管理。但是这样就让各种检查都需要在运行时才能进行,还需要额外处理报错的情况。此时就需要使用Typestate模式!

真正的用法#

还是刚刚的例子,构建一个Builder模式,这是Typestate模式最经典的应用场景。

但是不再使用enum表示状态,而是使用struct表示:

use std::marker::PhantomData;
struct Missing;
struct Ready;
struct Data;
struct Builder<S> {
data1: Option<Data>,
data2: Option<Data>,
_state: PhantomData<S>, // 零大小,仅用于类型标记
}
impl Builder<(Missing, Missing)> {
fn new() -> Self {
Self {
data1: None,
data2: None,
_state: PhantomData,
}
}
}
// data1() 只存在于「第一个字段还是 Missing」的任意状态下
impl<S2> Builder<(Missing, S2)> {
fn data1(self, d: Data) -> Builder<(Ready, S2)> {
Builder {
data1: Some(d),
data2: self.data2,
_state: PhantomData,
}
}
/// 此处可放一些只有data2 Ready了才能做的事
fn some_thing_only_data2_can_do(&self) {}
}
// data2() 只存在于「第二个字段还是 Missing」的任意状态下
impl<S1> Builder<(S1, Missing)> {
fn data2(self, d: Data) -> Builder<(S1, Ready)> {
Builder {
data1: self.data1,
data2: Some(d),
_state: PhantomData,
}
}
/// 此处可放一些只有data1 Ready了才能做的事
fn some_thing_only_data1_can_do(&self) {}
}
// 只有两个字段都 Ready 了,build() 才存在
impl Builder<(Ready, Ready)> {
fn build(self) -> (Data, Data) {
// 类型系统已保证两个都是 Some,unwrap 不会 panic
(self.data1.unwrap(), self.data2.unwrap())
}
}

采用这种模式之后,没有正确设置的都会报错:

let b: Builder<(Missing, Missing)> = Builder::new();
let b: Builder<(Ready, Missing)> = b.data1(Data);
b.build(); //no method named `build` found for struct `Builder<(Ready, Missing)>` in the current scope the method was found for `Builder<(Ready, Ready)>`

正确设置后才能调用.build():

let b: Builder<(Missing, Missing)> = Builder::new();
let b: Builder<(Ready, Ready)> = b.data1(Data).data2(Data);
b.build(); // 没报错

并且消耗旧状态产生新状态刚好可以完美地使用rust的链式调用,肥肠方便^_^

优缺点权衡#

优势#

  • 编译期安全:将状态机不变量检查从运行时提前到编译期,消除了一整类 bug。

  • 零运行时开销:状态标记(如 PhantomData)在编译后会被擦除,不占用内存或影响性能。

  • 自文档化:类型签名本身就清晰地描述了合法的操作序列。

代价#

  • 样板代码较多:需要定义多个标记类型和独立的 impl 块。

  • 对状态组合的灵活性较低:在需要动态改变状态或状态组合非常复杂时,可能不如运行时状态机灵活。


总之,Typestate 是 Rust 类型系统能力的一种深刻体现。它把对“正确性”的保证从程序员的记忆和测试用例,转移到了编译器的强制检查中。

Rust的Typestate思想
https://www.lkhssssss.cn/posts/rust/rust-typestate-design/
作者
LKHSSS
发布于
2026-10-30
许可协议
CC BY-NC-SA 4.0

分享文章

生成精美分享图或复制链接,与更多人分享本文。

继续阅读

沿着主题读

基于共同的标签与分类

换条路线

从其他文章中稳定抽取