3.4.3 带泛型的 Typestate 模式 on 编程那些事儿

3.4.3.1 Serializer：实现 Root

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/typestate-pattern/typestate-generics/root.html

Serializer：实现 Root

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


# 3.4.3.1 Serializer：实现 Root
// SPDX-License-Identifier: Apache-2.0
# use std::fmt::Write as _;
struct Serializer<S> {
 // [...]
 indent: usize,
 buffer: String,
 state: S,
}

struct Root;
struct Struct<S>(S);

impl Serializer<Root> {
 fn new() -> Self {
 // [...]
 Self { indent: 0, buffer: String::new(), state: Root }
 }

 fn serialize_struct(mut self, name: &str) -> Serializer<Struct<Root>> {
 // [...]
 writeln!(self.buffer, "{name} {{").unwrap();
 Serializer {
 indent: self.indent + 1,
 buffer: self.buffer,
 state: Struct(self.state),
 }
 }

 fn finish(self) -> String {
 // [...]
 self.buffer
 }
}

回到最初的有效转换示意图，可将实现的开端可视化如下：

3.4.3.2 Serializer：实现 Struct

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/typestate-pattern/typestate-generics/struct.html

Serializer：实现 Struct

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


# 3.4.3.2 Serializer：实现 Struct
// SPDX-License-Identifier: Apache-2.0
# use std::fmt::Write as _;
struct Serializer<S> {
 // [...]
 indent: usize,
 buffer: String,
 state: S,
}

struct Struct<S>(S);
struct Property<S>(S);

impl<S> Serializer<Struct<S>> {
 fn serialize_property(mut self, name: &str) -> Serializer<Property<Struct<S>>> {
 // [...]
 write!(self.buffer, "{}{name}: ", " ".repeat(self.indent * 2)).unwrap();
 Serializer {
 indent: self.indent,
 buffer: self.buffer,
 state: Property(self.state),
 }
 }

 fn finish_struct(mut self) -> Serializer<S> {
 // [...]
 self.indent -= 1;
 writeln!(self.buffer, "{}}}", " ".repeat(self.indent * 2)).unwrap();
 Serializer { indent: self.indent, buffer: self.buffer, state: self.state.0 }
 }
}

示意图现可扩展如下：

3.4.3.3 Serializer：实现 Property

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/typestate-pattern/typestate-generics/property.html

Serializer：实现 Property

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


# 3.4.3.3 Serializer：实现 Property
// SPDX-License-Identifier: Apache-2.0
# use std::fmt::Write as _;
struct Serializer<S> {
 // [...]
 indent: usize,
 buffer: String,
 state: S,
}

struct Struct<S>(S);
struct Property<S>(S);
struct List<S>(S);

impl<S> Serializer<Property<Struct<S>>> {
 fn serialize_struct(mut self, name: &str) -> Serializer<Struct<Struct<S>>> {
 // [...]
 writeln!(self.buffer, "{name} {{").unwrap();
 Serializer {
 indent: self.indent + 1,
 buffer: self.buffer,
 state: Struct(self.state.0),
 }
 }

 fn serialize_list(mut self) -> Serializer<List<Struct<S>>> {
 // [...]
 writeln!(self.buffer, "[").unwrap();
 Serializer {
 indent: self.indent + 1,
 buffer: self.buffer,
 state: List(self.state.0),
 }
 }

 fn serialize_string(mut self, value: &str) -> Serializer<Struct<S>> {
 // [...]
 writeln!(self.buffer, "{value},").unwrap();
 Serializer { indent: self.indent, buffer: self.buffer, state: self.state.0 }
 }
}

加上 Property 状态的方法后，我们的示意图已接近完整：

3.4.3.4 Serializer：完整实现

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/leveraging-the-type-system/typestate-pattern/typestate-generics/complete.html

3.4.3.4 Serializer：完整实现

Serializer：完整实现

回顾最初期望的流程：

 +-----------+ +---------+------------+-----+
 | | | | | |
 V | V | V |
 + |
serializer --> structure --> property --> list +-+

 | | ^ | ^
 V | | | |
 | +-----------+ |
 String | |
 +--------------------------+

现在可以直接在序列化器的类型中看到这一点：