Vector 如何实现包含自身向量的Cow的枚举？

我是。到目前为止，我所做的就是：

use std::borrow::Cow;

pub struct Float {
    pub min: f64,
    pub max: f64,
    pub value: f64,
}

pub struct Text<'a> {
    pub value: Cow<'a, str>
}

pub enum Value<'a> {
    None,
    Float(Float),
    Text(Text<'a>),
}

这使我可以在以下功能中使用它：

fn append_string(s1: &Value, s2: &Value) {
    Value::Text(Text {
        value: format!("{}{}", s1.str_val(), s2.str_val()),
    })
}

我希望向量也是这样，我假设如下：

pub fn vec(&'a self) -> Vec<Value> {
    match self {
        Value::Vector(v) => v.value,
        _ => Cow::Owned(Vector { value: vec![] }),
    }
}

pub fn vec(&'a self) -> Vec<Value> {
match self {
        Value::Vector(v) => v.value,
        _ => Cow::Owned(Vector { value: vec![] }),
    }
}

pub-fn-vec（&'a-self）->vec{
匹配自我{
值：：向量（v）=>v.Value，
_=>Cow:：Owned（向量{value:vec！[]}），
}
}

我希望向量也是这样，我假设如下：

pub fn vec(&'a self) -> Vec<Value> {
    match self {
        Value::Vector(v) => v.value,
        _ => Cow::Owned(Vector { value: vec![] }),
    }
}

pub fn vec(&'a self) -> Vec<Value> {
match self {
        Value::Vector(v) => v.value,
        _ => Cow::Owned(Vector { value: vec![] }),
    }
}

然后，您的

to_vec

将如下所示：

impl<'a> Value<'a> {
    pub fn to_vec(&'a self) -> Cow<'a, [Value<'a>]> {
        match self {
            Value::Vector(v) => Cow::Borrowed(&v.value),
            _ => Cow::Owned(Vec::new()),
        }
    }
}

impl<'a> Value<'a> {
    pub fn to_vec_slice(&'a self) -> &'a [Value<'a>] {
        match self {
            Value::Vector(v) => &v.value,
            _ => &[],
        }
    }
}

我希望向量也是这样，我假设如下：

pub fn vec(&'a self) -> Vec<Value> {
    match self {
        Value::Vector(v) => v.value,
        _ => Cow::Owned(Vector { value: vec![] }),
    }
}

pub fn vec(&'a self) -> Vec<Value> {
match self {
        Value::Vector(v) => v.value,
        _ => Cow::Owned(Vector { value: vec![] }),
    }
}

然后，您的

to_vec

将如下所示：

impl<'a> Value<'a> {
    pub fn to_vec(&'a self) -> Cow<'a, [Value<'a>]> {
        match self {
            Value::Vector(v) => Cow::Borrowed(&v.value),
            _ => Cow::Owned(Vec::new()),
        }
    }
}

impl<'a> Value<'a> {
    pub fn to_vec_slice(&'a self) -> &'a [Value<'a>] {
        match self {
            Value::Vector(v) => &v.value,
            _ => &[],
        }
    }
}

---

@Hellagot我相信您可以使用返回

Cow

s的函数，而不必将

Cow

s存储在

Value

中。在结构/枚举中使用

Cow

，可以存储拥有的值或借用的值；你真的需要吗？用

Rc

或

Arc

代替怎么样？@Hellagot

Cow>

有点奇怪。您可能想要Cow]>

，它在借用时是一个切片，在拥有时是一个

Vec`。但问题的根源是，

Cow

需要

T:Toowed

才能创建一个拥有的变体。它之所以建议使用

Clone

，是因为对于所有类型的

Clone

，都有一个全面的

ToOwned

实现。但这并不一定是你想要的。如果你试图为

Value

或

[Value]

自己实现

ToOwned

，你会发现自己需要在某处进行克隆。@PeterHall不会

Vec

和

[]

在这里提供间接寻址吗？@Hellagot我相信您可以使用返回

Cow

s的函数，而无需将

Cow

s存储在

值中。在结构/枚举中使用
Cow
，可以存储拥有的值或借用的值；你真的需要吗？用
Rc
或
Arc
代替怎么样？@Hellagot
Cow>
有点奇怪。您可能想要Cow]>
，它在借用时是一个切片，在拥有时是一个
Vec`。但问题的根源是，
Cow
需要
T:Toowed
才能创建一个拥有的变体。它之所以建议使用
Clone
，是因为对于所有类型的
Clone
，都有一个全面的
ToOwned
实现。但这并不一定是你想要的。如果你尝试为
Value
或
[Value]
自己实现
ToOwned
，你会发现自己需要在某处进行克隆。@PeterHall不
Vec
和
[]
在这里提供间接定向？
Cow]>
和
&a[Value Cow]>
和
fn to_-vec（&self）->&[价值尽管如此，我想统一生命周期可能是有意的？如果一切都是不变的，它会起作用。@trentcl不，我只是有点懒。这可能仍然是OP想要的。很难说清楚。OP的
stru_val
出于同样的原因是可疑的。谢谢大家，切片版本是我一直在寻找的，还在学习中。目前，我希望保持源代码值不变，但我将尽可能删除返回的生存期，让编译器省略它，正如@trentcl
Cow]>
和
&a[Value Cow]>
和
fn to_vec（&self）->所建议的那样&[价值尽管如此，我想统一生命周期可能是有意的？如果一切都是不变的，它会起作用。@trentcl不，我只是有点懒。这可能仍然是OP想要的。很难说清楚。OP的
stru_val
出于同样的原因是可疑的。谢谢大家，切片版本是我一直在寻找的，还在学习中。目前，我希望保持源代码值不变，但我将尽可能删除返回的生存期，让编译器删除它，正如@trentcl所建议的那样