Rustという言語を学ぶ上で、避けては通れない非常に重要な機能の一つが「ジェネリクス」です。
ジェネリクスを活用することで、特定のデータ型に依存しない抽象的なコードを記述できるようになります。
これはコードの再利用性を大幅に向上させ、プログラムの重複を減らすための強力な武器となります。
本記事では、Rustにおけるジェネリクス (<T>) の基本的な使い方から、実務で役立つ応用テクニックまでを詳しく解説します。
2026年現在のモダンな開発環境においても、ジェネリクスは効率的なソフトウェア設計の根幹を支えています。
ジェネリクスとは何か
ジェネリクスは、具体的な型（i32やStringなど）の代わりに「型パラメータ」を使用する手法です。
プログラムを書く際、処理の内容は同じでも扱うデータ型だけが異なるという場面が多々あります。
例えば、2つの値を入れ替える処理や、リストの中から最大値を探す処理などが該当します。
ジェネリクスを使用しない場合、それぞれの型に対して個別の関数を定義しなければなりません。
しかし、ジェネリクスを使えば、「どんな型でも受け取れる汎用的な関数」を一つ定義するだけで済みます。
Rustのジェネリクスは、コンパイル時に具体的な型へと展開されるため、実行時のオーバーヘッドが発生しないという特徴があります。
関数におけるジェネリクスの活用
まずは、最も基本的な関数の定義においてジェネリクスを使用する方法を見ていきましょう。
関数名の後ろに <T> を付けることで、その関数がジェネリックであることを宣言します。
// 2つの引数のうち、どちらかを返す単純な関数
fn pick_one<T>(a: T, b: T, choice: bool) -> T {
if choice {
a
} else {
b
}
}
fn main() {
// i32型での利用
let result_int = pick_one(10, 20, true);
println!("選ばれた数値: {}", result_int);
// &str型での利用
let result_str = pick_one("Rust", "Generics", false);
println!("選ばれた文字列: {}", result_str);
}選ばれた数値: 10
選ばれた文字列: Genericsこのコードでは、pick_one という関数が T という抽象的な型を受け取っています。
main 関数内で呼び出す際、Rustのコンパイラは引数から型を推論し、自動的に最適なコードを生成します。
このように、一つの関数定義で複数のデータ型に対応できるのがジェネリクスの最大の利点です。
構造体でのジェネリクス利用
関数だけでなく、構造体のフィールドにもジェネリクスを適用することが可能です。
座標を表す Point 構造体を例に考えてみましょう。
// xとyに同じ型Tを持つ構造体
struct Point<T> {
x: T,
y: T,
}
fn main() {
let integer_point = Point { x: 5, y: 10 };
let float_point = Point { x: 1.0, y: 4.5 };
println!("整数座標: ({}, {})", integer_point.x, integer_point.y);
println!("実数座標: ({}, {})", float_point.x, float_point.y);
}整数座標: (5, 10)
実数座標: (1, 4.5)上記の例では、Point<T> と定義することで、整数でも浮動小数点数でも保持できる構造体を作成しました。
もし x と y で異なる型を許可したい場合は、複数の型パラメータを使用します。
// 異なる型TとUを持つ構造体
struct MultiPoint<T, U> {
x: T,
y: U,
}
fn main() {
let mixed = MultiPoint { x: 5, y: 4.5 };
println!("混合座標: ({}, {})", mixed.x, mixed.y);
}このように、必要に応じて <T, U, V> のように複数の型パラメータを定義できます。
ただし、パラメータを増やしすぎるとコードの可読性が低下するため、慎重に設計することが推奨されます。
列挙型(Enum)でのジェネリクス
Rustにおいて最も頻繁に使用されるジェネリクスの例は、標準ライブラリの Option<T> や Result<T, E> です。
これらは列挙型 (enum) にジェネリクスを適用したもので、Rustの安全性を支える重要な要素です。
// 標準ライブラリでの定義イメージ
enum MyOption<T> {
Some(T),
None,
}
enum MyResult<T, E> {
Ok(T),
Err(E),
}Option<T> は、値が存在するかどうか (None) を表現するために使われます。
Result<T, E> は、成功時の値 (T) と失敗時のエラー (E) を柔軟に扱うことができます。
これらのおかげで、私たちはあらゆる型に対して一貫したエラーハンドリングを行うことが可能です。
トレイト境界による型制約
単純なジェネリクス <T> だけでは、その型に対してどのような操作ができるか保証されていません。
例えば、2つの値を比較する関数を作りたい場合、T が比較可能である必要があります。
そこで使用するのが、トレイト境界 (Trait Bounds) です。
// TはPartialOrdトレイトを実装している必要がある
fn compare_and_print<T: PartialOrd + std::fmt::Display>(a: T, b: T) {
if a > b {
println!("{} は {} より大きいです", a, b);
} else {
println!("{} は {} 以下です", a, b);
}
}
fn main() {
compare_and_print(10, 5);
compare_and_print("apple", "banana");
}この例では、T: PartialOrd + std::fmt::Display と記述することで、2つの条件を課しています。
1つ目は比較可能であること (PartialOrd)、2つ目は文字列として表示可能であること (Display) です。
トレイト境界を使用することで、ジェネリクスの汎用性を保ちつつ、型安全な操作を保証できます。
where句による整理
トレイト境界が増えると、関数シグネチャが長くなり読みづらくなることがあります。
そのような場合は、where 句を使って制約を整理するのがベストプラクティスです。
fn complex_function<T, U>(t: T, u: U) -> i32
where
T: std::fmt::Display + Clone,
U: PartialOrd + Copy,
{
// 処理内容
0
}where 句を使うことで、関数の名前と引数、戻り値の型が明確になり、コードの保守性が向上します。
ジェネリクスのパフォーマンス：単相化
Rustのジェネリクスが優れている大きな理由は、「ゼロコスト抽象化」を実現している点にあります。
コンパイル時、Rustはジェネリクスを使用している箇所を、具体的な型ごとのコードに書き換えます。
このプロセスを「単相化 (Monomorphization)」と呼びます。
例えば、Option<i32> と Option<f64> を使っている場合、コンパイラはそれぞれに最適化されたバイナリを生成します。
これにより、実行時に型を判定する「動的ディスパッチ」のコストを回避でき、手書きで型ごとのコードを書いた場合と同等の速度で動作します。
バイナリサイズは若干増加する傾向にありますが、実行速度を最優先するRustにおいて非常に合理的な設計と言えます。
ジェネリクスを使いこなすためのヒント
ジェネリクスは強力ですが、何でもかんでも抽象化すれば良いというわけではありません。
まずは具体的な型で実装を行い、コードの重複が目立ってきた段階でジェネリクスへのリファクタリングを検討するのがスムーズです。
また、標準ライブラリのソースコードを読むことで、プロがどのようにジェネリクスを設計しているか学ぶことができます。
特に Vec<T> や HashMap<K, V> などのコレクションクラスは、ジェネリクスの宝庫です。
まとめ
Rustのジェネリクス (<T>) は、再利用性が高く、かつパフォーマンスを犠牲にしないコードを書くための不可欠な機能です。
関数、構造体、列挙型、そしてメソッド定義の至る所で、ジェネリクスはその威力を発揮します。
トレイト境界を組み合わせることで、型の柔軟性と安全性を高い次元で両立させることが可能です。
単相化という仕組みによって、抽象的な記述がそのまま高速なマシンコードへと変換される点はRustの大きな魅力です。
この記事で紹介した基本パターンを抑え、まずは身近な処理の共通化から始めてみてください。
ジェネリクスをマスターすることで、あなたのRustプログラミングはより洗練された、保守性の高いものへと進化するでしょう。