struct - 如何捕获结构中的自消耗变量？

Question

我有一个 Reader 实例，其方法是 consumes the Reader and returns a Writer并且 Writer 可以类似地再次返回给 Reader。使用不变性很简单，但我想不出如何向调用者隐藏不变性，而只是在幕后用可变的 Self 做读者-作者-读者的舞蹈。

基本上我想要这样的东西:

struct Container<'a> {
    reader: Reader<'a, File>
}

fn update(&mut self) {
    let writer = self.reader.as_writer();
    writer.write_something();
    self.reader = writer.as_reader();
}

这只会给出 cannot move out of borrowed content 错误。尝试在 Reader 周围添加 Box、Cell 或 RefCell，这只会导致其他错误。

reader 是否可以隐藏在可变接口(interface)后面，或者它是否强制整个结构层次结构也可变？ (即类似于 Haskell 中的 IO)

---

独立样本，类型与真实事物相匹配(我认为)

#[derive(Debug)]
struct NoCopy(u32);

#[derive(Debug)]
struct Flipper<'a, T: 'a> {
    data: &'a mut T,
}
#[derive(Debug)]
struct Flopper<'a, T: 'a> {
    data: &'a mut T,
}
impl<'a, T> Flipper<'a, T> {
    fn flip(self) -> Flopper<'a, T> {
        Flopper{data: self.data}
    }
}
impl<'a, T> Flopper<'a, T> {
    fn flop(self) -> Flipper<'a, T> {
        Flipper{data: self.data}
    }
}

#[derive(Debug)]
struct Container<'a, T: 'a> {
    flipper: Flipper<'a, T>,
}
impl<'a, T> Container<'a, T> {
    fn run(&mut self) {
        self.flipper = self.flipper.flip().flop();
    }
}

fn main() {
    let f = Flipper{data: &mut NoCopy(42)};
    let f = f.flip().flop();
    println!("f={:?}", f);

    let mut c = Container{flipper: f};
    c.run();
    println!("c={:?}", c);
}

error[E0507]: cannot move out of borrowed content  --> src/main.rs:29:24   |29 |         self.flipper = self.flipper.flip().flop();   |                        ^^^^ cannot move out of borrowed content

Answer 1

更简单的解决方案是使用Option 来包装Reader。

Option 有一个返回内容的take 方法(并将None 放入Option)，然后您可以通过分配将 Reader 放回原位。

struct Container<'a> {
    reader: Option<Reader<'a, File>>
}

fn update(&mut self) {
    let writer = self.reader.take().unwrap().as_writer();
                             ^~~~~~~
    writer.write_something();
    self.reader = Some(writer.as_reader());
                  ^~~~~                  ^
}