Iterable objects

Problem

What becomes confusing, fragile, or impossible without understanding iterable objects? This lesson answers that through explanation, a worked example, two runnable exercises, and a reference solution. No teacher-supplied worksheet is required.

JavaScript began as a small browser scripting language, then accumulated object, functional, metaprogramming, module, and runtime capabilities while preserving early coercion rules.

Concept explanation

Iterable objects belongs to “Iteration as protocol”. Iteration is protocol: iterator next returns {value, done}; iterable supplies iterator. This lesson turns iterable objects into a working part of weekly fixture.

For iterable objects, trace concrete input, state transition, output, and failure through a JavaScript semantic rule observable through values, property operations, scope, calls, or protocol steps.

Execution evaluates expressions against lexical environments. Objects are property tables linked through prototypes; functions are callable objects with closures. Apply that model to supplied normal, boundary, and failure cases; each case below names its input and expected evidence.

Example bank

Compare normal, boundary, failure, and cross-layer cases. Predict each observation before revealing the explanation.

Worked example

Start from supplied lab.mjs. Focus: Build iterable objects around this exact fixture: Implement range iterable and consume with for-of, spread, and destructuring.

1. Run: node lab.mjs
2. Save baseline evidence. Use property descriptors, scope panels, call stacks, console probes, and deliberately tiny cases.
3. Boundary case: Add iterable objects support for weekly boundary case: Stop early and implement return cleanup.
4. Failure case: Make iterable objects surface—not hide—this failure: Return malformed iterator result and capture consumer failure.

RESULT
iterable objects handles baseline and boundary while preserving this observable result: Lazy production, done transition, early cleanup, and protocol violation are logged in order. Starter-level baseline: Two labeled records print in stable order; each exposes value, runtime type, and string representation.

Starter material

Create lab.mjs, paste this exact content, then run the command below.

const cases = [
  { label: "baseline", input: 0 },
  { label: "boundary", input: 1 },
];

function observe(value) {
  // Change only this function while investigating iterable objects.
  return { value, type: typeof value, text: String(value) };
}

for (const test of cases) console.log(test.label, observe(test.input));

STOP / CLEANUPScripts exit by themselves; no cleanup command required.

Independent exercise

Add one real case: iterable objects

1. Create second case from blank file: Add iterable objects support for weekly boundary case: Stop early and implement return cleanup.
2. Then create controlled failure: Make iterable objects surface—not hide—this failure: Return malformed iterator result and capture consumer failure.
3. Use Chromium Sources · console · hx · Node REPL to prove behavior, then repair controlled failure.
4. Compare result against supplied acceptance checks and reference approach before marking complete.

Expected result

• iterable objects handles baseline and boundary while preserving this observable result: Lazy production, done transition, early cleanup, and protocol violation are logged in order.
• Two labeled records print in stable order; each exposes value, runtime type, and string representation.
• Controlled iterable objects failure produces captured evidence; repair restores stated invariant without hiding error.

Hints

Solution

Attempt both exercises before opening reference approach.