Question

我经常想在Rust中定义递归数据类型。我们需要某种程度的间接访问，以避免使用无限制大小的类型。经典的解决方案是使用Box（playground）：

enum IntList {
    Empty,
    Cons(i32, Box<IntList>),
}

我对此有一个问题，那就是它要求列表拥有自己的尾巴。这意味着您不能在两个共享一条尾巴的列表之间共享空间，因为两者都想拥有它。您可以使用借用的参考（playground）：

enum IntList<'a> {
    Empty,
    Cons(i32, &'a IntList<'a>),
}

但是创建一个列表很困难，因为不允许它拥有自己的尾巴。

有没有一种方法可以让列表不在乎列表是否拥有尾巴？这样，我可以让一个列表拥有尾巴，而另一个列表引用与该列表相同的列表尾巴。

我的尝试

我的第一个想法是为此目的使用Cow，但我无法使其正常工作。这是我尝试过的（playground）：

#[derive(Clone)]
enum IntList<'a> {
    Empty,
    Cons(i32, Cow<'a, IntList<'a>),
}

但失败并出现错误

error[E0275]: overflow evaluating the requirement `IntList<'a>: std::marker::Sized`
 --> src/main.rs:8:13
  |
8 |   Cons(i32, Cow<'a, IntList<'a>>),
  |             ^^^^^^^^^^^^^^^^^^^^
  |
  = note: required because of the requirements on the impl of `std::borrow::ToOwned` for `IntList<'a>`
  = note: required because it appears within the type `std::borrow::Cow<'a, IntList<'a>>`
  = note: no field of an enum variant may have a dynamically sized type

Answer 1

我创建了一种类似Cow的数据类型，称为Cowish。如果已经有类似的东西了，请告诉我！

pub enum Cowish<'a, T, O>
where
    T: 'a,
{
    Borrowed(&'a T),
    Owned(O),
}

impl<'a, T, O> Borrow<T> for Cowish<'a, T, O>
where
    T: 'a,
    O: Borrow<T>,
{
    fn borrow(&self) -> &T {
        match self {
            Borrowed(b) => b,
            Owned(o) => o.borrow(),
        }
    }
}

impl<'a, T, O> Cowish<'a, T, O>
where
    T: ToOwned<Owned=O> + 'a,
    O: Borrow<T>,
{
    pub fn into_owned(self) -> O {
        match self {
            Borrowed(b) => b.to_owned(),
            Owned(o) => o,
        }
    }
}

使用它，我可以做我想做的事：

enum IntList<'a> {
    Empty,
    Cons(i32, Cowish<'a, IntList<'a>, Box<IntList<'a>>>),
}

可以找到一个更大的示例here。

Answer 2

这可能太旧了，但仅作记录用途，如果要创建链接列表，可以使用std::rc::Rc。就像Box一样，但是您可以对一个对象有多个引用。唯一的警告是，一旦列表包含在Rc中，您就无法对其进行突变。这是来自rust book的示例：

enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil))))); // [10, 5]
    let b = Cons(3, Rc::clone(&a)); // [10, 5, 3]
    let c = Cons(4, Rc::clone(&a)); // [10, 5, 4]
}

不在乎拥有子结构的递归数据类型

我的尝试

2 个答案: