Rust中生命周期、Cow<str>与Builder模式的协同使用问题

我正在学习Rust生命周期，想用状态标记结构体（Init/Parsed/Html）结合PhantomData实现一个基于Pest的Markdown解析器Parkdown，通过状态控制API暴露范围，核心需求是切换状态时保留content的&str借用，避免不必要的复制。

定义的核心结构体 #

use std::{
    borrow::Cow,
    marker::PhantomData,
};
struct Init;
struct Parsed;
struct Html;

/// 基于**Pest**构建的Markdown解析器
pub struct Parkdown<'a, TState = Init> {
    /// 原始Markdown内容
    pub content: Cow<'a, str>,
    /// 内容来源文件（若提供）
    file: Option<String>,
    /// 解析使用的规则
    pub rule: Rule,
    /// 规则生成的"pairs"
    pairs: Option<Pairs<'a, Rule>>,

    state: PhantomData<TState>,
}

尝试的实现与报错 #

我希望在Parkdown<'_, Init>上实现parse方法，返回Parsed状态的Parkdown，但两种尝试均失败：

方案1：使用&self的parse方法

impl<'a, Init> Parkdown<'a, Init> {
    pub fn new(content: &'a str) -> Self {
        Self {
            content: Cow::Borrowed(content),
            rule: Rule::file,
            file: None,
            pairs: None,
            state: PhantomData::<Init>,
        }
    }

    pub fn parse<'b>(&'b self) -> Result<Parkdown<'b, Parsed>, Err> {
        let pairs: Pairs<'b, Rule> = Markdown::parse(
            self.rule,
            &self.content,
        )?;

        let p: Parkdown<'b, Parsed> = Parkdown {
            state: PhantomData::<Parsed>,
            pairs: Some(pairs),
            // 报错：Cow<str>未实现Copy trait
            content: self.content,
            rule: self.rule,
            file: self.file.clone(),
        };
        Ok(p)
    }
}

报错原因：Cow<'a, str>没有实现Copy trait，直接赋值会触发移动逻辑，但我需要保留原有的引用语义而非复制内容。

方案2：使用self的parse方法（他人建议）

pub fn parse(self) -> Result<Parkdown<'a, Parsed>> {
    color_eyre::install()?;
    let pairs: Pairs<'a, Rule> = Markdown::parse(
        self.rule,
        &self.content,
    )?;

    self.pairs = Some(pairs);
    // 报错：expected struct `PhantomData<Init>` found struct `PhantomData<Parsed>`
    self.state = PhantomData::<Parsed>;

    Ok(self)
}

报错原因：TState是结构体的编译期泛型参数，无法通过修改PhantomData的类型来切换实例的状态。

补充：content的Owned变体实现 #

impl<'a, Init> Parkdown<'a, Init> {
    // ...

    pub fn new_owned(content: String) -> Self {
        Self {
            content: Cow::Owned(content),
            rule: Rule::file,
            file: None,
            pairs: None,
            state: PhantomData::<Init>,
        }
    }

    pub fn from_file(file: &str) -> Result<Parkdown<'a, Init>, Err> {
        let content = read_to_string(&file)?;

        let mut p = Parkdown::new_owned(content);
        p.file = Some(file.to_string());

        Ok(p)
    }
}

解决方案：所有权转移+重新构造实现状态转换 #

由于泛型状态是编译期确定的，无法在运行时修改，正确的做法是获取原结构体的所有权，用原有字段构造新状态的Parkdown实例，同时利用Cow的特性自动保留借用或转移所有权：

// 仅针对Init状态的Parkdown实现parse方法，确保状态机的正确性
impl<'a> Parkdown<'a, Init> {
    pub fn new(content: &'a str) -> Self {
        Self {
            content: Cow::Borrowed(content),
            rule: Rule::file,
            file: None,
            pairs: None,
            state: PhantomData,
        }
    }

    pub fn parse(self) -> Result<Parkdown<'a, Parsed>, Err> {
        let pairs = Markdown::parse(self.rule, &self.content)?;

        Ok(Parkdown {
            // 直接转移content所有权，自动保留借用/Owned状态
            content: self.content,
            rule: self.rule,
            file: self.file,
            pairs: Some(pairs),
            state: PhantomData,
        })
    }
}

// 单独实现Init状态的其他构造方法
impl<'a> Parkdown<'a, Init> {
    pub fn new_owned(content: String) -> Self {
        Self {
            content: Cow::Owned(content),
            rule: Rule::file,
            file: None,
            pairs: None,
            state: PhantomData,
        }
    }

    pub fn from_file(file: &str) -> Result<Parkdown<'a, Init>, Err> {
        let content = read_to_string(file)?;

        Ok(Parkdown {
            content: Cow::Owned(content),
            rule: Rule::file,
            file: Some(file.to_string()),
            pairs: None,
            state: PhantomData,
        })
    }
}

关键说明 #

1. 限定状态实现方法：将parse方法的实现限定在Parkdown<'a, Init>上，确保只有初始状态能调用该方法，符合状态机的设计逻辑。
2. 所有权转移优化：使用self而非&self，直接转移content、file等字段的所有权，无需复制Cow（Cow实现了Clone但此处无需调用，转移更高效）。
3. 编译期状态切换：通过构造新的Parkdown<'a, Parsed>实例，让编译器自动处理泛型参数的切换，避免修改原有实例的PhantomData类型。
4. 保留借用语义：当content是Cow::Borrowed(&'a str)时，转移所有权后新实例依然保持借用状态，不会触发字符串复制；如果是Cow::Owned(String)则直接转移字符串所有权。

这种方式既满足了状态切换的需求，又完美保留了Cow的借用/所有权语义，避免不必要的内存开销。

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