// ===== コード例1: 所有者の基本 =====
 
fn main() {
    // s が "hello" という String 値の所有者
    let s = String::from("hello");
 
    // String のメモリレイアウト:
    //
    //  スタック (s)         ヒープ
    //  +---------+         +---+---+---+---+---+
    //  | ptr   --|-------->| h | e | l | l | o |
    //  | len: 5  |         +---+---+---+---+---+
    //  | cap: 5  |
    //  +---------+
    //
    // s はスタック上のメタデータ (ポインタ, 長さ, 容量) を持ち、
    // 実際の文字列データはヒープ上に格納される。
 
    println!("{}", s); // s を通じて値にアクセス
}
// ← s がスコープを抜ける → drop(s) が呼ばれ、ヒープメモリが解放される

// ===== コード例2: スコープとdropの動作 =====
 
struct DatabaseConnection {
    url: String,
}
 
impl DatabaseConnection {
    fn new(url: &str) -> Self {
        println!("[OPEN] DB接続を確立: {}", url);
        DatabaseConnection { url: url.to_string() }
    }
}
 
impl Drop for DatabaseConnection {
    fn drop(&mut self) {
        println!("[CLOSE] DB接続を切断: {}", self.url);
    }
}
 
fn process_data() {
    let conn = DatabaseConnection::new("postgres://localhost/mydb");
    // conn を使った処理...
    println!("[QUERY] データを取得中...");
 
    {
        let temp_conn = DatabaseConnection::new("postgres://localhost/tempdb");
        println!("[QUERY] 一時データを取得中...");
    } // ← temp_conn がスコープを抜ける → drop 呼び出し
      //   出力: [CLOSE] DB接続を切断: postgres://localhost/tempdb
 
    println!("[QUERY] 追加処理中...");
} // ← conn がスコープを抜ける → drop 呼び出し
  //   出力: [CLOSE] DB接続を切断: postgres://localhost/mydb
 
// 実行結果:
// [OPEN]  DB接続を確立: postgres://localhost/mydb
// [QUERY] データを取得中...
// [OPEN]  DB接続を確立: postgres://localhost/tempdb
// [QUERY] 一時データを取得中...
// [CLOSE] DB接続を切断: postgres://localhost/tempdb
// [QUERY] 追加処理中...
// [CLOSE] DB接続を切断: postgres://localhost/mydb

let s1 = String::from("hello");
let s2 = s1;  // 所有権が s1 → s2 に移動（ムーブ）
// println!("{}", s1);  // コンパイルエラー! s1 はもう使えない
println!("{}", s2);     // OK: s2 が新しい所有者

// ===== コード例3: ムーブが発生する各場面 =====
 
fn main() {
    // (1) 変数への代入
    let s1 = String::from("hello");
    let s2 = s1;  // ムーブ
 
    // (2) 関数の引数に渡す
    let s3 = String::from("world");
    take_ownership(s3);  // s3 の所有権が関数に移動
    // println!("{}", s3);  // コンパイルエラー!
 
    // (3) 関数の戻り値
    let s4 = give_ownership();  // 関数から所有権を受け取る
    println!("{}", s4);  // OK
 
    // (4) ベクタへの push
    let s5 = String::from("item");
    let mut vec = Vec::new();
    vec.push(s5);  // s5 の所有権がベクタに移動
    // println!("{}", s5);  // コンパイルエラー!
 
    // (5) パターンマッチ
    let opt = Some(String::from("data"));
    match opt {
        Some(s) => println!("Got: {}", s),  // s に所有権がムーブ
        None => println!("None"),
    }
    // println!("{:?}", opt);  // コンパイルエラー!
}
 
fn take_ownership(s: String) {
    println!("Took ownership of: {}", s);
} // ← s がスコープを抜ける → メモリ解放
 
fn give_ownership() -> String {
    String::from("gifted")  // 所有権を呼び出し元に移動
}

// Copy トレイトを実装する型（コピーされる型）
let x: i32 = 42;
let y = x;     // コピー（x はまだ有効）
println!("{}", x);  // OK
 
let a: f64 = 3.14;
let b = a;     // コピー
println!("{}", a);  // OK
 
let c: bool = true;
let d = c;     // コピー
 
let e: char = 'A';
let f = e;     // コピー
 
let g: (i32, f64) = (1, 2.0);
let h = g;     // タプルの全要素が Copy なのでコピー
 
// Copy トレイトを実装しない型（ムーブされる型）
let s1 = String::from("hello");
let s2 = s1;   // ムーブ (s1 は無効)
 
let v1 = vec![1, 2, 3];
let v2 = v1;   // ムーブ (v1 は無効)
 
// 明示的なクローン（ディープコピー）
let s3 = String::from("world");
let s4 = s3.clone();  // ヒープデータも含めた完全なコピー
println!("{} {}", s3, s4);  // 両方有効

// Copy + Clone を derive する（全フィールドが Copy の場合のみ）
#[derive(Debug, Copy, Clone)]
struct Point {
    x: f64,
    y: f64,
}
 
let p1 = Point { x: 1.0, y: 2.0 };
let p2 = p1;  // コピー（p1 は有効）
println!("{:?} {:?}", p1, p2);
 
// Clone のみ derive する（ヒープデータを含む場合）
#[derive(Debug, Clone)]
struct Person {
    name: String,    // String は Copy でない
    age: u32,
}
 
let alice = Person { name: String::from("Alice"), age: 30 };
let alice2 = alice.clone();  // 明示的クローン
// let alice3 = alice;       // ムーブ（clone しないとムーブされる）
println!("{:?}", alice2);
 
// カスタム Clone の実装
#[derive(Debug)]
struct Config {
    name: String,
    values: Vec<i32>,
    read_count: std::cell::Cell<u32>,
}
 
impl Clone for Config {
    fn clone(&self) -> Self {
        Config {
            name: self.name.clone(),
            values: self.values.clone(),
            read_count: std::cell::Cell::new(0),  // クローン時はカウントをリセット
        }
    }
}

// ===== コード例4: 不変借用の詳細 =====
 
fn main() {
    let s = String::from("hello, world");
 
    // 不変参照を複数同時に作成できる
    let r1 = &s;
    let r2 = &s;
    let r3 = &s;
 
    println!("{}, {}, {}", r1, r2, r3); // 全て有効
 
    // 関数に不変参照を渡す
    let length = calculate_length(&s);
    let first = first_word(&s);
 
    println!("'{}' の長さ: {}, 最初の単語: '{}'", s, length, first);
    // s はまだ有効（所有権は移動していない）
}
 
// 不変参照を受け取る関数
fn calculate_length(s: &String) -> usize {
    s.len()
    // s はここでスコープを抜けるが、参照なので何も起きない
    // 元のデータは解放されない
}
 
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &byte) in bytes.iter().enumerate() {
        if byte == b' ' {
            return &s[..i];
        }
    }
    s
}

fn main() {
    let mut s = String::from("hello");
 
    // 可変参照を作成
    let r = &mut s;
    r.push_str(", world!");
    println!("{}", r);  // "hello, world!"
 
    // 可変参照は同時に 1 つだけ
    let mut data = vec![1, 2, 3];
 
    let r1 = &mut data;
    // let r2 = &mut data;  // コンパイルエラー! 2 つ目の可変参照
    r1.push(4);
    println!("{:?}", r1);
 
    // r1 の使用が終わった後なら新しい可変参照を作れる
    let r2 = &mut data;
    r2.push(5);
    println!("{:?}", r2);
}
 
// 可変参照を受け取る関数
fn append_greeting(s: &mut String) {
    s.push_str(", world!");
}

fn main() {
    // --- 違反例 1: 不変参照中に可変参照を取る ---
    let mut s = String::from("hello");
    let r1 = &s;         // 不変参照
    let r2 = &s;         // 不変参照（OK）
    // let r3 = &mut s;  // コンパイルエラー!
    //   不変参照 r1, r2 が生きている間は可変参照を取れない
    println!("{} {}", r1, r2);
    // ここで r1, r2 の最後の使用が終わる（NLL: Non-Lexical Lifetimes）
 
    let r3 = &mut s;  // OK: r1, r2 はもう使われない
    r3.push_str("!");
    println!("{}", r3);
 
    // --- 違反例 2: 同時に 2 つの可変参照 ---
    let mut v = vec![1, 2, 3, 4, 5];
    // split_at_mut は安全に 2 つの可変スライスを得る方法
    let (left, right) = v.split_at_mut(3);
    left[0] = 10;
    right[0] = 40;
    println!("{:?} {:?}", left, right); // [10, 2, 3] [40, 5]
}

fn main() {
    let mut s = String::from("hello");
 
    // Rust 2015 では、r1 はブロックの終わりまで有効だった
    // Rust 2018+ (NLL) では、r1 は最後に使用された行で終了
 
    let r1 = &s;
    println!("{}", r1);  // r1 の最後の使用 → ここで r1 の借用が終了
 
    let r2 = &mut s;     // OK: r1 はもう使われない
    r2.push_str(", world");
    println!("{}", r2);
}

fn main() {
    let mut scores = vec![100, 85, 92, 78, 95];
 
    // NG: イテレーション中にベクタを変更しようとする
    // for &score in &scores {
    //     if score < 80 {
    //         scores.push(0);  // コンパイルエラー!
    //         // &scores (不変借用) と scores.push (可変借用) が衝突
    //     }
    // }
 
    // OK: まず条件を収集し、後で変更する
    let low_scores: Vec<usize> = scores
        .iter()
        .enumerate()
        .filter(|(_, &s)| s < 80)
        .map(|(i, _)| i)
        .collect();
 
    for &idx in &low_scores {
        scores[idx] = 0;  // 不変借用はもう存在しない
    }
    println!("{:?}", scores); // [100, 85, 92, 0, 95]
 
    // OK: retain を使う（内部的に安全に処理される）
    let mut names = vec!["Alice", "Bob", "Charlie", "Dave"];
    names.retain(|name| name.len() > 3);
    println!("{:?}", names); // ["Alice", "Charlie", "Dave"]
}

// ===== コード例5: ダングリング参照とその防止 =====
 
// NG: ダングリング参照を返そうとする
// fn dangling() -> &String {
//     let s = String::from("hello");
//     &s  // コンパイルエラー: s はこの関数で破棄されるのに参照を返そうとしている
// }
// エラーメッセージ:
//   this function's return type contains a borrowed value,
//   but there is no value for it to be borrowed from
 
// 解決策 1: 所有権を返す（ムーブ）
fn not_dangling_v1() -> String {
    let s = String::from("hello");
    s  // 所有権をムーブして返す
}
 
// 解決策 2: 'static ライフタイム（プログラム全体で有効）
fn not_dangling_v2() -> &'static str {
    "hello"  // 文字列リテラルは 'static ライフタイムを持つ
}
 
// 解決策 3: 引数の参照を返す（ライフタイムを明示）
fn not_dangling_v3<'a>(s: &'a str) -> &'a str {
    &s[..3]  // 引数と同じライフタイムの参照を返す
}

// ライフタイム注釈の構文: 'a, 'b, 'c ...（慣例的に小文字のアルファベット）
 
// 2 つの文字列スライスのうち長い方を返す関数
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
 
// 'a の意味:
// 「戻り値の参照は、x と y の両方のライフタイムの
//   短い方と同じかそれより短い期間だけ有効である」
 
fn main() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
        println!("Longest: {}", result);  // OK: string2 はまだ有効
    }
    // println!("{}", result);  // コンパイルエラー!
    // string2 が解放されたため、result は無効
}
 
// 異なるライフタイムを持つ引数
fn first_or_default<'a, 'b>(first: &'a str, _default: &'b str) -> &'a str {
    first  // 戻り値は first と同じライフタイム
}

// 参照を保持する構造体にはライフタイム注釈が必須
#[derive(Debug)]
struct Excerpt<'a> {
    part: &'a str,  // 'a の期間だけ有効な参照
}
 
impl<'a> Excerpt<'a> {
    fn level(&self) -> i32 {
        3  // 参照を返さないのでライフタイム注釈不要
    }
 
    fn announce_and_return(&self, announcement: &str) -> &str {
        println!("Attention: {}", announcement);
        self.part  // self.part と同じライフタイムの参照を返す
    }
}
 
fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence;
    {
        let sentences: Vec<&str> = novel.split('.').collect();
        first_sentence = Excerpt { part: sentences[0] };
    }
    // first_sentence はまだ有効:
    // part が参照する novel はまだスコープ内にあるため
    println!("{:?}", first_sentence);
}

// 省略規則が適用される例
 
// 書いたコード                  コンパイラが推論する完全形
fn first_word(s: &str) -> &str  // fn first_word<'a>(s: &'a str) -> &'a str
{
    &s[..s.find(' ').unwrap_or(s.len())]
}
 
// 省略できない例（2 つの入力参照）
// fn longest(x: &str, y: &str) -> &str  // コンパイルエラー!
// → どちらのライフタイムを返すか不明
// → 明示的な注釈が必要:
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// 文字列リテラルは 'static
let s: &'static str = "I live forever";
 
// 'static な値はプログラム終了まで有効
// バイナリに直接埋め込まれるため、解放の必要がない
 
// 注意: 'static を安易に使うのはアンチパターン
// 本当にプログラム全体で有効にする必要がある場合のみ使用すること
// エラーメッセージで 'static を提案されても、多くの場合は
// 設計を見直すべきサインである

// Box<T>: データをヒープに配置し、スタックにはポインタのみ置く
 
// 用途 1: コンパイル時にサイズ不明な型
// 再帰的データ型（Box なしではコンパイルエラー）
#[derive(Debug)]
enum List {
    Cons(i32, Box<List>),  // Box で間接参照にすることでサイズが確定
    Nil,
}
 
use List::{Cons, Nil};
 
fn main() {
    let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
    println!("{:?}", list);
    // Cons(1, Cons(2, Cons(3, Nil)))
}
 
// 用途 2: 大きなデータをムーブする際のコスト削減
struct LargeData {
    buffer: [u8; 1_000_000],  // 1MB のデータ
}
 
fn process(data: Box<LargeData>) {
    // Box のムーブはポインタのコピーのみ（8 バイト）
    // LargeData を直接ムーブすると 1MB のコピーが発生する
    println!("Processing {} bytes", data.buffer.len());
}
 
// 用途 3: トレイトオブジェクト（動的ディスパッチ）
trait Animal {
    fn speak(&self) -> &str;
}
 
struct Dog;
struct Cat;
 
impl Animal for Dog {
    fn speak(&self) -> &str { "Woof!" }
}
 
impl Animal for Cat {
    fn speak(&self) -> &str { "Meow!" }
}
 
fn get_animal(is_dog: bool) -> Box<dyn Animal> {
    if is_dog {
        Box::new(Dog)
    } else {
        Box::new(Cat)
    }
}

use std::rc::Rc;
 
// Rc<T>: 複数の所有者を持つための参照カウント
// 単一スレッドでのみ使用可能
 
fn main() {
    // グラフ構造: ノード C を A と B の両方が参照する
    //
    //     A ---+
    //          |
    //          v
    //          C
    //          ^
    //          |
    //     B ---+
 
    let c = Rc::new(String::from("shared data"));
    println!("参照カウント (初期): {}", Rc::strong_count(&c));  // 1
 
    let a = Rc::clone(&c);  // カウント +1 (データのクローンではない!)
    println!("参照カウント (a 作成後): {}", Rc::strong_count(&c));  // 2
 
    {
        let b = Rc::clone(&c);  // カウント +1
        println!("参照カウント (b 作成後): {}", Rc::strong_count(&c));  // 3
    }  // b がスコープを抜ける → カウント -1
 
    println!("参照カウント (b 破棄後): {}", Rc::strong_count(&c));  // 2
 
    // 全ての Rc が破棄された時点で、データが解放される
}
// a, c が破棄 → カウント 0 → データ解放
 
// Weak<T>: 循環参照を防ぐ弱い参照
use std::rc::Weak;
 
#[derive(Debug)]
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,      // 弱い参照（カウントに含まれない）
    children: RefCell<Vec<Rc<Node>>>,  // 強い参照
}
 
// 親 → 子: Rc（強い参照）
// 子 → 親: Weak（弱い参照）
// → 循環参照にならないため、メモリリークしない

use std::sync::Arc;
use std::thread;
 
// Arc<T>: Rc のスレッド安全版
// アトミック操作で参照カウントを管理するため、若干のオーバーヘッドがある
 
fn main() {
    let data = Arc::new(vec![1, 2, 3, 4, 5]);
    let mut handles = vec![];
 
    for i in 0..3 {
        let data_clone = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let sum: i32 = data_clone.iter().sum();
            println!("Thread {}: sum = {}", i, sum);
        });
        handles.push(handle);
    }
 
    for handle in handles {
        handle.join().unwrap();
    }
 
    println!("Final ref count: {}", Arc::strong_count(&data));  // 1
}
 
// Arc + Mutex: スレッド間で可変データを共有
use std::sync::Mutex;
 
fn concurrent_counter() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
 
    for _ in 0..10 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter_clone.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
 
    for handle in handles {
        handle.join().unwrap();
    }
 
    println!("Counter: {}", *counter.lock().unwrap());  // 10
}

use std::cell::RefCell;
 
// RefCell<T>: コンパイル時ではなく実行時に借用ルールをチェック
// 「不変参照しか持てない状況で、内部を変更したい」場合に使う
 
fn main() {
    let data = RefCell::new(vec![1, 2, 3]);
 
    // 不変な data から可変借用を取得
    data.borrow_mut().push(4);
    println!("{:?}", data.borrow());  // [1, 2, 3, 4]
 
    // 実行時の借用ルール違反はパニックになる
    // let r1 = data.borrow();      // 不変借用
    // let r2 = data.borrow_mut();  // パニック! 不変借用中に可変借用
}
 
// よくある使用パターン: Rc<RefCell<T>>
// 複数の所有者 + 内部可変性
use std::rc::Rc;
 
#[derive(Debug)]
struct SharedState {
    value: Rc<RefCell<i32>>,
}
 
impl SharedState {
    fn new(val: i32) -> Self {
        SharedState { value: Rc::new(RefCell::new(val)) }
    }
 
    fn increment(&self) {
        *self.value.borrow_mut() += 1;
    }
 
    fn get(&self) -> i32 {
        *self.value.borrow()
    }
}

// ===== コード例6: Builder パターン =====
 
#[derive(Debug)]
struct HttpRequest {
    method: String,
    url: String,
    headers: Vec<(String, String)>,
    body: Option<String>,
}
 
struct HttpRequestBuilder {
    method: String,
    url: String,
    headers: Vec<(String, String)>,
    body: Option<String>,
}
 
impl HttpRequestBuilder {
    fn new(url: &str) -> Self {
        HttpRequestBuilder {
            method: "GET".to_string(),
            url: url.to_string(),
            headers: Vec::new(),
            body: None,
        }
    }
 
    // self を消費して返す → メソッドチェーンが可能
    fn method(mut self, method: &str) -> Self {
        self.method = method.to_string();
        self
    }
 
    fn header(mut self, key: &str, value: &str) -> Self {
        self.headers.push((key.to_string(), value.to_string()));
        self
    }
 
    fn body(mut self, body: &str) -> Self {
        self.body = Some(body.to_string());
        self
    }
 
    fn build(self) -> HttpRequest {
        HttpRequest {
            method: self.method,
            url: self.url,
            headers: self.headers,
            body: self.body,
        }
    }
}
 
fn main() {
    let request = HttpRequestBuilder::new("https://api.example.com/data")
        .method("POST")
        .header("Content-Type", "application/json")
        .header("Authorization", "Bearer token123")
        .body(r#"{"key": "value"}"#)
        .build();
 
    println!("{:#?}", request);
}

// ===== コード例7: 型駆動状態マシン =====
 
// 各状態を型で表現
struct Draft;
struct PendingReview;
struct Published;
 
struct BlogPost<State> {
    title: String,
    content: String,
    state: std::marker::PhantomData<State>,
}
 
// Draft 状態でのみ利用可能なメソッド
impl BlogPost<Draft> {
    fn new(title: &str) -> Self {
        BlogPost {
            title: title.to_string(),
            content: String::new(),
            state: std::marker::PhantomData,
        }
    }
 
    fn add_content(&mut self, text: &str) {
        self.content.push_str(text);
    }
 
    // Draft → PendingReview への遷移（元の値を消費して新しい型を返す）
    fn request_review(self) -> BlogPost<PendingReview> {
        BlogPost {
            title: self.title,
            content: self.content,
            state: std::marker::PhantomData,
        }
    }
}
 
// PendingReview 状態でのみ利用可能なメソッド
impl BlogPost<PendingReview> {
    fn approve(self) -> BlogPost<Published> {
        BlogPost {
            title: self.title,
            content: self.content,
            state: std::marker::PhantomData,
        }
    }
 
    fn reject(self) -> BlogPost<Draft> {
        BlogPost {
            title: self.title,
            content: self.content,
            state: std::marker::PhantomData,
        }
    }
}
 
// Published 状態でのみ content を公開
impl BlogPost<Published> {
    fn content(&self) -> &str {
        &self.content
    }
}
 
fn main() {
    let mut post = BlogPost::<Draft>::new("Ownership Guide");
    post.add_content("Rust's ownership system is...");
 
    // post.content();  // コンパイルエラー! Draft 状態では content() がない
    let post = post.request_review();
    // post.add_content("more");  // コンパイルエラー! PendingReview では変更不可
    let post = post.approve();
    println!("{}", post.content());  // OK: Published 状態でのみ公開
}

// 引数に &str を受け取ると、String と &str の両方を受け付けられる
fn greet(name: &str) {
    println!("Hello, {}!", name);
}
 
fn main() {
    let owned = String::from("Alice");
    let borrowed = "Bob";
 
    greet(&owned);    // String → &str への自動変換 (Deref)
    greet(borrowed);  // &str はそのまま
 
    // AsRef トレイトを使うとさらに柔軟に
    fn process_path<P: AsRef<std::path::Path>>(path: P) {
        let path = path.as_ref();
        println!("Processing: {:?}", path);
    }
 
    process_path("/home/user/file.txt");         // &str
    process_path(String::from("/tmp/data.csv")); // String
    process_path(std::path::PathBuf::from("/var/log"));  // PathBuf
}

use std::borrow::Cow;
 
// Cow<'a, T>: 必要な時だけクローンする遅延コピー
// - 読み取りのみ → 参照のまま（コスト 0）
// - 変更が必要 → その時点でクローン
 
fn normalize_name(name: &str) -> Cow<'_, str> {
    if name.contains(char::is_uppercase) {
        // 大文字が含まれる → 変換が必要 → 新しい String を作成
        Cow::Owned(name.to_lowercase())
    } else {
        // 変換不要 → 元の参照をそのまま返す（コスト 0）
        Cow::Borrowed(name)
    }
}
 
fn main() {
    let name1 = normalize_name("alice");    // Borrowed: クローンなし
    let name2 = normalize_name("BOB");      // Owned: to_lowercase() のコスト
    let name3 = normalize_name("charlie");  // Borrowed: クローンなし
 
    println!("{}, {}, {}", name1, name2, name3);
}

// C++: RAII + unique_ptr（Rust の Box に相当）
#include <memory>
#include <string>
#include <iostream>
 
class Resource {
    std::string name_;
public:
    Resource(const std::string& name) : name_(name) {
        std::cout << "Acquired: " << name_ << std::endl;
    }
    ~Resource() {
        std::cout << "Released: " << name_ << std::endl;
    }
};
 
void cpp_example() {
    // unique_ptr: 単一所有（Rust の Box に近い）
    auto r1 = std::make_unique<Resource>("DB Connection");
    auto r2 = std::move(r1);  // ムーブ（r1 は nullptr になる）
    // r1->...  // 未定義動作! (Rust ではコンパイルエラー)
 
    // shared_ptr: 共有所有（Rust の Rc/Arc に近い）
    auto r3 = std::make_shared<Resource>("Cache");
    auto r4 = r3;  // 参照カウント +1
}
// r2, r3, r4 がスコープを抜ける → 自動解放

// Swift: ARC（自動参照カウント）
class User {
    var name: String
    var friend: User?  // 強い参照 → 循環参照のリスク
 
    init(name: String) {
        self.name = name
        print("User \(name) created")
    }
 
    deinit {
        print("User \(name) deallocated")
    }
}
 
// 循環参照の例
var alice: User? = User(name: "Alice")
var bob: User? = User(name: "Bob")
alice?.friend = bob    // Alice → Bob (強い参照)
bob?.friend = alice    // Bob → Alice (強い参照) → 循環参照!
alice = nil
bob = nil
// 両方 nil にしても deinit は呼ばれない → メモリリーク!
 
// 解決: weak または unowned を使う
class SafeUser {
    var name: String
    weak var friend: SafeUser?  // 弱い参照
 
    init(name: String) { self.name = name }
    deinit { print("SafeUser \(name) deallocated") }
}

// Go: ガベージコレクション
package main
 
import "fmt"
 
func main() {
    // Go では所有権の概念がない
    // GC が不要なメモリを自動回収
    s1 := "hello"
    s2 := s1  // コピー（文字列は不変）
    fmt.Println(s1, s2)
 
    // スライスは参照型（暗黙的な共有）
    a := []int{1, 2, 3}
    b := a  // 浅いコピー（同じ配列を指す）
    b[0] = 100
    fmt.Println(a)  // [100 2 3]  ← a も変わっている!
    // Rust ではこのような暗黙的な共有はムーブで防がれる
}

// ===== アンチパターン: clone() の乱用 =====
 
// NG: 借用で済むのに clone している
fn bad_process_items(items: &Vec<String>) {
    for item in items {
        let owned = item.clone();  // NG: 不要な clone
        println!("{}", owned);
        // owned はこの行で破棄される → clone の意味がない
    }
}
 
// OK: 参照のまま使う
fn good_process_items(items: &[String]) {
    for item in items {
        println!("{}", item);  // &String のまま使えば十分
    }
}
 
// NG: HashMap のキー探索のために clone
fn bad_lookup(map: &std::collections::HashMap<String, i32>, key: &str) -> Option<i32> {
    let owned_key = key.to_string();  // NG: 不要なアロケーション
    map.get(&owned_key).copied()
}
 
// OK: &str で直接探索
fn good_lookup(map: &std::collections::HashMap<String, i32>, key: &str) -> Option<i32> {
    map.get(key).copied()  // HashMap<String, _> は &str でも探索できる
}
 
// clone が正当化されるケース:
// 1. データを別スレッドに送る必要がある場合
// 2. 構造体のフィールドとして所有する必要がある場合
// 3. 元のデータとは独立に変更する必要がある場合
fn justified_clone(data: &[String]) -> Vec<String> {
    // フィルタ結果を新しいベクタとして返す → clone が必要
    data.iter()
        .filter(|s| s.starts_with("important"))
        .cloned()
        .collect()
}

// ===== アンチパターン: Rc<RefCell<T>> の過剰使用 =====
 
use std::rc::Rc;
use std::cell::RefCell;
 
// NG: 全てを Rc<RefCell<T>> で包む「GC スタイル」
struct BadGameState {
    player_hp: Rc<RefCell<i32>>,
    player_mp: Rc<RefCell<i32>>,
    enemies: Rc<RefCell<Vec<Rc<RefCell<Enemy>>>>>,
    items: Rc<RefCell<Vec<Rc<RefCell<Item>>>>>,
}
// 問題点:
// 1. 実行時パニックのリスク（借用ルール違反）
// 2. 参照カウントのオーバーヘッド
// 3. コードの可読性が著しく低下
// 4. コンパイル時の安全性保証が失われる
 
// OK: 所有権を明確にした設計
struct GoodGameState {
    player: Player,
    enemies: Vec<Enemy>,
    items: Vec<Item>,
}
 
struct Player {
    hp: i32,
    mp: i32,
}
 
struct Enemy {
    name: String,
    hp: i32,
}
 
struct Item {
    name: String,
    effect: i32,
}
 
impl GoodGameState {
    // 明確な借用で安全にアクセス
    fn apply_damage(&mut self, enemy_idx: usize, damage: i32) {
        if let Some(enemy) = self.enemies.get_mut(enemy_idx) {
            enemy.hp -= damage;
        }
    }
 
    fn heal_player(&mut self, amount: i32) {
        self.player.hp += amount;
    }
}
 
// Rc<RefCell<T>> が正当化されるケース:
// - グラフ構造（ノード間の相互参照）
// - Observer パターン（複数の観察者が同じデータを監視）
// - GUI フレームワーク（ウィジェット間の参照）

// 落とし穴 1: 構造体に参照を持たせる際の複雑さ
// 参照を持つ構造体は、ライフタイムが伝播して呼び出し側を制約する
 
struct Config<'a> {
    name: &'a str,
    values: &'a [i32],
}
 
// この関数は config のライフタイムに制約される
fn process_config<'a>(config: &Config<'a>) -> &'a str {
    config.name
}
 
// 構造体に参照を持たせるのは短命なオブジェクトのみに限定し、
// 長命な構造体は所有型（String, Vec<i32>）を使う方が扱いやすい
 
// OK: 所有型を使った設計（シンプルで扱いやすい）
struct OwnedConfig {
    name: String,
    values: Vec<i32>,
}
 
// 落とし穴 2: クロージャと借用の衝突
fn closure_trap() {
    let mut data = vec![1, 2, 3];
 
    // NG: クロージャが data を不変借用 + 直接の可変借用
    // let print_data = || println!("{:?}", data);
    // data.push(4);  // コンパイルエラー!
    // print_data();
 
    // OK: 必要な操作をまとめる
    data.push(4);
    let print_data = || println!("{:?}", data);
    print_data();  // [1, 2, 3, 4]
}
 
// 落とし穴 3: 文字列スライスのライフタイム
fn string_lifetime_trap() {
    let result;
    {
        let s = String::from("hello");
        // result = &s[..];  // コンパイルエラー: s より長生きできない
        result = s;  // OK: 所有権をムーブ
    }
    println!("{}", result);
}

// ===== 演習 1: テンプレート =====
// 以下のコードのコンパイルエラーを修正せよ。
// ルール: .clone() は使用禁止。参照（借用）で解決すること。
 
fn main() {
    let mut names = vec![
        String::from("Alice"),
        String::from("Bob"),
        String::from("Charlie"),
    ];
 
    // タスク 1: 全員の名前を表示する（names は後で使う）
    print_names(names);  // <-- ここを修正
 
    // タスク 2: 新しい名前を追加する
    add_name(names, "Dave");  // <-- ここを修正
 
    // タスク 3: 最も長い名前を見つける
    let longest = find_longest(names);  // <-- ここを修正
    println!("最長の名前: {}", longest);
 
    // タスク 4: 全員の名前を大文字にする
    uppercase_all(names);  // <-- ここを修正
 
    // 最終確認
    print_names(names);  // <-- ここを修正
}
 
fn print_names(names: Vec<String>) {
    // <-- シグネチャを修正
    for name in names {
        println!("- {}", name);
    }
}
 
fn add_name(names: Vec<String>, name: &str) {
    // <-- シグネチャを修正
    names.push(String::from(name));
}
 
fn find_longest(names: Vec<String>) -> String {
    // <-- シグネチャを修正
    names.iter().max_by_key(|n| n.len()).unwrap()
}
 
fn uppercase_all(names: Vec<String>) {
    // <-- シグネチャを修正
    for name in names {
        *name = name.to_uppercase();
    }
}

fn main() {
    let mut names = vec![
        String::from("Alice"),
        String::from("Bob"),
        String::from("Charlie"),
    ];
 
    print_names(&names);                  // 不変借用
    add_name(&mut names, "Dave");         // 可変借用
    let longest = find_longest(&names);   // 不変借用
    println!("最長の名前: {}", longest);
    uppercase_all(&mut names);            // 可変借用
    print_names(&names);                  // 不変借用
}
 
fn print_names(names: &[String]) {        // スライス参照
    for name in names {
        println!("- {}", name);
    }
}
 
fn add_name(names: &mut Vec<String>, name: &str) {
    names.push(String::from(name));
}
 
fn find_longest<'a>(names: &'a [String]) -> &'a str {
    names.iter().map(|n| n.as_str()).max_by_key(|n| n.len()).unwrap()
}
 
fn uppercase_all(names: &mut Vec<String>) {
    for name in names.iter_mut() {
        *name = name.to_uppercase();
    }
}

// ===== 演習 2: リンクリストの実装 =====
 
#[derive(Debug)]
enum List<T> {
    Cons(T, Box<List<T>>),
    Nil,
}
 
impl<T: std::fmt::Display> List<T> {
    /// 空リストを作成
    fn new() -> Self {
        List::Nil
    }
 
    /// リストの先頭に要素を追加
    fn prepend(self, value: T) -> Self {
        List::Cons(value, Box::new(self))
    }
 
    /// リストの長さを返す
    fn len(&self) -> usize {
        match self {
            List::Nil => 0,
            List::Cons(_, tail) => 1 + tail.len(),
        }
    }
 
    /// リストを文字列表現に変換
    fn to_string_repr(&self) -> String {
        match self {
            List::Nil => String::from("Nil"),
            List::Cons(head, tail) => {
                format!("{} -> {}", head, tail.to_string_repr())
            }
        }
    }
 
    /// イテレータを返す
    fn iter(&self) -> ListIter<'_, T> {
        ListIter { current: self }
    }
}
 
struct ListIter<'a, T> {
    current: &'a List<T>,
}
 
impl<'a, T> Iterator for ListIter<'a, T> {
    type Item = &'a T;
 
    fn next(&mut self) -> Option<Self::Item> {
        match self.current {
            List::Nil => None,
            List::Cons(value, tail) => {
                self.current = tail;
                Some(value)
            }
        }
    }
}
 
fn main() {
    // リストを構築（prepend は self を消費してムーブする）
    let list = List::new()
        .prepend(3)
        .prepend(2)
        .prepend(1);
 
    println!("リスト: {}", list.to_string_repr());
    // 出力: リスト: 1 -> 2 -> 3 -> Nil
 
    println!("長さ: {}", list.len());  // 3
 
    // イテレータで走査（不変借用）
    let sum: i32 = list.iter().sum();
    println!("合計: {}", sum);  // 6
 
    // list はスコープを抜けると自動的に全ノードが解放される
    // Box の drop が再帰的に呼ばれる
}
// ← list が drop される:
//   Cons(1, Box) → Box が drop → Cons(2, Box) → Box が drop → Cons(3, Box) → Nil

// ===== パズル 1: ベクタの要素参照と変更 =====
// 以下のコードはコンパイルエラーになる。理由を説明し、修正せよ。
 
fn puzzle_1() {
    let mut v = vec![1, 2, 3, 4, 5];
    let first = &v[0];      // 不変借用
    v.push(6);              // 可変借用（ベクタの再アロケーションが起きうる）
    println!("{}", first);  // first がダングリングになる可能性!
}
// ヒント: push によりベクタが再アロケーションされると、
// first が指していたメモリが無効になる。
 
// 修正例:
fn puzzle_1_fixed() {
    let mut v = vec![1, 2, 3, 4, 5];
    let first = v[0];  // 値をコピー（i32 は Copy）
    v.push(6);
    println!("{}", first);  // OK: コピーした値を使う
}
 
 
// ===== パズル 2: 構造体の部分借用 =====
// 以下のコードはコンパイルエラーになる。理由を説明し、修正せよ。
 
struct User {
    name: String,
    email: String,
    age: u32,
}
 
fn puzzle_2() {
    let mut user = User {
        name: String::from("Alice"),
        email: String::from("alice@example.com"),
        age: 30,
    };
 
    let name_ref = &user.name;  // name を不変借用
    user.age += 1;              // age を可変借用
    println!("{}", name_ref);
    // 注意: Rust 2021 ではこのコードはコンパイルが通る!
    // フィールドごとの部分借用 (disjoint borrows) が認められている。
    // ただし、メソッド経由でアクセスすると通らない場合がある。
}
 
fn puzzle_2_method() {
    let mut user = User {
        name: String::from("Alice"),
        email: String::from("alice@example.com"),
        age: 30,
    };
 
    let name_ref = &user.name;
    // user.celebrate_birthday();  // &mut self が必要 → user 全体を可変借用
    // println!("{}", name_ref);   // コンパイルエラー!
    println!("{}", name_ref);
 
    // 修正: メソッドを使わず直接フィールドを変更
    user.age += 1;
}
 
 
// ===== パズル 3: クロージャと所有権 =====
fn puzzle_3() {
    let mut numbers = vec![5, 2, 8, 1, 9, 3];
 
    // ソート用のクロージャ
    let sort_desc = |v: &mut Vec<i32>| {
        v.sort_by(|a, b| b.cmp(a));
    };
 
    sort_desc(&mut numbers);
    println!("{:?}", numbers);  // [9, 8, 5, 3, 2, 1]
 
    // move クロージャ: 所有権をクロージャに移動
    let numbers2 = vec![10, 20, 30];
    let sum_fn = move || -> i32 {
        numbers2.iter().sum()
    };
    // println!("{:?}", numbers2);  // コンパイルエラー! 所有権がクロージャに移動済み
    println!("合計: {}", sum_fn());  // 60
}
 
 
// ===== パズル 4: ライフタイムの推論 =====
// 以下の関数シグネチャにライフタイム注釈を追加せよ。
 
// Q: fn first_or_second(a: &str, b: &str, use_first: bool) -> &str
// A:
fn first_or_second<'a>(a: &'a str, b: &'a str, use_first: bool) -> &'a str {
    if use_first { a } else { b }
}
 
// Q: fn get_or_insert(map: &mut HashMap<String, String>, key: &str) -> &str
// ヒント: これは参照だけでは解決できない。戻り値の型を変更する必要がある。
use std::collections::HashMap;
fn get_or_insert(map: &mut HashMap<String, String>, key: &str) -> String {
    map.entry(key.to_string())
        .or_insert_with(|| format!("default_{}", key))
        .clone()
}
 
 
// ===== パズル 5: 相互参照の設計 =====
// 親子関係を持つデータ構造を、所有権を考慮して設計せよ。
 
use std::rc::{Rc, Weak};
use std::cell::RefCell;
 
#[derive(Debug)]
struct Parent {
    name: String,
    children: RefCell<Vec<Rc<Child>>>,
}
 
#[derive(Debug)]
struct Child {
    name: String,
    parent: Weak<Parent>,  // 弱い参照で循環を防止
}
 
fn puzzle_5() {
    let parent = Rc::new(Parent {
        name: String::from("Parent"),
        children: RefCell::new(vec![]),
    });
 
    let child1 = Rc::new(Child {
        name: String::from("Child1"),
        parent: Rc::downgrade(&parent),
    });
 
    let child2 = Rc::new(Child {
        name: String::from("Child2"),
        parent: Rc::downgrade(&parent),
    });
 
    parent.children.borrow_mut().push(Rc::clone(&child1));
    parent.children.borrow_mut().push(Rc::clone(&child2));
 
    // 子から親にアクセス（Weak を upgrade して Rc に変換）
    if let Some(p) = child1.parent.upgrade() {
        println!("{} の親: {}", child1.name, p.name);
    }
 
    println!("親の子供数: {}", parent.children.borrow().len());
}

// Arena パターンの例
struct Arena<T> {
    nodes: Vec<T>,
}
 
type NodeId = usize;
 
struct GraphNode {
    value: String,
    edges: Vec<NodeId>,  // インデックスで他のノードを参照
}
 
impl Arena<GraphNode> {
    fn add_node(&mut self, value: String) -> NodeId {
        let id = self.nodes.len();
        self.nodes.push(GraphNode { value, edges: vec![] });
        id
    }
 
    fn add_edge(&mut self, from: NodeId, to: NodeId) {
        self.nodes[from].edges.push(to);
    }
}