fn main() {
    {
        let s = String::from("hello"); // s がスコープに入る
        println!("{}", s);             // s は有効
    }                                  // s がスコープを抜ける → drop() 呼び出し
    // println!("{}", s);              // コンパイルエラー: s は存在しない
}

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;                    // ムーブ: s1 → s2
    // println!("{}", s1);          // エラー: s1 は無効化済み
    println!("{}", s2);             // OK
}

fn main() {
    let s = String::from("hello");
 
    // (1) 変数束縛でムーブ
    let s2 = s;
    // s は無効
 
    // (2) 関数への引数渡しでムーブ
    let s3 = String::from("world");
    takes_string(s3);
    // s3 は無効
 
    // (3) 関数からの戻り値でムーブ
    let s4 = gives_string();
    // s4 が所有権を受け取る
 
    // (4) コレクションへの挿入でムーブ
    let s5 = String::from("item");
    let mut v = Vec::new();
    v.push(s5);
    // s5 は無効（Vec が所有権を持つ）
 
    // (5) パターンマッチでのムーブ
    let opt = Some(String::from("data"));
    if let Some(inner) = opt {
        println!("{}", inner);
    }
    // opt は無効（inner にムーブ済み）
 
    // (6) 構造体の構築でムーブ
    let name = String::from("太郎");
    let user = User { name };   // name は無効
    println!("{}", user.name);   // OK: user.name としてアクセス
}
 
fn takes_string(s: String) {
    println!("受け取った: {}", s);
    // s はこの関数の終了時に drop される
}
 
fn gives_string() -> String {
    let s = String::from("新しい文字列");
    s // 所有権を呼び出し元に返す
}
 
struct User {
    name: String,
}

struct DatabaseConnection {
    url: String,
    connected: bool,
}
 
impl DatabaseConnection {
    fn new(url: &str) -> Self {
        println!("接続を開きます: {}", url);
        DatabaseConnection {
            url: url.to_string(),
            connected: true,
        }
    }
 
    fn query(&self, sql: &str) -> Vec<String> {
        println!("クエリ実行: {}", sql);
        vec!["結果1".to_string(), "結果2".to_string()]
    }
}
 
impl Drop for DatabaseConnection {
    fn drop(&mut self) {
        println!("接続を閉じます: {}", self.url);
        self.connected = false;
    }
}
 
fn main() {
    {
        let conn = DatabaseConnection::new("postgres://localhost/mydb");
        let results = conn.query("SELECT * FROM users");
        println!("結果: {:?}", results);
    } // conn がスコープを抜ける → drop() が自動呼び出し → 接続クローズ
 
    println!("接続は自動的に閉じられました");
}

fn main() {
    let x: i32 = 42;
    let y = x;          // コピー（i32 は Copy トレイト実装済み）
    println!("x={}, y={}", x, y); // 両方有効！
 
    // タプルも全要素がCopyなら Copy
    let point = (3, 4);
    let point2 = point;
    println!("point={:?}, point2={:?}", point, point2); // 両方有効
 
    // 配列も要素が Copy なら Copy
    let arr = [1, 2, 3, 4, 5];
    let arr2 = arr;
    println!("arr={:?}, arr2={:?}", arr, arr2); // 両方有効
 
    // 参照も Copy
    let s = String::from("hello");
    let r1 = &s;
    let r2 = r1;  // 参照のコピー（String 自体はコピーされない）
    println!("r1={}, r2={}", r1, r2); // 両方有効
}

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone();           // 明示的にヒープデータもコピー
    println!("s1={}, s2={}", s1, s2); // 両方有効
 
    // Vec の clone
    let v1 = vec![1, 2, 3, 4, 5];
    let v2 = v1.clone();
    println!("v1={:?}, v2={:?}", v1, v2);
 
    // ネストしたデータ構造の clone
    let nested = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
    ];
    let nested_clone = nested.clone(); // 全てのデータが深くコピーされる
    println!("nested={:?}", nested);
    println!("nested_clone={:?}", nested_clone);
}

// Copy を derive するには、全フィールドが Copy でなければならない
#[derive(Debug, Clone, Copy)]
struct Point {
    x: f64,
    y: f64,
}
 
// Copy できない構造体
// #[derive(Clone, Copy)]  // コンパイルエラー！ String は Copy ではない
#[derive(Debug, Clone)]
struct NamedPoint {
    name: String,
    x: f64,
    y: f64,
}
 
fn main() {
    let p1 = Point { x: 1.0, y: 2.0 };
    let p2 = p1;           // Copy
    println!("p1={:?}", p1); // OK: p1 はまだ有効
 
    let np1 = NamedPoint {
        name: "原点".to_string(),
        x: 0.0,
        y: 0.0,
    };
    let np2 = np1.clone();  // Clone 必須
    // let np3 = np1;       // ムーブ! np1 は無効になる
    println!("np2={:?}", np2);
}

fn calculate_length(s: &String) -> usize {
    s.len()
    // s はここで破棄されるが、所有権は持っていないのでデータは解放されない
}
 
fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s);  // 借用(参照を渡す)
    println!("'{}' の長さは {}", s, len); // s はまだ有効
}

fn append_world(s: &mut String) {
    s.push_str(", world!");
}
 
fn main() {
    let mut s = String::from("hello");
    append_world(&mut s);
    println!("{}", s); // "hello, world!"
}

fn main() {
    let mut s = String::from("hello");
 
    let r1 = &s;        // OK: 不変参照1
    let r2 = &s;        // OK: 不変参照2
    println!("{}, {}", r1, r2);
    // r1, r2 はここ以降使われない (NLL)
 
    let r3 = &mut s;    // OK: r1, r2 のライフタイムは終了済み
    println!("{}", r3);
}

fn main() {
    let mut s = String::from("hello");
 
    let r1 = &s;          // 不変参照
    let r2 = &mut s;      // エラー！不変参照が生きている間に可変参照は作れない
    println!("{}", r1);    // r1 がまだ使われている
}

// もし同時に2つの可変参照が許されたら...
// （以下は架空の危険な例：実際のRustではコンパイルエラー）
fn hypothetical_danger() {
    let mut data = vec![1, 2, 3];
 
    // 仮に2つの可変参照が同時に存在できたとすると:
    // let r1 = &mut data;  // 可変参照1
    // let r2 = &mut data;  // 可変参照2（実際はエラー）
 
    // r1.push(4);          // Vec がリアロケーションを起こす可能性
    // println!("{}", r2[0]); // r2 は無効なメモリを参照！
    //                        // → use-after-free の脆弱性
}
 
// Rustはこれをコンパイル時に防止する
fn safe_version() {
    let mut data = vec![1, 2, 3];
 
    // 可変参照は1つだけ
    let r1 = &mut data;
    r1.push(4);
    // r1 のライフタイム終了
 
    // 新しい可変参照を取得
    let r2 = &mut data;
    println!("{}", r2[0]); // 安全
}

fn main() {
    let mut s = String::from("hello");
    let r = &mut s;
 
    // 再借用: 可変参照から不変参照を作る
    let r2 = &*r;  // 再借用（暗黙的にも起こる）
    println!("{}", r2);
 
    // 再借用: 可変参照から一時的な可変参照を作る
    modify(r);  // &mut String が &mut String として再借用される
    println!("{}", r);
}
 
fn modify(s: &mut String) {
    s.push_str(", world!");
}

fn takes_ownership(s: String) -> String {
    println!("受け取った: {}", s);
    s  // 所有権を返す
}
 
fn main() {
    let s1 = String::from("hello");
    let s2 = takes_ownership(s1); // s1 → 関数 → s2
    // println!("{}", s1);        // エラー: s1 は無効
    println!("{}", s2);           // OK
}

// パターン1: 読み取りのみ → 不変参照 &T
fn print_info(s: &str) {
    println!("文字列: {}, 長さ: {}", s, s.len());
}
 
// パターン2: 変更が必要 → 可変参照 &mut T
fn make_uppercase(s: &mut String) {
    *s = s.to_uppercase();
}
 
// パターン3: 所有権が必要 → T（値渡し）
fn into_bytes(s: String) -> Vec<u8> {
    s.into_bytes()  // String を消費して Vec<u8> を返す
}
 
// パターン4: 条件付きで所有権を取る → Cow (Clone on Write)
use std::borrow::Cow;
 
fn ensure_uppercase(s: &str) -> Cow<'_, str> {
    if s.chars().all(|c| c.is_uppercase()) {
        Cow::Borrowed(s)        // 変更不要: 借用をそのまま返す
    } else {
        Cow::Owned(s.to_uppercase()) // 変更必要: 新しい String を返す
    }
}
 
fn main() {
    let s = String::from("hello");
 
    // パターン1: 不変参照
    print_info(&s);
    println!("s はまだ使える: {}", s);
 
    // パターン2: 可変参照
    let mut s2 = String::from("hello");
    make_uppercase(&mut s2);
    println!("大文字: {}", s2);
 
    // パターン3: 所有権の移動
    let s3 = String::from("hello");
    let bytes = into_bytes(s3);
    // s3 は使えない
    println!("バイト: {:?}", bytes);
 
    // パターン4: Cow
    let result = ensure_uppercase("HELLO");
    println!("Cow: {}", result);
}

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 longest_word(s: &str) -> &str {
    s.split_whitespace()
        .max_by_key(|word| word.len())
        .unwrap_or("")
}
 
fn main() {
    let sentence = String::from("hello world foo bar");
    let word = first_word(&sentence);
    println!("最初の単語: {}", word); // "hello"
 
    let longest = longest_word(&sentence);
    println!("最長の単語: {}", longest); // "hello" or "world"
 
    // 文字列リテラルもスライスとして渡せる
    let word2 = first_word("good morning");
    println!("最初の単語: {}", word2); // "good"
}

// 所有型を使う構造体（最も一般的）
struct OwnedUser {
    name: String,
    email: String,
}
 
// 借用型を使う構造体（ライフタイム注釈が必要）
struct BorrowedUser<'a> {
    name: &'a str,
    email: &'a str,
}
 
// 使い分けの例
fn create_owned_user(name: &str, email: &str) -> OwnedUser {
    OwnedUser {
        name: name.to_string(),
        email: email.to_string(),
    }
}
 
fn create_borrowed_user<'a>(name: &'a str, email: &'a str) -> BorrowedUser<'a> {
    BorrowedUser { name, email }
}
 
fn main() {
    // 所有型: 構造体がデータを所有するため、ライフタイムの制約がない
    let owned = create_owned_user("田中", "tanaka@example.com");
    println!("{}: {}", owned.name, owned.email);
 
    // 借用型: 元データより長く生きることはできない
    let name = String::from("鈴木");
    let email = String::from("suzuki@example.com");
    let borrowed = create_borrowed_user(&name, &email);
    println!("{}: {}", borrowed.name, borrowed.email);
    // name, email はここで有効 → borrowed も有効
}

// ライフタイム注釈なし（コンパイルエラー）
// fn longest(x: &str, y: &str) -> &str {
//     if x.len() > y.len() { x } else { y }
// }
 
// ライフタイム注釈あり
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
 
fn main() {
    let string1 = String::from("長い文字列");
    let result;
    {
        let string2 = String::from("短い");
        result = longest(string1.as_str(), string2.as_str());
        println!("長い方: {}", result); // OK: string2 はまだ有効
    }
    // println!("{}", result); // エラー: string2 のライフタイムが切れている
}

// 規則1: 各入力参照に固有のライフタイムが割り当てられる
fn first(s: &str) -> &str { &s[..1] }
// 展開: fn first<'a>(s: &'a str) -> &'a str
 
// 規則2: 入力参照が1つだけなら、その参照のライフタイムが全出力に適用
fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap_or("")
}
// 展開: fn first_word<'a>(s: &'a str) -> &'a str
 
// 規則3: メソッドの場合、&self のライフタイムが出力に適用
struct Parser {
    input: String,
}
 
impl Parser {
    fn first_token(&self) -> &str {
        self.input.split_whitespace().next().unwrap_or("")
    }
    // 展開: fn first_token<'a>(&'a self) -> &'a str
}
 
// 規則が適用できない場合は明示的なライフタイム注釈が必要
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// 'static ライフタイム: プログラム全体の実行期間中有効
fn get_greeting() -> &'static str {
    "こんにちは！"  // 文字列リテラルは 'static
}
 
// 定数も 'static
static GLOBAL_CONFIG: &str = "デフォルト設定";
 
fn main() {
    let greeting = get_greeting();
    println!("{}", greeting);
    println!("{}", GLOBAL_CONFIG);
 
    // T: 'static は「所有型」であることを意味する場合もある
    // String は 'static を満たす（参照を含まないため）
    fn takes_owned<T: 'static>(value: T) {
        // T は参照を含まない型
        std::mem::drop(value);
    }
 
    takes_owned(String::from("hello")); // OK
    takes_owned(42i32);                  // OK
    // takes_owned(&String::from("hello")); // エラー: 一時的な参照は 'static ではない
}

use std::cell::{Cell, RefCell};
 
// Cell<T>: Copy な型に対する内部可変性
struct Counter {
    count: Cell<u32>,
}
 
impl Counter {
    fn new() -> Self {
        Counter { count: Cell::new(0) }
    }
 
    fn increment(&self) {
        // &self（不変参照）なのに内部状態を変更できる
        self.count.set(self.count.get() + 1);
    }
 
    fn get(&self) -> u32 {
        self.count.get()
    }
}
 
// RefCell<T>: 任意の型に対する内部可変性（実行時チェック）
struct CachedValue {
    value: String,
    cache: RefCell<Option<String>>,
}
 
impl CachedValue {
    fn new(value: String) -> Self {
        CachedValue {
            value,
            cache: RefCell::new(None),
        }
    }
 
    fn get_computed(&self) -> String {
        // &self なのに cache を変更できる
        let mut cache = self.cache.borrow_mut();
        if cache.is_none() {
            println!("キャッシュ計算中...");
            *cache = Some(format!("computed_{}", self.value));
        }
        cache.clone().unwrap()
    }
}
 
fn main() {
    let counter = Counter::new();
    counter.increment();
    counter.increment();
    counter.increment();
    println!("カウント: {}", counter.get()); // 3
 
    let cached = CachedValue::new("hello".to_string());
    println!("{}", cached.get_computed()); // "キャッシュ計算中..." → "computed_hello"
    println!("{}", cached.get_computed()); // キャッシュヒット → "computed_hello"
}

use std::rc::Rc;
 
// Box<T>: ヒープ上への単一所有権
fn box_example() {
    let b = Box::new(5);
    println!("Box: {}", b);
 
    // 再帰的なデータ構造
    enum List {
        Cons(i32, Box<List>),
        Nil,
    }
 
    let list = List::Cons(1,
        Box::new(List::Cons(2,
            Box::new(List::Cons(3,
                Box::new(List::Nil))))));
}
 
// Rc<T>: 参照カウントによる共有所有権（シングルスレッド）
fn rc_example() {
    let a = Rc::new(String::from("共有データ"));
    println!("参照カウント: {}", Rc::strong_count(&a)); // 1
 
    let b = Rc::clone(&a);  // 参照カウントを増やす（データのコピーではない）
    println!("参照カウント: {}", Rc::strong_count(&a)); // 2
 
    {
        let c = Rc::clone(&a);
        println!("参照カウント: {}", Rc::strong_count(&a)); // 3
    }
    // c がドロップ
    println!("参照カウント: {}", Rc::strong_count(&a)); // 2
 
    println!("a={}, b={}", a, b);
}
 
fn main() {
    box_example();
    rc_example();
}

enum Message {
    Text(String),
    Number(i32),
    Pair(String, String),
}
 
fn process_message(msg: Message) {
    match msg {
        // msg の所有権はムーブされる
        Message::Text(text) => {
            println!("テキスト: {}", text);
            // text を所有している
        }
        Message::Number(n) => {
            println!("数値: {}", n);
        }
        Message::Pair(a, b) => {
            println!("ペア: {} / {}", a, b);
        }
    }
    // msg は完全にムーブされたため使えない
}
 
fn process_message_ref(msg: &Message) {
    match msg {
        // 参照のパターンマッチでは借用のみ
        Message::Text(text) => {
            println!("テキスト: {}", text);
            // text は &String
        }
        Message::Number(n) => {
            println!("数値: {}", n);
        }
        Message::Pair(a, b) => {
            println!("ペア: {} / {}", a, b);
        }
    }
    // msg はまだ使える
}
 
fn main() {
    let msg = Message::Text("hello".to_string());
    process_message_ref(&msg);
    process_message_ref(&msg);  // OK: 参照なので再利用可能
 
    let msg2 = Message::Pair("左".to_string(), "右".to_string());
    process_message(msg2);
    // process_message(msg2);  // エラー: ムーブ済み
}

// BAD: 参照で十分なのにクローンする
fn print_length(s: String) {
    println!("長さ: {}", s.len());
}
fn bad_example() {
    let s = String::from("hello");
    print_length(s.clone()); // 不要なクローン
    print_length(s.clone()); // また不要なクローン
    println!("{}", s);
}
 
// GOOD: 参照を使う
fn print_length_good(s: &str) {
    println!("長さ: {}", s.len());
}
fn good_example() {
    let s = String::from("hello");
    print_length_good(&s);
    print_length_good(&s);
    println!("{}", s);
}

// BAD: ローカル変数への参照を返そうとする
// fn dangle() -> &String {
//     let s = String::from("hello");
//     &s  // s はこの関数終了時にドロップされる → ダングリング参照！
// }
 
// GOOD: 所有権ごと返す
fn no_dangle() -> String {
    let s = String::from("hello");
    s  // 所有権をムーブして返す
}

// BAD: 変更しないのに &mut を使う
fn just_read(data: &mut Vec<i32>) -> i32 {
    data.iter().sum()
}
 
// GOOD: 読み取りだけなら不変参照で十分
fn just_read_good(data: &[i32]) -> i32 {
    data.iter().sum()
}

// BAD: 不必要にライフタイムが伝播する
struct Config<'a> {
    host: &'a str,
    port: u16,
    database: &'a str,
}
 
// このような構造体を返す関数は非常に複雑になる
// fn load_config<'a>() -> Config<'a> { ... }  // ← ライフタイムの管理が困難
 
// GOOD: 所有型を使う
struct ConfigGood {
    host: String,
    port: u16,
    database: String,
}
 
fn load_config() -> ConfigGood {
    ConfigGood {
        host: "localhost".to_string(),
        port: 5432,
        database: "myapp".to_string(),
    }
}

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];
 
    // BAD: イテレーション中にコレクションを変更しようとする
    // for item in &v {
    //     if *item > 3 {
    //         v.push(*item * 2);  // エラー！不変借用中に可変借用できない
    //     }
    // }
 
    // GOOD: 結果を別のコレクションに集めてから追加
    let additions: Vec<i32> = v.iter()
        .filter(|&&x| x > 3)
        .map(|&x| x * 2)
        .collect();
    v.extend(additions);
    println!("{:?}", v); // [1, 2, 3, 4, 5, 8, 10]
 
    // GOOD: retain で条件に合わない要素を除去
    let mut v2 = vec![1, 2, 3, 4, 5];
    v2.retain(|&x| x % 2 == 0);
    println!("{:?}", v2); // [2, 4]
}

// 所有権を使って状態遷移を型レベルで表現
struct Idle;
struct Running {
    start_time: std::time::Instant,
}
struct Finished {
    duration: std::time::Duration,
}
 
struct Task<State> {
    name: String,
    state: State,
}
 
impl Task<Idle> {
    fn new(name: &str) -> Self {
        Task {
            name: name.to_string(),
            state: Idle,
        }
    }
 
    // self を消費して新しい状態の Task を返す
    fn start(self) -> Task<Running> {
        println!("タスク '{}' を開始", self.name);
        Task {
            name: self.name,
            state: Running {
                start_time: std::time::Instant::now(),
            },
        }
    }
}
 
impl Task<Running> {
    fn finish(self) -> Task<Finished> {
        let duration = self.state.start_time.elapsed();
        println!("タスク '{}' が完了 ({:?})", self.name, duration);
        Task {
            name: self.name,
            state: Finished { duration },
        }
    }
}
 
impl Task<Finished> {
    fn report(&self) {
        println!("レポート: '{}' は {:?} で完了", self.name, self.state.duration);
    }
}
 
fn main() {
    let task = Task::new("データ処理");
    // task.finish();  // コンパイルエラー！Idle から直接 Finished にはなれない
    let running = task.start();
    // task.start();   // コンパイルエラー！task は既にムーブ済み
    let finished = running.finish();
    finished.report();
}

use std::fs::File;
use std::io::{self, Write, BufWriter};
 
// ファイルの所有権を持つ構造体
struct Logger {
    writer: BufWriter<File>,
    count: u64,
}
 
impl Logger {
    fn new(path: &str) -> io::Result<Self> {
        let file = File::create(path)?;
        Ok(Logger {
            writer: BufWriter::new(file),
            count: 0,
        })
    }
 
    fn log(&mut self, message: &str) -> io::Result<()> {
        self.count += 1;
        writeln!(self.writer, "[{}] {}", self.count, message)?;
        Ok(())
    }
 
    // 所有権を消費してファイルを確実にフラッシュ
    fn close(mut self) -> io::Result<()> {
        self.writer.flush()?;
        println!("ログファイルを閉じました（{} 件のログ）", self.count);
        Ok(())
        // self がドロップされ、File が自動的にクローズされる
    }
}
 
fn main() -> io::Result<()> {
    let mut logger = Logger::new("/tmp/app.log")?;
    logger.log("アプリケーション開始")?;
    logger.log("処理実行中")?;
    logger.log("アプリケーション終了")?;
    logger.close()?;
    // logger は使えない（close で消費済み）
    // logger.log("もう一つ");  // コンパイルエラー！
    Ok(())
}

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

fn accepts_str(s: &str) {
    println!("{}", s);
}
 
fn main() {
    let owned = String::from("hello");
    let literal = "world";
 
    accepts_str(&owned);    // &String → &str (Deref coercion)
    accepts_str(literal);   // &str そのまま
    accepts_str(&owned[1..]); // スライスも渡せる
}

// 省略規則で推論できる → 注釈不要
fn first(s: &str) -> &str { &s[..1] }
 
// 複数の入力参照 → 注釈必要
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
 
// 構造体の参照フィールド → 注釈必要
struct Excerpt<'a> {
    text: &'a str,
}