generics - “cannot borrow as mutable more than once”，即使是在放弃第一次借阅后

Question

trait Output {
    fn write(&mut self, text: &str);
}

struct DummyOutput {}

impl Output for DummyOutput {
    fn write(&mut self, text: &str) {
        // self does not need to be mut in this reproducer,
        // but it would in the real version
        println!("{}", text);
    }
}

enum EncoderOutput<'a, T> {
    Owned(T),
    Borrowed(&'a mut T),
}

impl<'a, T> AsMut<T> for EncoderOutput<'a, T> {
    fn as_mut(&mut self) -> &mut T {
        match self {
            EncoderOutput::Owned(ref mut o) => o,
            EncoderOutput::Borrowed(b) => b,
        }
    }
}

struct Encoder<'a, O: Output> {
    output: EncoderOutput<'a, O>,
}

impl<'a, O: Output> Encoder<'a, O> {
    // here's the idea:
    // every child instance will have a borrowed output,
    // and always only one level of indirection, i.e.:
    // - root: "&mut O" or "O"
    // - child1: "&mut O"
    // - child2: "&mut O"
    // but never:
    // - childN: "&mut &mut O"
    fn child(&'a mut self) -> Self {
        Encoder {
            output: EncoderOutput::Borrowed(self.output.as_mut()),
        }
    }
}

fn main() {
    let mut enc1 = Encoder {
        output: EncoderOutput::Owned(DummyOutput {}),
    };

    {
        // I know this borrows mutably from enc1
        let mut enc2 = enc1.child();

        // so this will obviously not work:
        // enc1.output.as_mut().write("bar 2b");

        // but this does work:
        enc2.output.as_mut().write("bar 2a");
    } // but then the borrow "enc2" should be dropped here?

    // so why does this fail with:
    // "cannot borrow [...] as mutable more than once"
    enc1.output.as_mut().write("bar 3");
}

error[E0499]: cannot borrow `enc1.output` as mutable more than once at a time
  --> src/main.rs:68:5
   |
57 |         let mut enc2 = enc1.child();
   |                        ---- first mutable borrow occurs here
...
68 |     enc1.output.as_mut().write("bar 3");
   |     ^^^^^^^^^^^
   |     |
   |     second mutable borrow occurs here
   |     first borrow later used here

我的直觉告诉我这失败了，因为 Encoder返回的 child()中借用的有效期与“父”的有效期相同-但我看不到解耦有效期的方法，即使返回的值显然应该有一个生命周期比父项短或相等，因为它可以事先删除。
我也尝试过先没有 EncoderOutput的版本，只是直接在 &mut O中有一个 Encoder，但是问题是相同的。
我的思路是:在 main()中的作用域结束时，会删除 enc2，并运行隐式的 Drop impl，这会清理 EncoderOutput::Borrowed和其中的引用，因此不会将其他 &mut ref保留给 enc1和 enc1可以再次可变地借用。
我在哪里错呢？

Answer 1

改变:

fn child(&'a mut self) -> Encoder<'a, O>;

到:

fn child(&mut self) -> Encoder<'_, O>;

固定的编译示例:

trait Output {
    fn write(&mut self, text: &str);
}

struct DummyOutput {}

impl Output for DummyOutput {
    fn write(&mut self, text: &str) {
        println!("{}", text);
    }
}

enum EncoderOutput<'a, T> {
    Owned(T),
    Borrowed(&'a mut T),
}

impl<'a, T> AsMut<T> for EncoderOutput<'a, T> {
    fn as_mut(&mut self) -> &mut T {
        match self {
            EncoderOutput::Owned(ref mut o) => o,
            EncoderOutput::Borrowed(b) => b,
        }
    }
}

struct Encoder<'a, O: Output> {
    output: EncoderOutput<'a, O>,
}

impl<'a, O: Output> Encoder<'a, O> {
    // line below changed from:
    // fn child(&'a mut self) -> Encoder<'a, O> {
    // to:
    // child(&mut self) -> Encoder<'_, O> {
    fn child(&mut self) -> Encoder<'_, O> {
        Encoder {
            output: EncoderOutput::Borrowed(self.output.as_mut()),
        }
    }
}

fn main() {
    let mut enc1 = Encoder {
        output: EncoderOutput::Owned(DummyOutput {}),
    };

    {
        let mut enc2 = enc1.child();
        enc2.output.as_mut().write("bar 2a");
    }

    enc1.output.as_mut().write("bar 3");
}

playground

说明 &'a self和 &'a mut self是所有Rust中最常见的生存陷阱，大多数初学者甚至中级Rustaceans最终都会陷入其中。我知道您的示例中的第二行是错的，甚至没有尝试去理解其余代码的其他内容。超过99.9％的时间 &'a self和 &'a mut self是错误的，只要您看到两者中的任何一个，它都应该发出一个大的红色标记，当您看到它们时，应该积极地重构它们。好的，顺便说一句，这就是它们如此糟糕的原因:
如果您有一些包含引用的容器，我们将其称为 Container<'a>，那么该容器的生命周期是多少？它的生命周期与引用生命周期相同，因为容器不能超过其所包含的生命周期。让我们将其称为生命周期 'a。非常重要: 'a中的 Container<'a>代表了容器的整个生命周期。因此，当您使用 &'a self或 &'a mut self接收器编写方法时，与编译器通信的内容是“为了调用此方法，该方法必须在整个生命周期的剩余时间内借用该容器”。现在，您真正想要的是什么时候？几乎从不!极少需要编写一个只能被调用一次的方法，因为它在 self的整个生命周期中都永久借用了 self。 Ergo， &'a self和 &'a mut self是新手陷阱，请避免使用它们。
澄清
当 &'a self代表 &'a mut self本身的整个生命周期时， 'a和 self只是红色标记。在以下情况下， 'a仅限于单个方法，那么就可以了:

// 'a only local to this method, this is okay
fn method<'a>(&'a self) {
    // etc
}