イテレータとは

イテレータ（Iterator）は、値の列を生成する値で、要素を順番に取り出すことができる仕組みです。Rust では、文字列や Vec などから要素を取り出して処理するイテレータが用意されています。他にも、様々な場面でイテレータの仕組みが利用されています。

Rust の for 文はイテレータにとって自然に扱える構文となっており、シンプルなプログラム例は以下のようなものです。

fn main() {
    let v = vec![1, 2, 3];

    for x in v {
        println!("{}", x);
    }
}

【実行結果】
1
2
3

Rust では、このような繰り返し処理の多くがイテレータを使って実装されており、Rust における重要な仕組みです。Rust のイテレータは、具体的には、Iterator トレイトや IntoIterator トレイトにより表現されています。

この記事では、Rust のイテレータ（Iterator）の基本を解説します。

イテレータの基本

イテレータを実現する中心的なトレイトは、Iterator トレイトと IntoIterator トレイトです。ここでは、それぞれの概要について紹介します。

Iterator トレイト

Iterator トレイトは、以下のように定義されています。

pub trait Iterator {
    type Item;

    // Required method
    fn next(&mut self) -> Option<Self::Item>;

    ...(他のメソッドは省略)...
}

Item という取り出す要素の型と next メソッドを持ちます。独自の型に Iterator トレイトを実装する際には next メソッドは必須のメソッドになります。他にもトレイトで定義されているメソッドはありますが、明確に定義しない場合はデフォルト実装が使用されます。

next メソッド

next メソッドは、イテレータの中心となる重要なメソッドです。

fn main() {
    let v = vec![1, 2, 3];
    let mut iter = v.iter();

    println!("{:?}", iter.next()); // Some(1)
    println!("{:?}", iter.next()); // Some(2)
    println!("{:?}", iter.next()); // Some(3)
    println!("{:?}", iter.next()); // None
}

【実行結果】
Some(1)
Some(2)
Some(3)
None

iter メソッドは、対象のイテレータを取得します。（iter については後ほど説明します。）

イテレータにおける next メソッドは、順に要素を取り出し、値 x がある場合は、Option 型の Some(x) を返却します。要素を取り出し続け、取り出す要素がなくなったら最後に None を返却します。 イテレータは、Option 型を使って処理の終了を表現していることがポイントです。

v は、イミュータブル（変更不可）ですが、iter は mut を付けてミュータブル（変更可能）にしています。これは、next() メソッドがイテレータ自身の状態を更新するためであり、イテレータは mut で宣言する必要があります。

IntoIterator トレイト

IntoIterator トレイトは、イテレータを生成できる型を表すトレイトで、以下のように定義されています。

pub trait IntoIterator {
    type Item;
    type IntoIter: Iterator<Item = Self::Item>;

    // Required method
    fn into_iter(self) -> Self::IntoIter;
}

IntoIterator を実装している型は、into_iter メソッドによってイテレータに変換することができます。

into_iter メソッド

into_iter メソッドは、値や参照からイテレータを生成するメソッドです。into_iter() で理解しておくべきことは以下の通りです。対象 v に対してそれぞれ呼ばれる実装が変わります。

• (&v).into_iter()：不変参照のイテレータを生成する
• (&mut v).into_iter()：可変参照のイテレータを生成する
• v.into_iter()：所有権を移動するイテレータを生成する

以下の例を見てみましょう。

fn main() {
    let v1 = vec![1, 2, 3];

    // 不変参照のイテレータを作成
    for x in (&v1).into_iter() {
        println!("{}", x);
    }

    let mut v2 = vec![4, 5, 6];

    // 可変参照のイテレータを作成
    for x in (&mut v2).into_iter() {
        *x += 1; // 各要素に1を加える
        println!("{}", x);
    }

    let v3 = vec![7, 8, 9];

    // 所有権を移動するイテレータを作成
    for x in v3.into_iter() {
        println!("{}", x);
    }

    // v3は所有権が移動したため、ここで使用できない
    // println!("{:?}", v3); // コンパイルエラー
}

【実行結果】
1
2
3
5
6
7
7
8
9

このように、into_iter() は同じ名前のメソッドであっても、値に対して呼ぶのか、参照に対して呼ぶのかで返すイテレータの型が異なります。この違いは、IntoIterator が「値」「不変参照」「可変参照」のそれぞれに対して実装されていることによるものです。そのため、要素の型も T / &T / &mut T のように変化します。なお、T は型パラメータです。

for 文と Iterator の関係

Rust の for 文は、IntoIterator トレイトを実装している型に対して使用できます。つまり、for 文は内部的に into_iter() を呼び出し、イテレータとして要素を取り出しています。

for 文で繰り返し処理を実装する場合は、明示的に into_iter() を書かなくても、以下のように不変参照で繰り返し処理を行うことができます。なお、可変参照や所有権移動の場合も同様に考えることができます。

for x in &v {
    println!("{}", x);
}

これは、内部的には、概ね次のような処理が行われていると考えることができます。

fn main() {
    let v = vec![1, 2, 3];

    let mut iter = (&v).into_iter();

    while let Some(x) = iter.next() {
        println!("{}", x);
    }
}

つまり、「for x in &v」は、(&v).into_iter() を使ってイテレータを生成し、next() で要素を順番に取り出して処理をしているというイメージです。

コレクションにおける iter や iter_mut メソッド

Vec などのコレクションでは、Iterator を返すメソッドとして、iter メソッドや iter_mut メソッドが提供されています。名称の通り、iter メソッドは不変参照のイテレータを、iter_mut メソッドは、可変参照のイテレータを返却します。

以下の例で見てみましょう。

fn main() {
    let mut v = vec![1, 2, 3];

    // iter メソッドで不変参照のイテレータを返却
    for x in v.iter() {
        println!("{}", x);

        // 不変参照なので、以下のように値を変更することはできない
        // *x += 1;
    }

    // iter_mut メソッドで可変参照のイテレータを返却
    for x in v.iter_mut() {
        *x += 1;
        println!("{}", x);
    }
}

【実行結果】
1
2
3
2
3
4

例えば、iter を使用すると要素への不変参照を順番に取り出すことができます。不変参照なので、値を変更しようとするとコンパイルエラーとなります。一方で、iter_mut を使用すると要素への可変参照を取得できるため、要素の値を書き換えることができます。

ポイント

多くのコレクションでは以下のような対応関係があります。

• v.iter() は (&v).into_iter() に対応
• v.iter_mut() は (&mut v).into_iter() に対応

つまり、iter や iter_mut は、参照に対する into_iter() をより分かりやすく使うためのメソッドと考えることができます。ただし、誤解しやすいポイントですが、iter や iter_mut は、Iterator トレイトや IntoIterator トレイトで定義されているメソッドではありません。

これらは、Rust の標準ライブラリにおいて、コレクションがイテレータを生成するための便利なメソッドとして提供しているものです。そのため、必ずしも上記対応が保証されているわけではありませんので注意してください。

Iterator トレイトの必須メソッドとされている next や IntoIterator トレイトの必須メソッドとされている into_iter とは位置づけが異なることを理解しておきましょう。

まとめ

Rust におけるイテレータ（Iterator）の基本を解説しました。

イテレータは、値の列を生成する値で、要素を順番に取り出すことができる仕組みで for 文などの繰り返し処理で利用されます。

イテレータの中心となるのが、Iterator トレイトと IntoIterator トレイトです。この記事では、それぞれの必須メソッドである next や into_iter メソッドの役割について説明しました。また、for 文との関係や、Rust のコレクションで提供される iter、iter_mut といったメソッドについても紹介しました。

イテレータは、Rust のデータ処理の中心的な仕組みです。基本の考え方をしっかりと理解しておきましょう。

あわせて読みたい

Rust プログラミング入門

Rust のクロージャの型とトレイト

Rust におけるクロージャ（Closure）とは、「その場で定義できる無名の関数のようなもの」のことです。クロージャの使い方の基本については「クロージャの基本と使い方を分かりやすく解説」を参考にしてください。

この記事では、基本からは一段深く、クロージャの「型」と「トレイト」について踏み込んで紹介します。

クロージャの型

まずは、クロージャーの本質について確認してみましょう。結論から述べるとクロージャは、コンパイラが生成する固有の型です。

記事冒頭で「その場で定義できる無名の関数のようなもの」と説明しましたが、実際には「関数」ではありません。ここではその違いを具体的なコードで確認します。

関数の型とクロージャの型は異なる

Rust のクロージャは、以下のように使用することができます。

fn main() {
    // クロージャで使用する外部変数
    let base = 1;

    // クロージャーを定義
    let add_one_closure = |x| x + base;
    println!("クロージャーを呼び出す: {}", add_one_closure(5));
}

【実行結果】
クロージャーを呼び出す: 6

この例では、base という外部変数をキャプチャしています。これにより add_one_closure は引数 x に与えられた値に base の値を加算する機能を提供します。

では、このクロージャが関数として扱えるかを試してみましょう。以下の call_function は関数を引数として受け取り呼び出すだけの関数です。比較のために add_one という通常の関数を用意しています。

// 関数を引数として受け取り、呼び出す関数
fn call_function(f: fn(i32) -> i32, x: i32) -> i32 {
    f(x)
}

// 1を加算する通常の関数
fn add_one(x: i32) -> i32 {
    x + 1
}

fn main() {
    // クロージャで使用する外部変数
    let base = 1;

    // クロージャーを定義
    let add_one_closure = |x| x + base;
    println!("クロージャーを呼び出す: {}", add_one_closure(5));

    // 通常の関数を呼び出す
    println!(
        "通常の関数を call_function 経由で呼び出す: {}",
        call_function(add_one, 5)
    );

    // クロージャーを call_function に渡す。（これはエラーとなる）
    // println!(
    //     "クロージャーを call_function 経由で呼び出す: {}",
    //     call_function(add_one_closure, 5)
    // );
}

例の call_function は、「fn(i32) -> i32」という型を受け取ります。この型は、関数ポインタ型と呼ばれ、「i32 型を受け取り i32 型の結果を返す」ことを意味しています。

通常関数の add_one も、クロージャである add_one_closure も「i32 型を受け取り i32 型の結果を返す」という形式に一致しています。しかし、例でコメントアウトしているクロージャー add_one_closure を call_function に渡している部分はコンパイルエラーとなります。

理由はシンプルで、クロージャーの型は「fn(i32) -> i32」ではないためです。この結果から分かりますが、クロージャは、コンパイラが生成する固有の型となっています。

トレイト境界でクロージャと関数を同様に扱う

上記で、通常関数とクロージャは型が異なることが分かりました。しかし、関数にクロージャを渡して実行したいケースは非常に多くあります。関数とクロージャーを同じように扱う方法はないのでしょうか？もちろんあります。ポイントとなるのが Fn トレイトです。

次の例のようにトレイト境界を用いた call_function を使用すれば、通常関数もクロージャも両方受け取ることができるようになります。Fn トレイトについては詳細は後述しますので、一旦ここでは、このようにすることで対応できると理解していただければと思います

// クロージャも引数として受け取ることができる関数
fn call_function_closure<F>(f: F, x: i32) -> i32
where
    F: Fn(i32) -> i32,
{
    f(x)
}

// 1を加算する通常の関数
fn add_one(x: i32) -> i32 {
    x + 1
}

fn main() {
    // クロージャで使用する外部変数
    let base = 1;

    // クロージャーを定義
    let add_one_closure = |x| x + base;
    println!("クロージャーを呼び出す: {}", add_one_closure(5));

    // 通常の関数を呼び出す
    println!(
        "通常の関数を call_function 経由で呼び出す: {}",
        call_function_closure(add_one, 5)
    );

    // クロージャーを call_function_closure に渡す
    println!(
        "クロージャーを call_function_closure 経由で呼び出す: {}",
        call_function_closure(add_one_closure, 5)
    );
}

このようにすることで「通常の関数」と「クロージャ」をどちらも同じように扱うことができます。これは、通常の関数もクロージャも、Fn トレイトを通じて扱うことができるためです。

実は、クロージャは、常に同じトレイトを実装するわけではありません。外部変数のキャプチャ方法（不変参照、可変参照、所有権移動）によって実装されるトレイトが変わります。以降では、クロージャのトレイトについて説明していきます。

クロージャのトレイト（Fn / FnMut / FnOnce）

Rust では、この違いを表現するために、以下の 3 つのトレイトが用意されています。

• Fn：不変参照
• FnMut：可変参照
• FnOnce：所有権の移動

これらは、クロージャが外部の変数をどのように扱うかによって使い分けられます。以降では、クロージャのトレイトの違いについて詳しく見ていきます。

クロージャの基本記事「クロージャの基本と使い方を分かりやすく解説」で紹介しているクロージャのキャプチャ方法は、この各トレイトに相当しています。基本記事で使用したコードを再掲しながら確認してみましょう。

Fn トレイト（不変参照）

Fn トレイトは、外部の変数を変更せずに利用するクロージャに対して実装されるトレイトです。つまり、キャプチャした変数を「読み取るだけ」の 場合に Fn が実装されます。

fn main() {
    // ===== 不変参照でのキャプチャ例
    let x = 10;
    // x は不変参照でキャプチャされる
    let f = |y| x + y;

    // クロージャの呼び出し
    println!("f(5) = {}", f(5));
    // xはまだ使用可能
    println!("x = {}", x);
}

例では、x をクロージャの中で参照しているだけで変更していません。そのため、このクロージャは Fn トレイトを実装します。Fn のクロージャは、状態を変更しないため何度でも安全に呼び出すことができます。

FnMut トレイト（可変参照）

FnMut トレイトは、キャプチャした変数を「変更する」クロージャに対して実装されるトレイトです。

fn main() {
    // ===== 可変参照でのキャプチャ例
    let mut count = 0;
    println!("count before: {}", count);
    // countは可変参照でキャプチャされる
    let mut g = || count += 1;

    // クロージャを呼び出すとcountが変更される
    g();
    // countは変更されている
    println!("count after: {}", count);
}

例では、クロージャの中で count を変更しています。そのため、このクロージャは FnMut トレイトを実装します。

FnMut のクロージャは、キャプチャした変数を変更する可能性があります。そのため、呼び出し時には、クロージャ自身が変更される可能性があるため、クロージャを変数に束縛するには「let mut g」のように mut をつける必要があります。

FnOnce トレイト（所有権の移動）

FnOnce トレイトは、「キャプチャした値の所有権を消費する」クロージャに対して実装されるトレイトです。

fn main() {
    // ===== move による所有権の移動でのキャプチャ例
    let s = String::from("Hello");
    // s は move で所有権がクロージャに移動される
    let h = move || println!("{s} World!");

    // 実行時に s は消費されて使用できなくなる
    h();
    // sはmoveで所有権が移動されているため以降は使用できない
    // println!("{s}"); // コンパイルエラー
}

例では、move を使用して s の所有権をクロージャに移動しています。このような場合、クロージャはキャプチャした値を消費する可能性があるため、1 回しか安全に呼び出すことができません。そのため、このようなクロージャは FnOnce トレイトを実装します。

let s = String::from("Hello");
let h = || drop(s);

Fn / FnMut / FnOnce の関係性

上記で紹介したトレイトは、次のような関係になっています。

Fn ⊂ FnMut ⊂ FnOnce

上記図は「Fn は FnMut のサブトレイト」「FnMut は FnOnce のサブトレイト」という意味を表しています。つまり、Fn を実装するクロージャは FnMut としても扱うことができ、FnMut を実装するクロージャは FnOnce としてもあつかえるという関係になっています。

記事の前半で Fn をトレイト境界に持つ関数の例を紹介しましたが、この call_function は、FnMut のクロージャを受け取ることができません。一方で、FnMut をトレイト境界に持つ関数は、Fn トレイトのクロージャを受け取ることが可能となります。

ここまでで紹介してきたように、Rust では、クロージャの振る舞いに応じて Fn / FnMut / FnOnce のトレイトが自動的に決定されます。このような仕組みとなっていることをしっかり理解していただければと思います。

まとめ

Rust におけるクロージャ（Closure）の型とトレイト（Fn / FnMut / FnOnce）について解説しました。

クロージャは、通常の関数とは異なり、コンパイラが生成する固有の型です。一方で、トレイト境界を使うことで通常の関数と同じように扱うことができます。

また、クロージャは、キャプチャする外部変数の扱い方に応じて、Fn / FnMut / FnOnce のいずれかのトレイトを実装します。これらの違いを理解しておくことで、クロージャを引数として受け取る関数や所有権が関わるコードをより正確に理解して実装ができるようになります。

あわせて読みたい

Rust プログラミング入門

Rust のトレイト

トレイトとは

Rust におけるトレイト（trait）は、型に共通の振る舞いを定義する仕組みです。Haskell の型クラスに非常によく似ており、Java 等のオブジェクト指向言語ではインターフェースに近いものとなっています。

オブジェクト指向では、振る舞いをクラスに内包されたメソッドで定義しますが、Rust のトレイトではデータ構造（struct や enum）と振る舞い（trait）を分離する点で違いがあります。型そのものには基本的にはデータ構造しかなく、振る舞いはトレイトを後から付与して実装するという考え方です。

トレイトを使用することで、例えば「コンソールに出力ができる」「数値計算ができる」のような共通の振る舞いを定義し、型がその振る舞いをどのように実現するのかを実装できるようになります。

この記事では、トレイトの基本について分かりやすく解説します。

トレイトの定義と実装の基本

トレイトの説明をする際によく利用される図形を用いた例でトレイトを説明します。例えば、図形には、Circle（円）、Rectangle（矩形）などを色々と考えることができます。これらの図形に共通的なことを考えてみると「面積を計算できる」ということが挙げられます。

領域に関するトレイトを Area トレイトとして、面積を計算する振る舞いを area メソッドとして実装してみましょう。

use std::f64::consts::PI;

// 領域に関するトレイト
trait Area {
    // 面積を計算するメソッド
    fn area(&self) -> f64;
}

// 円の構造体の定義
struct Circle { radius: f64 }

// トレイトの実装 (Circle)
impl Area for Circle {
    fn area(&self) -> f64 {
        PI * self.radius * self.radius
    }
}

// 矩形の構造体の定義
struct Rectangle { width: f64, height: f64 }

// トレイトの実装 (Rectangle)
impl Area for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }
}

fn main() {
    let circle = Circle{
        radius: 5.0
    };
    let circle_area = circle.area();
    println!("Circle(radius={:.2}), Area: {:.2}", circle.radius, circle_area);

    let rect = Rectangle{
        width: 5.0,
        height: 10.5,
    };
    let rect_area = rect.area();
    println!("Rectangle(width={:.2}, height={:.2}), Area: {:.2}", rect.width, rect.height, rect_area);
}

【実行結果】
Circle(radius=5.00), Area: 78.54
Rectangle(width=5.00, height=10.50), Area: 52.50

Area トレイトは「trait Area {}」のように定義し、内部にはそのトレイトが持つべきメソッドの定義を「fn area(&self) -> f64;」のように型注釈を含めて記載します。なお、今回は area というメソッドのみですが Area という領域に関する振る舞いを他に定義したい場合は、複数のメソッドを定義可能です。

今回用意した円（Circle）や矩形（Rectangle）という型に Area トレイトを実装するには「impl Area for 型名 {}」のように定義し、内部では先ほど型注釈のみで実装はしていなかった area メソッドの具体的な実装を記載します。

なお、トレイトでは、トレイトが定義するメソッドを実装することを強制します。厳密には、後ほど説明するデフォルト実装がないメソッドの実装が必須です。

そのため、「impl Area for 型名 {}」と宣言したら、area メソッドの実装は必須です。もし他にもメソッドがトレイトで定義されていたら全てのメソッドを実装する必要があります。これにより、あるトレイトを持つ型は、そのトレイトで定義されているメソッドが確実に実装されているものとして安心して型を使用することができます。

main 関数では、各型をインスタンス化していますが、それぞれ Area トレイトを実装しているので area メソッドを使用して面積を計算できていることが分かります。他の形状の型が出てきた場合にも、それぞれに関する Area トレイトの実装を追加していくことができます。

トレイトのデフォルト実装

トレイトには「デフォルト実装」として基本となる実装を定義しておくことができます。デフォルト実装とは、もし型側で実装が行われなかった場合に使用される実装のことです。

Area トレイトに describe という面積を表示するメソッドを追加してデフォルト実装の例を見てみましょう。

use std::f64::consts::PI;

// 領域に関するトレイト
trait Area {
    // 面積を計算するメソッド
    fn area(&self) -> f64;
    // デフォルト実装
    fn describe(&self) {
        println!("Area: {:.2}", self.area())
    }
}

// 円の構造体の定義
struct Circle { radius: f64 }

// トレイトの実装 (Circle)
impl Area for Circle {
    fn area(&self) -> f64 {
        PI * self.radius * self.radius
    }
    // describe はデフォルト実装を使用
}

// 矩形の構造体の定義
struct Rectangle { width: f64, height: f64 }

// トレイトの実装 (Rectangle)
impl Area for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }
    // describeのデフォルト実装をオーバーライドしている
    fn describe(&self) {
        println!("Rectangle(width={:.2}, height={:.2}), Area: {:.2}", self.width, self.height, self.area());
    }
}

fn main() {
    let circle = Circle{
        radius: 5.0
    };
    let _circle_area = circle.area();
    circle.describe();

    let rect = Rectangle{
        width: 5.0,
        height: 10.5,
    };
    let _rect_area = rect.area();
    rect.describe();
}

【実行結果】
Area: 78.54
Rectangle(width=5.00, height=10.50), Area: 52.50

上記例では describe により area を呼び出した結果の面積の値を println で表示するようにしています。これにより、型で describe を実装していなくても「Area: xx.xx」と表示されるようになります。これがデフォルト実装です。

Circle 型に対する Area トレイトの実装には、describe に関する定義をしていませんが main 関数内では問題なく describe が使用できています。なお、デフォルト実装を用意していないメソッドを実装していない場合は「missing describe in implementation」というコンパイルエラーとなります。これは、トレイトが定義するメソッドの実装が強制されているためです。

一方で、Rectangle 型についてはdescribe メソッドを個別に定義してオーバーライドすることで、デフォルト実装とは異なる表示ができていることが分かります。

トレイトの自動実装 #[derive()]

トレイトの自動実装の使い方

Rust のトレイトでは、標準トレイトが用意されており、作成した型に対して #[derive()] を使用することで、トレイトを自動で実装することができます。

代表的な例としては、作成した型の情報を println で表示したい場合です。通常は、構造体名.フィールド名 というようにアクセスして表示する必要がありますが、標準トレイトに Debug というトレイトが用意されており、以下の例のように derive することで println の {:?} で型の値を表示することができるようになります。

// 円の構造体の定義
#[derive(Debug)]
struct Circle { radius: f64 }

// 矩形の構造体の定義
#[derive(Debug)]
struct Rectangle { width: f64, height: f64 }

fn main() {
    let circle = Circle{
        radius: 5.0
    };
    println!("{:?}", circle);

    let rect = Rectangle{
        width: 5.0,
        height: 10.5,
    };
    println!("{:?}", rect);
}

【実行結果】
Circle { radius: 5.0 }
Rectangle { width: 5.0, height: 10.5 }

Debug トレイトの自動実装を行うためには、型（struct）定義の上に「#[derive(Debug)]」というように記載します。他にも複数の標準トレイトを自動実装したい場合には「,」で列挙することが可能です。

これにより、main 関数内での println で {:?} とした部分に型のインスタンスを指定すると「Circle { radius: 5.0 }」や「Rectangle { width: 5.0, height: 10.5 }」といったように型名とフィールドの値を表現した形で表示することが可能になります。

トレイト自動実装が使える標準ライブラリのトレイト

Rust の標準ライブラリ（std）のドキュメントの Traitsで、標準ライブラリで定義されているトレイトの一覧を確認できます。各 Traits の参照先ドキュメントで、derive できるかどうかを確認することができます。代表的な derive できる標準トレイトには以下があります。

「Copy を実装する型は Clone も実装している必要がある」といったようなルールがある型については「#[derive(Copy, Clone)]」のようにセットで使用する必要があるので注意が必要です。列挙する場合の順序は関係ありません。

また、Debug が derive できるので std::fmt::Display でもできそうな気がしますが、Display トレイトは使用できません。Debug が開発者がとりあえず読める形で出せればよいという性質であるのに対して、Display はユーザー向けの整形出力で、状況に応じた文言やフォーマットを設計する必要があるため、自動実装の対象に含まれていません。

このように標準トレイトでも必ずしも自動実装が使えるわけではないことは覚えておいてください。また、自動実装で求めている機能を提供できるかは十分に確認してください。もし、求めている内容ではない場合には、自分で実装をしてオーバーライドする必要があります。

トレイト境界

トレイトは、共通の振る舞いを型に付与できるものでした。ジェネリックな関数を作成する際には、引数の型があるトレイトを実装している型のみを許容するように制限することができます。このような制約のことを「トレイト境界（Trait Bounds）」と言います。

例えば、以下のように面積を表示するような関数 show_area を定義してみます。

use std::f64::consts::PI;
use std::fmt::Debug;

// 領域に関するトレイト
trait Area {
    // 面積を計算するメソッド
    fn area(&self) -> f64;
}

// 円の構造体の定義
#[derive(Debug)]
struct Circle { radius: f64 }

// トレイトの実装 (Circle)
impl Area for Circle {
    fn area(&self) -> f64 {
        PI * self.radius * self.radius
    }
}

// 矩形の構造体の定義
#[derive(Debug)]
struct Rectangle { width: f64, height: f64 }

// トレイトの実装 (Rectangle)
impl Area for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }
}

// 面積を表示する関数 (トレイト境界)
fn show_area<T: Area + Debug>(shape: &T) {
    println!("{:?}, Area: {:.2}", shape, shape.area());
}

fn main() {
    let circle = Circle{
        radius: 5.0
    };
    show_area(&circle);

    let rect = Rectangle{
        width: 5.0,
        height: 10.5,
    };
    show_area(&rect);
}

【実行結果】
Circle { radius: 5.0 }, Area: 78.54
Rectangle { width: 5.0, height: 10.5 }, Area: 52.50

show_area では、型の情報を表示し、面積を計算した結果を表示するので Debug トレイトと Area トレイトを持った型を引数に受け取りたくなります。

このような場合でトレイト境界を指定するには、関数名の後ろに <T: Area + Debug> のように制約のトレイトを記載します。T はジェネリックの型パラメータで、Area と Debug が実装された任意の型ということを示します。複数のトレイトを制約として指定したい場合には「+」で記載します。Debug は「use std::fmt::Debug;」で宣言する必要があるので注意してください。

また、トレイト境界は以下のように where を使用しても表現可能です。ジェネリックの型パラメータが増えた場合には where を使用した方が可読性が上がる可能性があります。

// 面積を表示する関数 (トレイト境界を where 指定)
fn show_area<T>(shape: &T)
where T: Area + Debug
{
    println!("{:?}, Area: {:.2}", shape, shape.area());
}

ジェネリックな関数は、任意の型を受け取れる柔軟性がある一方で、関数の処理に適さない型を受け取ってしまうと予期せぬエラーが発生してしまいます。トレイト境界で、関数の処理の前提となる型の特徴を指定することができるので、安全に処理を実行できる関数を実現できます。

まとめ

Rust のトレイト（trait）の基本について解説しました。トレイトとは、型に共通の振る舞いを定義する仕組みで、Rust では、データ構造と振る舞いを分離して設計する特徴があります。

トレイトは、trait キーワードで定義し、各型に対して impl で実装をします。デフォルト実装を用意していないメソッドは必ず実装する必要があり、これにより型の利用者はトレイトのメソッドが実装されているものとして安心して利用できます。

Rust には標準トレイトが色々と用意されていますが、derive による自動実装が使用できます。便利である一方で Display のように自動実装できないものもあります。また、自動実装が求めている結果となるかはよく確認が必要です。

トレイトは、ジェネリックな関数に対してトレイト境界として、型が特定のトレイトを実装している必要があるという制約を表現できます。これにより安全で柔軟な関数設計ができます。

このようにトレイトは、Rust の柔軟で強力な型システムを支える重要な仕組みとなっています。単なる共通の振る舞いの定義にとどまらず、抽象化、コード再利用性、安全性の確保といった観点でも役に立ちます。ぜひ、トレイトの基本を理解してもらいたいと思います。

あわせて読みたい

Rust プログラミング入門

ジェネリック

ジェネリックとは

ジェネリック（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 プログラミング入門