ジェネリック

ジェネリックとは

ジェネリック（generic）とは、型をパラメータとして受け取ることで、様々な異なる型に対応できるようにする仕組みのことです。

例えば、i32 型専用の関数を作成した場合、i64 型や f64 型に対しては、別の関数を定義しなければなりません。しかし、ジェネリックを使うことで「型に依存しない」関数にすることが可能です。Rust では、ジェネリックを関数、構造体、列挙体などで使用することができます。

この記事では、ジェネリックな関数や型の基本について分かりやすく説明します。なお、公式ドキュメントなどではジェネリクス（generics）という複数形で表現されることも多いですが、この記事では「ジェネリックな」という表現に統一して紹介します。

ジェネリックな関数

Rust は型安全性が高く、コンパイル時に厳密な型チェックを行うプログラミング言語です。もし、関数を書く場合に「fn func(x: i32) -> i32」という型注釈をつけた場合には、i32 型以外の型を渡すことはできません。Rust には多くの数値型があるので、関数を書くときにどの型を選ぶのか、関数名をどうするかといった煩わしさに取り組まなくてはいけなくなります。

以降で紹介するジェネリックな関数を使うことで、この問題を解決することができます。

ジェネリックな関数の定義と使い方

以下の例を使用してジェネリックな関数の定義と使い方を説明します。

// 基本的なジェネリック関数
fn identity<T>(x: T) -> T {
    x
}

// 複数の型パラメータを持つ関数
fn make_pair<T, U>(x: T, y: U) -> (T, U){
    (x, y)
}


fn main() {
    let a: i32 = 10;
    let b: i64 = 50;
    let c: f64 = 100.5;

    // identity 関数の使用
    println!("{}", identity(a));
    println!("{}", identity(b));
    println!("{}", identity(c));

    // make_pair 関数の使用
    println!("{:?}", make_pair(a, b));
    println!("{:?}", make_pair(b, c));
    println!("{:?}", make_pair(c, c));
}

【実行結果】
10
50
100.5
(10, 50)
(50, 100.5)
(100.5, 100.5)

上記は、受け取った引数をそのまま返却する identity 関数と受け取った 2 つの引数をペアのタプルにして返却する make_pair 関数です。

identity 関数の直後に <> で囲んだ T という文字があります。この <T> は、関数定義の型パラメータ（type parameter）と言います。これは、identity 関数が T という型パラメータで表現されるジェネリック関数であることを意味しています。

T は x の型注釈と戻り値の型注釈に使用されています。これにより、x に i32 が渡されたときは、戻り値も i32 型、x が f64 の場合は、戻り値も f64 というように、同じ型パラメータの部分には同一の型が入ることを示します。実際に、main 関数の identity 呼び出しでは、i32、i64、f64 の変数を渡していますが、Rust コンパイラが型を推論することで適切に処理ができています。

複数の型パラメータが必要となるような場合には、make_pair 関数での <T, U> のように複数の型パラメータを指定します。T や U の部分は任意の文字でよいですが、慣習として T, U, V, …といった型パラメータがよく使用されます。

この時、make_pair 関数の戻り値を (y, x) とすると、T、U に同じ型の変数を渡す場合には問題になりませんが、型が異なる場合に不一致が発生してしまうので注意が必要です。(y, x) を返却するようにしたい場合には、戻り値の型パラメータを (U, T) とするのが適切です。

明示的な型指定での呼び出し

Rust は型推論が強力であるため、関数に渡される変数などから型を適切に推論してくれます。型を明示的に指定して呼び出したい場合は「関数名::<型名>()」という形で明示的に呼び出すことも可能です。

fn main() {
    let a: i32 = 10;
    let b: i64 = 50;
    let c: f64 = 100.5;

    // identity 関数の使用
    println!("{}", identity::<i32>(a));
    println!("{}", identity::<i64>(b));
    println!("{}", identity::<f64>(c));

    // make_pair 関数の使用
    println!("{:?}", make_pair::<i32, i64>(a, b));
    println!("{:?}", make_pair::<i64, f64>(b, c));
    println!("{:?}", make_pair::<f64, f64>(c, c));
}

基本的には型推論に任せればよいでしょう。意図的に型を指定したい場合に、明示的に型を指定する方法があるということだけ覚えておいてもらえればと思います。

ジェネリックな構造体

ジェネリックな構造体の定義と使い方

型パラメータは、以下のようにジェネリックな構造体の宣言にも使用することができます。

// ジェネリックな構造体
struct SomeNum<T, U> {
    c: char,
    num1: T,
    num2: U,
    num3: U,
}

fn main() {
    let some_number = SomeNum{
        c:'a', num1: 10, num2: 20.5, num3: 30.5
    };
    println!("{}", some_number.c);
    println!("{}", some_number.num1);
    println!("{}", some_number.num2);
    println!("{}", some_number.num3);

    let some_number1 = SomeNum{
        c: 'b', num1: 10.5, num2: 20, num3: 30
    };
    println!("{}", some_number1.c);
    println!("{}", some_number1.num1);
    println!("{}", some_number1.num2);
    println!("{}", some_number1.num3);
}

【実行結果】
a
10
20.5
30.5
b
10.5
20
30

上記の構造体は、char型のc と、T、U という型パラメータの要素を持つ構造体となっています。num1 は T 型、num2 と num3 は U 型の要素になっています。この構造体を使用する場合には、num2 と num3 は、同じ型でないといけないことに注意してください。

ジェネリックな列挙体

ジェネリックな列挙体の定義と使い方

型パラメータは、以下のようにジェネリックな列挙体の宣言にも使用することができます。列挙体の代表例である Option<T> 型や Result<T, E> 型についても、型パラメータの T、 E を持つジェネリックな列挙体となっています。

以下では、Result<T, E> に似た独自の MyResult<S, F> 列挙体を定義しています。

// ジェネリックな列挙体
enum MyResult<S, F> {
    Success(S),    // 成功時の値
    Failure(F, String),  // 失敗時の値とエラー文字列
    Uncertainty,
}

fn main() {
    let mut result = MyResult::Success::<i32, u16>(10);
    if let MyResult::Success(code) = result {
        println!("Success {}", code);
    };

    result = MyResult::Failure(1, "Error1".to_string());
    if let MyResult::Failure(code, error) = result {
        println!("Failure {} {}", code, error);
    }

    result = MyResult::Uncertainty;
    if let MyResult::Uncertainty = result {
        println!("Uncertain");
    }

    // result の S は i32型で使用しているので以下はエラーとなる
    // result = MyResult::Success(10.0);

    // 異なる型での利用
    let result = MyResult::Success::<f64, u8>(10.5);
    if let MyResult::Success(code) = result {
        println!("Success {}", code);
    };
}

【実行結果】
Success 10
Failure 1 Error1
Uncertain
Success 10.5

列挙体を使用する際には「MyResult::Success::<i32, u16>(10)」のように S や F が何の型であるかを指定して使用します。この時、型パラメータ F については、以降のコードで使用されれば型推論で型を特定できますが、基本的には使用するタイミングで明示して定義するのが良いでしょう。以下のように型注釈をつけても構いません。

    let mut result: MyResult<i32, u16> = MyResult::Success(10);

なお、コメントアウトしている「result = MyResult::Success(10.0);」は、既に result の S が i32 型であるのに対して、浮動小数点数を指定しているためエラーとなります。必要であれば、上記例のようにシャドーイングで再定義するか、別の変数で使用する必要があります。

トレイト境界を利用した型の制約

ジェネリックな関数は便利ですが、任意の型でも受け入れることができてしまいます。そのため、関数内で想定していない型が渡されると、コンパイルエラーとなります。

Rust では「トレイト」という仕組みを使って型の振る舞いを定義できます。ジェネリックな関数では、型パラメータがどのトレイトを実装しているかを指定することで制約を加えることができ、これを「トレイト境界」と呼びます。

use std::fmt::Display;

enum MyResult<S, F> {
    Success(S),    // Result
    Failure(F, String),  // FailureCode と エラー文字列
    Uncertainty,
}

// トレイト境界を指定したチェック関数
fn check_result<S, F> (result: &MyResult<S, F>) 
where S: Display, F: Display
{
    match result {
        MyResult::Success(code) => println!("Success: {}", code),
        MyResult::Failure(code, error) => println!("Failure: {} detail: {}", code, error),
        MyResult::Uncertainty => println!("Uncertain Result")
    }
}

fn main() {
    let mut result = MyResult::Success::<i32, u16>(10);
    check_result(&result);

    result = MyResult::Failure(1, "Error1".to_string());
    check_result(&result);
    
    result = MyResult::Uncertainty;
    check_result(&result);
}

【実行結果】
Success: 10
Failure: 1 detail: Error1
Uncertain Result

上記の check_result 関数では、結果の形式を match で判定して println で出力していますが、その中で {} を指定しています。{} に値を埋め込むには、その型が Display トレイトを実装している必要があります。

S、 F という型パラメータが Display トレイトを実装していることを where で指定しています。「fn check_result<S: Display, F: Display>() 」と指定することも可能です。 なお、複数のトレイトを実装している必要がある場合は「Display + Debug」のように「+」でつなげていきます。

このようにすることでジェネリックの汎用性を使いつつ、型の制約を入れることで安全な処理を設計することが可能となります。

ジェネリックとゼロコスト抽象化

Rust のジェネリックは ゼロコスト抽象化（zero-cost abstraction） を実現しています。これは「抽象化を使っても、コンパイル後の実行時コストは手書きのコードと変わらない」という考え方です。プログラミング言語によっては、実行時にどの型かを判別して振る舞いを切り替えるためにパフォーマンスに影響が出る場合があります。

Rust のジェネリックは「モノモーフィゼーション（Monomorphization）」という仕組みで処理されます。これはコンパイル時に、ジェネリック関数や型が実際に使われる具体的な型に展開して最適化されたコードを生成する仕組みです。

例えば、上記でも紹介した identity 関数を考えます。

// 基本的なジェネリック関数
fn identity<T>(x: T) -> T {
    x
}

fn main() {
    // identity 関数の使用
    let a = identity(10);
    let b = identity(20.5);
}

コンパイル後には、identity<i32> と identity<f64> という型ごとの別々の関数が具体的に生成されます。そのため、実行時に型を判別して振る舞いを切り替える余分な処理が発生せず、最初から i32 専用関数と f64 専用関数を書いたかのようなパフォーマンスが得られます。

この仕組みにより Rust は抽象化と高パフォーマンスを両立させています。「分かりやすく安全なコードを書きつつ、速度も妥協しない」という Rust の大きな強みが、ジェネリックのゼロコスト抽象化により支えられています。

まとめ

この記事では、Rust におけるジェネリックの基本について解説しました。

• ジェネリックな関数を使うと、型に依存しない柔軟な関数を定義できます。
• ジェネリックな構造体や列挙体 により、さまざまなデータ型を扱える再利用性の高い型を設計できます。
• Rust のジェネリックは、モノモーフィゼーションによりコンパイル時に具体的な型に展開されるゼロコスト抽象化を実現しており、抽象化しても実行時のオーバーヘッドは発生しない高速な処理を実現できます。

ジェネリックを使うことで、安全で読みやすく、高いパフォーマンスを両立できるのが Rust の大きな特徴です。

あわせて読みたい

Rust プログラミング入門

Rust とは何か？

Rust は、非常に高いパフォーマンスやメモリ安全性など、近年人気が高まってきているモダンなプログラミング言語の 1 つです。

なぜ Rust に注目が集まっているのか？

Rust は、なぜ近年注目を集めているのでしょうか。いくつかの理由をご紹介します。

信頼性・安全性の高い実装の実現

近年は、サイバーセキュリティの脅威が増加しており、攻撃者はシステムの脆弱性をついて攻撃してきます。そのため、信頼性の高いシステムを構築することが必要不可欠です。Rust では、メモリ安全性を言語レベルで保証するような仕組みがあり、コンパイルが通れば、メモリ安全性の多くが保証されるため、非常に信頼性の高いシステムを構築できます。

実際に、バッファオーバーフローやダングリングポインタ（解放されたメモリ領域を指すポインタ）へのアクセスなどメモリ安全性の問題は、重大な脆弱性の大半を占めるとも言われています。このように、セキュリティ要求への対応への高まりに伴い、Rust への注目と期待が高まっています。

高速性と開発効率の両立

これまでは、高性能な処理を実現するには C/C++ を選び、開発効率を重視する際には Python などのスクリプト言語を選ぶといった、性能と生産性のどちらを取るかという二者択一の判断を迫られることが多くありました。Rust は C/C++ に匹敵する高性能を持ちながら、Python などのモダンな言語に見られる表現のしやすさや安全性も備えており、その両立を実現しています。

Rust は、C/C++ と同等の性能を保ちつつ、メモリ安全性や並行性の安全性をコンパイル時に保証することを目指して設計されており、C/C++ の代替としても大きな期待を集めています。

幅広い適用範囲

Rust は、C/C++ に変わるシステムプログラミング言語として注目されがちですが、実は様々な分野で活用できる汎用性の高いプログラミング言語です。

エコシステムの充実

Rust は、言語としての素晴らしい設計思想だけではなく、開発環境やライブラリ（クレートと呼ばれます）関連のエコシステムが非常に充実していることも注目される理由の 1 つです。

例えば、Rust のプロジェクト管理では標準で Cargo というビルドツール兼パッケージマネージャが標準で用意されており、ビルド・テスト・ドキュメント生成の実行、パッケージの依存関係管理などを一貫して行うことができます。

また、Rust のパッケージは crates.io という公式のリポジトリを通じて簡単に検索、導入ができるようになっており、高品質かつ実用的な各種ライブラリが数多く公開されています。このように、実際の開発に必要な機能をすぐに利用できる環境が整っているため、Rust は「学習コストは高いが、開発効率も高い」と評価されることが増えてきています。

大手企業での採用

Rust は、その安全性・性能・開発効率の高さから、近年では Google、Microsoft、Amazon などの大手企業でも採用が進められています。例えば、Microsoft では Windows や Azure（クラウド）などのプロジェクトで Rust を積極的に評価・導入を進めています。このように世界の IT 大手企業が Rust を本番環境に導入し始めていることは、Rust の信頼性や将来性を強く示す動きと言えます。

最も称賛された言語ランキング（2025年調査）

Stack Overflow Developer Survey 2025 の Most Admired Language (最も称賛された言語) として、72.4% のスコアで 2024 年に続いて再び 1 位を獲得しています。これは、現在 Rust を使用する開発者が今後も使いたいと強く思っていることを意味しており、Rust の安全性や充実したエコシステムによる開発が開発者に受け入れられていることがよく分かります。

また、Desired Language (=使用を望まれている言語)では、Python や Javascript といった言語にはやや劣りますが、29.2% で上位となっています。

このように Rust は今後も使用の拡大が十分に期待できる言語です。

ビルドツール兼パッケージマネージャ Cargo は高評価（2025年調査）

Rust の開発時においては、ビルドツール兼パッケージマネージャとして Cargo が使用されています。Stack Overflow Developer Survey 2025 の Cloud development (クラウド開発環境) では、Cargo の Desired は、13.9% と主要なインフラ系ツールと比較すると高い割合ではありませんが、Admired は 70.8% と非常に高いスコアとなっています。これは、実際に使用している開発者の多くが今後も使いたいと考えていることを示しています。

類似するパッケージマネージャーである npm や pip の Admired が 45% 前後であることを考えると Cargo の満足度の高さが際立っています。

このように、Rust は言語自体だけでなく、開発環境 (Cargo を中心としたツールチェーン) も非常に高く評価されていることが分かります。

また、Python では、近年 Rust 製のパッケージマネージャーである uv が注目を集めています。uv は依存解決やロックファイル管理など設計思想において Cargo と共通点が多く、Rust のツール設計思想が他言語にも影響を与えつつあることが感じられます。

Rust の歴史

Rust は、Web ブラウザの Firefox などで知られる Mozilla のエンジニア Graydon Hoare 氏の個人プロジェクトとして 2006 年に始まり、2009 年から Mozilla が公式プロジェクトとして支援するようになりました。

2015 年に Rust 1.0 が正式にリリースされ、以後は安定性と後方互換性を重視した開発が継続されています。2021 年には Rust Foundation が設立され、これを機に Mozilla から独立し、コミュニティによるオープンな体制での開発が進められるようになりました。

また、2018 年からは「エディション」という形で言語仕様の大きな節目が導入されており、本記事執筆時点での最新エディションは、Rust 2024 (バージョン1.85.0以降) です。

Rust はこのように、Mozilla プロジェクトから始まり、オープンなエコシステムへ成長しました。今では世界中の開発者や企業が支える「高性能」と「安全性」を両立する近代的な言語として注目を集めています。

Rust の特徴と強み

ここでは、Rust が注目・評価されている特徴と強みについて概要を紹介していきます。

メモリ安全性（所有権、借用、ライフタイム）

Rust が高く評価されている特徴の一つに「メモリ安全性」を言語仕様のレベルで保証している点があげられます。C/C++ などでは、メモリを十分意識した開発が求められますが、メモリの解放忘れ、解放したメモリへのアクセス（ダングリングポインタ）、バッファオーバーフローなどのシステムに大きく影響する深刻なバグが発生しやすいです。

Rust では、これらの問題をコンパイル時に防ぐ仕組みが言語仕様として備わっています。代表的な「所有権」「借用」「ライフタイム」といった仕組みについて簡単にご紹介します。

所有権（Ownership）

Rust では、変数がデータの所有者であるという所有権の考え方を持っています。他の変数へ所有権が移動すると、元の変数は該当するメモリ上のデータにはアクセスできなくなります。これによりあるメモリ領域へアクセスできる変数が限定されるため、安全にデータを処理できます。

借用（Borrowing）

データの所有権を移動させずにデータを一時的に参照させることを借用といいます。借用には不変参照（読み取り専用）と可変参照（読み書き可）があります。

読み取り専用の不変参照はデータを変更できないため、同時に複数作ることができます。一方で、可変参照は同時に一つしか存在することができず、その間は他の参照や元の変数からのアクセスも禁止されます。これによりデータ競合や不整合のない安全なメモリ管理が実現できます。

ライフタイム（Lifetime）

ライフタイムは、借用に関連する概念であり、どれだけの間で参照ができるのか管理します。ライフタイムの考えにより、元の変数が解放されているのに参照がアクセスするような処理をコンパイル時点で見つけることができ、ダングリングポインタによる不正なメモリへのアクセスを排除できます。

これらの仕組みは少し理解が難しい内容ですが、理解できるとコンパイラが多くの部分を推論、チェックしてくれるため、自然に安全な実装ができるようなものとなっています。

型安全性

Rust は、型によって安全性と開発者の意図を明確に表現できるようになっています。これはHaskell などの関数型言語の影響を受けた設計とも言われています。代表的な例として「値が存在しない可能性」を明示的に扱う Option<T> 型や「成功または失敗」という処理結果を表す Result<T, E> 型などがあります。

Rust では「値がないかもしれない」「エラーが起こるかもしれない」といったケースに対して、型レベルで明示的に扱う必要があり、開発者はこの状況に正面から向き合うことになります。この強力な型システムにより、開発者の見落としによるバグを未然に防ぐことができます。

一方で、こうした明示的な設計はコードの記述量を増やす可能性がありますが、Rust には型推論やパターンマッチングといった仕組みにより、開発者の負担を減らしながら安全性を高めることができるようになっています。

ゼロコスト抽象化

Rust には「ゼロコスト抽象化」という概念があります。これは、抽象的で柔軟なプログラムの書き方をしたとしても、コンパイル後には余計な処理が入らずに高速な処理性能が得られるという設計思想です。

例えば、特徴的なものとしてトレイト (Trait) があります。トレイトは、型に共通する振る舞いを定義するもので、他の言語でいうところのインターフェースに近いようなものです。

このような抽象的な実装においては、他の言語で実行時に動的に決定されて処理されることが多く、処理性能に影響します。一方で、Rust ではコンパイル時に静的に決定します。具体的には、コードの記述されているそれぞれの型に対するコードを生成しています。これにより、高性能かつ安全な実装を実現しています。

非同期処理

Rust では、モダンな言語らしく async / await といった構文による非同期処理をサポートしています。

また、これまでに紹介したような所有権、強力な型システムといった仕組みにより、非同期であってもメモリ安全性を維持しやすく、スレッドやデータ競合に起因するバグを防ぎやすいという点で非常に優れています。

さらに、コンパイル時に処理の安全性が検証されるため、非同期処理にありがちな実行時エラーを未然に防ぎつつ、効率の良い並行処理が可能となっています。

他の言語との違い

Rust は、処理性能で C/C++ に匹敵しながらも安全性が高く、現代的な開発体験を提供してくれる点で、他の多くの言語とは一線を画しています。以下は主要な他の言語との比較です。

Rust と他言語の比較表

比較ポイントの要約

C/C++ との違い

Rust は、C/C++ と同等の性能を持っています。C/C++ では、メモリの手動管理によるバグのリスクが大きいですが、Rust では、コンパイル時にメモリ安全性を言語レベルで保証できるのが大きな違いです。

Python との違い

Python は、非常に書きやすく初心者でも学びやすい言語ですが、実行速度や型安全性に難があります。一方で Rust は、所有権や型に関する理解が必要なため学習コストは高いですが、高速・安全なコードが書けるという違いがあります。

Haskell との違い

Rust は、Haskell のような関数型の良い部分（Option 型、Result 型、パターンマッチングなど）を取り入れつつ、手続き型スタイルにも自然に対応できます。純粋関数型の Haskell ほど抽象度はない分、現実的で実用的なコードを速く書きやすいという違いがあります。

Rust の将来性と課題

Rust は、これまで見てきたように、将来性・安全性・抽象化といった観点で非常にバランスの優れた魅力的な言語です。Rust の将来性と課題についてまとめてみます。

Rust の将来性

大手企業での採用拡大

Google や Microsoft、Amazon などの大手企業での採用も進んでおり、今後も Rust に対応した開発基盤が増えていくと予想されます。

先端的な技術領域での活用

Linux カーネルへの導入や WebAssembly との連携など、先端的な技術領域で活用が広がってきています。

言語仕様・ツールの成熟

コンパイラである rustc やパッケージ管理の Cargo は既に非常に高品質であり、今後も安定的な機能拡張が期待できます。

Rust の課題

学習コストの高さ

所有権やライフタイム、型システムなど、Rust 独自の概念は初学者には難しく、習得までに時間がかかる傾向があります。一方で、C/C++、Java、Python、Haskell 等の複数の言語を触ったことがある人にとっては、Rust の設計思想や言語仕様の良さを感じることができ、非常によい学びになると考えます。

人材や情報の不足

利用者が増加傾向ではあるものの、やはり Python や JavaScript などの主流なエンジニアに比べて Rust エンジニアは少数派です。また、情報についても多くは英語であり、日本語のドキュメントも他言語と比べるとまだ少ないです。ただし、着実に増えては来ています。

一方で、Rust を学ぶことで貴重な知識・技術を持っている技術者として人材価値を生み出すことができる言語であるともいえます。

まとめ

Rust は、C/C++ に匹敵する高いパフォーマンスと Python などのモダンな言語の開発効率を兼ね備えつつ、安全性の高いプログラミングができる現代的なプログラミング言語です。所有権や型安全性といったユニークな仕組みによってバグの少ない堅牢なシステム開発が可能です。

また、エコシステムの充実、大手企業での採用、WebAssembly や非同期処理といった先進技術への対応により、Rust は今後ますます活用の幅が広がっていくと考えられます。

初学者にとっては学習コストがやや高いですが、習得すれば大きな武器となる言語です。本サイトでは、Rust を学びたい方に向けて、分かりやすく実践的な記事を提供していきます。

Rust の魅力をぜひ一緒に体感し、学習に役立てていただければと思います。

あわせて読みたい

Rust プログラミング入門