# 外部イテレータの例（Pull型）
it = iter([1, 2, 3, 4, 5])
a = next(it)  # 1 --- クライアントが主導
b = next(it)  # 2 --- 好きなタイミングで取得
# 残りの 3, 4, 5 はまだ「取り出されていない」
 
# 内部イテレータの例（Push型）
[1, 2, 3, 4, 5].forEach(x => console.log(x))
# コレクション側がすべての要素を走査する
# クライアントは「各要素に何をするか」だけを指定

class Countdown:
    """カウントダウンイテレータの実装例"""
 
    def __init__(self, start):
        self.current = start
 
    def __iter__(self):
        return self
 
    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1
 
# 使用例
for n in Countdown(5):
    print(n)  # 5, 4, 3, 2, 1
 
# for ループの内部動作を展開すると:
it = iter(Countdown(5))   # __iter__() を呼ぶ
while True:
    try:
        n = next(it)      # __next__() を呼ぶ
        print(n)
    except StopIteration:
        break             # 終了

# イテラブルとイテレータの違い
lst = [1, 2, 3]
print(type(lst))         # <class 'list'> --- イテラブル
it = iter(lst)
print(type(it))          # <class 'list_iterator'> --- イテレータ
 
# イテラブルは何度でもイテレータを生成できる
for x in lst: pass  # 1回目
for x in lst: pass  # 2回目（問題なく動作）
 
# イテレータは使い切ると空になる
it = iter(lst)
list(it)  # [1, 2, 3]
list(it)  # [] --- 使い切った後は空

struct Countdown {
    current: u32,
}
 
impl Countdown {
    fn new(start: u32) -> Self {
        Countdown { current: start }
    }
}
 
impl Iterator for Countdown {
    type Item = u32;
 
    fn next(&mut self) -> Option<u32> {
        if self.current == 0 {
            None
        } else {
            self.current -= 1;
            Some(self.current + 1)
        }
    }
}
 
fn main() {
    // for ループで使用
    for n in Countdown::new(5) {
        println!("{}", n);  // 5, 4, 3, 2, 1
    }
 
    // IntoIterator トレイト: for ループの糖衣構文
    // for item in collection { ... }
    // は以下と等価:
    // let mut iter = collection.into_iter();
    // while let Some(item) = iter.next() { ... }
}

let v = vec![1, 2, 3];
 
// 1. iter(): 不変参照のイテレータ (&T)
for val in v.iter() {
    // val は &i32 型
    println!("{}", val);
}
// v はまだ使える
 
// 2. iter_mut(): 可変参照のイテレータ (&mut T)
let mut v2 = vec![1, 2, 3];
for val in v2.iter_mut() {
    // val は &mut i32 型
    *val *= 2;
}
// v2 は [2, 4, 6] に変更された
 
// 3. into_iter(): 所有権を移動するイテレータ (T)
for val in v.into_iter() {
    // val は i32 型（所有権が移動）
    println!("{}", val);
}
// v はもう使えない（所有権が移動した）

class Countdown {
    constructor(start) {
        this.start = start;
    }
 
    [Symbol.iterator]() {
        let current = this.start;
        return {
            next() {
                if (current <= 0) {
                    return { value: undefined, done: true };
                }
                return { value: current--, done: false };
            }
        };
    }
}
 
// for-of ループで使用
for (const n of new Countdown(5)) {
    console.log(n);  // 5, 4, 3, 2, 1
}
 
// スプレッド構文でも使用可能
const arr = [...new Countdown(5)];  // [5, 4, 3, 2, 1]
 
// 分割代入でも使用可能
const [a, b, c] = new Countdown(5);  // a=5, b=4, c=3

import java.util.Iterator;
 
class Countdown implements Iterable<Integer> {
    private final int start;
 
    Countdown(int start) {
        this.start = start;
    }
 
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int current = start;
 
            @Override
            public boolean hasNext() {
                return current > 0;
            }
 
            @Override
            public Integer next() {
                return current--;
            }
        };
    }
}
 
// 拡張 for ループで使用
for (int n : new Countdown(5)) {
    System.out.println(n);  // 5, 4, 3, 2, 1
}

// 基本的なアダプタチェーン
let result: Vec<i32> = (1..=100)
    .filter(|n| n % 3 == 0)      // 3の倍数
    .map(|n| n * n)               // 二乗
    .take(5)                      // 最初の5個
    .collect();
// => [9, 36, 81, 144, 225]
 
// 重要: collect() を呼ぶまで何も実行されない（遅延評価）
// 各要素は filter -> map -> take のパイプラインを1つずつ通過する

let v = vec![1, 2, 3, 4, 5];
 
// map: 各要素を変換
v.iter().map(|x| x * 2);                    // [2, 4, 6, 8, 10]
 
// filter: 条件を満たす要素のみ残す
v.iter().filter(|x| **x > 2);               // [3, 4, 5]
 
// filter_map: filter と map を同時に（None を除去）
v.iter().filter_map(|x| {
    if *x > 2 { Some(x * 10) } else { None }
}); // [30, 40, 50]
 
// take / skip: 先頭N個を取得 / スキップ
v.iter().take(3);                            // [1, 2, 3]
v.iter().skip(2);                            // [3, 4, 5]
 
// take_while / skip_while: 条件による取得/スキップ
v.iter().take_while(|x| **x < 4);           // [1, 2, 3]
v.iter().skip_while(|x| **x < 4);           // [4, 5]
 
// enumerate: インデックスを付与
v.iter().enumerate();                        // [(0,1), (1,2), (2,3), ...]
 
// zip: 2つのイテレータを結合
v.iter().zip(vec![10, 20, 30].iter());       // [(1,10), (2,20), (3,30)]
 
// chain: イテレータを連結
v.iter().chain(vec![6, 7].iter());           // [1,2,3,4,5,6,7]
 
// flat_map: 要素をイテレータに展開して平坦化
v.iter().flat_map(|x| vec![*x, *x * 10]);   // [1,10,2,20,3,30,4,40,5,50]
 
// flatten: ネストしたイテレータを平坦化
vec![vec![1,2], vec![3,4]].into_iter().flatten(); // [1,2,3,4]
 
// peekable: 次の要素を消費せずに覗く
let mut it = v.iter().peekable();
assert_eq!(it.peek(), Some(&&1));            // 覗くだけ
assert_eq!(it.next(), Some(&1));             // 消費
 
// scan: 状態を持つ変換（累積和など）
v.iter().scan(0, |acc, x| {
    *acc += x;
    Some(*acc)
}); // [1, 3, 6, 10, 15]
 
// inspect: デバッグ用（要素を変更せずに副作用を実行）
v.iter()
    .inspect(|x| println!("before filter: {}", x))
    .filter(|x| **x > 2)
    .inspect(|x| println!("after filter: {}", x))
    .collect::<Vec<_>>();

let v = vec![1, 2, 3, 4, 5];
 
// collect: コレクションに変換
let vec: Vec<_> = v.iter().collect();
let set: HashSet<_> = v.iter().collect();
let s: String = vec!['a', 'b', 'c'].into_iter().collect();
 
// sum / product: 合計 / 積
let total: i32 = v.iter().sum();             // 15
let product: i32 = v.iter().product();       // 120
 
// count: 要素数
v.iter().count();                             // 5
 
// any / all: 条件判定
v.iter().any(|x| *x > 3);                   // true
v.iter().all(|x| *x > 0);                   // true
 
// find: 条件を満たす最初の要素
v.iter().find(|x| **x > 3);                 // Some(&4)
 
// position: 条件を満たす最初のインデックス
v.iter().position(|x| *x > 3);              // Some(3)
 
// min / max: 最小/最大
v.iter().min();                               // Some(&1)
v.iter().max();                               // Some(&5)
 
// fold: 畳み込み（reduce の一般化）
v.iter().fold(0, |acc, x| acc + x);          // 15
 
// reduce: 初期値なしの畳み込み
v.iter().copied().reduce(|a, b| a + b);      // Some(15)
 
// for_each: 各要素に副作用を実行
v.iter().for_each(|x| println!("{}", x));

import itertools
 
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
# 組み込み関数によるイテレータ操作
list(map(lambda x: x ** 2, data))              # [1, 4, 9, 16, 25, ...]
list(filter(lambda x: x % 2 == 0, data))       # [2, 4, 6, 8, 10]
list(zip(data, range(10, 20)))                  # [(1,10), (2,11), ...]
list(enumerate(data))                           # [(0,1), (1,2), ...]
list(reversed(data))                            # [10, 9, 8, ..., 1]
sum(data)                                       # 55
min(data)                                       # 1
max(data)                                       # 10
any(x > 5 for x in data)                       # True
all(x > 0 for x in data)                       # True
 
# itertools による高度な操作
list(itertools.chain([1,2], [3,4], [5,6]))      # [1,2,3,4,5,6]
list(itertools.islice(range(100), 5, 10))       # [5,6,7,8,9]
list(itertools.takewhile(lambda x: x < 5, data))  # [1,2,3,4]
list(itertools.dropwhile(lambda x: x < 5, data))  # [5,6,...,10]
list(itertools.accumulate(data))                 # [1,3,6,10,15,...]
 
# groupby: 連続する同じキーの要素をグループ化
sorted_data = sorted(data, key=lambda x: x % 3)
for key, group in itertools.groupby(sorted_data, key=lambda x: x % 3):
    print(f"key={key}: {list(group)}")
 
# product / permutations / combinations: 組み合わせ生成
list(itertools.product('AB', '12'))         # [('A','1'),('A','2'),('B','1'),('B','2')]
list(itertools.permutations('ABC', 2))      # [('A','B'),('A','C'),('B','A'),...]
list(itertools.combinations('ABCD', 2))     # [('A','B'),('A','C'),...]
 
# tee: イテレータを複製
it1, it2 = itertools.tee(iter(data), 2)
# it1 と it2 は独立して走査できる

# 基本的なジェネレータ
def fibonacci():
    """フィボナッチ数列を無限に生成するジェネレータ"""
    a, b = 0, 1
    while True:
        yield a           # 値を返して中断
        a, b = b, a + b   # 再開時にここから続行
 
# 使用例: 無限シーケンスだが、必要な分だけ生成
fib = fibonacci()
for _ in range(10):
    print(next(fib))  # 0, 1, 1, 2, 3, 5, 8, 13, 21, 34
 
# ジェネレータ式（内包表記のジェネレータ版）
# リスト内包表記との比較
squares_list = [x**2 for x in range(1_000_000)]  # メモリに全要素を保持
squares_gen  = (x**2 for x in range(1_000_000))  # 1要素ずつ生成（省メモリ）
 
# ジェネレータ式はメモリフットプリントが極めて小さい
import sys
print(sys.getsizeof(squares_list))  # 約 8.5 MB
print(sys.getsizeof(squares_gen))   # 約 200 バイト（固定）

# yield from を使わない場合
def chain_v1(*iterables):
    for it in iterables:
        for item in it:
            yield item
 
# yield from を使う場合（等価だがより効率的）
def chain_v2(*iterables):
    for it in iterables:
        yield from it
 
list(chain_v2([1, 2], [3, 4], [5, 6]))  # [1, 2, 3, 4, 5, 6]
 
# yield from は再帰的なジェネレータに特に有用
def flatten(nested):
    """ネストしたリストを平坦化する"""
    for item in nested:
        if isinstance(item, (list, tuple)):
            yield from flatten(item)  # 再帰的に委譲
        else:
            yield item
 
list(flatten([1, [2, [3, 4], 5], [6, 7]]))  # [1, 2, 3, 4, 5, 6, 7]

def accumulator():
    """送り込まれた値を累積するジェネレータ"""
    total = 0
    while True:
        value = yield total    # total を返し、send された値を value に受け取る
        if value is None:
            break
        total += value
 
acc = accumulator()
next(acc)            # 0 （ジェネレータを最初の yield まで進める）
acc.send(10)         # 10（total = 0 + 10）
acc.send(20)         # 30（total = 10 + 20）
acc.send(5)          # 35（total = 30 + 5）
 
# 実用例: コルーチンとしてのジェネレータ（移動平均の計算）
def moving_average(window_size):
    """移動平均を計算するコルーチン"""
    window = []
    average = None
    while True:
        value = yield average
        window.append(value)
        if len(window) > window_size:
            window.pop(0)
        average = sum(window) / len(window)
 
ma = moving_average(3)
next(ma)         # None（初期化）
ma.send(10)      # 10.0
ma.send(20)      # 15.0
ma.send(30)      # 20.0
ma.send(40)      # 30.0（窓: [20, 30, 40]）

// function* でジェネレータ関数を定義
function* fibonacci() {
    let a = 0, b = 1;
    while (true) {
        yield a;
        [a, b] = [b, a + b];
    }
}
 
const fib = fibonacci();
console.log(fib.next());  // { value: 0, done: false }
console.log(fib.next());  // { value: 1, done: false }
console.log(fib.next());  // { value: 1, done: false }
 
// ヘルパージェネレータ: take
function* take(iter, n) {
    let count = 0;
    for (const item of iter) {
        if (count++ >= n) break;
        yield item;
    }
}
 
// for-of で消費
for (const n of take(fibonacci(), 10)) {
    console.log(n);  // 0, 1, 1, 2, 3, 5, 8, 13, 21, 34
}
 
// yield* でサブジェネレータ委譲
function* flatten(arr) {
    for (const item of arr) {
        if (Array.isArray(item)) {
            yield* flatten(item);  // 再帰的に委譲
        } else {
            yield item;
        }
    }
}
 
console.log([...flatten([1, [2, [3, 4], 5], [6, 7]])]);
// [1, 2, 3, 4, 5, 6, 7]
 
// send に相当する機能: next(value)
function* accumulator() {
    let total = 0;
    while (true) {
        const value = yield total;
        total += value;
    }
}
 
const acc = accumulator();
acc.next();        // { value: 0, done: false } -- 初期化
acc.next(10);      // { value: 10, done: false }
acc.next(20);      // { value: 30, done: false }
acc.next(5);       // { value: 35, done: false }

def natural_numbers():
    """自然数を無限に生成"""
    n = 1
    while True:
        yield n
        n += 1
 
def primes():
    """素数を無限に生成（エラトステネスの篩の変形）"""
    yield 2
    composites = {}
    n = 3
    while True:
        if n not in composites:
            yield n
            composites[n * n] = [n]
        else:
            for prime in composites[n]:
                composites.setdefault(prime + n, []).append(prime)
            del composites[n]
        n += 2
 
# 最初の20個の素数を取得
from itertools import islice
print(list(islice(primes(), 20)))
# [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]

// 遅延評価により、take(5) の条件が満たされた時点で処理が停止する
// 10万要素すべてを処理する必要がない
let result: Vec<i32> = (1..=100_000)
    .filter(|n| is_prime(*n))    // 素数のみ
    .map(|n| n * n)              // 二乗
    .take(5)                     // 最初の5個で停止！
    .collect();
// is_prime は最初の5つの素数が見つかるまでしか呼ばれない
// => [4, 9, 25, 49, 121]

# 危険: 遅延評価と副作用の組み合わせ
def log_and_double(x):
    print(f"Processing: {x}")  # 副作用
    return x * 2
 
gen = (log_and_double(x) for x in range(5))
# この時点では何も出力されない！
 
# ジェネレータを消費して初めて副作用が発生する
result = list(gen)
# Processing: 0
# Processing: 1
# Processing: 2
# Processing: 3
# Processing: 4

gen = (x ** 2 for x in range(5))
 
# 1回目の走査
print(sum(gen))   # 30（0 + 1 + 4 + 9 + 16）
 
# 2回目の走査（空！ジェネレータは使い切りである）
print(sum(gen))   # 0 --- よくあるバグ

-- 無限リストが自然に書ける
naturals = [1..]                    -- [1, 2, 3, 4, ...]
evens    = [2, 4..]                 -- [2, 4, 6, 8, ...]
fibs     = 0 : 1 : zipWith (+) fibs (tail fibs)  -- フィボナッチ数列
 
-- 必要な分だけ取得
take 10 fibs    -- [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
take 5 naturals -- [1, 2, 3, 4, 5]
 
-- 無限リストを使ったエレガントな表現
-- 「最初の10個の素数」
take 10 [n | n <- [2..], isPrime n]
 
-- 遅延評価があるからこそ可能な定義
-- ones = 1 : ones  -- [1, 1, 1, 1, ...] 無限に1が続くリスト

// async function* で非同期ジェネレータ
async function* fetchPages(baseUrl) {
    let page = 1;
    while (true) {
        const response = await fetch(`${baseUrl}?page=${page}`);
        const data = await response.json();
        if (data.items.length === 0) break;
        yield data.items;       // 各ページのデータを yield
        page++;
    }
}
 
// for await ... of で消費
async function processAllUsers(url) {
    for await (const users of fetchPages(url)) {
        for (const user of users) {
            console.log(user.name);
        }
    }
}
 
// Symbol.asyncIterator プロトコル
class EventStream {
    constructor(eventSource) {
        this.source = eventSource;
    }
 
    [Symbol.asyncIterator]() {
        const source = this.source;
        return {
            next() {
                return new Promise((resolve) => {
                    source.once('data', (data) => {
                        resolve({ value: data, done: false });
                    });
                    source.once('end', () => {
                        resolve({ value: undefined, done: true });
                    });
                });
            }
        };
    }
}
 
// 非同期ジェネレータのユーティリティ
async function* asyncMap(asyncIter, fn) {
    for await (const item of asyncIter) {
        yield fn(item);
    }
}
 
async function* asyncFilter(asyncIter, predicate) {
    for await (const item of asyncIter) {
        if (predicate(item)) {
            yield item;
        }
    }
}
 
async function* asyncTake(asyncIter, n) {
    let count = 0;
    for await (const item of asyncIter) {
        if (count++ >= n) break;
        yield item;
    }
}
 
// 組み合わせて使用
const activeUsers = asyncFilter(
    asyncMap(
        fetchPages("/api/users"),
        page => page.filter(u => u.active)
    ),
    page => page.length > 0
);

import aiohttp
import asyncio
 
# async def + yield = 非同期ジェネレータ
async def fetch_pages(base_url):
    """ページネーションされたAPIからデータを非同期に取得"""
    page = 1
    async with aiohttp.ClientSession() as session:
        while True:
            async with session.get(f"{base_url}?page={page}") as resp:
                data = await resp.json()
                if not data["items"]:
                    break
                yield data["items"]
                page += 1
 
# async for で消費
async def process_all_users():
    async for users in fetch_pages("https://api.example.com/users"):
        for user in users:
            print(user["name"])
 
asyncio.run(process_all_users())
 
# 非同期内包表記
async def get_active_users():
    return [
        user
        async for page in fetch_pages("/api/users")
        for user in page
        if user.get("active")
    ]
 
# 非同期ジェネレータの aclose() による明示的クリーンアップ
async def resource_stream():
    resource = await acquire_resource()
    try:
        while True:
            data = await resource.read()
            if data is None:
                break
            yield data
    finally:
        await resource.release()  # クリーンアップが保証される
 
# aclose() で途中終了してもクリーンアップが実行される
stream = resource_stream()
first_item = await stream.__anext__()
await stream.aclose()  # finally ブロックが実行される

use tokio_stream::{self, StreamExt};
use tokio::time::{self, Duration};
 
// Stream は非同期版 Iterator
// poll_next() が Future を返す
 
// tokio_stream を使った例
#[tokio::main]
async fn main() {
    // 基本的な Stream の作成と消費
    let mut stream = tokio_stream::iter(vec![1, 2, 3, 4, 5])
        .filter(|n| *n % 2 == 0)
        .map(|n| n * 10);
 
    while let Some(value) = stream.next().await {
        println!("{}", value);  // 20, 40
    }
 
    // インターバルストリーム
    let mut interval = tokio_stream::wrappers::IntervalStream::new(
        time::interval(Duration::from_secs(1))
    );
 
    // 最初の5回だけ処理
    let mut count = 0;
    while let Some(_tick) = interval.next().await {
        count += 1;
        println!("Tick {}", count);
        if count >= 5 { break; }
    }
}
 
// async-stream クレートを使ったストリーム生成
// （Rust にはまだネイティブの async ジェネレータ構文がない）
use async_stream::stream;
 
fn countdown(from: u32) -> impl tokio_stream::Stream<Item = u32> {
    stream! {
        for i in (1..=from).rev() {
            tokio::time::sleep(Duration::from_millis(100)).await;
            yield i;
        }
    }
}

import csv
from typing import Iterator, Dict, Any
 
def read_csv(filename: str) -> Iterator[Dict[str, str]]:
    """CSVファイルを1行ずつ読み取るジェネレータ"""
    with open(filename) as f:
        reader = csv.DictReader(f)
        for row in reader:
            yield row
    # ファイルは自動的にクローズされる
 
def parse_numbers(rows: Iterator[Dict]) -> Iterator[Dict]:
    """数値フィールドを変換"""
    for row in rows:
        row["age"] = int(row["age"])
        row["salary"] = float(row["salary"])
        yield row
 
def filter_by_age(rows: Iterator[Dict], min_age: int) -> Iterator[Dict]:
    """年齢でフィルタ"""
    for row in rows:
        if row["age"] >= min_age:
            yield row
 
def top_n(rows: Iterator[Dict], n: int, key: str) -> list:
    """上位N件を取得（ヒープを使用してメモリ効率的に）"""
    import heapq
    return heapq.nlargest(n, rows, key=lambda r: r[key])
 
# パイプラインの構築と実行
# 100万行のCSVでもメモリ使用量は一定
pipeline = read_csv("employees.csv")
pipeline = parse_numbers(pipeline)
pipeline = filter_by_age(pipeline, 30)
top_earners = top_n(pipeline, 10, "salary")
 
for emp in top_earners:
    print(f"{emp['name']}: ${emp['salary']:,.0f}")

from collections import deque
from typing import Iterator, TypeVar, Tuple
import itertools
 
T = TypeVar('T')
 
def sliding_window(iterable, size: int) -> Iterator[Tuple]:
    """スライディングウィンドウ"""
    it = iter(iterable)
    window = deque(itertools.islice(it, size), maxlen=size)
    if len(window) == size:
        yield tuple(window)
    for item in it:
        window.append(item)
        yield tuple(window)
 
# 使用例: 移動平均
data = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
for window in sliding_window(data, 3):
    avg = sum(window) / len(window)
    print(f"window={window}, avg={avg:.1f}")
# window=(10, 20, 30), avg=20.0
# window=(20, 30, 40), avg=30.0
# window=(30, 40, 50), avg=40.0
# ...
 
def chunked(iterable, size: int) -> Iterator[list]:
    """イテラブルを固定サイズのチャンクに分割"""
    it = iter(iterable)
    while True:
        chunk = list(itertools.islice(it, size))
        if not chunk:
            break
        yield chunk
 
# 使用例: バッチ処理
for batch in chunked(range(100), 10):
    process_batch(batch)  # 10件ずつ処理

class TreeNode:
    def __init__(self, value, children=None):
        self.value = value
        self.children = children or []
 
def dfs_preorder(node: TreeNode) -> Iterator:
    """深さ優先探索（前順）をジェネレータで実装"""
    yield node.value
    for child in node.children:
        yield from dfs_preorder(child)
 
def dfs_postorder(node: TreeNode) -> Iterator:
    """深さ優先探索（後順）"""
    for child in node.children:
        yield from dfs_postorder(child)
    yield node.value
 
def bfs(node: TreeNode) -> Iterator:
    """幅優先探索をジェネレータで実装"""
    from collections import deque
    queue = deque([node])
    while queue:
        current = queue.popleft()
        yield current.value
        queue.extend(current.children)
 
# ツリー構築
tree = TreeNode(1, [
    TreeNode(2, [TreeNode(4), TreeNode(5)]),
    TreeNode(3, [TreeNode(6), TreeNode(7)])
])
 
print(list(dfs_preorder(tree)))   # [1, 2, 4, 5, 3, 6, 7]
print(list(dfs_postorder(tree)))  # [4, 5, 2, 6, 7, 3, 1]
print(list(bfs(tree)))            # [1, 2, 3, 4, 5, 6, 7]

def lexer(text: str):
    """簡易的なトークナイザを状態機械で実装"""
    i = 0
    while i < len(text):
        # 空白をスキップ
        if text[i].isspace():
            i += 1
            continue
 
        # 数値トークン
        if text[i].isdigit():
            start = i
            while i < len(text) and text[i].isdigit():
                i += 1
            yield ("NUMBER", text[start:i])
            continue
 
        # 識別子トークン
        if text[i].isalpha():
            start = i
            while i < len(text) and text[i].isalnum():
                i += 1
            yield ("IDENT", text[start:i])
            continue
 
        # 演算子トークン
        if text[i] in "+-*/=<>":
            yield ("OP", text[i])
            i += 1
            continue
 
        raise ValueError(f"Unexpected character: {text[i]}")
 
# 使用例
for token_type, value in lexer("x = 42 + y * 3"):
    print(f"{token_type}: {value}")
# IDENT: x
# OP: =
# NUMBER: 42
# OP: +
# IDENT: y
# OP: *
# NUMBER: 3

from contextlib import contextmanager
 
@contextmanager
def managed_cursor(connection):
    """データベースカーソルのライフサイクルを管理"""
    cursor = connection.cursor()
    try:
        yield cursor
    finally:
        cursor.close()
 
def query_rows(connection, sql, params=None):
    """大量の行を1行ずつ取得するジェネレータ"""
    with managed_cursor(connection) as cursor:
        cursor.execute(sql, params or ())
        while True:
            row = cursor.fetchone()
            if row is None:
                break
            yield row
    # with ブロックを抜けると cursor.close() が呼ばれる
 
# 100万行のクエリ結果をメモリ効率的に処理
for row in query_rows(conn, "SELECT * FROM large_table"):
    process_row(row)
# イテレーション途中で break しても、カーソルは確実にクローズされる

# =========================================
# ANTI-PATTERN: ジェネレータの二重消費
# =========================================
 
def get_numbers():
    yield from range(10)
 
numbers = get_numbers()
 
# 1回目: 正しく動作
total = sum(numbers)          # 45
 
# 2回目: 空のジェネレータ！ 値は 0 になる
average = total / sum(numbers) if sum(numbers) > 0 else 0
# ZeroDivisionError or 想定外の結果
 
# -----------------------------------------
# 修正方法1: リストに変換して再利用
# -----------------------------------------
numbers = list(get_numbers())  # メモリに全要素を保持
total = sum(numbers)           # 45
average = total / len(numbers) # 4.5
 
# -----------------------------------------
# 修正方法2: itertools.tee で複製
# -----------------------------------------
import itertools
nums1, nums2 = itertools.tee(get_numbers(), 2)
total = sum(nums1)
count = sum(1 for _ in nums2)
average = total / count  # 4.5
# 注意: tee は内部にバッファを持つため、大きなイテレータには不向き
 
# -----------------------------------------
# 修正方法3: イテラブルクラスを定義（推奨）
# -----------------------------------------
class NumberRange:
    """何度でもイテレートできるイテラブル"""
    def __iter__(self):
        yield from range(10)
 
numbers = NumberRange()
total = sum(numbers)           # 45（1回目）
average = total / sum(1 for _ in numbers)  # 4.5（2回目も動作）

# =========================================
# ANTI-PATTERN: ループ変数のクロージャキャプチャ
# =========================================
 
# 期待: [0, 1, 4, 9, 16] を生成するジェネレータのリスト
generators = [lambda: i ** 2 for i in range(5)]
 
# 全てが 16 を返す！（i は最終値 4 を参照している）
results = [g() for g in generators]
print(results)  # [16, 16, 16, 16, 16]
 
# -----------------------------------------
# 修正方法1: デフォルト引数でキャプチャ
# -----------------------------------------
generators = [lambda i=i: i ** 2 for i in range(5)]
results = [g() for g in generators]
print(results)  # [0, 1, 4, 9, 16]
 
# -----------------------------------------
# 修正方法2: ジェネレータ式を使う
# -----------------------------------------
gen = (i ** 2 for i in range(5))
print(list(gen))  # [0, 1, 4, 9, 16]

# =========================================
# ANTI-PATTERN: 不要な中間リストの生成
# =========================================
 
# 悪い例: 各ステップでリストを全生成
data = list(range(1_000_000))
filtered = [x for x in data if x % 2 == 0]        # 50万要素のリスト
mapped   = [x ** 2 for x in filtered]              # 50万要素のリスト
result   = [x for x in mapped if x > 1000]         # さらにリスト
final    = sum(result)
# メモリ: 元データ + filtered + mapped + result = 約4倍
 
# -----------------------------------------
# 修正: ジェネレータ式でパイプライン化
# -----------------------------------------
data = range(1_000_000)                             # range は遅延
filtered = (x for x in data if x % 2 == 0)         # ジェネレータ
mapped   = (x ** 2 for x in filtered)               # ジェネレータ
result   = (x for x in mapped if x > 1000)          # ジェネレータ
final    = sum(result)                               # ここで初めて計算
# メモリ: O(1) --- 中間リストなし

# =========================================
# ANTI-PATTERN: ジェネレータの finally が実行されない場合
# =========================================
 
def file_lines(path):
    """ファイルを1行ずつ読むジェネレータ"""
    f = open(path)
    try:
        for line in f:
            yield line.strip()
    finally:
        f.close()
        print("File closed")
 
# 問題: ジェネレータが途中で放棄されると...
gen = file_lines("data.txt")
first_line = next(gen)
# gen が GC されるまで finally は実行されない
# CPython では参照カウントにより即座に GC されるが、
# PyPy や他の実装では遅延する可能性がある
 
# -----------------------------------------
# 修正: close() を明示的に呼ぶ、またはコンテキストマネージャを使用
# -----------------------------------------
 
# 方法1: close() を明示的に呼ぶ
gen = file_lines("data.txt")
first_line = next(gen)
gen.close()  # finally ブロックが実行される
 
# 方法2: contextlib.closing を使用
from contextlib import closing
with closing(file_lines("data.txt")) as lines:
    first_line = next(lines)
# with ブロックを抜けると close() が自動的に呼ばれる

// イテレータチェーン版
let sum: i32 = (0..1000)
    .filter(|n| n % 3 == 0 || n % 5 == 0)
    .sum();
 
// 手書きのループ版（同等のパフォーマンス）
let mut sum = 0;
for n in 0..1000 {
    if n % 3 == 0 || n % 5 == 0 {
        sum += n;
    }
}
 
// コンパイラが生成するマシンコードはほぼ同一
// イテレータ版はむしろ境界チェックの省略により高速な場合もある

# 最適化1: ジェネレータ式 vs リスト内包表記
# 結果をすべて必要としない場合はジェネレータ式を使う
 
# 悪い例（不要な中間リスト）
has_error = any([line.startswith("ERROR") for line in open("log.txt")])
# "ERROR" が見つかっても残り全行を処理してしまう
 
# 良い例（ジェネレータ式 + 短絡評価）
has_error = any(line.startswith("ERROR") for line in open("log.txt"))
# "ERROR" が見つかった時点で停止
 
# 最適化2: itertools は C 実装なので高速
import itertools
 
# 遅い（Python ループ）
def my_chain(*iterables):
    for it in iterables:
        yield from it
 
# 速い（C 実装）
itertools.chain(*iterables)
 
# 最適化3: 大量データには sorted() よりも heapq.nlargest()
import heapq
 
# 全件ソートは O(N log N)
top_10 = sorted(huge_data, key=extract_key, reverse=True)[:10]
 
# ヒープは O(N log K) で K が小さい場合に高速
top_10 = heapq.nlargest(10, huge_data, key=extract_key)

// Rust での最適化テクニック
 
// 最適化1: collect のヒント
// サイズが分かっている場合は、Vec の容量を事前確保
let result: Vec<i32> = Vec::with_capacity(1000);
let result: Vec<i32> = (0..1000).collect();  // size_hint を活用して自動確保
 
// 最適化2: 不要なクローンを避ける
// 悪い例
let names: Vec<String> = people.iter()
    .map(|p| p.name.clone())  // 毎回クローン
    .collect();
 
// 良い例（参照で十分な場合）
let names: Vec<&str> = people.iter()
    .map(|p| p.name.as_str())  // 参照のみ
    .collect();
 
// 最適化3: flat_map vs flatten
// flat_map は map + flatten を1ステップで行い、中間イテレータを省略
let result: Vec<i32> = data.iter()
    .flat_map(|row| row.iter().copied())  // 効率的
    .collect();

class EvenRange:
    """偶数のみを生成するイテレータ"""
    def __init__(self, start, end):
        # TODO: 実装
        pass
 
    def __iter__(self):
        # TODO: 実装
        pass
 
    def __next__(self):
        # TODO: 実装
        pass
 
# テスト
assert list(EvenRange(1, 10)) == [2, 4, 6, 8]
assert list(EvenRange(0, 6)) == [0, 2, 4]
assert list(EvenRange(7, 8)) == [8]

def fizzbuzz(n):
    """1 から n までの FizzBuzz を生成するジェネレータ"""
    # TODO: 実装
    pass
 
# テスト
result = list(fizzbuzz(15))
assert result == [
    1, 2, "Fizz", 4, "Buzz", "Fizz", 7, 8, "Fizz", "Buzz",
    11, "Fizz", 13, 14, "FizzBuzz"
]

class LazyIter:
    """遅延評価のイテレータラッパー"""
 
    def __init__(self, iterable):
        self._iter = iter(iterable)
 
    def __iter__(self):
        return self._iter
 
    def __next__(self):
        return next(self._iter)
 
    def map(self, fn):
        # TODO: 新しい LazyIter を返す
        pass
 
    def filter(self, pred):
        # TODO: 新しい LazyIter を返す
        pass
 
    def take(self, n):
        # TODO: 新しい LazyIter を返す
        pass
 
    def enumerate(self):
        # TODO: 新しい LazyIter を返す
        pass
 
    def collect(self):
        # TODO: リストに変換
        pass
 
    def sum(self):
        # TODO: 合計を計算
        pass
 
    def any(self, pred):
        # TODO: いずれかが条件を満たすか
        pass
 
# テスト
result = (LazyIter(range(100))
    .filter(lambda x: x % 3 == 0)
    .map(lambda x: x * x)
    .take(5)
    .collect())
 
assert result == [0, 9, 36, 81, 144]

def collatz(n):
    """コラッツ数列を生成
    n が偶数なら n/2、奇数なら 3n+1 を繰り返す。1 に到達したら終了。
    """
    # TODO: 実装
    pass
 
# テスト
assert list(collatz(6)) == [6, 3, 10, 5, 16, 8, 4, 2, 1]
assert list(collatz(1)) == [1]

import asyncio
 
async def merge(*async_iterables):
    """複数の非同期イテラブルをマージし、到着順に yield する"""
    # TODO: 実装
    # ヒント: asyncio.Queue と asyncio.create_task を使う
    pass
 
# テスト用の非同期ジェネレータ
async def delayed_range(name, start, end, delay):
    for i in range(start, end):
        await asyncio.sleep(delay)
        yield (name, i)
 
# 使用例
async def main():
    async for source, value in merge(
        delayed_range("A", 0, 5, 0.3),
        delayed_range("B", 10, 15, 0.5),
    ):
        print(f"{source}: {value}")
    # 到着順に出力される
 
asyncio.run(main())

# 同じ機能をイテレータとジェネレータで実装した比較
# イテレータ版: 13行
class RangeIterator:
    def __init__(self, n):
        self.n = n
        self.current = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.current >= self.n:
            raise StopIteration
        value = self.current
        self.current += 1
        return value
 
# ジェネレータ版: 3行
def range_generator(n):
    for i in range(n):
        yield i

// Rust nightly では gen ブロックが実験的に使用可能
#![feature(gen_blocks)]
 
fn fibonacci() -> impl Iterator<Item = u64> {
    gen {
        let (mut a, mut b) = (0, 1);
        loop {
            yield a;
            (a, b) = (b, a + b);
        }
    }
}

def filtered_lines(filename, keyword):
    """ファイルからキーワードを含む行だけを yield する"""
    with open(filename) as f:
        for line in f:        # for ループ
            if keyword in line:
                yield line    # 各反復で条件を満たす行を返す
 
# 使う側
for line in filtered_lines("access.log", "ERROR"):
    print(line)