ホーム / Rust /

もう迷わない！Rustのジェネリクスの書き方・使い方を徹底解説

2025年4月21日月曜日

Rust

Rustのジェネリクス、ちょっととっつきにくいイメージ、ありますよね？ 「型をパラメータ化する」なんて聞くと、なんだか難しそうで敬遠しちゃう…なんて方もいるかもしれません。

この記事では、そんなジェネリクスの基本のキから、関数や構造体での具体的な使い方、そして「トレイト境界」っていうちょっと応用的な話や注意点まで、初心者の方にも分かりやすいように、サンプルコードを交えながら、まるっと解説しちゃいます。

この記事を読み終わるころには、「なんだ、ジェネリクスって意外とシンプルで便利じゃん！」って思わずニヤリとしちゃうはずですよ。もうジェネリクスで迷う必要はありません！

この記事で学べること

  • ジェネリクスが何なのか、なぜコードを書く上で助けになるのかが分かる
  • 関数や構造体でジェネリクスを使うための基本的な書き方が身につく
  • Rustでお馴染みの `Option<T>` や `Result<T, E>` がジェネリクスでできている仕組みを理解できる
  • ジェネリックな型に制約をつける「トレイト境界」という便利な機能を使えるようになる
  • ジェネリクスを使うときに、ちょっとだけ気に留めておきたいコツが掴める

Rustのジェネリクスとは？コードの再利用性を高める強力な武器

Rustのジェネリクス、名前だけ聞くとちょっと難しそうに感じるかもしれませんね。

でも、安心してください！ジェネリクスは、Rustプログラミングをもっと効率的で、もっと楽しくしてくれる、いわば「コードの節約術」みたいなものなんです。

簡単に言うと、ジェネリクスは「型を固定せずに、色々な型で使いまわせる関数や構造体を作るための仕組み」のことです。

例えば、数値用、文字列用、自作のデータ用…と、処理内容はほとんど同じなのに型が違うだけで、いくつも似たような関数を書いていませんか？ジェネリクスを使えば、それをたった一つにまとめられる可能性があるんです！

ジェネリクスを使う主なメリットはこんな感じです。

  • コードの重複を減らせる（書く量が減る！）
  • 色々な型に対応できる、柔軟な部品が作れる
  • コンパイル時に型チェックが行われるので、実行時のエラーを減らせる（Rustの得意技ですね！）

最初はちょっと戸惑うかもしれませんが、一度コツを掴めば、きっと「なんで今まで使わなかったんだろう！」と思うはず。さっそく、その書き方から見ていきましょう！

Rustのジェネリクスの基本的な書き方

ジェネリクスを使うには、まず「型パラメータ」というものを宣言します。

これは「ここには、後で具体的な型が入るよ」という目印のようなものです。一般的には `<T>` のように、大文字一文字（特に T は Type の頭文字でよく使われます）を山括弧で囲んで書きます。

関数と構造体、それぞれどこで宣言するのか見てみましょう。

関数のジェネリクスの書き方

関数でジェネリクスを使う場合、関数名の直後に型パラメータを宣言します。こんな感じです。

// 関数 `some_function` は型パラメータ `T` を持つ
fn some_function<T>(arg: T) {
    // 関数の中で型 `T` を持つ引数 `arg` を使える
    // ... 何かの処理 ...
}

この例では、`some_function` という関数が `<T>` という型パラメータを持っていることを示しています。引数 `arg` の型も `T` となっていて、これで色々な型の引数を受け取れる関数になるわけです。実際にどんな型で使うかは、この関数を呼び出す時に決まります。

構造体のジェネリクスの書き方

構造体でジェネリクスを使う場合は、構造体名の直後に型パラメータを宣言します。

// 構造体 `Point` は型パラメータ `T` を持つ
struct Point<T> {
    x: T,
    y: T,
}

この `Point` 構造体は、`x` と `y` というフィールドを持っていますが、その型は `T` となっています。

これで、例えば `Point<i32>` なら整数座標、`Point<f64>` なら浮動小数点数座標を持つ点を、同じ構造体定義で表現できるようになります。便利ですよね！ 

構造体を使う（インスタンス化する）時に、`Point { x: 5, y: 10 }` のように具体的な値を入れれば、多くの場合、Rustが型を推論してくれます。

Rustのジェネリクスの具体的な使い方

基本的な書き方がわかったところで、次は実際にジェネリクスをどう使っていくのか、もう少し具体的なコード例を見ていきましょう。

関数、構造体、メソッド、そしてRustでお馴染みの `Option` や `Result` で、ジェネリクスがどう活躍しているのかを探っていきます。

関数での使い方 - 様々な型に対応する処理を実装

ジェネリックな関数は、色々な型のデータに対して同じ処理を行いたい場合にとても役立ちます。

例えば、受け取った値をそのまま画面に表示するだけの単純な関数を考えてみましょう。

// 型Tを受け取って、デバッグ表示する関数
fn print_value<T: std::fmt::Debug>(value: T) {
    println!("The value is: {:?}", value);
}

fn main() {
    print_value(10);          // 整数を渡す
    print_value(3.14);        // 浮動小数点数を渡す
    print_value("Hello");     // 文字列スライスを渡す
    print_value(vec![1, 2, 3]); // ベクタを渡す
}

表示結果

The value is: 10
The value is: 3.14
The value is: "Hello"
The value is: [1, 2, 3]

この `print_value` 関数は、`<T: std::fmt::Debug>` という型パラメータを持っています。（`: std::fmt::Debug` の部分は後で説明する「トレイト境界」というもので、「デバッグ表示できる型」という制限を加えています）。

このおかげで、整数、浮動小数点数、文字列、ベクタなど、様々な型の値を引数として渡せています。

もしジェネリクスがなかったら、それぞれの型に関数を用意する必要があったかもしれませんね。

構造体・メソッド定義での使い方 - 柔軟なデータ構造を作成

ジェネリックな構造体と、その構造体に対するメソッドを組み合わせてみましょう。先ほど例に出した `Point` 構造体に、メソッドを追加してみます。

use std::fmt::Display;

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

// Point にメソッドを実装するブロック
// ここでも同じ型パラメータ T を使う
impl<T> Point<T> {
    // x座標への参照を返すメソッド
    fn x(&self) -> &T {
        &self.x
    }
}

// Point 用のメソッドだが、TがDisplayトレイトを実装している場合のみ有効
impl<T: Display> Point<T> {
    fn print(&self) {
        println!("Point coordinates: ({}, {})", self.x, self.y);
    }
}


fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.0, y: 4.0 };

    println!("Integer point x: {}", integer_point.x());
    // println!("Float point x: {}", float_point.x()); // メソッド呼び出しも可能

    integer_point.print();
    float_point.print();
}

表示結果

Integer point x: 5
Point coordinates: (5, 10)
Point coordinates: (1.0, 4.0)

まず `Point<T>` というジェネリックな構造体を定義しました。次に `impl<T> Point<T>` ブロックで、この構造体に対するメソッド `x` を定義しています。

`impl<T>` と書くことで、`Point` 構造体の型パラメータ `T` をメソッド定義の中でも使えるようになります。メソッド `x` は、どんな型の `Point` でも、`x` フィールドへの参照を返せるわけです。

さらに、`impl<T: Display> Point<T>` ブロックでは、型`T`が画面表示可能(`Display`トレイトを持つ)な場合にのみ有効な`print`メソッドを定義しています。

Enum定義での使い方 - `Option<T>` と `Result<T, E>` を理解する

Rustを使っていると必ず目にする `Option<T>` や `Result<T, E>` も、実はジェネリクスを使って定義されたEnum（列挙型）なんです。

`Option<T>` は、「値があるかもしれないし(`Some(T)`)、ないかもしれない(`None`)」状態を表します。`T` が型パラメータですね。

enum Option<T> {
    Some(T), // 何らかの値 T を含む
    None,    // 値がない
}

`Result<T, E>` は、「処理が成功して値 `T` を持つか(`Ok(T)`)、失敗してエラー値 `E` を持つか(`Err(E)`)」を表します。こちらは `T` と `E` の二つの型パラメータを持っています。

enum Result<T, E> {
    Ok(T),  // 成功。値 T を含む
    Err(E), // 失敗。エラー値 E を含む
}

例えば、ファイルを開く操作は成功するかもしれないし（ファイルハンドルが手に入る）、失敗するかもしれません（ファイルが見つからないなど）。こういう状況を `Result` で表現します。

use std::fs::File;

fn main() {
    let f = File::open("hello.txt"); // Result が返る

    let _file_handle = match f {
        Ok(file) => file, // 成功したらファイルハンドル(File型)を取り出す
        Err(error) => {  // 失敗したらエラー(std::io::Error型)に応じた処理
            panic!("Problem opening the file: {:?}", error)
        },
    };
}

このように、Rustの基本的な部品にもジェネリクスが活用されていることを知ると、ジェネリクスがより身近に感じられませんか？

Rustのジェネリクスとトレイト境界 - 使える型を制限して安全性を高める

ジェネリクスはとても便利ですが、「どんな型でも受け入れます！」だと、困る場面も出てきます。例えば、二つの値を比較して大きい方を返す関数を作りたいとしましょう。

// これはコンパイルエラーになります！
// fn largest<T>(a: T, b: T) -> T {
//     if a > b { // エラー: 型 'T' では `>` 演算子が使えないかもしれない
//         a
//     } else {
//         b
//     }
// }

上のコードはコンパイルエラーになります。なぜなら、型 `T` がどんな型か分からない状態では、`>` 演算子（より大きいか比較する）が使える保証がないからです。数値なら比較できますが、例えば自作の構造体は、そのままでは比較できませんよね。

そこで登場するのが「トレイト境界」です。これは、型パラメータ `T` が「最低限この機能（トレイト）は持っていてね」と約束させる仕組みです。

比較演算を使いたい場合は、`PartialOrd` というトレイト（部分的な順序付けができることを示す）で制限をかけます。

use std::cmp::PartialOrd; // PartialOrdトレイトをインポート

// T が PartialOrd トレイトを実装している型に限定する
fn largest<T: PartialOrd>(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

fn main() {
    let num1 = 10;
    let num2 = 5;
    println!("Largest number is: {}", largest(num1, num2)); // OK

    let char1 = 'a';
    let char2 = 'z';
    println!("Largest char is: {}", largest(char1, char2)); // OK
}

表示結果

Largest number is: 10
Largest char is: z

`fn largest<T: PartialOrd>` のように、型パラメータの後ろにコロン `:` とトレイト名を書くことで、「`T` は `PartialOrd` を実装している型でないとダメだよ」と指定できます。これで、比較可能な型だけをこの関数で扱えるようになり、安全性が高まります。

複数のトレイト境界を指定したり、`where` キーワードを使ってもっと複雑な条件を書いたりもできますが、まずはこの基本形を覚えておきましょう！

Rustのジェネリクスを使う上での注意点 - パフォーマンスとコードの肥大化

ジェネリクスを使う上で、ちょっとだけ頭の片隅に置いておいてほしいことがあります。それは、コンパイル時に何が起きているか、という話です。

Rustコンパイラは、ジェネリックなコード（例えば `Option<T>`）が実際に使われる時に、具体的な型（例えば `Option<i32>` や `Option<String>`）ごとに、専用のコードを生成します。このプロセスを「単相化（たんそうか、monomorphization）」と呼びます。

イメージとしては、ジェネリックな「設計図」をもとに、使われる型に応じた「実物」のコードをコンパイラが作ってくれる感じです。

この単相化のおかげで、ジェネリックなコードを使っても、実行時のパフォーマンスが低下することはほとんどありません。多くの場合、型が決まっている非ジェネリックなコードと同等か、場合によっては最適化が進んで速くなることさえあります。

ただし、副作用として、ジェネリックなコードを色々な具体的な型でたくさん使うと、生成されるコードの量が増えて、最終的なプログラムのサイズが少し大きくなる可能性があります。

とはいえ、現代の開発では、コードの再利用性や安全性のメリットの方がはるかに大きい場合がほとんどなので、過度に心配する必要はありません。ジェネリクスの便利さをどんどん活用していきましょう！

【まとめ】Rustのジェネリクスをマスターして柔軟なコードを書こう！

さて、「Rustのジェネリクス」について、基本から応用、注意点まで駆け足で見てきましたがいかがでしたか？

この記事でお伝えしてきた要点をまとめると、こんな感じです。

  • ジェネリクスは、型をパラメータ化してコードの重複を減らし、柔軟性を高める仕組み。
  • 関数や構造体の名前の後に `<T>` のように型パラメータを宣言して使う。
  • `Option<T>` や `Result<T, E>` など、Rustの基本機能にも使われている。
  • トレイト境界 (`T: Trait`) を使うと、ジェネリックな型に特定の機能を要求でき、安全性が向上する。
  • コンパイル時に単相化されるため実行時パフォーマンスは良いが、コードサイズが少し増える可能性はある。

ジェネリクスは、Rustの型システムがもたらす安全性と、効率的なコード記述を両立させるための、とても強力な機能です。

最初は少し複雑に感じるかもしれませんが、実際にコードを書きながら試していくうちに、その便利さがきっと実感できるはず。

【関連記事】
Rustとは？いま学ぶべき理由と特徴や始め方を詳しく解説

このブログを検索
  • ()

自己紹介

自分の写真
リモートワークでエンジニア兼Webディレクターとして活動しています。プログラミングやAIなど、日々の業務や学びの中で得た知識や気づきをわかりやすく発信し、これからITスキルを身につけたい人にも役立つ情報をお届けします。 note → https://note.com/yurufuri X → https://x.com/mnao111

QooQ