Rustのライフタイムで複雑なデータ構造を効率的に管理する方法を徹底解説

fn example<'a>(x: &'a i32) {
    println!("{}", x);
}

fn print_value<'a>(x: &'a i32) {
    println!("{}", x);
}

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

struct Book<'a> {
    title: &'a str,
    author: &'a str,
}

fn main() {
    let title = String::from("Rust Programming");
    let author = String::from("John Doe");
    let book = Book {
        title: &title,
        author: &author,
    };
    println!("{} by {}", book.title, book.author);
}

fn first_word(s: &str) -> &str {
    &s[0..1]
}

   let x = String::from("Hello");
   let y = &x;  // 不変借用
   println!("{}", y);

   let mut x = String::from("Hello");
   let y = &mut x;  // 可変借用
   y.push_str(", world");
   println!("{}", y);

fn print_message<'a>(msg: &'a str) {
    println!("{}", msg);
}

fn main() {
    let message = String::from("Hello, Rust!");
    print_message(&message);  // 借用は `message` が有効な間のみ可能
}

   let mut data = String::from("Rust");
   let borrow1 = &data;       // 不変借用
   // let borrow2 = &mut data; // エラー: 同時に可変借用はできない
   println!("{}", borrow1);

fn dangling_reference() -> &String {
    let s = String::from("Rust");
    &s  // `s`は関数終了後に破棄されるため参照は無効になる
}

struct Book<'a> {
    title: &'a str,
    author: &'a str,
}

fn print_book_details(book: &Book) {
    println!("Title: {}, Author: {}", book.title, book.author);
}

fn main() {
    let title = String::from("Rust Programming");
    let author = String::from("John Doe");

    let book = Book {
        title: &title,
        author: &author,
    };

    print_book_details(&book);
}

struct Pair<'a, T> {
    first: &'a T,
    second: &'a T,
}

fn compare_pair<'a, T: std::fmt::Debug>(pair: &'a Pair<'a, T>) {
    println!("First: {:?}, Second: {:?}", pair.first, pair.second);
}

fn main() {
    let x = 10;
    let y = 20;

    let pair = Pair {
        first: &x,
        second: &y,
    };

    compare_pair(&pair);
}

trait Describe<'a> {
    fn describe(&self) -> &'a str;
}

struct Item<'a> {
    description: &'a str,
}

impl<'a> Describe<'a> for Item<'a> {
    fn describe(&self) -> &'a str {
        self.description
    }
}

fn main() {
    let desc = String::from("An important item.");
    let item = Item {
        description: &desc,
    };

    println!("{}", item.describe());
}

fn create_dangling_ref() -> &String {
    let s = String::from("Rust");
    &s  // `s`は関数のスコープを抜けると破棄される
}

error[E0106]: missing lifetime specifier

fn create_string() -> String {
    let s = String::from("Rust");
    s  // 所有権を返す
}

fn main() {
    let mut data = String::from("Hello");
    let borrow1 = &data;        // 不変借用
    let borrow2 = &mut data;    // 可変借用
    println!("{}, {}", borrow1, borrow2);
}

error[E0502]: cannot borrow `data` as mutable because it is also borrowed as immutable

fn main() {
    let mut data = String::from("Hello");
    {
        let borrow1 = &data;     // 不変借用のスコープ
        println!("{}", borrow1);
    }
    let borrow2 = &mut data;     // 可変借用
    borrow2.push_str(", world");
    println!("{}", borrow2);
}

fn longest<'a>(x: &'a str, y: &'b str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y  // ライフタイムが一致しない
    }
}

error[E0623]: lifetime mismatch

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

struct Person<'a> {
    name: &'a str,
    age: u32,
}

fn main() {
    let name = String::from("Alice");
    let person = Person {
        name: &name,
        age: 30,
    };
    println!("{} is {} years old.", person.name, person.age);
}

struct Book<'a, 'b> {
    title: &'a str,
    author: &'b str,
}

fn main() {
    let title = String::from("Rust in Action");
    let author = String::from("Tim McNamara");

    let book = Book {
        title: &title,
        author: &author,
    };

    println!("Title: {}, Author: {}", book.title, book.author);
}

struct Message<'a> {
    content: &'a str,
}

impl<'a> Message<'a> {
    fn display(&self) {
        println!("Message: {}", self.content);
    }
}

fn main() {
    let msg = String::from("Hello, Rust!");
    let message = Message { content: &msg };
    message.display();
}

   struct Example<'a> {
       value: &'a i32,
   }

   fn main() {
       let example;
       {
           let x = 10;
           example = Example { value: &x }; // エラー: `x`はこのスコープで終了
       }
       // println!("{}", example.value); // エラー: ダングリング参照
   }

   struct Person {
       name: String, // 参照ではなくStringを使用
       age: u32,
   }

fn function_name<'a>(param: &'a Type) -> &'a Type {
    param
}

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("Hello");
    let string2 = String::from("World!");

    let result = longest(&string1, &string2);
    println!("The longest string is: {}", result);
}

fn print_both<'a, 'b>(x: &'a str, y: &'b str) {
    println!("x: {}, y: {}", x, y);
}

fn main() {
    let str1 = String::from("First");
    let str2 = String::from("Second");

    print_both(&str1, &str2);
}

fn invalid_return() -> &str {
    let s = String::from("Rust");
    &s  // エラー: `s`は関数終了後に破棄される
}

fn valid_return<'a>(s: &'a str) -> &'a str {
    s
}

fn first_word(s: &str) -> &str {
    &s[0..1]
}

struct User<'a> {
    name: &'a str,
    email: &'a str,
}

fn get_contact_info<'a>(user: &'a User, get_email: bool) -> &'a str {
    if get_email {
        user.email
    } else {
        user.name
    }
}

fn main() {
    let name = String::from("Alice");
    let email = String::from("alice@example.com");
    let user = User {
        name: &name,
        email: &email,
    };

    let contact = get_contact_info(&user, true);
    println!("Contact info: {}", contact);
}

use std::collections::HashMap;

struct Database<'a> {
    records: HashMap<&'a str, &'a str>,
}

impl<'a> Database<'a> {
    fn get_record(&self, key: &str) -> Option<&&'a str> {
        self.records.get(key)
    }
}

fn main() {
    let mut records = HashMap::new();
    records.insert("id1", "Alice");
    records.insert("id2", "Bob");

    let db = Database { records };

    if let Some(name) = db.get_record("id1") {
        println!("Found record: {}", name);
    }
}

fn print_items<'a, T: std::fmt::Debug>(item1: &'a T, item2: &'a T) {
    println!("Item 1: {:?}, Item 2: {:?}", item1, item2);
}

fn main() {
    let num1 = 42;
    let num2 = 84;

    print_items(&num1, &num2);
}

struct Pair<'a, 'b> {
    first: &'a str,
    second: &'b str,
}

fn main() {
    let string1 = String::from("First");
    let string2 = String::from("Second");

    let pair = Pair {
        first: &string1,
        second: &string2,
    };

    println!("Pair: {}, {}", pair.first, pair.second);
}