Rust从头至尾构建链表：能否移除unwrap方法？

有观点认为应尽可能避免使用unwrap方法。我在从头至尾构建链表时，发现似乎无法避免使用unwrap。我的问题是：是否可以移除这个unwrap？或是存在理论上无法移除的原因？

（已更新代码为最小可复现示例，供参考）

pub struct Node {
    pub value: i32,
    pub next: Option<Box<Node>>
}

impl Node {
    fn new(value: i32) -> Self {
        Node { next: None, value }
    }
}

fn vector_to_linked_list(v: &Vec<i32>) -> Option<Box<Node>> {
    let mut sentinel: Box<Node> = Box::new(Node {
        value: -1,
        next: None,
    });
    let mut current: &mut Box<Node> = &mut sentinel;
    for value in v.iter() {
        current.next = Some(Box::new(Node {
            value: *value,
            next: None,
        }));
        current = current.next.as_mut().unwrap();
    }
    sentinel.next
}

fn main() {
    let v: Vec<i32> = vec! [1, 2, 3];
    vector_to_linked_list(&v);
}

注：我不希望得到添加let-else或if-let这类无意义分支的解决方案。另外，反向构建链表时，replace方法似乎很有用，示例如下：

self.root = Some(Box::new(Node {
    value: value,
    next: ::std::mem::replace(&mut self.root, None),
}));

完全可以移除这个unwrap，不需要添加无意义的分支，核心是调整current的更新逻辑，让编译器在编译期就能确认引用的有效性，避免运行时断言。

直接修改代码如下，完全规避unwrap：

pub struct Node {
    pub value: i32,
    pub next: Option<Box<Node>>
}

impl Node {
    fn new(value: i32) -> Self {
        Node { next: None, value }
    }
}

fn vector_to_linked_list(v: &[i32]) -> Option<Box<Node>> {
    let mut sentinel = Box::new(Node { value: -1, next: None });
    let mut current = &mut sentinel;

    for &val in v {
        // 先创建新节点并获取其可变引用
        let mut new_node = Box::new(Node::new(val));
        let new_node_ref = &mut *new_node;
        
        // 将新节点挂到当前节点的next上
        current.next = Some(new_node);
        // 更新current为新节点的引用
        current = new_node_ref;
    }

    sentinel.next
}

fn main() {
    let v = vec![1, 2, 3];
    let _list = vector_to_linked_list(&v);
}

为什么这个方法可行？ #

之前的代码需要unwrap，是因为你先把Some(new_node)赋值给current.next，再调用as_mut()尝试获取引用——此时编译器无法在编译期证明current.next一定是Some（虽然我们逻辑上知道），所以必须用unwrap断言。

而修改后的逻辑是先获取新节点的可变引用，再将节点赋值给current.next：因为新节点是我们刚创建的，引用绝对有效，编译器能直接确认这一点，完全不需要运行时断言。

额外说明 #

你提到反向构建链表时用std::mem::replace很有用，这个思路在正向构建中其实没必要，因为我们不需要替换已有节点，只需要提前拿到新节点的引用即可。不过replace在反向构建中确实能优雅地避免unwrap，因为它直接返回原来的头部节点，不需要额外断言。

总之，移除unwrap没有任何理论障碍，只要调整逻辑让编译器能推导引用的有效性就行。

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