Rustのライフタイムを理解したい

# はじめに

超個人的な感想だけど、Rustでちょっと凝ったことをしようとするとぶつかる壁がライフタイム。
公式の[ライフタイムで参照を検証する](https://doc.rust-jp.rs/book-ja/ch10-03-lifetime-syntax.html#%E3%83%A9%E3%82%A4%E3%83%95%E3%82%BF%E3%82%A4%E3%83%A0%E3%81%A7%E5%8F%82%E7%85%A7%E3%82%92%E6%A4%9C%E8%A8%BC%E3%81%99%E3%82%8B)を熟読すればそれだけで済むことを記事にする。

重ねて書くけど、[ライフタイムで参照を検証する](https://doc.rust-jp.rs/book-ja/ch10-03-lifetime-syntax.html#%E3%83%A9%E3%82%A4%E3%83%95%E3%82%BF%E3%82%A4%E3%83%A0%E3%81%A7%E5%8F%82%E7%85%A7%E3%82%92%E6%A4%9C%E8%A8%BC%E3%81%99%E3%82%8B)を熟読している方は本記事から得るものはない。


個人的には、コンパイラに頼らなくても何とかなるところまで持っていきたい。

# 本記事

## 基本の関数シグネチャ

公式に記載のある通り

+ ライフタイムとは、参照が有効になるスコープ
+ 参照は全てライフタイムを保持する

なので、`コンパイラがライフタイムをどうだこうだ言ってくる` = `参照のスコープがよく分からんことになっている` 状態。

公式にもジャストの例が載っていて、

```rust
fn main() {
    let str1 = String::from("エリザベス");
    let str2 = "モリザベス";
    let result = longest(str1.as_str(), str2);
    println!("{}", result);
}

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
```

↑を実行しようとするとちゃんとライフタイムのエラーが出る。引数が参照で複数なのでどっちのライフタイムに合わせればいいかわからん状態。

```text
  |
8 | fn longest(x: &str, y: &str) -> &str {
  |               ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
  |
8 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
  |           ++++     ++          ++          ++
```

エラーの通り修正すると実行可能になる

```rust
fn main() {
    let str1 = String::from("エリザベス");
    let str2 = "モリザベス";
    let result = longest(str1.as_str(), str2);
    println!("{}", result);
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
```

ここで使ってる`<'a>`とか`'a`とかがライフタイム注釈記法と呼ばれるもの。

```rust
// <'a>はライフタイムの宣言
// パラメタとか戻り値についてる'aがライフタイム指定
// パラメタのライフタイムは入力ライフタイム、戻り値のライフタイムが出力ライフタイムと呼ばれる
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
```

↑の意味は、`引数のx, yのどちらか小さい方のスコープを'aとして関数のスコープとする`と言うもの。ちなみに、ライフタイム注釈は小文字の連続なら何でもよい。frierenでも大丈夫。仕事で使ったら怒られるだろうけどRust的には問題ない。まず実装でお目にかかることはないだろうけど、アンダースコアも使える。`frieren_and_fern`とかでも問題ない(はず)。

```rust
fn longest<'frieren>(x: &'frieren str, y: &'frieren str) -> &'frieren str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
```

ライフタイム注釈には3つの規則がある

1 - 各引数は、独自のライフタイム引数を得る
2 - 入力ライフタイム引数が一つなら出力ライフタイム引数も同じになる
3 - `&self`とか`&mut self`使ったら`&self`のライフタイムになる(構造体のメソッドのやつ)

以下が例

```rust
 fn main() {
    let a = 50;
    let b = 51;
    let c = 49;
    let z1 = process01(&a, &b, &c);
    println!("z1: {}", z1);
    let z2 = process02(&a, &b, &c);
    println!("z2: {}", z2);
    let z3 = process03(&a);
    println!("z3: {}", z3);
    let z4 = process04(&a);
    println!("z4: {}", z4);
 }

// 各引数は独自のライフタイムを得る(戻り値を&i32へすると、ライフタイム指定が必要になる)
 fn process01<'izen, 'himmel, 'frieren>(x: &'izen i32, y: &'himmel i32, z: &'frieren i32) -> i32 {
    *x + *y + *z 
 }

 fn process02<'frieren>(x: &'frieren i32, y: &'frieren i32, z: &'frieren i32) -> &'frieren i32 {
    x
 }

 // 入力ライフタイム引数が一つなら出力ライフタイム引数も同じになる
 fn process03(x: &i32) -> &i32 {
    x
 }

 fn process04<'frieren>(x: &'frieren i32) -> &'frieren i32 {
    x
 }
 ```

## 構造体シグネチャ

先にあった通り、`参照は全てライフタイムを保持する`なので参照を持つ構造体はライフタイムの指定が必要。

特に参照を持たない場合はライフタイム関係なく使える。平和な世界。

```rust
#[derive(Debug)]
struct Easygoing {
    feel: bool,
}

impl Easygoing {
    fn feeling() -> bool {
        true
    }

    fn feeling_self(&self) -> bool {
        self.feel || false
    }
}

fn main() {
    let easygoing = Easygoing {
        feel: true,
    };

    println!("{:?}", &easygoing);
    println!("feeling: {}", Easygoing::feeling());
    println!("feeling self: {}", easygoing.feeling_self());
}
```

参照が入ってくると少しややこしくなるが、こちらもジャストな例が公式に載ってる。

```rust
fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let i = ImportantExcerpt {
        part: first_sentence,
    };
    println!("{:?}", &i);
}

#[derive(Debug)]
struct ImportantExcerpt<'a> {
    part: &'a str,
}
```

ちなみにライフタイム注釈を外すと以下のようになる

```text
error[E0106]: missing lifetime specifier
  --> src/main.rs:30:11
   |
30 |     part: &str,
   |           ^ expected named lifetime parameter
   |
help: consider introducing a named lifetime parameter
   |
29 ~ struct ImportantExcerpt<'a> {
30 ~     part: &'a str,
   |
```

怒られている内容としては`構造体に保持している参照のライフタイムが謎やぞ`。なので、構造体のライフタイムと合わせる必要がある(*1)。
ちなみに`struct ImportantExcerpt<'a>`の`<'a>`はジェネリックなライフタイム指定。次で出てくるimplに関連する。

ライフタイムを指定したImportantExcerptにimplを単純に指定すると

```rust
#[derive(Debug)]
struct ImportantExcerpt<'a> {
    part: &'a str,
}

// ↓追加
impl ImportantExcerpt {
    fn level() -> i32 {
        3
    }
    fn level_self(&self) -> i32 {
        3
    }
    fn get_part(&self) -> &str {
        self.part
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let i = ImportantExcerpt {
        part: first_sentence,
    };
    println!("{:?}", &i);
}
```

下記エラーが出る

```text
  --> src/main.rs:26:6
   |
26 | impl ImportantExcerpt {
   |      ^^^^^^^^^^^^^^^^ expected lifetime parameter
   |
help: indicate the anonymous lifetime
   |
26 | impl ImportantExcerpt<'_> {
   |                      ++++
```

これは、参照を持つ構造体に合わせたライフタイム指定が必要なため。匿名ライフタイムの指定でも回避可能だし、ライフタイムを明示的に指定しても回避可能。

```rust
#[derive(Debug)]
struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'frieren> ImportantExcerpt<'frieren> {
    fn level() -> i32 {
        3
    }
    fn level_self(&self) -> i32 {
        3
    }
    fn get_part(&self) -> &str {
        self.part
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let i = ImportantExcerpt {
        part: first_sentence,
    };
    println!("{:?}", &i);
}
```

implのライフタイム指定がややこしい。`impl<'frieren> ImportantExcerpt<'frieren>`に関して軽く補足すると
1回目の`<'frieren>` -> ライフタイムの定義
2回目の`<'frieren>` -> ImportantExceprtのジェネリックに`'freiren`を割り当て

みたいな感じと理解している。定義と割り当てで同じ感じだからややこしいけど意味合いが別(*2)。

*1: 個人的には構造体の範囲を超えて使うことないからいいじゃんって思ってる
*2: 巷の例でもだいたいが`'a`で書いてあるから余計に見分けつきづらい

## ライフタイム境界

いまだに理解できてるのかが怪しい項目。使わなきゃならないユースケースにぶつかった事がない。
公式の[Rust By Example 日本語版 - ライフタイム境界](https://doc.rust-jp.rs/rust-by-example-ja/scope/lifetime/lifetime_bounds.html)を読んですぐ何のことか理解できる人は多くないと思いたい。

> ジェネリック型に境界(bound)を与え、特定のトレイトを実装していることを保証できるのと同様、ライフタイム（それ自身ジェネリック型）にも境界を与えることができます。

自分なりの理解として、↑を順序立てて説明してみる。

まず、大前提として構造体はジェネリックが使える。

```rust
#[derive(Debug)]
struct Buffer<T> {
    value: T,
}

pub fn run_lifetime_bound() {
    let value = 100;
    let buffer = Buffer{
        value: value,
    };
    println!("{:?}", buffer);
}
```

構造体のジェネリックも参照型が使える。勿論ライフタイムの指定が必要。

```rust
#[derive(Debug)]
struct Buffer<'a, T> {
    value: &'a T,
}

pub fn run_lifetime_bound() {
    let value = 100;
    let buffer = Buffer { value: &value };
    println!("{:?}", buffer);
}
```

構造体なのでトレイトを実装できる。(printとかで利用する場合はジェネリックにDebugトレイトが実装されていることを明示する必要があることに注意)

```rust
use std::fmt::Debug;

trait BufferBehavior<T> {
    fn buffer(&self)
    where
        T: Debug,
    {
    }
}

#[derive(Debug)]
struct Buffer<'a, T> {
    value: &'a T,
}

impl<'buffer_life, T> BufferBehavior<T> for Buffer<'buffer_life, T> {
    fn buffer(&self)
    where
        T: Debug,
    {
        println!("BufferBehavior: {:?}", self.value);
    }
}

pub fn run_lifetime_bound() {
    let value = 100;
    let buffer = Buffer { value: &value };
    println!("{:?}", buffer);
    buffer.buffer();
}
```

ここで、トレイト自体にジェネリックの参照を返す処理を定義する。

```rust
use std::fmt::Debug;

trait BufferBehavior<T> {
    fn buffer(&self)
    where
        T: Debug,
    {
    }
    fn get_value(&self) -> &T;
}

#[derive(Debug)]
struct Buffer<'a, T> {
    value: &'a T,
}

impl<'buffer_life, T> BufferBehavior<T> for Buffer<'buffer_life, T> {
    fn buffer(&self)
    where
        T: Debug,
    {
        println!("BufferBehavior: {:?}", self.value);
    }

    fn get_value(&self) -> &T {
        self.value
    }
}

pub fn run_lifetime_bound() {
    let value = 100;
    let buffer = Buffer { value: &value };
    println!("{:?}", buffer);
    buffer.buffer();
    println!("buffer value: {:?}", buffer.get_value());
}
```

トレイト内の参照にライフタイムをつけられる！ <- ライフタイム境界

```rust
use std::fmt::Debug;

trait BufferBehavior<'a, T: 'a> {
    fn buffer(&self)
    where
        T: Debug,
    {
    }
    fn get_value(&self) -> &'a T;
}

#[derive(Debug)]
struct Buffer<'a, T> {
    value: &'a T,
}

impl<'buffer_life, T> BufferBehavior<'buffer_life, T> for Buffer<'buffer_life, T> {
    fn buffer(&self)
    where
        T: Debug,
    {
        println!("BufferBehavior: {:?}", self.value);
    }

    fn get_value(&self) -> &'buffer_life T {
        self.value
    }
}

pub fn run_lifetime_bound() {
    let value = 100;
    let buffer = Buffer { value: &value };
    println!("{:?}", buffer);
    buffer.buffer();
    println!("buffer value: {:?}", buffer.get_value());
}
```

これなんに使うんだか

# まとめ

ライフタイムの学習にいまいち身が入らないのは、ジェネリックとかとごっちゃになりやすいからと思う。
ライフタイム境界は未だに謎。