生命周期过大-02

继上篇文章后，我们再来看一段可能涉及生命周期过大导致的无法编译问题:


fn bar(writer: &mut Writer) {
    baz(writer.indent());
    writer.write("world");
}

fn baz(writer: &mut Writer) {
    writer.write("hello");
}

pub struct Writer<'a> {
    target: &'a mut String,
    indent: usize,
}

impl<'a> Writer<'a> {
    fn indent(&'a mut self) -> &'a mut Self {
        &mut Self {
            target: self.target,
            indent: self.indent + 1,
        }
    }

    fn write(&mut self, s: &str) {
        for _ in 0..self.indent {
            self.target.push(' ');
        }
        self.target.push_str(s);
        self.target.push('\n');
    }
}

fn main() {}

报错如下：


error[E0623]: lifetime mismatch
 --> src/main.rs:2:16
  |
1 | fn bar(writer: &mut Writer) {
  |                -----------
  |                |
  |                these two types are declared with different lifetimes...
2 |     baz(writer.indent());
  |                ^^^^^^ ...but data from `writer` flows into `writer` here

WTF，这什么报错，之前都没有见过，而且很难理解，什么叫writer滑入了另一个writer？

别急，我们先来仔细看下代码，注意这一段：


#![allow(unused)]
fn main() {
impl<'a> Writer<'a> {
    fn indent(&'a mut self) -> &'a mut Self {
        &mut Self {
            target: self.target,
            indent: self.indent + 1,
        }
    }
}

这里的生命周期定义说明indent方法使用的。。。等等！你的代码错了，你怎么能在一个函数中返回一个新创建实例的引用？！！最重要的是，编译器不提示这个错误，竟然提示一个莫名其妙看不懂的东东。

行，那我们先解决这个问题，将该方法修改为:


#![allow(unused)]
fn main() {
fn indent(&'a mut self) -> Writer<'a> {
    Writer {
        target: self.target,
        indent: self.indent + 1,
    }
}
}

怀着惴惴这心，再一次运行程序，果不其然，编译器又朝我们扔了一坨错误：


error[E0308]: mismatched types
 --> src/main.rs:2:9
  |
2 |     baz(writer.indent());
  |         ^^^^^^^^^^^^^^^
  |         |
  |         expected `&mut Writer<'_>`, found struct `Writer`
  |         help: consider mutably borrowing here: `&mut writer.indent()`

哦，这次错误很明显，因为baz需要&mut Writer，但是咱们writer.indent返回了一个Writer，因此修改下即可:


#![allow(unused)]
fn main() {
fn bar(writer: &mut Writer) {
    baz(&mut writer.indent());
    writer.write("world");
}
}

这次总该成功了吧？再次心慌慌的运行编译器，哐：


error[E0623]: lifetime mismatch
 --> src/main.rs:2:21
  |
1 | fn bar(writer: &mut Writer) {
  |                -----------
  |                |
  |                these two types are declared with different lifetimes...
2 |     baz(&mut writer.indent());
  |                     ^^^^^^ ...but data from `writer` flows into `writer` here

可恶，还是这个看不懂的错误，仔细检查了下代码，这次真的没有其他错误了，只能硬着头皮上。

大概的意思可以分析，生命周期范围不匹配，说明一个大一个小，然后一个writer中流入到另一个writer说明，两个writer的生命周期定义错了，既然这里提到了indent方法调用，那么我们再去仔细看一眼：


#![allow(unused)]
fn main() {
impl<'a> Writer<'a> {
    fn indent(&'a mut self) -> Writer<'a> {
        Writer {
            target: self.target,
            indent: self.indent + 1,
        }
    }
    ...
}
}

好像有点问题，indent返回的Writer的生命周期和外面调用者的Writer的生命周期一模一样，这很不合理，一眼就能看出前者远小于后者。

这里稍微展开以下，为何indent方法返回值的生命周期不能与参数中的self相同。首先，我们假设它们可以相同，也就是上面的代码可以编译通过，由于此时在返回值中借用了self的可变引用，意味着如果你在返回值被使用后，还继续使用self 会导致重复借用的错误，因为返回值的生命周期将持续到 self 结束。

既然不能相同，那我们尝试着修改下indent:


#![allow(unused)]
fn main() {
 fn indent<'b>(&'b mut self) -> Writer<'b> {
    Writer {
        target: self.target,
        indent: self.indent + 1,
    }
}
}

Bang! 编译成功，不过稍等，回想下生命周期消除的规则，我们还可以实现的更优雅：


fn bar(writer: &mut Writer) {
    baz(&mut writer.indent());
    writer.write("world");
}

fn baz(writer: &mut Writer) {
    writer.write("hello");
}

pub struct Writer<'a> {
    target: &'a mut String,
    indent: usize,
}

impl<'a> Writer<'a> {
    fn indent(&mut self) -> Writer {
        Writer {
            target: self.target,
            indent: self.indent + 1,
        }
    }

    fn write(&mut self, s: &str) {
        for _ in 0..self.indent {
            self.target.push(' ');
        }
        self.target.push_str(s);
        self.target.push('\n');
    }
}

fn main() {}

至此，问题彻底解决，太好了，我感觉我又变强了。可是默默看了眼自己的头发，只能以哎～一声叹息结束本章内容。

Rust语言圣经(Rust Course)

生命周期过大-02