Rustイテレータの仕組みを理解する：遅延評価から最適化までを学ぼう

2026年5月27日

標準ライブラリ

Rustというプログラミング言語において、イテレータは単なるループの代用品ではなく、安全性と高効率を両立させるための心臓部とも言える機能です。

多くのプログラミング言語がイテレータを採用していますが、Rustのそれは「ゼロコスト抽象化」という設計思想を最も象徴する存在の一つです。

本記事では、Rustのイテレータがどのように動作し、なぜこれほどまでに高速なのか、その内部構造から最適化の仕組みまでを詳しく解き明かしていきます。

初心者の方から、よりパフォーマンスを追求したい中級者の方まで、次世代のRustプログラミングに役立つ知識を提供します。

目次 [ close ]

イテレータの基本概念とIteratorトレイト

Rustのイテレータとは、一連の要素に対して順番にアクセスするための共通インターフェースです。

このインターフェースの中心にあるのが、標準ライブラリで定義されている Iterator トレイトです。

Iterator トレイトを実装するには、next というメソッドを定義するだけで十分です。

この next メソッドは、呼び出されるたびにコレクションから次の要素を Option<Item> 型として返します。

要素が存在する場合は Some(item) を返し、すべての要素を返し終えた後は None を返します。

以下に、最もシンプルなイテレータの使用例を示します。

Rust

fn main() {
    let v = vec![1, 2, 3];
    // ベクタからイテレータを作成
    let mut iter = v.iter();

    // next()を呼び出して要素を取得
    assert_eq!(iter.next(), Some(&1));
    assert_eq!(iter.next(), Some(&2));
    assert_eq!(iter.next(), Some(&3));
    assert_eq!(iter.next(), None);
}

Iteratorトレイトの定義

Iterator トレイトの定義は、非常にシンプルながらも拡張性に富んでいます。

関連型（Associated Type）である Item を通じて、イテレータがどのような型の値を返すかを指定します。

Rust

pub trait Iterator {
    type Item;

    // このメソッドを実装することが必須
    fn next(&mut self) -> Option<Self::Item>;

    // 他にも多くのメソッドがデフォルト実装として提供されている
}

Rustのイテレータの強みは、この next メソッドを基盤として、100種類近い便利なメソッドがデフォルトで提供されている点にあります。

遅延評価 (Lazy Evaluation) の仕組みとメリット

Rustのイテレータにおける最大の特徴は、「遅延評価（Lazy Evaluation）」という性質です。

遅延評価とは、実際に値が必要になるまで計算を行わない仕組みのことを指します。

例えば、map や filter といったメソッドを呼び出しただけでは、コレクションの要素に対して何の処理も行われません。

これらは「イテレータアダプタ」と呼ばれ、元のイテレータをラップした新しいイテレータ構造体を返すだけです。

実際の計算は、collect や for ループなどの「コンシューマ（消費者）」メソッドが呼び出された瞬間に開始されます。

Rust

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

    // この時点では何も実行されない（計算コストはほぼゼロ）
    let iter = v.iter().map(|x| {
        println!("加工中: {}", x);
        x * 2
    });

    println!("イテレータを定義しました");

    // collectを呼び出すことで初めて計算が動き出す
    let result: Vec<i32> = iter.collect();
    println!("結果: {:?}", result);
}

実行結果

イテレータを定義しました
加工中: 1
加工中: 2
加工中: 3
加工中: 4
加工中: 5
結果: [2, 4, 6, 8, 10]

遅延評価がもたらすパフォーマンスの最適化

遅延評価には、メモリ使用量を抑え、不要な計算を避けるという大きなメリットがあります。

例えば、数百万件のデータに対して複数のフィルタリングを行う場合、中間的な一時ベクタを作成する必要がありません。

複数の処理を一つのパイプラインとして連結し、要素ごとに一気に処理を適用できるため、CPUキャッシュを効率的に活用できます。

所有権とイテレータの関係：iter, iter_mut, into_iter

Rustの厳格な所有権システムは、イテレータの設計にも深く関わっています。

コレクションからイテレータを生成する際、どのように要素にアクセスしたいかに応じて3つの主要なメソッドを使い分ける必要があります。

メソッド	返す型	所有権の扱い
`iter()`	`&T` (不変参照)	要素を借用する（元のコレクションはそのまま）
`iter_mut()`	`&mut T` (可変参照)	要素を可変で借用する（値を書き換え可能）
`into_iter()`	`T` (値そのもの)	所有権を消費する（元のコレクションは使えなくなる）

これらの使い分けを誤ると、コンパイルエラーが発生し、メモリ安全性が保証されます。

不変の参照が必要な場合は iter() を使い、ループ内で値を書き換えたい場合は iter_mut() を選択します。

もし、ループ後に元のコレクションを使用する予定がないのであれば、into_iter() を使って所有権を移動させるのが最も効率的です。

頻出するアダプタと消費者の活用パターン

Rustのイテレータを使いこなすには、多くのアダプタメソッドとコンシューマメソッドを組み合わせるパターンを覚えるのが近道です。

主要なイテレータアダプタ

アダプタはイテレータを変換し、別のイテレータを返します。

map(): 各要素に関数を適用して別の値に変換します。
filter(): 条件に一致する要素だけを残します。
take(n): 最初の n 個の要素だけを取り出します。
enumerate(): 要素にインデックス（番号）を付与します。
zip(): 2つのイテレータを組み合わせてペア（タプル）を作ります。

主要なコンシューマ（消費者）

コンシューマはイテレータを消費して、最終的な結果を導き出します。

collect(): イテレータの要素を Vec や HashMap などのコレクションにまとめます。
fold(): 初期値に対して各要素を順番に適用し、単一の値を生成します。
find(): 条件に合う最初の要素を検索します。
any(): いずれかの要素が条件を満たすか判定します。
all(): すべての要素が条件を満たすか判定します。

Rust

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];

    // 偶数だけを抽出し、それぞれを2乗して、合計を計算する
    let sum: i32 = numbers.iter()
        .filter(|&&x| x % 2 == 0) // 偶数のみ
        .map(|x| x * x)           // 2乗する
        .sum();                   // 合計

    println!("偶数の2乗の合計: {}", sum);
}

実行結果

偶数の2乗の合計: 56

イテレータのパフォーマンスと最適化

「イテレータを使うと、手動で for ループを書くよりも遅くなるのではないか？」という懸念を抱く方もいるかもしれません。

しかし、Rustにおいてその心配はほとんど不要です。

Rustのコンパイラ（LLVM）は、イテレータの連鎖を高度に最適化し、手書きのループと同等か、場合によってはそれ以上のバイナリを生成します。

これを実現しているのが、インライン化（Inlining）とループアンローリング（Loop Unrolling）です。

イテレータを使用することで、境界チェック（Bounds Check）を回避できることも大きな利点です。

通常の for i in 0..v.len() というインデックス指定のループでは、各アクセスごとに範囲内チェックが行われます。

一方、イテレータは内部的にポインタを移動させる仕組みであるため、コンパイラは安全性を確信した上で境界チェックを省略できます。

結果として、「抽象化によるオーバーヘッドはゼロ」というRustの約束が守られています。

カスタムイテレータの実装方法

独自のデータ構造を作成した際、それに対してイテレータを提供したい場合があります。

そのためには、自分の型に対して Iterator トレイトを実装します。

例として、指定された範囲のフィボナッチ数列を生成するイテレータを考えてみましょう。

Rust

struct Fibonacci {
    curr: u32,
    next: u32,
}

impl Fibonacci {
    fn new() -> Self {
        Fibonacci { curr: 0, next: 1 }
    }
}

// Iteratorトレイトを実装
impl Iterator for Fibonacci {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        let new_next = self.curr + self.next;
        self.curr = self.next;
        self.next = new_next;

        // 無限に続くが、今回は単純化のためOptionで包んで返す
        Some(self.curr)
    }
}

fn main() {
    let fib = Fibonacci::new();
    
    // カスタムイテレータも標準のメソッドがすべて使える
    for num in fib.take(10) {
        println!("{}", num);
    }
}

このように next を定義するだけで、take や filter といった強力な機能を自作の型でも利用できるようになります。

これこそが、Rustのトレイトシステムの美しさです。