サンプルコードで身につける: ジェネリック関数 — 型をパラメータにする

解説で学んだ概念を、5つの具体例で確認します。素朴な例から実務寄りの例へと進みます。

1どんな型でもそのまま返す identity

型パラメータ T を受け取ってそのまま返すだけの、最小のジェネリック関数です。i32 にも &str にも f64 にも、同じ1つの定義で対応できています。呼び出し時に型を書かなくても、引数から T が推論される点に注目してください。

Rust

fn identity<T>(value: T) -> T {
    value // T が何であってもそのまま返す
}

fn main() {
    let n = identity(42); // T = i32 と推論される
    let s = identity("hello"); // T = &str
    let f = identity(2.5); // T = f64
    println!("n = {}, s = {}, f = {}", n, s, f);
}

2型パラメータを2つ使う

<T, U> のように型パラメータは複数並べられ、それぞれ独立した型に決まります。文字列と数値、小数と真偽値など、どんな組み合わせでも1つの定義で組にできます。「型ごとに同じ関数を書き分けない」というジェネリクスの動機がいちばん見えやすい形です。

Rust

fn make_pair<T, U>(a: T, b: U) -> (T, U) {
    (a, b) // 2つの型パラメータは別々の型に決まる
}

fn main() {
    let item = make_pair("apple", 3); // T = &str, U = i32
    println!("{} を {} 個", item.0, item.1);

    let status = make_pair(99.5, true); // T = f64, U = bool
    println!("{} / {}", status.0, status.1);
}

3スライス &[T] を受け取る

要素の型をジェネリックにすれば、数値のスライスでも文字列のスライスでも同じ関数で先頭要素を返せます。戻り値の &T は「要素と同じ型への参照」という意味で、所有権を奪わない点も含めて汎用的です。標準ライブラリのスライス系メソッドの多くがこの形をしています。

Rust

fn first<T>(items: &[T]) -> &T {
    &items[0] // 要素の型が何でも先頭への参照を返せる
}

fn main() {
    let numbers = [10, 20, 30];
    println!("先頭の数値: {}", first(&numbers));

    let words = ["apple", "banana"];
    println!("先頭の単語: {}", first(&words));
}

4Vec<T> を扱うヘルパー関数

「Vec の末尾から1件取り出す」処理を、要素の型を問わないヘルパーとして切り出した例です。戻り値が Option<T> なのは空の Vec に備えるためで、ジェネリクスとエラー処理のレッスンが自然に組み合わさっています。タスクキューやスタック処理など、実務のデータ操作ヘルパーの典型です。

Rust

fn take_last<T>(items: &mut Vec<T>) -> Option<T> {
    items.pop() // pop は末尾の要素を Option<T> で返す
}

fn main() {
    let mut tasks = vec![String::from("設計"), String::from("実装")];
    match take_last(&mut tasks) {
        Some(task) => println!("取り出したタスク: {}", task),
        None => println!("タスクはもうない"),
    }
    println!("残り: {} 件", tasks.len());
}

5ジェネリックな構造体と impl<T>

Option<T> や Vec<T> と同じように、自作の構造体も <T> で型をパラメータにできます。impl<T> と書けば、メソッドもどの型に対しても1度だけ定義すれば済みます。実務では「中身の型だけ違う入れ物」(キャッシュ、ペア、レスポンスのラッパーなど)をこの形で作ります。

Rust

struct Pair<T> {
    first: T,
    second: T,
}

impl<T> Pair<T> {
    fn new(first: T, second: T) -> Self {
        Pair { first, second }
    }
    fn swapped(self) -> Pair<T> {
        Pair { first: self.second, second: self.first }
    }
}

fn main() {
    let p = Pair::new("前半", "後半").swapped();
    println!("{} / {}", p.first, p.second);
    let q = Pair::new(1, 2).swapped();
    println!("{} / {}", q.first, q.second);
}