如何实现与Cow相同的自有/借用功能？如何创建永不克隆的Cow类型？

一、实现与Cow相同的自有/借用值统一处理功能 #

你可以通过自定义枚举并实现Deref trait来复刻Cow的核心功能，让类型既能持有借用值，也能持有自有值，并且统一对外暴露相同的访问接口：

use std::ops::Deref;

// 自定义枚举，包含借用和自有两个变体
enum MyCow<'a, T: ?Sized + 'a> {
    Borrowed(&'a T),
    Owned(T),
}

// 实现Deref，让MyCow可以像&T一样被访问
impl<'a, T: ?Sized + 'a> Deref for MyCow<'a, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        match self {
            MyCow::Borrowed(val) => val,
            MyCow::Owned(val) => val,
        }
    }
}

// 用法示例
fn main() {
    let borrowed_str = "hello";
    let owned_str = String::from("world");

    let cow1 = MyCow::Borrowed(borrowed_str);
    let cow2 = MyCow::Owned(owned_str);

    // 统一调用&str的方法
    println!("{}", cow1.len()); // 输出5
    println!("{}", cow2.len()); // 输出5
}

这个自定义的MyCow和标准库Cow的核心逻辑一致：通过枚举封装两种值的形态，再借助Deref trait让外部代码无需区分变体，直接以统一的方式访问内部值。

二、创建永不执行克隆的自定义Cow类型 #

标准库Cow的克隆行为来自to_mut、into_owned这类方法——当你调用这些方法时，如果当前是借用变体，会自动克隆生成自有值。要避免这种行为，只需不提供触发克隆的方法，或限制这类方法的行为，确保借用变体不会被自动克隆：

方案1：仅保留核心访问能力，不提供转换方法 #

use std::ops::Deref;

enum NoCloneCow<'a, T: ?Sized + 'a> {
    Borrowed(&'a T),
    Owned(T),
}

impl<'a, T: ?Sized + 'a> Deref for NoCloneCow<'a, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        match self {
            NoCloneCow::Borrowed(val) => val,
            NoCloneCow::Owned(val) => val,
        }
    }
}

// 仅给自有变体提供提取自有值的方法，借用变体无法转换
impl<T> NoCloneCow<'_, T> {
    fn into_owned(self) -> Option<T> {
        match self {
            NoCloneCow::Owned(val) => Some(val),
            NoCloneCow::Borrowed(_) => None,
        }
    }
}

这个NoCloneCow只能统一访问值，但无法从借用变体自动生成自有值——如果需要自有值，必须由调用者提前准备好并传入Owned变体，完全避免了克隆操作。

方案2：实现Clone但仅复用引用，不克隆借用值 #

如果需要实现Clone trait，也可以让借用变体直接复用原有引用，只有自有变体才执行克隆：

use std::ops::Deref;

enum NoCloneCow<'a, T: ?Sized + 'a> {
    Borrowed(&'a T),
    Owned(T),
}

impl<'a, T: ?Sized + 'a> Deref for NoCloneCow<'a, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        match self {
            NoCloneCow::Borrowed(val) => val,
            NoCloneCow::Owned(val) => val,
        }
    }
}

impl<'a, T: Clone + 'a> Clone for NoCloneCow<'a, T> {
    fn clone(&self) -> Self {
        match self {
            // 借用变体直接返回新的借用，不克隆
            NoCloneCow::Borrowed(val) => NoCloneCow::Borrowed(val),
            // 自有变体正常克隆自身
            NoCloneCow::Owned(val) => NoCloneCow::Owned(val.clone()),
        }
    }
}

这种实现下，即使调用clone()，借用变体也不会触发任何克隆操作，完全符合你的需求。

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