Rustのジェネリクスを使ったカスタムイテレーター作成ガイド

Rustでジェネリクスを活用したカスタムイテレーターの作成方法について解説します。プログラミングにおけるイテレーターは、コレクションデータを効率的に処理するための重要な仕組みです。そしてRustでは、ジェネリクスを用いることで柔軟で再利用可能なコードを記述できます。本記事では、ジェネリクスの基本概念から、Rustのトレイトを利用したカスタムイテレーターの実装方法までを詳しく解説します。さらに、実用的な応用例や演習問題を通じて、理解を深める内容を提供します。Rustの強力な型システムを活かし、より効果的なプログラムを書く方法を学びましょう。

ジェネリクスとイテレーターの基本概念

Rustにおけるジェネリクスとイテレーターは、柔軟性と効率性を実現するための基本的な要素です。ここでは、それぞれの概念と重要性について解説します。

ジェネリクスとは

ジェネリクスとは、型に依存しないコードを記述するための仕組みです。ジェネリクスを使用することで、以下のようなメリットが得られます：

柔軟性

ジェネリクスを使用すると、同じコードで異なる型を処理することができます。例えば、数値型や文字列型など、さまざまなデータ型に対応可能です。

再利用性

型に依存しないため、汎用的な関数や構造体を作成できます。この結果、コードの重複を減らし、保守性が向上します。

イテレーターとは

イテレーターは、コレクションデータを順次処理するための抽象的な概念です。Rustでは、Iteratorトレイトがこれを実現します。

主要な特徴

効率的なデータ処理：必要なデータだけを順に処理するため、メモリ効率が高い。
関数型プログラミングのサポート：mapやfilterといった高階関数と組み合わせることで、簡潔で直感的なコードが書けます。

Rustでのイテレーターの基本的な使い方

以下は、Rustでの基本的なイテレーター使用例です：

let numbers = vec![1, 2, 3, 4, 5];
let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
println!("{:?}", doubled); // 出力: [2, 4, 6, 8, 10]

ジェネリクスとイテレーターを組み合わせる利点

ジェネリクスとイテレーターを組み合わせることで、さらに柔軟で効率的なコードを作成できます。例えば、異なる型のコレクションに対しても、統一された操作を行うことが可能になります。

次のセクションでは、Rustにおけるジェネリクスの基本構文について詳しく見ていきます。

Rustにおけるジェネリクスの基本構文

ジェネリクスはRustの型システムを最大限に活用するための強力な仕組みです。ここでは、ジェネリクスを使用した基本的なコードの書き方を解説します。

ジェネリクスの基本構文

Rustでは、ジェネリクスは<T>という形式で記述されます。このTは型パラメータを表し、任意の型に置き換えることができます。

関数でのジェネリクス

ジェネリクスを使った関数の例を以下に示します：

fn print_value<T: std::fmt::Debug>(value: T) {
    println!("{:?}", value);
}

fn main() {
    print_value(42);       // 整数型
    print_value("Hello");  // 文字列型
}

この例では、Tがジェネリックな型パラメータです。関数print_valueは任意の型の値を受け取ることができ、Debugトレイトを実装している型であればどのような型でも使用可能です。

構造体でのジェネリクス

ジェネリクスを使用して構造体を定義することもできます：

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

fn main() {
    let pair = Pair { first: 1, second: 2 };
    println!("Pair: ({}, {})", pair.first, pair.second);
}

この構造体Pairは、同じ型の2つのフィールドを持つジェネリックな構造体です。

列挙型でのジェネリクス

列挙型にもジェネリクスを適用できます：

enum Option<T> {
    Some(T),
    None,
}

fn main() {
    let some_number = Option::Some(5);
    let some_string = Option::Some("Hello");
}

Optionは標準ライブラリにも存在する型ですが、これは任意の型Tを保持できるジェネリックな列挙型の例です。

トレイト境界

ジェネリクスに型制約を加える場合は、トレイト境界を使用します：

fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b
}

この例では、Addトレイトを実装している型に限定して、ジェネリック関数addを定義しています。

ジェネリクスを使う際の注意点

コンパイル時に型が確定：Rustでは、ジェネリクスはコンパイル時に具体的な型に展開されるため、高速な実行コードが生成されます。
適切なトレイト境界の指定：ジェネリクスを使う場合、型制約を正確に指定することで、コードの安全性と可読性を向上させることが重要です。

次のセクションでは、ジェネリクスとイテレーターを使うことで得られるメリットについて説明します。

イテレーターを作成するメリット

カスタムイテレーターを作成することは、Rustのプログラムを効率化し、柔軟性を向上させるための強力な方法です。このセクションでは、イテレーターを作成する利点とその実用性について解説します。

1. コードの効率化

イテレーターを利用すると、データの操作や変換を簡潔に記述できます。これにより、繰り返し処理に関する複雑なコードが不要になり、メモリ効率も向上します。

例: ベクタの変換

次のコードは、イテレーターを使ったデータ変換の例です：

let numbers = vec![1, 2, 3, 4, 5];
let squared: Vec<i32> = numbers.iter().map(|x| x * x).collect();
println!("{:?}", squared); // 出力: [1, 4, 9, 16, 25]

イテレーターを使うことで、複雑なループを明確で簡潔な形式に置き換えられます。

2. 再利用性の向上

カスタムイテレーターを作成することで、特定の処理ロジックを簡単に再利用できます。たとえば、フィルタリングや特定の演算を行うカスタムロジックを一度定義すれば、複数の場面で活用できます。

例: カスタムイテレーターでの特定条件のフィルタリング

以下は、フィルタリング処理をカスタムイテレーターで再利用する例です：

struct EvenNumbers {
    current: i32,
    max: i32,
}

impl Iterator for EvenNumbers {
    type Item = i32;

    fn next(&mut self) -> Option<Self::Item> {
        self.current += 1;
        if self.current <= self.max && self.current % 2 == 0 {
            Some(self.current)
        } else {
            None
        }
    }
}

fn main() {
    let evens = EvenNumbers { current: 0, max: 10 };
    for num in evens {
        println!("{}", num);
    }
}

この例では、特定の条件（偶数のみ）に基づいて数値を生成するカスタムイテレーターを作成しています。

3. 遅延評価による効率的なデータ処理

イテレーターの遅延評価特性により、データの生成や処理が必要なタイミングまで実行されないため、大量のデータを扱う場合でもメモリの使用量を最小限に抑えることができます。

例: 無限イテレーター

以下のコードは、遅延評価の例です：

let infinite = (1..).filter(|x| x % 2 == 0).take(5).collect::<Vec<_>>();
println!("{:?}", infinite); // 出力: [2, 4, 6, 8, 10]

このコードでは、無限に続く範囲から必要なデータだけを取り出すことで効率的な処理を実現しています。

4. 関数型プログラミングとの親和性

Rustのイテレーターは、map、filter、foldなどの高階関数と組み合わせて、関数型プログラミングスタイルでコードを記述することを可能にします。これにより、プログラムの意図を明確に表現できます。

例: データ集約

let sum: i32 = (1..=5).fold(0, |acc, x| acc + x);
println!("{}", sum); // 出力: 15

この例では、イテレーターを使ってデータの集約処理を簡潔に記述しています。

次のセクションでは、Rustにおけるイテレーターの実装に必要な基本トレイトについて解説します。

イテレーターを実装する際の重要なトレイト

Rustでイテレーターをカスタム実装するには、Iteratorトレイトとその関連メソッドの理解が欠かせません。このセクションでは、イテレーターの基本トレイトと実装の際に重要なポイントを解説します。

`Iterator`トレイトとは

Iteratorトレイトは、イテレーターを実現するためのRust標準ライブラリに定義されたトレイトです。このトレイトを実装することで、カスタムイテレーターを作成できます。

主なメソッド

nextメソッド
Iteratorトレイトを実装する際に必須となる唯一のメソッドです。次の値を生成する処理を定義します。

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

戻り値: Option<Self::Item>
- Some(value)：次の値が存在する場合に返す。
- None：イテレーションが終了した場合に返す。

size_hintメソッド（任意）
イテレーターの残りの要素数のヒントを返します。デフォルトではオーバーライド不要です。

基本的なイテレーターの実装例

以下は、単純なカウンターを実装した例です：

struct Counter {
    current: usize,
    max: usize,
}

impl Iterator for Counter {
    type Item = usize;

    fn next(&mut self) -> Option<Self::Item> {
        if self.current < self.max {
            self.current += 1;
            Some(self.current)
        } else {
            None
        }
    }
}

fn main() {
    let mut counter = Counter { current: 0, max: 5 };
    while let Some(value) = counter.next() {
        println!("{}", value);
    }
}

トレイトを活用した高度なイテレーターの作成

イテレーターを強化するために、以下のようなトレイトを組み合わせることができます：

1. `DoubleEndedIterator`

このトレイトを実装すると、前方向と後方向の両方にイテレーションできるようになります。

impl DoubleEndedIterator for Counter {
    fn next_back(&mut self) -> Option<Self::Item> {
        if self.max > self.current {
            self.max -= 1;
            Some(self.max)
        } else {
            None
        }
    }
}

2. `ExactSizeIterator`

イテレーターのサイズが正確に計算できる場合に実装します。これにより、性能向上が見込まれます。

カスタムイテレーターを作成する際の注意点

Option型の活用: nextメソッドは値がない場合に必ずNoneを返すように設計します。
イミュータブル設計: カスタムイテレーターは通常ミュータブルに使用されるため、設計段階で考慮します。
トレイト境界: 必要に応じて、トレイト境界を明確に指定します。

次のセクションでは、カスタムイテレーターを実際に作成する具体的な手順を解説します。

実際にカスタムイテレーターを実装してみる

ここでは、Rustでカスタムイテレーターを実装する具体的な手順を紹介します。カウンター（指定した範囲内の値を順に返すイテレーター）を例に、基本的な構造とコード例を解説します。

ステップ1: データ構造を定義する

カスタムイテレーターに必要な情報を格納するデータ構造を定義します。

struct Counter {
    current: usize,
    max: usize,
}

ここでは、Counter構造体に現在のカウント値（current）と最大値（max）を格納します。

ステップ2: `Iterator`トレイトを実装する

Iteratorトレイトを実装し、nextメソッドを定義します。

impl Iterator for Counter {
    type Item = usize;

    fn next(&mut self) -> Option<Self::Item> {
        if self.current < self.max {
            self.current += 1;
            Some(self.current)
        } else {
            None
        }
    }
}

type Item: イテレーターが生成する値の型を指定します（ここではusize）。
nextメソッド: Some(value)またはNoneを返すことで、次の値を生成します。

ステップ3: 使用例

カスタムイテレーターを利用する例を示します。

fn main() {
    let counter = Counter { current: 0, max: 5 };

    for value in counter {
        println!("{}", value);
    }
}

出力結果：

ステップ4: イテレーターにカスタムロジックを追加する

さらにカスタムロジックを加えることで、より実用的なイテレーターを作成できます。例えば、偶数だけを返すカウンターを作成する場合：

struct EvenCounter {
    current: usize,
    max: usize,
}

impl Iterator for EvenCounter {
    type Item = usize;

    fn next(&mut self) -> Option<Self::Item> {
        self.current += 1;
        while self.current <= self.max {
            if self.current % 2 == 0 {
                return Some(self.current);
            }
            self.current += 1;
        }
        None
    }
}

fn main() {
    let even_counter = EvenCounter { current: 0, max: 10 };

    for value in even_counter {
        println!("{}", value);
    }
}

出力結果：

ステップ5: イテレーターの特性を活用する

作成したカスタムイテレーターは、RustのイテレーターAPI（map、filter、collectなど）と組み合わせてさらに強力になります。

fn main() {
    let counter = Counter { current: 0, max: 10 };
    let doubled: Vec<_> = counter.map(|x| x * 2).collect();

    println!("{:?}", doubled);
}

出力結果：

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

カスタムイテレーターを作成する際のポイント

必要なデータを簡潔に保持する構造体を設計する。
nextメソッドで処理を明確に記述し、Option型を適切に返す。
イテレーターAPIを活用し、再利用性を高める。

次のセクションでは、ジェネリクスとトレイトを組み合わせた高度なカスタムイテレーターの実装方法を解説します。

ジェネリクスとトレイトを組み合わせた実装

Rustのジェネリクスとトレイトを組み合わせることで、汎用性が高く柔軟なカスタムイテレーターを作成できます。このセクションでは、型に依存しないイテレーターを構築し、トレイト境界を利用した強力な型制約を実現する方法を解説します。

ジェネリクスを活用したイテレーターの作成

ジェネリクスを導入すると、異なる型のデータに対して同じロジックを適用できます。以下の例では、カスタムイテレーターをジェネリクス化しています。

例: 任意の型をサポートするイテレーター

struct GenericCounter<T> {
    current: T,
    step: T,
    max: T,
}

impl<T> Iterator for GenericCounter<T>
where
    T: std::ops::Add<Output = T> + PartialOrd + Copy,
{
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        if self.current < self.max {
            let next_value = self.current;
            self.current = self.current + self.step;
            Some(next_value)
        } else {
            None
        }
    }
}

fn main() {
    let counter = GenericCounter {
        current: 0,
        step: 2,
        max: 10,
    };

    for value in counter {
        println!("{}", value);
    }
}

出力結果：

トレイト境界の活用

この実装ではトレイト境界を指定することで、ジェネリクス型が加算可能（Addトレイト）であること、比較可能（PartialOrdトレイト）であることを保証しています。

トレイト境界のポイント

型制約を追加: 必要な操作や特性を型に制約することで、安全性と意図した動作を保証します。
組み合わせの柔軟性: 複数のトレイトを組み合わせて指定できます（例：T: Add + PartialOrd）。

トレイトオブジェクトを用いた動的ディスパッチ

場合によっては、トレイトオブジェクトを使用して異なる型を動的に扱うこともできます。以下はその例です。

例: トレイトオブジェクトを利用した動的イテレーション

trait CustomIterator {
    fn next_value(&mut self) -> Option<i32>;
}

struct StepIterator {
    current: i32,
    step: i32,
    max: i32,
}

impl CustomIterator for StepIterator {
    fn next_value(&mut self) -> Option<i32> {
        if self.current < self.max {
            let result = self.current;
            self.current += self.step;
            Some(result)
        } else {
            None
        }
    }
}

fn use_iterator(iterator: &mut dyn CustomIterator) {
    while let Some(value) = iterator.next_value() {
        println!("{}", value);
    }
}

fn main() {
    let mut step_iterator = StepIterator {
        current: 0,
        step: 3,
        max: 15,
    };

    use_iterator(&mut step_iterator);
}

出力結果：

ジェネリクスとトレイトを組み合わせる利点

型に依存しない汎用性: ジェネリクスにより異なる型のデータを扱えます。
安全性の向上: トレイト境界を指定することで、不正な型の使用を防げます。
コードの再利用性: 同じイテレーションロジックを多くの場面で適用可能です。

次のセクションでは、これまでの実装を活用した応用例を紹介します。

カスタムイテレーターを活用した応用例

カスタムイテレーターを使うことで、データ操作や変換、条件フィルタリングなど、さまざまな実用的な問題を効率よく解決できます。このセクションでは、具体的なユースケースをいくつか紹介します。

1. 条件フィルタリングの実装

特定の条件を満たすデータのみを返すイテレーターを実装します。以下は、偶数のみをフィルタリングする例です。

struct EvenFilter<I>
where
    I: Iterator<Item = i32>,
{
    iter: I,
}

impl<I> Iterator for EvenFilter<I>
where
    I: Iterator<Item = i32>,
{
    type Item = i32;

    fn next(&mut self) -> Option<Self::Item> {
        while let Some(value) = self.iter.next() {
            if value % 2 == 0 {
                return Some(value);
            }
        }
        None
    }
}

fn main() {
    let numbers = 1..10;
    let even_numbers = EvenFilter { iter: numbers };

    for value in even_numbers {
        println!("{}", value);
    }
}

出力結果：

2. 連続するデータペアの生成

データの連続する要素をペアとして返すカスタムイテレーターを実装します。

struct Pairwise<I>
where
    I: Iterator,
{
    iter: I,
    last: Option<I::Item>,
}

impl<I> Iterator for Pairwise<I>
where
    I: Iterator,
    I::Item: Clone,
{
    type Item = (I::Item, I::Item);

    fn next(&mut self) -> Option<Self::Item> {
        let next = self.iter.next();
        if let (Some(last), Some(next)) = (self.last.clone(), next.clone()) {
            self.last = Some(next);
            Some((last, next))
        } else {
            None
        }
    }
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let pairwise = Pairwise {
        iter: numbers.into_iter(),
        last: None,
    };

    for pair in pairwise {
        println!("{:?}", pair);
    }
}

出力結果：

(1, 2)
(2, 3)
(3, 4)
(4, 5)

3. 無限系列のカスタムイテレーター

例えば、フィボナッチ数列を生成する無限イテレーターを作成します。

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

impl Iterator for Fibonacci {
    type Item = u64;

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

fn main() {
    let fibonacci = Fibonacci { curr: 0, next: 1 };

    for value in fibonacci.take(10) {
        println!("{}", value);
    }
}

出力結果：

4. 複数のイテレーターの結合

複数のイテレーターを連結して扱うカスタムイテレーターを作成します。

struct Chain<I, J>
where
    I: Iterator,
    J: Iterator<Item = I::Item>,
{
    first: I,
    second: J,
}

impl<I, J> Iterator for Chain<I, J>
where
    I: Iterator,
    J: Iterator<Item = I::Item>,
{
    type Item = I::Item;

    fn next(&mut self) -> Option<Self::Item> {
        self.first.next().or_else(|| self.second.next())
    }
}

fn main() {
    let iter1 = vec![1, 2, 3].into_iter();
    let iter2 = vec![4, 5, 6].into_iter();
    let chained = Chain {
        first: iter1,
        second: iter2,
    };

    for value in chained {
        println!("{}", value);
    }
}

出力結果：

応用のメリット

柔軟性: 特定の処理に特化したイテレーターを簡単に作成可能。
効率性: 遅延評価により、必要なデータだけを処理できる。
再利用性: 共通のロジックを抽象化して複数の場面で活用可能。

次のセクションでは、カスタムイテレーターを練習するための演習問題を紹介します。

演習問題：自分でカスタムイテレーターを作成する

ここでは、ジェネリクスやトレイトを活用したカスタムイテレーターを自分で作成するための練習問題を提供します。解答例も提示するので、挑戦してみてください。

問題1: 範囲内の素数を生成するイテレーター

概要: 指定した範囲内の素数を順に返すイテレーターを作成してください。

要件:

範囲の開始値と終了値を指定可能。
素数判定には効率的なアルゴリズムを使用する（エラトステネスの篩でなくても可）。

ヒント:

素数は1と自分自身以外で割り切れない数です。

解答例:

struct PrimeIterator {
    current: u32,
    max: u32,
}

impl PrimeIterator {
    fn is_prime(n: u32) -> bool {
        if n < 2 {
            return false;
        }
        for i in 2..=((n as f64).sqrt() as u32) {
            if n % i == 0 {
                return false;
            }
        }
        true
    }
}

impl Iterator for PrimeIterator {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        while self.current <= self.max {
            let num = self.current;
            self.current += 1;
            if PrimeIterator::is_prime(num) {
                return Some(num);
            }
        }
        None
    }
}

fn main() {
    let primes = PrimeIterator { current: 2, max: 30 };

    for prime in primes {
        println!("{}", prime);
    }
}

出力結果:

問題2: 繰り返し処理を行うイテレーター

概要: 任意の要素を指定回数繰り返し返すイテレーターを作成してください。

要件:

要素と繰り返し回数を指定できる構造体を作成する。
繰り返し回数が0になったらNoneを返す。

ヒント:

要素はジェネリクス型で実装する。

解答例:

struct Repeat<T> {
    item: T,
    count: usize,
}

impl<T: Clone> Iterator for Repeat<T> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        if self.count > 0 {
            self.count -= 1;
            Some(self.item.clone())
        } else {
            None
        }
    }
}

fn main() {
    let repeated = Repeat { item: "hello", count: 3 };

    for value in repeated {
        println!("{}", value);
    }
}

出力結果:

hello
hello
hello

問題3: カスタム条件で値をスキップするイテレーター

概要: 元のイテレーターに対して、カスタム条件を満たす要素をスキップするラッパーイテレーターを作成してください。

要件:

元のイテレーターを受け取り、特定条件を満たす要素をスキップする。
条件はクロージャとして渡す。

解答例:

struct SkipIf<I, F>
where
    I: Iterator,
    F: Fn(&I::Item) -> bool,
{
    iter: I,
    predicate: F,
}

impl<I, F> Iterator for SkipIf<I, F>
where
    I: Iterator,
    F: Fn(&I::Item) -> bool,
{
    type Item = I::Item;

    fn next(&mut self) -> Option<Self::Item> {
        while let Some(value) = self.iter.next() {
            if !(self.predicate)(&value) {
                return Some(value);
            }
        }
        None
    }
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let skip_even = SkipIf {
        iter: numbers.into_iter(),
        predicate: |x| x % 2 == 0,
    };

    for value in skip_even {
        println!("{}", value);
    }
}

出力結果:

1
3
5

挑戦のまとめ

これらの演習問題を通じて、ジェネリクスやトレイトを活用したカスタムイテレーターの実装に慣れることができます。次のセクションでは、本記事のまとめを行います。

まとめ

本記事では、Rustにおけるジェネリクスを活用したカスタムイテレーターの作成方法を解説しました。イテレーターの基本概念から、ジェネリクスやトレイトを組み合わせた実装、さらには実用的な応用例や演習問題を通じて、イテレーターの強力さと柔軟性を学びました。

ジェネリクスを活用することで、型に依存しない汎用的なコードが書ける一方で、トレイト境界を活用することで安全性を担保できます。また、カスタムイテレーターを作成することで、効率的なデータ処理や再利用性の高いロジックを構築できます。

これらの知識を活用して、より洗練されたRustプログラムを作成し、プロジェクトの質を向上させてください。

Rustのジェネリクスを使ったカスタムイテレーター作成ガイド

ジェネリクスとイテレーターの基本概念

ジェネリクスとは

柔軟性

再利用性

イテレーターとは

主要な特徴

Rustでのイテレーターの基本的な使い方

ジェネリクスとイテレーターを組み合わせる利点

Rustにおけるジェネリクスの基本構文

ジェネリクスの基本構文

関数でのジェネリクス

構造体でのジェネリクス

列挙型でのジェネリクス

トレイト境界

ジェネリクスを使う際の注意点

イテレーターを作成するメリット

1. コードの効率化

例: ベクタの変換

2. 再利用性の向上

例: カスタムイテレーターでの特定条件のフィルタリング

3. 遅延評価による効率的なデータ処理

例: 無限イテレーター

4. 関数型プログラミングとの親和性

例: データ集約

イテレーターを実装する際の重要なトレイト

`Iterator`トレイトとは

主なメソッド

基本的なイテレーターの実装例

トレイトを活用した高度なイテレーターの作成

1. `DoubleEndedIterator`

2. `ExactSizeIterator`

カスタムイテレーターを作成する際の注意点

実際にカスタムイテレーターを実装してみる

ステップ1: データ構造を定義する

ステップ2: `Iterator`トレイトを実装する

ステップ3: 使用例

ステップ4: イテレーターにカスタムロジックを追加する

ステップ5: イテレーターの特性を活用する

カスタムイテレーターを作成する際のポイント

ジェネリクスとトレイトを組み合わせた実装

ジェネリクスを活用したイテレーターの作成

例: 任意の型をサポートするイテレーター

トレイト境界の活用

トレイト境界のポイント

トレイトオブジェクトを用いた動的ディスパッチ

例: トレイトオブジェクトを利用した動的イテレーション

ジェネリクスとトレイトを組み合わせる利点

カスタムイテレーターを活用した応用例

1. 条件フィルタリングの実装

2. 連続するデータペアの生成

3. 無限系列のカスタムイテレーター

4. 複数のイテレーターの結合

応用のメリット

演習問題：自分でカスタムイテレーターを作成する

問題1: 範囲内の素数を生成するイテレーター

問題2: 繰り返し処理を行うイテレーター

問題3: カスタム条件で値をスキップするイテレーター

挑戦のまとめ

まとめ

コメント

コメントする コメントをキャンセル

コメントするコメントをキャンセル