Day 008 — 借用と参照（& と &mut）— NLLとE0502

📚 背景知識（読んでから問題へ）

Day 007では借用規則の基本——「複数の&T」または「1個だけの&mut T」のどちらか一方しか同時に存在できない——を学びました。今日はこの規則をコンパイラが実際にはどう判定しているかを掘り下げます。

NLL（Non-Lexical Lifetimes）——借用は「最後に使われた地点」で終わる

以下のコードを見てください。

📋 コピーfn main() {
    let mut s = String::from("hello");
    let r1 = &s;
    println!("{}", r1); // r1 の最後の使用はここ
    let r2 = &mut s;    // r1 はもう使われないので OK
    r2.push_str(", world");
    println!("{}", r2);
}

r1（不変借用）とr2（可変借用）が同じsに対して存在しているように見えますが、これはコンパイルが通ります。理由は、Rust 2018 Edition以降に導入されたNLL（Non-Lexical Lifetimes）という仕組みにあります。

NLL以前（Rust 2015、〜2017年頃）の借用チェッカーは、借用の有効期間を変数のスコープ（{}で囲まれた範囲）全体として扱っていました。つまりr1はmain関数の終わりまで「生きている」と判定され、その途中でr2を作ろうとするとエラーになっていました。

NLL導入後は、借用チェッカーが制御フローグラフを解析し、「その参照が実際に最後に使われる行はどこか」を追跡します。r1はprintln!("{}", r1)の行で最後に使われ、それ以降のコードでは一切参照されません。そのためr1の借用はその時点で終了し、次の行でr2（可変借用）を作ることが許されます。

不変借用と可変借用が混在するとエラー（E0502）

NLLは「使われなくなった借用を早めに終わらせてくれる」だけであり、実際に借用が同時に生きている場合はやはりエラーになります。

📋 コピーfn main() {
    let mut s = String::from("hello");
    let r1 = &s;
    let r2 = &mut s;         // r1 がまだ後で使われるため NG
    println!("{}, {}", r1, r2);
}

このコードではr1はprintln!の中で使われるため「まだ生きている」と判定され、その状態でr2（可変借用）を作ろうとするのでE0502というエラーになります（Day 007のE0499は「可変×可変」、今日のE0502は「不変×可変」の衝突です）。

メソッド呼び出し越しだと「フィールド分割借用」が効かない

構造体のフィールドへの直接アクセスであれば、異なるフィールドは同時に借用できます（これをフィールド分割借用と呼びます）。

📋 コピーstruct Counter { value: i32, history: Vec }

fn ok_example(c: &mut Counter) {
    c.history.push(c.value); // OK: history と value は別フィールド
}

しかし、c.valueの代わりに「valueを返す&selfメソッド」を経由すると話が変わります。

📋 コピーimpl Counter {
    fn current(&self) -> i32 { self.value }

    fn increment_bad(&mut self) {
        self.history.push(self.current()); // これはエラーになる
    }
}

📝 問題

1. 概念理解課題: NLL（Non-Lexical Lifetimes）とは何か、Rust 2015のレキシカルスコープ方式の借用チェッカーとの違いを説明してください
2. デバッグ予測課題（成功パターン）: 背景知識の「NLLで動く例」（r1をprintln!した後にr2 = &mut sを作るコード）が実際にコンパイルできる理由を、r1の「最後の使用地点」という観点で説明してください
3. デバッグ予測課題（失敗パターン）: 背景知識の「E0502が出る例」（r1をprintln!の中でr2と一緒に使うコード）について、なぜエラーになるのか、r1がいつまで「生きている」と判定されるかを説明してください
4. 実装課題（フィールド分割借用の限界と回避）: 以下のincrement_badはコンパイルエラーになります。currentの戻り値を一度ローカル変数に退避することでエラーを回避したincrementメソッドを実装し、Counterを3回incrementした後にvalueが3、historyがvec![0, 1, 2]になることをテストで確認してください

   📋 コピーstruct Counter { value: i32, history: Vec }
   
   impl Counter {
       fn current(&self) -> i32 { self.value }
   
       fn increment_bad(&mut self) {
           self.history.push(self.current()); // ← ここでエラー
           self.value += 1;
       }
   }

5. 発展の設計課題（コードは不要）: increment_badがエラーになるのに、c.history.push(c.value)（フィールドへの直接アクセス）はエラーにならない理由を、「コンパイラは何を単位に借用の衝突を判定しているか」という観点で説明してください。また、大規模な構造体のメソッドを設計するとき、この制約を踏まえてどのような書き方の工夫をすべきか考えてください

🔍 ヒント（段階的開示）

📋 コピーstruct Counter {
    value: i32,
    history: Vec,
}

impl Counter {
    fn new() -> Self {
        Counter { value: 0, history: Vec::new() }
    }

    fn current(&self) -> i32 {
        self.value
    }

    fn increment(&mut self) {
        let current = self.current(); // ← ここで &self の借用は完了する
        self.history.push(current);   // ← ここでは &mut self.history だけが必要
        self.value += 1;
    }
}

fn main() {
    let mut counter = Counter::new();
    counter.increment();
    counter.increment();
    counter.increment();
    println!("value = {}", counter.value);
    println!("history = {:?}", counter.history);
}

✅ 模範解答

📋 コピーstruct Counter {
    value: i32,
    history: Vec,
}

impl Counter {
    fn new() -> Self {
        Counter { value: 0, history: Vec::new() }
    }

    fn current(&self) -> i32 {
        self.value
    }

    // 修正版: self.current() の呼び出し結果を先にローカル変数へ退避する。
    // こうすることで self 全体への不変借用（current()呼び出し）は
    // let current = self.current(); の行で完結・終了し、
    // 次の self.history.push(current) では self.history への
    // 可変借用だけが必要になるため衝突しない。
    fn increment(&mut self) {
        let current = self.current();
        self.history.push(current);
        self.value += 1;
    }
}

fn main() {
    let mut counter = Counter::new();
    counter.increment();
    counter.increment();
    counter.increment();
    println!("value = {}", counter.value);
    println!("history = {:?}", counter.history);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_increment() {
        let mut counter = Counter::new();
        counter.increment();
        counter.increment();
        counter.increment();
        assert_eq!(counter.value, 3);
        assert_eq!(counter.history, vec![0, 1, 2]);
    }

    #[test]
    fn test_current() {
        let counter = Counter::new();
        assert_eq!(counter.current(), 0);
    }
}

$ cargo run
value = 3
history = [0, 1, 2]

$ cargo test
running 2 tests
test tests::test_current ... ok
test tests::test_increment ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

🪜 Step-by-Step 解説

📋 コピーfn increment_bad(&mut self) {
    self.history.push(self.current()); // ← ここでエラー
    self.value += 1;
}

📋 コピーfn increment(&mut self) {
    let current = self.current(); // (1)
    self.history.push(current);   // (2)
    self.value += 1;
}

💡 設計思想・なぜこう書くのか

🛑 コンパイルエラーが出た場合

問題4のincrement_badです。

📋 コピーfn increment_bad(&mut self) {
    self.history.push(self.current()); // ← ここでエラー
    self.value += 1;
}

読み方:

• error[E0502]: 「不変借用したいのに、すでに可変借用が存在している（あるいはその逆）」ことを示すエラーコードです。Day 007のE0499（可変×可変の衝突）とは別系統のエラーです
• mutable borrow occurs here: self.history.push(...)を呼び出すためのレシーバとして、self.historyへの可変借用がここで発生しています
• immutable borrow occurs here: 引数self.current()を評価するために、self全体への不変借用がここで発生しています
• mutable borrow later used by call: 先に確保した可変借用（push呼び出し）が、引数の評価を終えた後の実際の呼び出しでまだ使われる予定であるため、その間は不変借用と共存できません

修正方法: 問題4の模範解答の通り、self.current()の呼び出し結果をletで一度ローカル変数へ退避してからself.history.push(...)に渡します。こうすることで「selfへの不変借用」と「self.historyへの可変借用」が時間的に重ならなくなります。

🌐 他言語との比較

Go・Java・C++・TypeScriptにはそもそも「借用が同時に生きているかどうか」をコンパイラが追跡する仕組みがないため、今日のようなエラーは発生し得ません（代わりに、実行時のデータ競合や、C++であればダングリングポインタといった形で問題が顕在化します）。Rustはこの追跡を型システムの一部として行うため、current()のような一見無害なヘルパーメソッドがシグネチャ由来の制約を生む、という独特の学習コストがありますが、それと引き換えにコンパイルが通ったコードにはデータ競合が存在しないという強い保証を得られます。

🏆 実務での使いどころ

• ゲッター/セッターの多い構造体設計: structのフィールドを直接いじらず、get_x()/set_x()のようなメソッド越しにアクセスする設計は、今日学んだ「メソッド越しだとフィールド分割借用が効かない」制約に頻繁にぶつかります。Rustではpubフィールドを直接使うか、フィールドをまとめて借用する設計にする方が自然な場面が多くあります
• ビルダーパターンやステートマシンの実装: 内部状態を読みながら別の内部状態を書き換えるロジック（今日のCounterのようなパターン）は、状態管理を持つあらゆるサービスクラスに現れます。値をローカル変数に退避してから書き込む、という今日のテクニックは非常に頻出です
• リファクタリング時の落とし穴の把握: self.valueを直接読んでいたコードを、後からself.current()のようなヘルパーメソッド呼び出しに置き換えると、それまでコンパイルが通っていたコードが突然E0502で壊れることがあります。「シグネチャだけで借用が判定される」ことを知っていれば、このエラーに遭遇しても慌てず対処できます

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: increment_badのエラーを、let current = ...を使わずに解決する別の方法（例: Counterのフィールドを2つの独立した構造体に分割する設計）も考えてみてください。「フィールドをどう分割するとメソッド境界を越えた借用衝突を避けられるか」はPhase 2で学ぶ設計パターンにもつながります
• 次回予告: Day 009ではスライス型（&str・&[T]）へ進みます。今日までに学んだ「借用」の考え方が、StringやVecの全体ではなく一部分だけを指す参照としてどう応用されるかを見ていきます

🎯 自己評価

自分の回答

気づき・メモ