---

0 引言：为什么需要“拆东墙补西墙”？

在所有权世界里，一个值 要么整体活着，要么整体死去。
然而真实业务常常出现 “只关心其中一部分” 的场景：

• 解析网络包：把头部字节 move 给解码器，剩余负载原地留下
• 构建 AST：把 token 抽走，留下 span 做错误定位
• 异步状态机：把已处理字段 move 进下一个状态，其余字段继续用

Rust 通过 部分移动（Partial Move） 让 字段级、元素级 的“拆”与“留”成为可能，同时保持 零成本、零悬垂、零泄露。
本文将：

1. 用 5 段递进代码 由浅入深 展示语言规则
2. 用 3 个生产级案例 实战落地
3. 用 1 个 自研解析器 把部分移动写成 宏规则，实现 零拷贝 JSON AST

---

1 语言规则：Partial Move 的三把钥匙

钥匙	作用	违反后果
字段级 a.x	单个字段被 move，其余字段继续可用	E0382
模式解构 let Struct { x, .. } = s;	把 x 移走，.. 留下	同上
索引解构 let [a, b @ ..] = arr;	把前缀移走，剩余 slice 留下	E0509

所有规则都在 MIR 层 被翻译成 字段级 drop flags，零运行时开销。

---

2 初级示例：结构体字段级拆包

#[derive(Debug)]
struct Packet {
    header: [u8; 4],
    payload: Vec<u8>,
}

fn process(mut p: Packet) {
    // 1. 部分移动：header 被 move，payload 仍留在 p
    let hdr = p.header;
    println!("header = {:?}", hdr);

    // 2. payload 还能继续用
    p.payload.push(0xff);
    println!("payload = {:?}", p.payload);

    // 3. 离开作用域时，只有 payload 被 drop
}

• p.header 被 move → 编译器把 p.header 标为 uninit
• p.payload 继续存活 → 不触发整体 drop

---

3 中级：Option 与 Result 的「零拷贝拆包」

3.1 Option<T> 的 take

fn take_example(opt: &mut Option<String>) -> Option<String> {
    opt.take() // 部分移动 Option 内部的 String
}

fn main() {
    let mut o = Some("hello".to_string());
    let inner = take_example(&mut o);
    assert!(o.is_none());
    println!("inner = {}", inner.unwrap());
}

take 本质：字段级部分移动 + 剩余 None。

3.2 Result<T, E> 的 ? 运算符

fn read_file(path: &str) -> Result<String, std::io::Error> {
    let mut file = std::fs::File::open(path)?; // 部分移动错误值
    let mut buf = String::new();
    file.read_to_string(&mut buf)?;
    Ok(buf)
}

• ? 把 Err(e) move 出去，留下 Ok 路径继续执行

---

4 高级：手动实现「部分移动感知」结构体

4.1 需求：把 token 字段 提前移走，span 留在原地

#[derive(Debug)]
struct Token {
    lexeme: String,
    span: std::ops::Range<usize>,
}

impl Token {
    fn into_lexeme(self) -> String {
        self.lexeme // 字段级 move
    }
}

fn main() {
    let tok = Token { lexeme: "let".into(), span: 0..3 };
    let lex = tok.into_lexeme();   // lexeme 被 move
    // println!("{:?}", tok.lexeme); // ❌ 已移动
    println!("span still usable: {:?}", tok.span);
}

---

5 生产级案例 1：零拷贝 JSON 解析器

目标：

• 解析 JSON → 不复制字符串
• 把 token lexeme 部分移动给 AST
• span 留在原地做错误定位

5.1 数据结构

#[derive(Debug)]
struct RawToken<'a> {
    lexeme: &'a str,  // 不可变借用，非 move
    span: std::ops::Range<usize>,
}

#[derive(Debug)]
enum Json<'a> {
    Str(&'a str),
    Num(&'a str),
    Arr(Vec<Json<'a>>),
    Obj(Vec<(&'a str, Json<'a>)>),
}

使用 不可变借用 而不是 部分移动，因为字符串切片无需所有权转移。
若需要 owned 字段，可改为 String + span，配合 into_owned() 部分移动。

---

6 生产级案例 2：异步状态机中的部分移动

6.1 状态机定义

enum State {
    Idle { buf: Vec<u8> },
    Reading { buf: Vec<u8>, pos: usize },
    Done { result: String },
}

6.2 状态转换：把 buf 部分移动

impl State {
    fn poll(&mut self) {
        *self = match std::mem::take(self) {
            State::Idle { mut buf } => {
                buf.resize(1024, 0);
                State::Reading { buf, pos: 0 }
            }
            State::Reading { buf, pos } => {
                if pos == buf.len() {
                    let result = String::from_utf8(buf).unwrap();
                    State::Done { result }
                } else {
                    State::Reading { buf, pos: pos + 1 }
                }
            }
            done @ State::Done { .. } => done,
        };
    }
}

• std::mem::take 把旧状态 整体 move 出来，留下 空壳 State::Idle
• 新状态按需 部分移动 字段，零拷贝、零额外分配

---

7 生产级案例 3：宏级「字段级解构」库

自研 partial_move! 宏，把部分移动写成声明式 DSL

7.1 宏定义（简化版）

macro_rules! partial_move {
    ($struct:ident { $($field:ident),+ } = $expr:expr => $body:expr) => {{
        let $struct { $($field),+ , .. } = $expr;
        $body
    }};
}

7.2 使用示例

#[derive(Debug)]
struct Person {
    name: String,
    age: u8,
    email: String,
}

fn greet(p: Person) {
    partial_move!(Person { name, age } = p => {
        println!("Hi {}, you are {}", name, age);
        // email 留在 p 中，但已不可访问
    });
}

---

8 常见坑与编译器诊断

代码	错误	修复
let x = s.field; use(s)	E0382	解构剩余字段
let [a, b] = arr;	E0509	使用 slice [a, b @ ..]
match x { Some(y) => y, _ => x }	使用 mem::take

---

9 性能观察：drop flags 的零成本真相

• 结构体字段级部分移动 → 编译器为 每个字段 生成独立 drop flag
• LLVM 优化 后，drop flag 被 常量折叠 → 真正零运行时开销

---

10 结语：部分移动让「高阶抽象」与「底层性能」握手

• 字段级：a.x 的零成本拆解
• 模式级：let Struct { x, .. } = s 的编译期线性化
• 状态机级：mem::take 的异步零拷贝

当你下一次写解析器、异步运行时、或零拷贝协议时，请记住：
部分移动 = 零成本抽象的瑞士军刀。