这个 rust 代码用于从未排序的链表中删除重复项，在 else 分支的低级上做什么？

问：

我有一个链表：

pub struct Node<T> {
    val: T,
    next: Option<Box<Node<T>>>
}

pub struct LinkedList<T> {
    head: Option<Box<Node<T>>>
}

我的问题涉及此功能以删除重复项：

impl<T: Clone + Eq + Hash> LinkedList<T> {
    pub fn remove_dupes(&mut self) {
        let mut set = HashSet::new();
        let mut current = &mut self.head;
        while let Some(mut node) = current.take() { // AO
            if set.contains(&node.val) {
                *current = node.next.take();
            } else {
                set.insert(node.val.clone());
                let next = node.next.take(); // A1 take rest of list. Node.next is now None
                *current = Some(node); // A2 restore ownership of node to current but its now pointing to None.
                 current = &mut current.as_mut().unwrap().next; // *A3* None because (A1) took ownership. *Why is this line necessary?*
                *current = next; // A4 move to next node to continue with rest of list
            }
        }
    }

它的工作原理和删除重复项，就像以下操作一样，以一种更易于理解的方式：

impl<T: Clone + Eq + Hash> LinkedList<T> {
    pub fn remove_dupes(&mut self) {
        let mut set = HashSet::new();
        let mut current = &mut self.head;
        while let Some(mut node) = current.take() //B0 {
            if set.contains(&node.val) {
                *current = node.next.take();
            } else {
                set.insert(node.val.clone());
                *current = Some(node); // B1
                 current = &mut current.as_mut().unwrap().next; // B2
            }
        }
    }

我是 rust 的新手，正在努力了解内存中发生的事情。我不明白 A3 行-- --需要什么以及它到底在做什么，但如果没有它，该功能就无法工作。有人可以current = &mut current.as_mut().unwrap().next;

1. 给出第一个函数中发生的事情的细分，以及为什么这会将所有权恢复到当前状态并移动到下一个节点？
2. 解释为什么 self.head 在函数返回后仍然指向列表的原始头部，但如果在第 A3 行中被注释掉，则指向列表的末尾 （None）。current = &mut current.as_mut().unwrap().next

我有一个带有此处代码的游乐场（打印调试语句有点嘈杂）：https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=0015a922b6cc0f7284c9b37d0dfb95e6

我的理解如下，可能有缺陷：

1. while let Some(mut node) = current.take()（答0）这条线在循环的每次迭代中都拥有电流的所有权，并将其交给变量“node”。 因此，它是 None。current
2. let next = node.next.take();（答1）此行获取 node.next 的所有权，并将其存储在变量中以供以后使用。 因此，它是 None。nextnode.next
3. *current = Some(node);（答2）再次将电流指向节点。current 不再是 None。它现在指向节点 { val：（无论当前值是多少），next：None}
4. current = &mut current.as_mut().unwrap().next;（答3）如果没有此行，循环仍将前进，但当函数返回给调用方时，链表最终将指向列表的末尾 （None）。此处的值应始终为 None，因为我们在 A1 中从 node.next 中夺走了所有权。current.as_mut().unwrap().next;
5. *current = next;（答4）将电流指向我们存储在 A1 中的下一个节点。next

请注意，注释掉倒数第二行 （A3） 等效于

    pub fn remove_dupes(&mut self) {
        let mut set = HashSet::new();
        let mut current = &mut self.head;
        let mut restore:&mut Option<Box<Node<T>>> = &mut None;
        while let Some(mut node) = current.take() {
            if set.contains(&node.val) {
                *current = node.next.take();
            } else {
                set.insert(node.val.clone());
                let next = node.next.take();
                *restore = Some(node);
                 current = &mut restore.as_mut().unwrap().next;
                *current = next;
            }
        }
    }

    pub fn remove_dupes(&mut self) {
        let mut set = HashSet::new();
        let mut current = &mut self.head;
        while let Some(mut node) = current.take() {
            if set.contains(&node.val) {
                *current = node.next.take();
            } else {
                set.insert(node.val.clone());
                let next = node.next.take();
                *current = Some(node);
                *current = next;
            }
        }
    }

调用后打印链表（使用我的格式化程序）会导致头部 == 无：

LL(0): |None|