// range-iterator.ts -- 範囲イテレータ
 
// ============================
// Iterable を実装するクラス
// ============================
class Range implements Iterable<number> {
  constructor(
    private readonly start: number,
    private readonly end: number,
    private readonly step: number = 1
  ) {
    if (step === 0) throw new Error('step must not be 0');
    if (step > 0 && start > end) throw new Error('start must be <= end for positive step');
    if (step < 0 && start < end) throw new Error('start must be >= end for negative step');
  }
 
  /** Iterable プロトコル: Iterator を生成して返す */
  [Symbol.iterator](): Iterator<number> {
    let current = this.start;
    const end = this.end;
    const step = this.step;
 
    return {
      next(): IteratorResult<number> {
        if ((step > 0 && current < end) || (step < 0 && current > end)) {
          const value = current;
          current += step;
          return { value, done: false };
        }
        return { value: undefined, done: true };
      },
    };
  }
 
  /** 要素数を事前計算（遅延評価を維持しつつサイズ取得） */
  get length(): number {
    return Math.max(0, Math.ceil((this.end - this.start) / this.step));
  }
 
  /** 要素が含まれるか判定（O(1)） */
  includes(value: number): boolean {
    if (this.step > 0) {
      if (value < this.start || value >= this.end) return false;
    } else {
      if (value > this.start || value <= this.end) return false;
    }
    return (value - this.start) % this.step === 0;
  }
}
 
// ============================
// 使用例
// ============================
 
// for...of で走査
for (const n of new Range(1, 5)) {
  console.log(n); // 1, 2, 3, 4
}
 
// スプレッド演算子
const numbers = [...new Range(0, 10, 2)]; // [0, 2, 4, 6, 8]
 
// 分割代入
const [first, second] = new Range(10, 0, -3); // first=10, second=7
 
// Array.from
const arr = Array.from(new Range(1, 6)); // [1, 2, 3, 4, 5]
 
// ★ Iterable なので何度でも走査可能
const range = new Range(1, 4);
console.log([...range]); // [1, 2, 3]
console.log([...range]); // [1, 2, 3] ← 2回目も同じ結果

// linked-list-iterator.ts -- 連結リストのイテレータ
 
// ============================
// Node と LinkedList の定義
// ============================
class ListNode<T> {
  constructor(
    public value: T,
    public next: ListNode<T> | null = null
  ) {}
}
 
class LinkedList<T> implements Iterable<T> {
  private head: ListNode<T> | null = null;
  private _size: number = 0;
 
  push(value: T): void {
    const node = new ListNode(value);
    node.next = this.head;
    this.head = node;
    this._size++;
  }
 
  get size(): number {
    return this._size;
  }
 
  /** 順方向のイテレータ */
  [Symbol.iterator](): Iterator<T> {
    let current = this.head;
 
    return {
      next(): IteratorResult<T> {
        if (current) {
          const value = current.value;
          current = current.next;
          return { value, done: false };
        }
        return { value: undefined, done: true };
      },
    };
  }
 
  /** 逆順イテレータ（複数の走査方法を提供） */
  reversed(): Iterable<T> {
    const items = [...this]; // 一度配列に
    let index = items.length - 1;
 
    return {
      [Symbol.iterator](): Iterator<T> {
        return {
          next(): IteratorResult<T> {
            if (index >= 0) {
              return { value: items[index--], done: false };
            }
            return { value: undefined, done: true };
          },
        };
      },
    };
  }
 
  /** 条件付きフィルタイテレータ */
  filter(predicate: (value: T) => boolean): Iterable<T> {
    const source = this;
    return {
      *[Symbol.iterator](): Iterator<T> {
        for (const item of source) {
          if (predicate(item)) yield item;
        }
      },
    };
  }
}
 
// ============================
// 使用例
// ============================
const list = new LinkedList<number>();
list.push(3);
list.push(2);
list.push(1);
 
// 順方向
for (const value of list) {
  console.log(value); // 1, 2, 3
}
 
// 逆順
for (const value of list.reversed()) {
  console.log(value); // 3, 2, 1
}
 
// フィルタ付き
for (const value of list.filter(v => v % 2 !== 0)) {
  console.log(value); // 1, 3
}

// generators.ts -- ジェネレータの基本と応用
 
// ============================
// 基本的なジェネレータ
// ============================
function* fibonacci(): Generator<number> {
  let a = 0;
  let b = 1;
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}
 
// 先頭 N 個を取得するヘルパー
function take<T>(n: number, iterable: Iterable<T>): T[] {
  const result: T[] = [];
  for (const item of iterable) {
    result.push(item);
    if (result.length >= n) break;
  }
  return result;
}
 
console.log(take(8, fibonacci()));
// [0, 1, 1, 2, 3, 5, 8, 13]
 
// ============================
// ジェネレータによるツリーの走査
// ============================
interface TreeNode<T> {
  value: T;
  children: TreeNode<T>[];
}
 
/** 深さ優先走査（前順: pre-order） */
function* depthFirst<T>(root: TreeNode<T>): Generator<T> {
  yield root.value;
  for (const child of root.children) {
    yield* depthFirst(child); // yield* で再帰的にデリゲート
  }
}
 
/** 深さ優先走査（後順: post-order） */
function* depthFirstPostOrder<T>(root: TreeNode<T>): Generator<T> {
  for (const child of root.children) {
    yield* depthFirstPostOrder(child);
  }
  yield root.value;
}
 
/** 幅優先走査 (BFS) */
function* breadthFirst<T>(root: TreeNode<T>): Generator<T> {
  const queue: TreeNode<T>[] = [root];
  while (queue.length > 0) {
    const node = queue.shift()!;
    yield node.value;
    queue.push(...node.children);
  }
}
 
/** レベルごとのグループ化走査 */
function* levelOrder<T>(root: TreeNode<T>): Generator<T[]> {
  let currentLevel: TreeNode<T>[] = [root];
  while (currentLevel.length > 0) {
    const values = currentLevel.map(n => n.value);
    yield values;
    const nextLevel: TreeNode<T>[] = [];
    for (const node of currentLevel) {
      nextLevel.push(...node.children);
    }
    currentLevel = nextLevel;
  }
}
 
// ============================
// 使用例
// ============================
const tree: TreeNode<string> = {
  value: 'A',
  children: [
    { value: 'B', children: [
      { value: 'D', children: [] },
      { value: 'E', children: [] },
    ]},
    { value: 'C', children: [
      { value: 'F', children: [] },
    ]},
  ],
};
 
console.log([...depthFirst(tree)]);
// ['A', 'B', 'D', 'E', 'C', 'F']
 
console.log([...depthFirstPostOrder(tree)]);
// ['D', 'E', 'B', 'F', 'C', 'A']
 
console.log([...breadthFirst(tree)]);
// ['A', 'B', 'C', 'D', 'E', 'F']
 
console.log([...levelOrder(tree)]);
// [['A'], ['B', 'C'], ['D', 'E', 'F']]

// async-iterators.ts -- 非同期イテレータの活用
 
// ============================
// API ページネーション
// ============================
interface PageResponse<T> {
  items: T[];
  total: number;
  page: number;
  perPage: number;
}
 
async function* fetchAllPages<T>(
  baseUrl: string,
  pageSize: number = 20
): AsyncGenerator<T> {
  let page = 1;
  let hasMore = true;
 
  while (hasMore) {
    const response = await fetch(
      `${baseUrl}?page=${page}&per_page=${pageSize}`
    );
 
    if (!response.ok) {
      throw new Error(`API error: ${response.status}`);
    }
 
    const data: PageResponse<T> = await response.json();
 
    for (const item of data.items) {
      yield item; // 1件ずつ yield（メモリ効率が良い）
    }
 
    hasMore = page * pageSize < data.total;
    page++;
  }
}
 
// 使用例: 全ユーザーを1件ずつ処理（メモリ効率が良い）
interface User { id: string; name: string; active: boolean; }
 
async function processAllUsers(): Promise<void> {
  let count = 0;
  for await (const user of fetchAllPages<User>('/api/users')) {
    if (user.active) {
      await processUser(user);
      count++;
    }
  }
  console.log(`Processed ${count} active users`);
}
 
// ============================
// ReadableStream のラインリーダー
// ============================
async function* readLines(
  stream: ReadableStream<Uint8Array>
): AsyncGenerator<string> {
  const reader = stream.getReader();
  const decoder = new TextDecoder();
  let buffer = '';
 
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
 
      buffer += decoder.decode(value, { stream: true });
      const lines = buffer.split('\n');
      buffer = lines.pop() ?? '';
 
      for (const line of lines) {
        yield line;
      }
    }
 
    // 最後のバッファ（改行なし）
    if (buffer) {
      yield buffer;
    }
  } finally {
    reader.releaseLock();
  }
}
 
// ============================
// Server-Sent Events (SSE) のストリーム
// ============================
async function* streamSSE(url: string): AsyncGenerator<{
  event: string;
  data: string;
}> {
  const response = await fetch(url);
  if (!response.body) throw new Error('No response body');
 
  for await (const line of readLines(response.body)) {
    if (line.startsWith('event: ')) {
      const event = line.slice(7);
      // 次の行が data:
      // (簡略化: 実際の SSE パーサーはもっと複雑)
      continue;
    }
    if (line.startsWith('data: ')) {
      yield { event: 'message', data: line.slice(6) };
    }
  }
}
 
// 使用例: SSE ストリームの購読
async function watchUpdates(): Promise<void> {
  for await (const { event, data } of streamSSE('/api/events')) {
    console.log(`[${event}] ${data}`);
    // 必要に応じて break で中断可能
  }
}

// iterator-pipeline.ts -- 関数型イテレータ操作
 
// ============================
// 遅延評価パイプラインクラス
// ============================
class Iter<T> implements Iterable<T> {
  constructor(private source: Iterable<T>) {}
 
  static from<T>(source: Iterable<T>): Iter<T> {
    return new Iter(source);
  }
 
  /** 無限の繰り返しイテレータ */
  static repeat<T>(value: T): Iter<T> {
    return new Iter((function* () {
      while (true) yield value;
    })());
  }
 
  /** 自然数列 (0, 1, 2, ...) */
  static naturals(): Iter<number> {
    return new Iter((function* () {
      let n = 0;
      while (true) yield n++;
    })());
  }
 
  *[Symbol.iterator](): Iterator<T> {
    yield* this.source;
  }
 
  /** 値の変換 */
  map<U>(fn: (item: T, index: number) => U): Iter<U> {
    const source = this.source;
    return new Iter((function* () {
      let i = 0;
      for (const item of source) {
        yield fn(item, i++);
      }
    })());
  }
 
  /** フィルタリング */
  filter(predicate: (item: T) => boolean): Iter<T> {
    const source = this.source;
    return new Iter((function* () {
      for (const item of source) {
        if (predicate(item)) yield item;
      }
    })());
  }
 
  /** 先頭 N 個を取得 */
  take(n: number): Iter<T> {
    const source = this.source;
    return new Iter((function* () {
      let count = 0;
      for (const item of source) {
        if (count >= n) break;
        yield item;
        count++;
      }
    })());
  }
 
  /** 先頭 N 個をスキップ */
  skip(n: number): Iter<T> {
    const source = this.source;
    return new Iter((function* () {
      let count = 0;
      for (const item of source) {
        if (count >= n) yield item;
        count++;
      }
    })());
  }
 
  /** 条件を満たす間だけ取得 */
  takeWhile(predicate: (item: T) => boolean): Iter<T> {
    const source = this.source;
    return new Iter((function* () {
      for (const item of source) {
        if (!predicate(item)) break;
        yield item;
      }
    })());
  }
 
  /** フラットマップ */
  flatMap<U>(fn: (item: T) => Iterable<U>): Iter<U> {
    const source = this.source;
    return new Iter((function* () {
      for (const item of source) {
        yield* fn(item);
      }
    })());
  }
 
  /** 隣接要素のペア */
  pairwise(): Iter<[T, T]> {
    const source = this.source;
    return new Iter((function* () {
      let prev: T | undefined;
      let first = true;
      for (const item of source) {
        if (!first) {
          yield [prev!, item] as [T, T];
        }
        prev = item;
        first = false;
      }
    })());
  }
 
  /** チャンク分割 */
  chunk(size: number): Iter<T[]> {
    const source = this.source;
    return new Iter((function* () {
      let chunk: T[] = [];
      for (const item of source) {
        chunk.push(item);
        if (chunk.length >= size) {
          yield chunk;
          chunk = [];
        }
      }
      if (chunk.length > 0) yield chunk;
    })());
  }
 
  /** 重複除去 */
  distinct(): Iter<T> {
    const source = this.source;
    return new Iter((function* () {
      const seen = new Set<T>();
      for (const item of source) {
        if (!seen.has(item)) {
          seen.add(item);
          yield item;
        }
      }
    })());
  }
 
  /** 畳み込み（即座に評価） */
  reduce<U>(fn: (acc: U, item: T) => U, initial: U): U {
    let result = initial;
    for (const item of this.source) {
      result = fn(result, item);
    }
    return result;
  }
 
  /** 配列に変換（即座に評価） */
  toArray(): T[] {
    return [...this.source];
  }
 
  /** 最初の要素を取得 */
  first(): T | undefined {
    for (const item of this.source) {
      return item;
    }
    return undefined;
  }
 
  /** 要素数をカウント */
  count(): number {
    let n = 0;
    for (const _ of this.source) n++;
    return n;
  }
 
  /** 全要素が条件を満たすか */
  every(predicate: (item: T) => boolean): boolean {
    for (const item of this.source) {
      if (!predicate(item)) return false;
    }
    return true;
  }
 
  /** いずれかの要素が条件を満たすか */
  some(predicate: (item: T) => boolean): boolean {
    for (const item of this.source) {
      if (predicate(item)) return true;
    }
    return false;
  }
}
 
// ============================
// 使用例: パイプラインで遅延評価
// ============================
 
// フィボナッチ数列から偶数の二乗を5個取得
const result = Iter.from(fibonacci())
  .filter(n => n % 2 === 0)       // 偶数のみ
  .map(n => n * n)                 // 二乗
  .take(5)                         // 先頭5個
  .toArray();
 
console.log(result); // [0, 4, 64, 17956, ...]
// → fibonacci は必要な分だけ生成される（遅延評価）
 
// 自然数から素数を生成
function isPrime(n: number): boolean {
  if (n < 2) return false;
  for (let i = 2; i <= Math.sqrt(n); i++) {
    if (n % i === 0) return false;
  }
  return true;
}
 
const primes = Iter.naturals()
  .skip(2)
  .filter(isPrime)
  .take(10)
  .toArray();
 
console.log(primes); // [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
 
// チャンク分割 + マップ
const chunks = Iter.from(new Range(1, 11))
  .chunk(3)
  .map(chunk => chunk.reduce((a, b) => a + b, 0))
  .toArray();
 
console.log(chunks); // [6, 15, 24, 10]
// [1+2+3, 4+5+6, 7+8+9, 10]

# python_iterators.py -- Python のイテレータパターン
 
from __future__ import annotations
from typing import Iterator, Iterable, TypeVar, Callable, Generator
from dataclasses import dataclass
 
T = TypeVar("T")
U = TypeVar("U")
 
 
# ============================
# カスタム Range (Python 組込みの range と同等)
# ============================
class MyRange:
    """Python の range() を再実装"""
 
    def __init__(self, start: int, stop: int, step: int = 1):
        self.start = start
        self.stop = stop
        self.step = step
 
    def __iter__(self) -> Iterator[int]:
        """__iter__ = [Symbol.iterator] に相当"""
        current = self.start
        while (self.step > 0 and current < self.stop) or \
              (self.step < 0 and current > self.stop):
            yield current  # Python ではジェネレータで簡潔に書ける
            current += self.step
 
    def __len__(self) -> int:
        return max(0, (self.stop - self.start + self.step - 1) // self.step)
 
    def __contains__(self, value: int) -> bool:
        if self.step > 0:
            return self.start <= value < self.stop and (value - self.start) % self.step == 0
        else:
            return self.stop < value <= self.start and (self.start - value) % (-self.step) == 0
 
 
# ============================
# ジェネレータの応用: パイプライン
# ============================
def take(n: int, iterable: Iterable[T]) -> Generator[T, None, None]:
    """先頭 N 個を取得"""
    count = 0
    for item in iterable:
        if count >= n:
            return
        yield item
        count += 1
 
 
def chunk(iterable: Iterable[T], size: int) -> Generator[list[T], None, None]:
    """チャンク分割"""
    buf: list[T] = []
    for item in iterable:
        buf.append(item)
        if len(buf) >= size:
            yield buf
            buf = []
    if buf:
        yield buf
 
 
def flatten(iterable: Iterable[Iterable[T]]) -> Generator[T, None, None]:
    """ネストしたイテラブルをフラット化"""
    for inner in iterable:
        yield from inner  # yield from = yield* に相当
 
 
# ============================
# Python のイテレータ式 (Generator Expression)
# ============================
def demonstrate_generators():
    # リスト内包表記（即座に全要素を生成）
    squares_list = [x**2 for x in range(10)]  # list
 
    # ジェネレータ式（遅延評価）
    squares_gen = (x**2 for x in range(10))   # generator
 
    # メモリ効率の違い:
    # squares_list: 10個のint を全てメモリに保持
    # squares_gen:  1個ずつ生成、メモリはO(1)
 
    # パイプライン（関数の合成）
    import itertools
    result = list(
        itertools.islice(                    # take(5)
            filter(lambda x: x % 2 == 0,    # filter(even)
                (x**2 for x in range(100))   # map(square)
            ),
            5
        )
    )
    print(result)  # [0, 4, 16, 36, 64]
 
 
# ============================
# 使用例
# ============================
if __name__ == "__main__":
    # カスタム Range
    for n in MyRange(1, 5):
        print(n, end=" ")  # 1 2 3 4
    print()
 
    # チャンク分割
    for c in chunk(range(1, 11), 3):
        print(c)
    # [1, 2, 3]
    # [4, 5, 6]
    # [7, 8, 9]
    # [10]
 
    # itertools の活用
    demonstrate_generators()

// external-vs-internal.ts -- 外部イテレータと内部イテレータ
 
// ============================
// 外部イテレータ (External Iterator)
// ============================
// 利用者が明示的に next() を呼んで制御する
class ExternalIterator<T> {
  private iterator: Iterator<T>;
 
  constructor(iterable: Iterable<T>) {
    this.iterator = iterable[Symbol.iterator]();
  }
 
  /** 次の要素があるか */
  hasNext(): boolean {
    const result = this.iterator.next();
    if (result.done) return false;
    // peek のために値を戻す必要があるが、Iterator は巻き戻せない
    // → 実用的には1要素先読みバッファが必要
    return true;
  }
 
  /** 次の要素を取得 */
  next(): T {
    const result = this.iterator.next();
    if (result.done) throw new Error('No more elements');
    return result.value;
  }
}
 
// 先読み付き外部イテレータ
class PeekableIterator<T> implements Iterable<T> {
  private iterator: Iterator<T>;
  private buffer: T[] = [];
 
  constructor(source: Iterable<T>) {
    this.iterator = source[Symbol.iterator]();
  }
 
  /** 次の要素を消費せずに確認 */
  peek(): T | undefined {
    if (this.buffer.length === 0) {
      const result = this.iterator.next();
      if (result.done) return undefined;
      this.buffer.push(result.value);
    }
    return this.buffer[0];
  }
 
  /** 次の要素を取得して消費 */
  next(): T | undefined {
    if (this.buffer.length > 0) {
      return this.buffer.shift();
    }
    const result = this.iterator.next();
    return result.done ? undefined : result.value;
  }
 
  hasNext(): boolean {
    return this.peek() !== undefined;
  }
 
  [Symbol.iterator](): Iterator<T> {
    return {
      next: () => {
        const value = this.next();
        if (value === undefined) {
          return { value: undefined, done: true };
        }
        return { value, done: false };
      },
    };
  }
}
 
// ============================
// 内部イテレータ (Internal Iterator)
// ============================
// コレクション側が走査を制御し、コールバックを呼ぶ
class InternalIterator<T> {
  constructor(private items: T[]) {}
 
  forEach(callback: (item: T, index: number) => void): void {
    for (let i = 0; i < this.items.length; i++) {
      callback(this.items[i], i);
    }
  }
 
  map<U>(fn: (item: T) => U): U[] {
    const result: U[] = [];
    this.forEach(item => result.push(fn(item)));
    return result;
  }
 
  find(predicate: (item: T) => boolean): T | undefined {
    for (const item of this.items) {
      if (predicate(item)) return item;
    }
    return undefined;
  }
}
 
// ============================
// 外部イテレータの活用例: トークナイザー
// ============================
function* tokenize(input: string): Generator<{ type: string; value: string }> {
  const patterns = [
    { type: 'number', regex: /^\d+/ },
    { type: 'operator', regex: /^[+\-*/]/ },
    { type: 'paren', regex: /^[()]/ },
    { type: 'whitespace', regex: /^\s+/ },
  ];
 
  let pos = 0;
  while (pos < input.length) {
    let matched = false;
    for (const { type, regex } of patterns) {
      const match = input.slice(pos).match(regex);
      if (match) {
        if (type !== 'whitespace') {
          yield { type, value: match[0] };
        }
        pos += match[0].length;
        matched = true;
        break;
      }
    }
    if (!matched) {
      throw new Error(`Unexpected character at position ${pos}: '${input[pos]}'`);
    }
  }
}
 
// PeekableIterator でパーサーを実装
function parseExpression(tokens: PeekableIterator<{ type: string; value: string }>): number {
  let result = parseTerm(tokens);
 
  while (tokens.peek()?.type === 'operator' &&
         ['+', '-'].includes(tokens.peek()!.value)) {
    const op = tokens.next()!.value;
    const right = parseTerm(tokens);
    result = op === '+' ? result + right : result - right;
  }
 
  return result;
}
 
function parseTerm(tokens: PeekableIterator<{ type: string; value: string }>): number {
  const token = tokens.next();
  if (!token) throw new Error('Unexpected end of input');
  if (token.type === 'number') return parseInt(token.value);
  if (token.type === 'paren' && token.value === '(') {
    const result = parseExpression(tokens);
    tokens.next(); // consume ')'
    return result;
  }
  throw new Error(`Unexpected token: ${token.value}`);
}
 
// 使用例
const tokens = new PeekableIterator(tokenize('3 + 5 - 2'));
console.log(parseExpression(tokens)); // 6

// ============================
// [NG] 100万件を配列に全て読み込み
// ============================
const allUsers = await fetchAllUsers(); // メモリに100万件!
const activeUsers = allUsers.filter(u => u.active);
const names = activeUsers.map(u => u.name);
// → 中間配列が2つ生成される
// → メモリ使用量: 100万件 × 3 配列
 
// ============================
// [OK] ジェネレータで1件ずつ処理
// ============================
async function* fetchActiveUserNames(): AsyncGenerator<string> {
  for await (const user of fetchAllPages<User>('/api/users')) {
    if (user.active) {
      yield user.name;
    }
  }
}
 
// メモリ使用量はページサイズ分のみ
const names2: string[] = [];
for await (const name of fetchActiveUserNames()) {
  names2.push(name);
  if (names2.length >= 100) break; // 早期終了も可能
}

// ============================
// [NG] 同じイテレータを2回消費しようとする
// ============================
function* nums() { yield 1; yield 2; yield 3; }
const iter = nums();
 
console.log([...iter]); // [1, 2, 3]
console.log([...iter]); // [] ← 空! イテレータは使い切り
 
// ============================
// [OK 方法1] Iterable を保持し、必要なときに新しい Iterator を生成
// ============================
const range = new Range(1, 4);
console.log([...range]); // [1, 2, 3]
console.log([...range]); // [1, 2, 3] ← Iterable なので何度でも
 
// ============================
// [OK 方法2] ジェネレータをファクトリ関数でラップ
// ============================
function numsIterable(): Iterable<number> {
  return {
    *[Symbol.iterator]() { yield 1; yield 2; yield 3; }
  };
}
 
const reusable = numsIterable();
console.log([...reusable]); // [1, 2, 3]
console.log([...reusable]); // [1, 2, 3] ← OK

// ============================
// [NG] forEach 内で async/await が期待通り動かない
// ============================
const urls = ['url1', 'url2', 'url3'];
 
// forEach は同期的に全コールバックを起動する
urls.forEach(async (url) => {
  const data = await fetch(url);
  console.log(data); // 順序不定、エラーも捕捉できない
});
console.log('完了'); // ← forEach のコールバックより先に実行される!
 
// ============================
// [OK] for...of + await で逐次処理
// ============================
for (const url of urls) {
  const data = await fetch(url);
  console.log(data); // 順序保証、try/catch で捕捉可能
}
console.log('完了'); // ← 全 fetch 完了後に実行
 
// [OK] 並列実行が必要な場合は Promise.all
const results = await Promise.all(urls.map(url => fetch(url)));

// ヒント
interface BSTNode<T> {
  value: T;
  left: BSTNode<T> | null;
  right: BSTNode<T> | null;
}

// ヒント: ジョブの定義
function* downloadJob(url: string): Generator<string, void, void> {
  yield `Starting download: ${url}`;
  yield `Downloading... 50%`;
  yield `Downloading... 100%`;
  yield `Download complete: ${url}`;
}

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

// 実践的なエラーハンドリング
async function* resilientFetch<T>(
  urls: string[]
): AsyncGenerator<T> {
  for (const url of urls) {
    try {
      const res = await fetch(url);
      if (!res.ok) {
        console.warn(`Skipping ${url}: ${res.status}`);
        continue; // 個別ページのエラーはスキップ
      }
      const data = await res.json();
      yield data;
    } catch (err) {
      console.warn(`Network error for ${url}:`, err);
      // 致命的でなければ continue、致命的なら throw
    }
  }
}

function* example() {
  yield 1;               // 1つの値
  yield* [2, 3, 4];      // 配列の全要素を順に
  yield* anotherGen();   // 別の Generator の全要素を順に
  yield 5;
}
// 結果: 1, 2, 3, 4, (anotherGen の全出力), 5