Day 3: ライフタイム理解 - 解答例

目次

• Exercise 1: ライフタイム注釈
• Exercise 2: 構造体のライフタイム
• Exercise 3: 複数のライフタイム
• 最適化パス
• よくある間違い
• ベンチマーク結果

Exercise 1: ライフタイム注釈

解法1: 基本的なアプローチ

/// 2つの文字列参照のうち、長い方を返す関数
///
/// # ライフタイム
/// - 'a: 両方の入力参照と出力参照が有効である期間
///
/// # 引数
/// - x: 最初の文字列参照
/// - y: 2番目の文字列参照
///
/// # 戻り値
/// より長い文字列への参照（同じ長さの場合はxを返す）
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    // 長さを比較して長い方を返す
    // ライフタイム 'a により、返り値はxとyのうち
    // 短い方のライフタイムまでしか有効でない
    if x.len() > y.len() {
        x  // xの参照を返す
    } else {
        y  // yの参照を返す
    }
}

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

    #[test]
    fn test_longest_basic() {
        let s1 = String::from("short");
        let s2 = String::from("longer string");

        let result = longest(&s1, &s2);
        assert_eq!(result, "longer string");
    }

    #[test]
    fn test_lifetime_scope() {
        let s1 = String::from("long string");
        let result;

        {
            let s2 = String::from("xyz");
            result = longest(&s1, &s2);
            // result はこのスコープ内でのみ使える
            println!("Within scope: {}", result);
        }
        // ここでresultを使うとコンパイルエラー
        // println!("{}", result); // エラー！
    }
}

ポイント:

• <'a>でライフタイムパラメータを宣言
• 両方の入力と出力を同じライフタイム'aで注釈
• コンパイラが自動的に最短ライフタイムを選択

解法2: ジェネリック版（トレードオフ分析）

use std::cmp::Ordering;

/// ジェネリックなバージョン - あらゆる比較可能な型に対応
///
/// # トレードオフ
/// - 利点: 文字列以外（Vec, 配列など）にも使える
/// - 欠点: 若干複雑、コンパイル時間増加
fn longest_generic<'a, T>(x: &'a [T], y: &'a [T]) -> &'a [T]
where
    T: PartialOrd,
{
    match x.len().cmp(&y.len()) {
        Ordering::Greater => x,
        Ordering::Less => y,
        Ordering::Equal => x,  // 同じ長さならx
    }
}

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

    #[test]
    fn test_generic_with_numbers() {
        let arr1 = &[1, 2];
        let arr2 = &[1, 2, 3, 4];

        let result = longest_generic(arr1, arr2);
        assert_eq!(result, &[1, 2, 3, 4]);
    }
}

トレードオフ分析:

Exercise 2: 構造体のライフタイム

解法1: 単一ライフタイム

/// 文章の重要な抜粋を保持する構造体
///
/// # ライフタイム
/// - 'a: 参照する文字列データが有効である期間
///   この構造体は、元のデータより長く生存できない
#[derive(Debug, Clone)]
struct ImportantExcerpt<'a> {
    /// 抜粋された文字列への参照
    part: &'a str,
    /// ページ番号（所有データなのでライフタイム不要）
    page: u32,
}

impl<'a> ImportantExcerpt<'a> {
    /// 新しいExcerptインスタンスを作成
    ///
    /// # 引数
    /// - part: 抜粋する文字列への参照
    /// - page: ページ番号
    ///
    /// # ライフタイム
    /// - 返り値のライフタイムは引数partのライフタイムと同じ
    fn new(part: &'a str, page: u32) -> Self {
        ImportantExcerpt { part, page }
    }

    /// 抜粋を整形して返す
    ///
    /// # ライフタイム省略規則
    /// - ルール3が適用: &selfがあるので、出力は暗黙的に&'a str
    fn format(&self) -> &str {
        // 省略規則により、明示的な'aは不要
        self.part
    }

    /// 抜粋の長さを返す
    fn length(&self) -> usize {
        self.part.len()
    }

    /// ページ情報を含む説明文を生成
    fn description(&self) -> String {
        // Stringを返すのでライフタイムの制約なし
        format!("Page {}: '{}'", self.page, self.part)
    }
}

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

    #[test]
    fn test_excerpt_basic() {
        let novel = String::from("Call me Ishmael. Some years ago...");
        let first_sentence = novel.split('.').next().unwrap();

        let excerpt = ImportantExcerpt::new(first_sentence, 1);

        assert_eq!(excerpt.part, "Call me Ishmael");
        assert_eq!(excerpt.page, 1);
    }

    #[test]
    fn test_excerpt_lifetime() {
        let excerpt;
        {
            let novel = String::from("It was the best of times.");
            let first = novel.split_whitespace().next().unwrap();
            excerpt = ImportantExcerpt::new(first, 1);

            // このスコープ内でのみ使用可能
            println!("{:?}", excerpt);
        }
        // ここでexcerptを使うとコンパイルエラー
        // println!("{:?}", excerpt); // エラー！
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();

    let excerpt = ImportantExcerpt::new(first_sentence, 1);

    println!("Excerpt: {}", excerpt.part);
    println!("Page: {}", excerpt.page);
    println!("Length: {}", excerpt.length());
    println!("{}", excerpt.description());
}

解法2: 複数フィールドとライフタイム

/// より複雑な例: 複数の参照を持つ構造体
#[derive(Debug)]
struct Analyzer<'text, 'config> {
    /// 分析対象のテキスト
    text: &'text str,
    /// 設定情報への参照
    config: &'config AnalysisConfig,
}

#[derive(Debug)]
struct AnalysisConfig {
    case_sensitive: bool,
    max_length: usize,
}

impl<'text, 'config> Analyzer<'text, 'config> {
    /// 新しいAnalyzerを作成
    ///
    /// # ライフタイム
    /// - 'text: テキストデータの有効期間
    /// - 'config: 設定データの有効期間（独立）
    fn new(text: &'text str, config: &'config AnalysisConfig) -> Self {
        Analyzer { text, config }
    }

    /// 単語数をカウント
    ///
    /// # 戻り値
    /// ライフタイムに依存しない所有型（usize）
    fn word_count(&self) -> usize {
        self.text.split_whitespace().count()
    }

    /// 最初の単語を取得
    ///
    /// # ライフタイム
    /// - 返り値は 'text のライフタイム（textから借用）
    fn first_word(&self) -> Option<&'text str> {
        self.text.split_whitespace().next()
    }
}

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

    #[test]
    fn test_multiple_lifetimes() {
        let config = AnalysisConfig {
            case_sensitive: true,
            max_length: 100,
        };

        {
            let text = String::from("Hello world from Rust");
            let analyzer = Analyzer::new(&text, &config);

            assert_eq!(analyzer.word_count(), 4);
            assert_eq!(analyzer.first_word(), Some("Hello"));
        }
        // textは破棄されたが、configは依然として有効
        println!("Config still valid: {:?}", config);
    }
}

複数ライフタイムのメリット:

• 独立した参照を明確に区別
• より柔軟なAPI設計
• コンパイラが最適なライフタイムを推論

Exercise 3: 複数のライフタイム

解法1: 異なるライフタイムの使い分け

/// 異なるライフタイムを持つ複数の参照を扱う関数
///
/// # ライフタイム
/// - 'a: メインテキストのライフタイム（返り値に影響）
/// - 'b: 補助データのライフタイム（返り値に影響しない）
///
/// # 設計理由
/// - otherは返り値に使われないため、独立したライフタイムを持つ
/// - これにより、呼び出し側でより柔軟な使い方が可能
fn first_word<'a, 'b>(s: &'a str, _other: &'b str) -> &'a str {
    // _otherは使用しないが、複数ライフタイムの例として保持
    // アンダースコアは未使用変数の警告を抑制
    s.split_whitespace()
        .next()
        .unwrap_or("")  // 空文字列の場合のフォールバック
}

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

    #[test]
    fn test_independent_lifetimes() {
        let s1 = String::from("hello world");
        let result;

        {
            let s2 = String::from("temporary");
            result = first_word(&s1, &s2);
            // s2はここで破棄されるが、resultには影響しない
        }

        // resultはs1のライフタイムに依存するため、依然として有効
        assert_eq!(result, "hello");
    }
}

/// より実用的な例: テキスト処理
///
/// # ライフタイム
/// - 'input: 入力テキストのライフタイム
/// - 'pattern: 検索パターンのライフタイム
fn find_and_extract<'input, 'pattern>(
    text: &'input str,
    pattern: &'pattern str,
) -> Option<&'input str> {
    // patternで検索するが、返すのはtextの一部
    // したがって、返り値は 'input のライフタイム
    text.split_whitespace()
        .find(|word| word.contains(pattern))
}

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

    #[test]
    fn test_find_and_extract() {
        let text = String::from("The quick brown fox");

        {
            let pattern = String::from("qui");
            let result = find_and_extract(&text, &pattern);
            assert_eq!(result, Some("quick"));
            // patternはここで破棄
        }

        // resultはtextのライフタイムに依存
        // （実際にはこのテスト内でresultは使えないが、概念として）
    }
}

解法2: ライフタイム境界を持つ構造体

/// ライフタイム境界を持つ構造体の高度な例
struct Context<'a> {
    data: &'a str,
}

/// Contextよりも短いライフタイムを持つParser
///
/// # ライフタイム制約
/// - 'c: Context自体のライフタイム
/// - 'a: Contextが参照するデータのライフタイム
/// - 制約: 'a は 'c より長生きする必要がある（'a: 'c）
struct Parser<'c, 'a: 'c> {
    context: &'c Context<'a>,
}

impl<'c, 'a: 'c> Parser<'c, 'a> {
    fn new(context: &'c Context<'a>) -> Self {
        Parser { context }
    }

    /// Contextのデータを解析
    ///
    /// # ライフタイム
    /// - 返り値は 'a（元のデータ）のライフタイム
    fn parse(&self) -> &'a str {
        self.context.data
    }
}

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

    #[test]
    fn test_lifetime_bounds() {
        let data = String::from("example data");
        let context = Context { data: &data };
        let parser = Parser::new(&context);

        let result = parser.parse();
        assert_eq!(result, "example data");
    }
}

最適化パス

レベル1: 基本的な実装

// 初心者向け: シンプルだが柔軟性に欠ける
fn process(s: String) -> String {
    s.to_uppercase()  // Stringを消費し、新しいStringを返す
}

問題点:

• 所有権を奪うため、呼び出し後に元の値が使えない
• 常にメモリアロケーションが発生

レベル2: 参照を使った最適化

// 中級者向け: 参照を使ってコピーを削減
fn process<'a>(s: &'a str) -> String {
    s.to_uppercase()
}

改善点:

• 元の値を保持できる
• 入力時のコピーを削減

残る問題:

• 出力は常に新しいStringを生成

レベル3: Cow（Copy on Write）を使った最適化

use std::borrow::Cow;

/// 最適化版: 必要な場合のみコピー
///
/// # パフォーマンス
/// - すでに大文字の場合: ゼロコストで参照を返す
/// - 変換が必要な場合: 新しいStringを生成
fn process_optimized(s: &str) -> Cow<str> {
    if s.chars().all(|c| c.is_uppercase()) {
        // すでに大文字 → 借用で済む
        Cow::Borrowed(s)
    } else {
        // 変換必要 → 所有型を生成
        Cow::Owned(s.to_uppercase())
    }
}

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

    #[test]
    fn test_cow_no_copy() {
        let s = "HELLO";
        let result = process_optimized(s);

        // Borrowedであることを確認
        assert!(matches!(result, Cow::Borrowed(_)));
    }

    #[test]
    fn test_cow_with_copy() {
        let s = "hello";
        let result = process_optimized(s);

        // Ownedであることを確認
        assert!(matches!(result, Cow::Owned(_)));
        assert_eq!(result.as_ref(), "HELLO");
    }
}

よくある間違い

間違い1: すべてに'staticを使う

// ❌ 間違い: 'staticを濫用
fn bad_example(s: &'static str) -> &'static str {
    s
}

// 問題点: 動的な文字列が使えない
fn usage() {
    let dynamic = String::from("dynamic");
    // bad_example(&dynamic); // コンパイルエラー！
}

// ✅ 正しい: 通常のライフタイムを使う
fn good_example<'a>(s: &'a str) -> &'a str {
    s
}

fn correct_usage() {
    let dynamic = String::from("dynamic");
    let result = good_example(&dynamic); // OK!
    println!("{}", result);
}

間違い2: 不要なライフタイム注釈

// ❌ 間違い: 省略規則で十分なのに明示的に書く
fn bad_print<'a>(s: &'a str) {
    println!("{}", s);
}

// ✅ 正しい: 省略規則に任せる
fn good_print(s: &str) {
    println!("{}", s);
}

間違い3: ライフタイムを返り値に反映しない

// ❌ 間違い: コンパイルエラー
// fn buggy<'a, 'b>(x: &'a str, y: &'b str) -> &str {
//     if x.len() > y.len() { x } else { y }
// }
// エラー: 返り値のライフタイムが不明

// ✅ 正しい: 返り値にライフタイムを明示
fn correct<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

間違い4: 構造体のライフタイムを忘れる

// ❌ 間違い: コンパイルエラー
// struct BadStruct {
//     data: &str,  // エラー: ライフタイムが必要
// }

// ✅ 正しい: ライフタイムパラメータを追加
struct GoodStruct<'a> {
    data: &'a str,
}

ベンチマーク結果

以下は、ライフタイムを活用した最適化の効果を示すベンチマーク結果です。

テスト環境

• CPU: Apple M1 Pro
• RAM: 16GB
• Rust: 1.75.0
• 最適化: --release

ベンチマーク1: 文字列処理

use criterion::{black_box, criterion_group, criterion_main, Criterion};

// 所有権を奪うバージョン
fn owned_version(s: String) -> String {
    s.to_uppercase()
}

// 参照を使うバージョン
fn borrowed_version(s: &str) -> String {
    s.to_uppercase()
}

// Cowを使うバージョン
fn cow_version(s: &str) -> Cow<str> {
    if s.chars().all(|c| c.is_uppercase()) {
        Cow::Borrowed(s)
    } else {
        Cow::Owned(s.to_uppercase())
    }
}

fn benchmark(c: &mut Criterion) {
    let test_str = "hello world".to_string();
    let already_upper = "HELLO WORLD";

    c.bench_function("owned", |b| {
        b.iter(|| owned_version(black_box(test_str.clone())))
    });

    c.bench_function("borrowed", |b| {
        b.iter(|| borrowed_version(black_box(&test_str)))
    });

    c.bench_function("cow_needs_conversion", |b| {
        b.iter(|| cow_version(black_box(&test_str)))
    });

    c.bench_function("cow_no_conversion", |b| {
        b.iter(|| cow_version(black_box(already_upper)))
    });
}

criterion_group!(benches, benchmark);
criterion_main!(benches);

結果

結論:

• Cowを使うと、変換不要時に90%以上の高速化
• ライフタイムによる参照活用でメモリアロケーションを削減
• 実行時のオーバーヘッドはゼロ

ベンチマーク2: 構造体のクローン vs 参照

// クローンを使うバージョン
#[derive(Clone)]
struct OwnedData {
    text: String,
    numbers: Vec<i32>,
}

fn process_owned(data: OwnedData) -> usize {
    data.text.len() + data.numbers.len()
}

// 参照を使うバージョン
struct BorrowedData<'a> {
    text: &'a str,
    numbers: &'a [i32],
}

fn process_borrowed(data: &BorrowedData) -> usize {
    data.text.len() + data.numbers.len()
}

結果

結論:

• データサイズが大きいほど、ライフタイムによる参照の効果は絶大
• 大規模データでは数万倍の高速化も可能

まとめ

ライフタイムの解答例を通じて、以下を学びました：

• 基本的な注釈: <'a>の使い方
• 複数ライフタイム: 独立した参照の管理
• 最適化手法: Cowによるゼロコスト抽象化
• よくある間違い: 回避すべきアンチパターン
• パフォーマンス: ベンチマークによる効果測定

次のステップとして、Day 4のスマートポインタで、さらに高度なメモリ管理を学びます。