Iterators, Generators & Symbols

// The iterable protocol: an object with a [Symbol.iterator] method
const range = {
  from: 1,
  to: 5,
  [Symbol.iterator]() {
    let current = this.from
    const last = this.to
    return {
      next() {
        return current <= last
          ? { value: current++, done: false }
          : { value: undefined, done: true }
      },
    }
  },
}

console.log([...range])          // [1, 2, 3, 4, 5]
for (const n of range) console.log(n)
const [first, second] = range    // 1, 2

// Generators write the same thing in three lines
function* rangeGen(from, to, step = 1) {
  for (let i = from; i <= to; i += step) yield i
}
console.log([...rangeGen(0, 10, 2)])   // [0, 2, 4, 6, 8, 10]
 

// Generators are lazy — nothing runs until you pull
function* idGenerator() {
  let id = 1
  while (true) yield id++     // infinite, but harmless
}
const ids = idGenerator()
console.log(ids.next().value)  // 1
console.log(ids.next().value)  // 2

// yield* delegates to another iterable
function* walk(node) {
  yield node.value
  for (const child of node.children ?? []) yield* walk(child)
}

const tree = {
  value: 'root',
  children: [
    { value: 'a', children: [{ value: 'a1' }] },
    { value: 'b' },
  ],
}
console.log([...walk(tree)])   // ['root', 'a', 'a1', 'b']

// Two-way: next(v) sends a value back INTO the generator
function* adder() {
  let total = 0
  while (true) {
    const n = yield total     // the yielded value goes out, next()'s arg comes in
    total += n
  }
}
const acc = adder()
acc.next()          // prime it
console.log(acc.next(5).value)   // 5
console.log(acc.next(3).value)   // 8
 

// Async iteration — for await...of over a stream of promises
async function* fetchPages(url) {
  let next = url
  while (next) {
    const res = await fetch(next)
    const page = await res.json()
    yield* page.items          // hand out each item
    next = page.nextUrl        // then request the next page
  }
}

for await (const item of fetchPages('/api/items?page=1')) {
  console.log(item.id)         // consumer never sees the pagination
}

// Symbols: unique keys that never collide with string keys
const CACHE = Symbol('cache')
class Repo {
  constructor() { this[CACHE] = new Map() }
  get(id) {
    if (!this[CACHE].has(id)) this[CACHE].set(id, { id })
    return this[CACHE].get(id)
  }
}
const repo = new Repo()
console.log(Object.keys(repo))   // []  — symbol keys are hidden from enumeration