rust - 盒装值(value)的生命周期不够长

Question

作为练习，我正在尝试在 Rust 中实现缺点列表。我已经设法解决了除此之外的所有编译器错误:

Compiling list v0.0.1 (file:///home/nate/git/rust/list)
/home/nate/git/rust/list/src/main.rs:18:24: 18:60 error: borrowed value does not live long enough
/home/nate/git/rust/list/src/main.rs:18         List::End => list = &*(box List::Node(x, box List::End)),
                                                                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/nate/git/rust/list/src/main.rs:16:34: 21:2 note: reference must be valid for the anonymous lifetime #1 defined on the block at 16:33...
/home/nate/git/rust/list/src/main.rs:16 fn add(mut list: &List, x: uint) {
/home/nate/git/rust/list/src/main.rs:17     match *list {
/home/nate/git/rust/list/src/main.rs:18         List::End => list = &*(box List::Node(x, box List::End)),
/home/nate/git/rust/list/src/main.rs:19         List::Node(_, ref next_node) => add(&**next_node, x),
/home/nate/git/rust/list/src/main.rs:20     }
/home/nate/git/rust/list/src/main.rs:21 }
/home/nate/git/rust/list/src/main.rs:18:16: 18:60 note: ...but borrowed value is only valid for the expression at 18:15
/home/nate/git/rust/list/src/main.rs:18         List::End => list = &*(box List::Node(x, box List::End)),
                                                             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
Could not compile `list`.

To learn more, run the command again with --verbose.

以及我要编译的代码:

enum List {
    Node(uint, Box<List>),
    End,
}

fn main() {
    let mut list = new();

    add(&*list, 10);
    //add(list, 20);
    //add(list, 30);

    print(&*list);
}

fn add(mut list: &List, x: uint) {
    match *list {
        List::End => list = &*(box List::Node(x, box List::End)),
        List::Node(_, ref next_node) => add(&**next_node, x),
    }
}

fn new() -> Box<List> {
    box List::End
}

那么为什么盒装值的生命周期不够长？是因为我立即取消引用它们吗？我这样试过:

match *list {
    List::End => {
        let end = box List::Node(x, box List::End);
        list = &*end;
    }
    List::Node(_, ref next_node) => add(&**next_node, x),
}

但我得到了完全相同的错误。我错过了什么？

Answer 1

我认为您遗漏了 Rust 的一些关键细节；我认为我们需要处理三件事:

1. 模式如何运作；
2. 不可变(&)和可变(&mut)引用之间的区别；
3. Rust 的所有权模型如何运作(因为您的 &*box 尝试)。

我会先处理模式部分；在fn add(mut list: &List, x: uint) , 使用了两种模式，mut list和 x .其他模式示例在 let lhs = rhs; 的左侧和 => 之前的位在 match 的每个分支上表达。这些模式如何有效地应用于调用？这真的就像你这样做:

fn add(__arg_0: &List, __arg_1: uint) {
    let mut list = __arg_0;
    let x = __arg_1;
    …
}

也许这样看事情会更清楚；函数的签名根本不考虑变量绑定(bind)的模式。您的函数签名实际上是规范形式 fn add(&List, uint) . mut list部分只是意味着您正在绑定(bind) &List可变名称的值；也就是说，您可以为 list 分配一个新值名称，但它在函数之外没有任何影响，这纯粹是将变量绑定(bind)到位置的问题。

现在进入第二个问题:了解不可变引用(类型 &T，值 &x)和可变引用(类型 &mut T，值 &x)之间的区别。这些非常基础，我不会在这里详细介绍——它们在其他地方有充分的记录，您可能应该阅读这些内容。我只想说:如果你想改变某些东西，你需要 &mut , 不是 & , 所以你的 add方法需要取&mut List .

第三个问题，所有权问题:在 Rust 中，每个对象都在恰好位置拥有；没有垃圾收集或任何东西，这种所有权的唯一性意味着一旦对象超出范围，它就会被销毁。在这种情况下，有问题的表达式是 &*(box List::Node(x, box List::End)) .您已经装箱了一个值，但实际上并没有将它存储在任何地方:您只是试图引用其中包含的值，但该箱子将立即被丢弃。在这种情况下，您真正​​想要的是修改 List 的内容。 ;你想写 *list = List::Node(x, box List::End) , 意思是“存储 List::Node list 内容里面的值” 而不是 list = &… , 意思是“分配给变量 list一个新的引用”。

您对值(value)观的限制也有点过火了；我倾向于说 new()应该返回 List , 不是 Box<List> ，尽管这个问题有待商榷。无论如何，这是add我最终得到的方法:

fn add(list: &mut List, x: uint) {
    match *list {
        List::End => *list = List::Node(x, box List::End),
        List::Node(_, box ref mut next_node) => add(next_node, x),
    }
}

您可能难以理解的主要一点是模式 box ref mut next_node . box ref mut部分内容为“从盒子中取出值，然后创建对该值的可变引用”；因此，给定一个 Box<List> , 它产生一个 &mut List指的是那个盒子里的东西。请记住，与普通表达式相比，模式完全是从前到后。

最后，我强烈推荐使用 impl对于所有这些，将所有方法放在 List 上输入:

enum List {
    Node(uint, Box<List>),
    End,
}

impl List {
    fn new() -> List {
        List::End
    }

    fn add(&mut self, x: uint) {
        match *self {
            List::End => *self = List::Node(x, box List::End),
            List::Node(_, box ref mut next_node) => next_node.add(x),
        }
    }
}

fn main() {
    let mut list = List::new();

    list.add(10);
}