生命周期阻碍状态机返回到最近的状态答案

【问题标题】：Lifetimes getting in the way of returning state machine to most recent state生命周期阻碍状态机返回到最近的状态
【发布时间】：2021-07-28 03:19:42
【问题描述】：

示例代码：

struct S1 {}
struct S2 {}
struct S3 {}

enum State {
    Zero,
    One(S1),
    Two(S1, S2),
    Three(S1, S2, S3),
}

struct Client {
    state: Option<State>,
}

impl Client {
    fn try_advancing(&mut self) {
        /* other code */
        if let Some(inner) = std::mem::replace(&mut self.state, None) {
            match inner {
                State::Zero => {
                    if predicate0() {
                        self.state = Some(State::One(S1 {}));
                    }
                    else {
                        // code won't compile as we
                        // no longer own inner after partial move
                        self.state = Some(inner);
                    }
                },
                State::One(s1) => {
                    if predicate1() {
                        self.state = Some(State::Two(s1, S2 {}));
                    }
                    else {
                        self.state = Some(inner);
                    }
                },
                State::Two(s1, s2) => {
                    if predicate2() {
                        self.state = Some(State::Three(s1, s2, S3 {}));
                    }
                    else {
                        self.state = Some(inner);
                    }
                },
                State::Three(..) => {
                    if predicate3() {
                        // something else happens now
                    }
                }
            }
        }
    }
}

我需要查看state来确定是否移动到下一个过渡，但是如果我借用它，那么我无法过渡，因为我不拥有该值。

作为可能的解决方案，我可以使用

智能指针
第二个匹配语句（第一个借用并确定是否需要过渡，第二个移动并进行过渡）
“重建”枚举，即 self.state = Some(inner); 变为 self.state = State::Zero;
只借inner的内容，直到我知道我想转让所有权，然后做一个if let，例如

State::One(ref s1) => {
   if predicate1() {
      if let State::One(s1) = inner {
         self.state = Some(State::Two(s1, S2 {}));

为单元结构派生Copy 和Clone。

所有这些解决方案都会产生运行时成本以及我认为不雅的代码。如果这是另一种语言，我可以按照我认为应该的方式编写算法，但是对于 Rust，生命周期似乎阻止了我这样做。如果有办法告诉 Rust 编译器“在 if 语句的这个分支中，我想撤销我的部分移动并将 inner 移动回原来的位置。”或者，“是的，我在借用数据，但现在我不再需要那些引用并想移动数据。”有没有这样的方法？还是我没有考虑过的更好的选择？

【问题讨论】：

仅供参考，std::mem::replace(&mut self.state, None) 只是 self.state.take()。
啊，很高兴知道！

标签： rust

【解决方案1】：

您可以将ifs 移动到匹配臂中，这样您可以获得不同的绑定：

match inner {
    State::Zero if predicate0() => {
        self.state = Some(State::One(S1 {}));
    },
    State::Zero => {
        self.state = Some(inner);
    },
    State::One(s1) if predicate1() => {
        self.state = Some(State::Two(s1, S2 {}));
    },
    State::One(_) => {
        self.state = Some(inner);
    },
    State::Two(s1, s2) if predicate2() => {
        self.state = Some(State::Three(s1, s2, S3 {}));
    },
    State::Two(_, _) => {
        self.state = Some(inner);
    },
    // ... snip ...
}

【讨论】：