第7章: Rustのジェネリクスとトレイト

Rustの型システムは非常に強力であり、型の安全性を保証するための仕組みが多く取り入れられています。その中でもジェネリクス（Generics）とトレイト（Traits）は、コードの柔軟性や再利用性を向上させる重要な要素です。ここではまずジェネリック型について学び、その後トレイトを使ってジェネリック型の機能を拡張する方法について詳しく説明します。

7.1 ジェネリック型とは何か？

ジェネリック型は、同じ機能を持つ異なる型に対して、共通のコードを提供するための仕組みです。Rustのジェネリクスは、関数や構造体、列挙型などにおいて、特定の型に依存しない汎用的な実装を提供することができます。これにより、型ごとに異なる処理を個別に書く必要がなくなり、コードがよりシンプルで再利用可能になります。

例: ジェネリックな関数の定義

以下のコードは、引数に渡された値を返す単純な関数 identity を示しています。この関数をジェネリクスを使用して定義してみましょう。

fn identity<T>(value: T) -> T {
    value
}

この例では、T という名前のジェネリック型パラメータを identity 関数の引数と戻り値に指定しています。T は実際の型を指定していませんが、関数が呼ばれたときに、その引数の型に基づいて具体的な型が決定されます。これにより、文字列でも整数でも同じ identity 関数を利用することができます。

fn main() {
    let int_value = identity(5); // i32 型として解釈される
    let string_value = identity("Hello, world!"); // &str 型として解釈される
    println!("{}, {}", int_value, string_value);
}

このように、identity 関数は異なる型の値に対しても同じ関数のロジックを提供することができ、Rustコンパイラはその都度適切な型を解釈してくれます。

7.2 構造体とジェネリクス

関数と同様に、構造体もジェネリック型を使用して定義できます。例えば、Point という2次元の座標を表す構造体を考えてみましょう。Point 構造体には、異なる型の x 座標と y 座標を持つことができるようにします。

struct Point<T> {
    x: T,
    y: T,
}

ここでは、T は x と y の両方のフィールドの型として使用されています。この Point 構造体は、i32 や f64 など、任意の型をサポートすることができます。

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.0, y: 4.0 };
    println!("Integer Point: ({}, {})", integer_point.x, integer_point.y);
    println!("Float Point: ({}, {})", float_point.x, float_point.y);
}

この例では、Point<i32> や Point<f64> として構造体をインスタンス化することができ、異なる型のポイントを簡単に表現できます。

7.3 トレイトの概要

トレイトは、特定の型が持つべき共通の振る舞いやインターフェースを定義するものです。これは、オブジェクト指向プログラミングでいうインターフェースに似た概念です。トレイトを使用することで、異なる型に共通のメソッドを実装するための共通の枠組みを提供できます。

トレイトの定義

次の例では、Printable という名前のトレイトを定義しています。このトレイトは print という関数を持ち、すべての Printable トレイトを実装する型は print 関数を提供する必要があります。

trait Printable {
    fn print(&self);
}

Printable トレイトを実装するには、impl キーワードを使用して、具体的な型（例えば、i32 や String）に対して print メソッドを実装します。

impl Printable for i32 {
    fn print(&self) {
        println!("i32: {}", self);
    }
}

impl Printable for String {
    fn print(&self) {
        println!("String: {}", self);
    }
}

fn main() {
    let my_number: i32 = 10;
    let my_string = String::from("Hello, Rust!");

    my_number.print();
    my_string.print();
}

このようにして、異なる型に対して Printable トレイトを実装することで、print メソッドを呼び出すことが可能になります。

7.4 トレイト境界によるジェネリックな制約

ジェネリック型にトレイトを適用することで、特定のトレイトを実装している型のみに制約をかけることができます。これを「トレイト境界（Trait Bounds）」と呼びます。例えば、Printable トレイトを実装した型にのみ動作する関数を定義したい場合、次のように記述できます。

fn print_value<T: Printable>(value: T) {
    value.print();
}

この print_value 関数は、引数に渡される型 T が Printable トレイトを実装していることを要求しています。この制約を持つことで、Printable トレイトを実装している型のみに対して print_value 関数を使用することができるようになります。

fn main() {
    let my_number: i32 = 10;
    let my_string = String::from("Hello, Rust!");

    print_value(my_number);
    print_value(my_string);
}

7.5 ジェネリクスとトレイトの組み合わせた実践例

最後に、ジェネリクスとトレイトを組み合わせてより複雑な例を作成してみましょう。例えば、Comparable というトレイトを定義し、compare というメソッドを実装してみます。このトレイトを使用して、異なる型の値を比較することができます。

trait Comparable {
    fn compare(&self, other: &Self) -> i32;
}

impl Comparable for i32 {
    fn compare(&self, other: &Self) -> i32 {
        self - other
    }
}

impl Comparable for f64 {
    fn compare(&self, other: &Self) -> i32 {
        if self < other {
            -1
        } else if self > other {
            1
        } else {
            0
        }
    }
}

fn compare_values<T: Comparable>(a: T, b: T) -> i32 {
    a.compare(&b)
}

fn main() {
    let result = compare_values(10, 5);
    println!("Comparison result (i32): {}", result);

    let float_result = compare_values(3.2, 7.8);
    println!("Comparison result (f64): {}", float_result);
}

この例では、Comparable トレイトを i32 型と f64 型に対して実装しています。compare_values 関数では、Comparable トレイトを実装した型であれば、どの型でも比較できるようになっています。

---

ジェネリクスとトレイトの組み合わせは、Rustのプログラミングにおいて強力なツールです。これを使いこなすことで、再利用性の高いコードを作成し、より柔軟で安全なプログラムを設計することができるようになります。