An iterator can reveal values one at a time, but school projects often need a real array for indexing, display or repeated array operations. Iterator.prototype.toArray is the terminal bridge between those two models.

The ECMAScript algorithm requires an object receiver, obtains its iterator directly, repeatedly steps it, appends each value to a new list and returns a new Array when the source reports done. The call eagerly consumes the iterator.

This guide teaches order, exhaustion, empty and partial sources, generator errors, memory limits, infinite-source safety, dense array results and the choice between toArray, spread, Array.from and manual iteration.

Punggol families can use this guide in short sessions around homework, CCAs and rest. The examples are proposed learning activities. They do not claim a physical tuition branch, timetable, fee, class size, school relationship or guaranteed result.

Use disposable data and repositories, preserve backups and check version-sensitive details against the linked primary source. Current documentation settles a technical contract; observation and explanation turn that contract into usable knowledge.

Iterator.prototype.toArray pulls the receiver until done and returns a new Array containing the yielded values. That is the invariant to preserve when names, data or surrounding project details change.

An array cannot be returned until the consumer has reached the finite end. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is treating toArray as another lazy helper. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const values=Iterator.from([2,4,6]).toArray();
console.log(values)

Read the trace, not just the last line

Trace call, each step, append and final array creation. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “toArray is an eager terminal consumer”, separate contract from coincidence. The contract is “Iterator.prototype.toArray pulls the receiver until done and returns a new Array containing the yielded values.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use a source that logs every next call.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “toArray is an eager terminal consumer” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.prototype.toArray pulls the receiver until done and returns a new Array containing the yielded values.” should remain invariant and what observation would expose treating toArray as another lazy helper.

Case 2: CCA event feed. Contrast “toArray is an eager terminal consumer” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.prototype.toArray pulls the receiver until done and returns a new Array containing the yielded values.” should remain invariant and what observation would expose treating toArray as another lazy helper.

Case 3: science reading pipeline. Stress-test “toArray is an eager terminal consumer” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.prototype.toArray pulls the receiver until done and returns a new Array containing the yielded values.” should remain invariant and what observation would expose treating toArray as another lazy helper.

Case 4: revision generator. Explain “toArray is an eager terminal consumer” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.prototype.toArray pulls the receiver until done and returns a new Array containing the yielded values.” should remain invariant and what observation would expose treating toArray as another lazy helper.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals treating toArray as another lazy helper.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use a source that logs every next call.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “toArray is an eager terminal consumer”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Iterator.prototype.toArray pulls the receiver until done and returns a new Array containing the yielded values.?”, and “Can you make a smaller example of treating toArray as another lazy helper?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict when the source logs occur. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Materialise only when an eager boundary is intended. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “toArray is an eager terminal consumer” means the learner can predict the ordinary case, recognise treating toArray as another lazy helper, diagnose the earliest mistaken assumption, recover with “Use a source that logs every next call.” and defend this decision: Materialise only when an eager boundary is intended. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The specification throws TypeError when the this value is not an object. That is the invariant to preserve when names, data or surrounding project details change.

Iterator helper methods operate on iterator objects. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is borrowing the method onto null or a primitive. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

Iterator.prototype.toArray.call(null)

Read the trace, not just the last line

Trace receiver validation before GetIteratorDirect. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “The receiver must be an object”, separate contract from coincidence. The contract is “The specification throws TypeError when the this value is not an object.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Test the receiver check in a disposable runtime.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “The receiver must be an object” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “The specification throws TypeError when the this value is not an object.” should remain invariant and what observation would expose borrowing the method onto null or a primitive.

Case 2: CCA event feed. Contrast “The receiver must be an object” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “The specification throws TypeError when the this value is not an object.” should remain invariant and what observation would expose borrowing the method onto null or a primitive.

Case 3: science reading pipeline. Stress-test “The receiver must be an object” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “The specification throws TypeError when the this value is not an object.” should remain invariant and what observation would expose borrowing the method onto null or a primitive.

Case 4: revision generator. Explain “The receiver must be an object” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “The specification throws TypeError when the this value is not an object.” should remain invariant and what observation would expose borrowing the method onto null or a primitive.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals borrowing the method onto null or a primitive.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Test the receiver check in a disposable runtime.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “The receiver must be an object”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The specification throws TypeError when the this value is not an object.?”, and “Can you make a smaller example of borrowing the method onto null or a primitive?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Compare null with Iterator.from([]). Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Adapt iterables with Iterator.from. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “The receiver must be an object” means the learner can predict the ordinary case, recognise borrowing the method onto null or a primitive, diagnose the earliest mistaken assumption, recover with “Test the receiver check in a disposable runtime.” and defend this decision: Adapt iterables with Iterator.from. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The method obtains an iterator record directly from the receiver rather than asking for a separate replayable source. That is the invariant to preserve when names, data or surrounding project details change.

Direct iterator consumption preserves the receiver cursor. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is assuming Symbol.iterator creates a fresh pass for this call. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const it=Iterator.from([1,2]);
console.log(it.toArray())

Read the trace, not just the last line

Trace the first manual next and subsequent direct steps. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “GetIteratorDirect uses the receiver cursor”, separate contract from coincidence. The contract is “The method obtains an iterator record directly from the receiver rather than asking for a separate replayable source.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Advance the iterator once before calling toArray.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “GetIteratorDirect uses the receiver cursor” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “The method obtains an iterator record directly from the receiver rather than asking for a separate replayable source.” should remain invariant and what observation would expose assuming Symbol.iterator creates a fresh pass for this call.

Case 2: CCA event feed. Contrast “GetIteratorDirect uses the receiver cursor” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “The method obtains an iterator record directly from the receiver rather than asking for a separate replayable source.” should remain invariant and what observation would expose assuming Symbol.iterator creates a fresh pass for this call.

Case 3: science reading pipeline. Stress-test “GetIteratorDirect uses the receiver cursor” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “The method obtains an iterator record directly from the receiver rather than asking for a separate replayable source.” should remain invariant and what observation would expose assuming Symbol.iterator creates a fresh pass for this call.

Case 4: revision generator. Explain “GetIteratorDirect uses the receiver cursor” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “The method obtains an iterator record directly from the receiver rather than asking for a separate replayable source.” should remain invariant and what observation would expose assuming Symbol.iterator creates a fresh pass for this call.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals assuming Symbol.iterator creates a fresh pass for this call.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Advance the iterator once before calling toArray.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “GetIteratorDirect uses the receiver cursor”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The method obtains an iterator record directly from the receiver rather than asking for a separate replayable source.?”, and “Can you make a smaller example of assuming Symbol.iterator creates a fresh pass for this call?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict the result after one pull. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Make cursor ownership explicit. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “GetIteratorDirect uses the receiver cursor” means the learner can predict the ordinary case, recognise assuming Symbol.iterator creates a fresh pass for this call, diagnose the earliest mistaken assumption, recover with “Advance the iterator once before calling toArray.” and defend this decision: Make cursor ownership explicit. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

When the first step reports done, toArray returns a new empty Array. That is the invariant to preserve when names, data or surrounding project details change.

Completion without values is a valid collection result. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is using null to represent a normal empty sequence. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const out=Iterator.from([]).toArray();
console.log(out, Array.isArray(out))

Read the trace, not just the last line

Trace first step and immediate array creation. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “An empty iterator becomes an empty array”, separate contract from coincidence. The contract is “When the first step reports done, toArray returns a new empty Array.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Test empty and one-value sources side by side.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “An empty iterator becomes an empty array” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “When the first step reports done, toArray returns a new empty Array.” should remain invariant and what observation would expose using null to represent a normal empty sequence.

Case 2: CCA event feed. Contrast “An empty iterator becomes an empty array” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “When the first step reports done, toArray returns a new empty Array.” should remain invariant and what observation would expose using null to represent a normal empty sequence.

Case 3: science reading pipeline. Stress-test “An empty iterator becomes an empty array” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “When the first step reports done, toArray returns a new empty Array.” should remain invariant and what observation would expose using null to represent a normal empty sequence.

Case 4: revision generator. Explain “An empty iterator becomes an empty array” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “When the first step reports done, toArray returns a new empty Array.” should remain invariant and what observation would expose using null to represent a normal empty sequence.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals using null to represent a normal empty sequence.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Test empty and one-value sources side by side.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “An empty iterator becomes an empty array”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests When the first step reports done, toArray returns a new empty Array.?”, and “Can you make a smaller example of using null to represent a normal empty sequence?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict the empty result. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Let array emptiness represent normal zero-item completion. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “An empty iterator becomes an empty array” means the learner can predict the ordinary case, recognise using null to represent a normal empty sequence, diagnose the earliest mistaken assumption, recover with “Test empty and one-value sources side by side.” and defend this decision: Let array emptiness represent normal zero-item completion. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Values are appended in the order the iterator produces them. That is the invariant to preserve when names, data or surrounding project details change.

Materialisation preserves iteration order. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is expecting toArray to sort or normalise values. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

function* g(){yield 'c';yield 'a';yield 'b'}
console.log(g().toArray())

Read the trace, not just the last line

Trace yielded value to appended array index. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “Yield order becomes array index order”, separate contract from coincidence. The contract is “Values are appended in the order the iterator produces them.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use a deliberately non-sorted generator.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “Yield order becomes array index order” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “Values are appended in the order the iterator produces them.” should remain invariant and what observation would expose expecting toArray to sort or normalise values.

Case 2: CCA event feed. Contrast “Yield order becomes array index order” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “Values are appended in the order the iterator produces them.” should remain invariant and what observation would expose expecting toArray to sort or normalise values.

Case 3: science reading pipeline. Stress-test “Yield order becomes array index order” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “Values are appended in the order the iterator produces them.” should remain invariant and what observation would expose expecting toArray to sort or normalise values.

Case 4: revision generator. Explain “Yield order becomes array index order” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “Values are appended in the order the iterator produces them.” should remain invariant and what observation would expose expecting toArray to sort or normalise values.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals expecting toArray to sort or normalise values.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use a deliberately non-sorted generator.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “Yield order becomes array index order”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Values are appended in the order the iterator produces them.?”, and “Can you make a smaller example of expecting toArray to sort or normalise values?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Write the index mapping. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Sort only when sorting is a separate reader job. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Yield order becomes array index order” means the learner can predict the ordinary case, recognise expecting toArray to sort or normalise values, diagnose the earliest mistaken assumption, recover with “Use a deliberately non-sorted generator.” and defend this decision: Sort only when sorting is a separate reader job. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A normal toArray call consumes the receiver through its done result. That is the invariant to preserve when names, data or surrounding project details change.

Iterators carry a cursor, while arrays preserve collected values. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is trying to reuse one iterator for a second report. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const it=Iterator.from([1,2]);
const first=it.toArray();
console.log(it.next())

Read the trace, not just the last line

Trace one shared cursor. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “The source is exhausted after successful collection”, separate contract from coincidence. The contract is “A normal toArray call consumes the receiver through its done result.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Inspect next before and after collection in separate fixtures.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “The source is exhausted after successful collection” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “A normal toArray call consumes the receiver through its done result.” should remain invariant and what observation would expose trying to reuse one iterator for a second report.

Case 2: CCA event feed. Contrast “The source is exhausted after successful collection” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “A normal toArray call consumes the receiver through its done result.” should remain invariant and what observation would expose trying to reuse one iterator for a second report.

Case 3: science reading pipeline. Stress-test “The source is exhausted after successful collection” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “A normal toArray call consumes the receiver through its done result.” should remain invariant and what observation would expose trying to reuse one iterator for a second report.

Case 4: revision generator. Explain “The source is exhausted after successful collection” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “A normal toArray call consumes the receiver through its done result.” should remain invariant and what observation would expose trying to reuse one iterator for a second report.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals trying to reuse one iterator for a second report.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Inspect next before and after collection in separate fixtures.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “The source is exhausted after successful collection”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A normal toArray call consumes the receiver through its done result.?”, and “Can you make a smaller example of trying to reuse one iterator for a second report?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Call toArray twice on one iterator. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Create a fresh iterator for a fresh pass. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “The source is exhausted after successful collection” means the learner can predict the ordinary case, recognise trying to reuse one iterator for a second report, diagnose the earliest mistaken assumption, recover with “Inspect next before and after collection in separate fixtures.” and defend this decision: Create a fresh iterator for a fresh pass. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

toArray starts at the receiver’s current cursor rather than its original beginning. That is the invariant to preserve when names, data or surrounding project details change.

The earlier pull legitimately owns the first value. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is calling the result incomplete data corruption. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const it=Iterator.from([10,20,30]);
it.next();
console.log(it.toArray())

Read the trace, not just the last line

Trace cursor positions 0, 1 and done. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “A partially consumed iterator yields only its remainder”, separate contract from coincidence. The contract is “toArray starts at the receiver’s current cursor rather than its original beginning.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Record every consumer of the iterator.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “A partially consumed iterator yields only its remainder” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “toArray starts at the receiver’s current cursor rather than its original beginning.” should remain invariant and what observation would expose calling the result incomplete data corruption.

Case 2: CCA event feed. Contrast “A partially consumed iterator yields only its remainder” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “toArray starts at the receiver’s current cursor rather than its original beginning.” should remain invariant and what observation would expose calling the result incomplete data corruption.

Case 3: science reading pipeline. Stress-test “A partially consumed iterator yields only its remainder” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “toArray starts at the receiver’s current cursor rather than its original beginning.” should remain invariant and what observation would expose calling the result incomplete data corruption.

Case 4: revision generator. Explain “A partially consumed iterator yields only its remainder” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “toArray starts at the receiver’s current cursor rather than its original beginning.” should remain invariant and what observation would expose calling the result incomplete data corruption.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals calling the result incomplete data corruption.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Record every consumer of the iterator.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “A partially consumed iterator yields only its remainder”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests toArray starts at the receiver’s current cursor rather than its original beginning.?”, and “Can you make a smaller example of calling the result incomplete data corruption?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict the collected remainder. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Avoid hidden shared consumers. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “A partially consumed iterator yields only its remainder” means the learner can predict the ordinary case, recognise calling the result incomplete data corruption, diagnose the earliest mistaken assumption, recover with “Record every consumer of the iterator.” and defend this decision: Avoid hidden shared consumers. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

CreateArrayFromList produces a new Array rather than returning the iterator or its source collection. That is the invariant to preserve when names, data or surrounding project details change.

A materialised snapshot has separate container identity. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is confusing equal elements with object identity. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const source=[1,2];
const out=source.values().toArray();
console.log(out===source)

Read the trace, not just the last line

Trace source array, iterator and result array identities. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “The output is a new ordinary Array”, separate contract from coincidence. The contract is “CreateArrayFromList produces a new Array rather than returning the iterator or its source collection.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Mutate the output container after collection.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “The output is a new ordinary Array” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “CreateArrayFromList produces a new Array rather than returning the iterator or its source collection.” should remain invariant and what observation would expose confusing equal elements with object identity.

Case 2: CCA event feed. Contrast “The output is a new ordinary Array” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “CreateArrayFromList produces a new Array rather than returning the iterator or its source collection.” should remain invariant and what observation would expose confusing equal elements with object identity.

Case 3: science reading pipeline. Stress-test “The output is a new ordinary Array” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “CreateArrayFromList produces a new Array rather than returning the iterator or its source collection.” should remain invariant and what observation would expose confusing equal elements with object identity.

Case 4: revision generator. Explain “The output is a new ordinary Array” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “CreateArrayFromList produces a new Array rather than returning the iterator or its source collection.” should remain invariant and what observation would expose confusing equal elements with object identity.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals confusing equal elements with object identity.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Mutate the output container after collection.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “The output is a new ordinary Array”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests CreateArrayFromList produces a new Array rather than returning the iterator or its source collection.?”, and “Can you make a smaller example of confusing equal elements with object identity?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Push into out. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Treat the output as a new collection. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “The output is a new ordinary Array” means the learner can predict the ordinary case, recognise confusing equal elements with object identity, diagnose the earliest mistaken assumption, recover with “Mutate the output container after collection.” and defend this decision: Treat the output as a new collection. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

An array iterator visits indices and can yield undefined for a hole; toArray appends that value into a dense result. That is the invariant to preserve when names, data or surrounding project details change.

Iterators communicate values, not the original property-hole metadata. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is expecting sparse structure to be preserved automatically. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const source=[,2];
const out=source.values().toArray();
console.log(0 in out, out[0], out.length)

Read the trace, not just the last line

Trace array iterator yield and append. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “Array holes become yielded values”, separate contract from coincidence. The contract is “An array iterator visits indices and can yield undefined for a hole; toArray appends that value into a dense result.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Inspect 0 in source and 0 in out.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “Array holes become yielded values” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “An array iterator visits indices and can yield undefined for a hole; toArray appends that value into a dense result.” should remain invariant and what observation would expose expecting sparse structure to be preserved automatically.

Case 2: CCA event feed. Contrast “Array holes become yielded values” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “An array iterator visits indices and can yield undefined for a hole; toArray appends that value into a dense result.” should remain invariant and what observation would expose expecting sparse structure to be preserved automatically.

Case 3: science reading pipeline. Stress-test “Array holes become yielded values” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “An array iterator visits indices and can yield undefined for a hole; toArray appends that value into a dense result.” should remain invariant and what observation would expose expecting sparse structure to be preserved automatically.

Case 4: revision generator. Explain “Array holes become yielded values” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “An array iterator visits indices and can yield undefined for a hole; toArray appends that value into a dense result.” should remain invariant and what observation would expose expecting sparse structure to be preserved automatically.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals expecting sparse structure to be preserved automatically.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Inspect 0 in source and 0 in out.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “Array holes become yielded values”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests An array iterator visits indices and can yield undefined for a hole; toArray appends that value into a dense result.?”, and “Can you make a smaller example of expecting sparse structure to be preserved automatically?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Compare the two membership checks. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use a structure-aware copy when holes matter. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Array holes become yielded values” means the learner can predict the ordinary case, recognise expecting sparse structure to be preserved automatically, diagnose the earliest mistaken assumption, recover with “Inspect 0 in source and 0 in out.” and defend this decision: Use a structure-aware copy when holes matter. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

toArray is a shallow materialisation of yielded values. That is the invariant to preserve when names, data or surrounding project details change.

Container creation and element cloning are different operations. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is assuming a new array deep-clones its elements. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const obj={score:1};
const out=Iterator.from([obj]).toArray();
out[0].score=2;
console.log(obj.score)

Read the trace, not just the last line

Trace reference append and later property mutation. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “Object references remain references”, separate contract from coincidence. The contract is “toArray is a shallow materialisation of yielded values.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use one harmless object and compare identity.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “Object references remain references” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “toArray is a shallow materialisation of yielded values.” should remain invariant and what observation would expose assuming a new array deep-clones its elements.

Case 2: CCA event feed. Contrast “Object references remain references” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “toArray is a shallow materialisation of yielded values.” should remain invariant and what observation would expose assuming a new array deep-clones its elements.

Case 3: science reading pipeline. Stress-test “Object references remain references” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “toArray is a shallow materialisation of yielded values.” should remain invariant and what observation would expose assuming a new array deep-clones its elements.

Case 4: revision generator. Explain “Object references remain references” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “toArray is a shallow materialisation of yielded values.” should remain invariant and what observation would expose assuming a new array deep-clones its elements.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals assuming a new array deep-clones its elements.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use one harmless object and compare identity.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “Object references remain references”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests toArray is a shallow materialisation of yielded values.?”, and “Can you make a smaller example of assuming a new array deep-clones its elements?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict out[0]===obj. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Clone values separately only when that is the real requirement. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Object references remain references” means the learner can predict the ordinary case, recognise assuming a new array deep-clones its elements, diagnose the earliest mistaken assumption, recover with “Use one harmless object and compare identity.” and defend this decision: Clone values separately only when that is the real requirement. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

If stepping the iterator throws, toArray does not convert the error into a partial successful array. That is the invariant to preserve when names, data or surrounding project details change.

Failure and completion are different records. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is treating a thrown step as ordinary done. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const bad=Iterator.from({[Symbol.iterator](){return {next(){throw new Error('source')}}}});
bad.toArray()

Read the trace, not just the last line

Trace successful steps, failing next and propagated error. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “Source errors propagate”, separate contract from coincidence. The contract is “If stepping the iterator throws, toArray does not convert the error into a partial successful array.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use a custom iterator that logs before throwing.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “Source errors propagate” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “If stepping the iterator throws, toArray does not convert the error into a partial successful array.” should remain invariant and what observation would expose treating a thrown step as ordinary done.

Case 2: CCA event feed. Contrast “Source errors propagate” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “If stepping the iterator throws, toArray does not convert the error into a partial successful array.” should remain invariant and what observation would expose treating a thrown step as ordinary done.

Case 3: science reading pipeline. Stress-test “Source errors propagate” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “If stepping the iterator throws, toArray does not convert the error into a partial successful array.” should remain invariant and what observation would expose treating a thrown step as ordinary done.

Case 4: revision generator. Explain “Source errors propagate” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “If stepping the iterator throws, toArray does not convert the error into a partial successful array.” should remain invariant and what observation would expose treating a thrown step as ordinary done.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals treating a thrown step as ordinary done.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use a custom iterator that logs before throwing.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “Source errors propagate”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests If stepping the iterator throws, toArray does not convert the error into a partial successful array.?”, and “Can you make a smaller example of treating a thrown step as ordinary done?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Collect one value then throw. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Handle errors where a recovery policy exists. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Source errors propagate” means the learner can predict the ordinary case, recognise treating a thrown step as ordinary done, diagnose the earliest mistaken assumption, recover with “Use a custom iterator that logs before throwing.” and defend this decision: Handle errors where a recovery policy exists. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The specified algorithm uses IteratorStepValue directly and propagates an abrupt step without a separate IteratorClose step in toArray. That is the invariant to preserve when names, data or surrounding project details change.

Close behaviour must be read from the exact algorithm. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is copying cleanup rules from callback helpers onto every terminal consumer. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

// custom iterator: next() throws; return() logs cleanup

Read the trace, not just the last line

Trace specification steps and the runtime event ledger. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “toArray does not add an automatic close on a next error”, separate contract from coincidence. The contract is “The specified algorithm uses IteratorStepValue directly and propagates an abrupt step without a separate IteratorClose step in toArray.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use a logged custom iterator and observe next and return events.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “toArray does not add an automatic close on a next error” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “The specified algorithm uses IteratorStepValue directly and propagates an abrupt step without a separate IteratorClose step in toArray.” should remain invariant and what observation would expose copying cleanup rules from callback helpers onto every terminal consumer.

Case 2: CCA event feed. Contrast “toArray does not add an automatic close on a next error” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “The specified algorithm uses IteratorStepValue directly and propagates an abrupt step without a separate IteratorClose step in toArray.” should remain invariant and what observation would expose copying cleanup rules from callback helpers onto every terminal consumer.

Case 3: science reading pipeline. Stress-test “toArray does not add an automatic close on a next error” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “The specified algorithm uses IteratorStepValue directly and propagates an abrupt step without a separate IteratorClose step in toArray.” should remain invariant and what observation would expose copying cleanup rules from callback helpers onto every terminal consumer.

Case 4: revision generator. Explain “toArray does not add an automatic close on a next error” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “The specified algorithm uses IteratorStepValue directly and propagates an abrupt step without a separate IteratorClose step in toArray.” should remain invariant and what observation would expose copying cleanup rules from callback helpers onto every terminal consumer.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals copying cleanup rules from callback helpers onto every terminal consumer.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use a logged custom iterator and observe next and return events.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “toArray does not add an automatic close on a next error”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The specified algorithm uses IteratorStepValue directly and propagates an abrupt step without a separate IteratorClose step in toArray.?”, and “Can you make a smaller example of copying cleanup rules from callback helpers onto every terminal consumer?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict the return log after next throws. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Design source cleanup within the source or higher-level ownership policy. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “toArray does not add an automatic close on a next error” means the learner can predict the ordinary case, recognise copying cleanup rules from callback helpers onto every terminal consumer, diagnose the earliest mistaken assumption, recover with “Use a logged custom iterator and observe next and return events.” and defend this decision: Design source cleanup within the source or higher-level ownership policy. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A source that never reports done gives toArray no point at which to return the array. That is the invariant to preserve when names, data or surrounding project details change.

Eager materialisation requires a finite boundary. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is running an infinite example to see what happens. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

function* naturals(){let n=0;while(true)yield n++;}
// naturals().toArray() never completes normally

Read the trace, not just the last line

Trace done condition and accumulated item count. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “Infinite iterators make unbounded toArray unsafe”, separate contract from coincidence. The contract is “A source that never reports done gives toArray no point at which to return the array.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Test only through a take limit.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “Infinite iterators make unbounded toArray unsafe” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “A source that never reports done gives toArray no point at which to return the array.” should remain invariant and what observation would expose running an infinite example to see what happens.

Case 2: CCA event feed. Contrast “Infinite iterators make unbounded toArray unsafe” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “A source that never reports done gives toArray no point at which to return the array.” should remain invariant and what observation would expose running an infinite example to see what happens.

Case 3: science reading pipeline. Stress-test “Infinite iterators make unbounded toArray unsafe” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “A source that never reports done gives toArray no point at which to return the array.” should remain invariant and what observation would expose running an infinite example to see what happens.

Case 4: revision generator. Explain “Infinite iterators make unbounded toArray unsafe” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “A source that never reports done gives toArray no point at which to return the array.” should remain invariant and what observation would expose running an infinite example to see what happens.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals running an infinite example to see what happens.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Test only through a take limit.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “Infinite iterators make unbounded toArray unsafe”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A source that never reports done gives toArray no point at which to return the array.?”, and “Can you make a smaller example of running an infinite example to see what happens?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain why no array is returned. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Never materialise an unbounded iterator directly. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Infinite iterators make unbounded toArray unsafe” means the learner can predict the ordinary case, recognise running an infinite example to see what happens, diagnose the earliest mistaken assumption, recover with “Test only through a take limit.” and defend this decision: Never materialise an unbounded iterator directly. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A finite take helper can bound an otherwise endless source before toArray. That is the invariant to preserve when names, data or surrounding project details change.

The terminal consumer leaves no iterator pipeline for a later bound. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is putting take after toArray. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const out=naturals().take(5).toArray();
console.log(out)

Read the trace, not just the last line

Trace source, remaining limit, done and array. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “take can create a safe finite boundary”, separate contract from coincidence. The contract is “A finite take helper can bound an otherwise endless source before toArray.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Write the pipeline order before running.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “take can create a safe finite boundary” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “A finite take helper can bound an otherwise endless source before toArray.” should remain invariant and what observation would expose putting take after toArray.

Case 2: CCA event feed. Contrast “take can create a safe finite boundary” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “A finite take helper can bound an otherwise endless source before toArray.” should remain invariant and what observation would expose putting take after toArray.

Case 3: science reading pipeline. Stress-test “take can create a safe finite boundary” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “A finite take helper can bound an otherwise endless source before toArray.” should remain invariant and what observation would expose putting take after toArray.

Case 4: revision generator. Explain “take can create a safe finite boundary” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “A finite take helper can bound an otherwise endless source before toArray.” should remain invariant and what observation would expose putting take after toArray.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals putting take after toArray.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Write the pipeline order before running.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “take can create a safe finite boundary”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A finite take helper can bound an otherwise endless source before toArray.?”, and “Can you make a smaller example of putting take after toArray?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Compare orderings. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Place the bound before materialisation. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “take can create a safe finite boundary” means the learner can predict the ordinary case, recognise putting take after toArray, diagnose the earliest mistaken assumption, recover with “Write the pipeline order before running.” and defend this decision: Place the bound before materialisation. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The result array holds every yielded value at once. That is the invariant to preserve when names, data or surrounding project details change.

Lazy processing and materialised storage solve different jobs. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is collecting a huge stream because arrays feel convenient. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const out=Iterator.from(records).take(limit).toArray()

Read the trace, not just the last line

Trace item count and retained result size. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “Materialisation has a memory cost”, separate contract from coincidence. The contract is “The result array holds every yielded value at once.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Measure a small controlled limit rather than stressing a shared machine.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “Materialisation has a memory cost” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “The result array holds every yielded value at once.” should remain invariant and what observation would expose collecting a huge stream because arrays feel convenient.

Case 2: CCA event feed. Contrast “Materialisation has a memory cost” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “The result array holds every yielded value at once.” should remain invariant and what observation would expose collecting a huge stream because arrays feel convenient.

Case 3: science reading pipeline. Stress-test “Materialisation has a memory cost” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “The result array holds every yielded value at once.” should remain invariant and what observation would expose collecting a huge stream because arrays feel convenient.

Case 4: revision generator. Explain “Materialisation has a memory cost” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “The result array holds every yielded value at once.” should remain invariant and what observation would expose collecting a huge stream because arrays feel convenient.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals collecting a huge stream because arrays feel convenient.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Measure a small controlled limit rather than stressing a shared machine.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “Materialisation has a memory cost”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The result array holds every yielded value at once.?”, and “Can you make a smaller example of collecting a huge stream because arrays feel convenient?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Choose between one-pass processing and collection. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Set explicit bounds for potentially large sources. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Materialisation has a memory cost” means the learner can predict the ordinary case, recognise collecting a huge stream because arrays feel convenient, diagnose the earliest mistaken assumption, recover with “Measure a small controlled limit rather than stressing a shared machine.” and defend this decision: Set explicit bounds for potentially large sources. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Iterator map and filter helpers produce values on demand; toArray triggers their evaluation to completion. That is the invariant to preserve when names, data or surrounding project details change.

Iterator helpers can preserve lazy stages before the terminal boundary. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is assuming map already built an intermediate array. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const out=Iterator.from([1,2,3,4]).filter(x=>x%2===0).map(x=>x*10).toArray()

Read the trace, not just the last line

Trace source pull, predicate, mapper and append for each item. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “Pipelines remain lazy until toArray”, separate contract from coincidence. The contract is “Iterator map and filter helpers produce values on demand; toArray triggers their evaluation to completion.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Add logs inside predicate and mapper.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “Pipelines remain lazy until toArray” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “Iterator map and filter helpers produce values on demand; toArray triggers their evaluation to completion.” should remain invariant and what observation would expose assuming map already built an intermediate array.

Case 2: CCA event feed. Contrast “Pipelines remain lazy until toArray” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “Iterator map and filter helpers produce values on demand; toArray triggers their evaluation to completion.” should remain invariant and what observation would expose assuming map already built an intermediate array.

Case 3: science reading pipeline. Stress-test “Pipelines remain lazy until toArray” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “Iterator map and filter helpers produce values on demand; toArray triggers their evaluation to completion.” should remain invariant and what observation would expose assuming map already built an intermediate array.

Case 4: revision generator. Explain “Pipelines remain lazy until toArray” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “Iterator map and filter helpers produce values on demand; toArray triggers their evaluation to completion.” should remain invariant and what observation would expose assuming map already built an intermediate array.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals assuming map already built an intermediate array.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Add logs inside predicate and mapper.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “Pipelines remain lazy until toArray”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Iterator map and filter helpers produce values on demand; toArray triggers their evaluation to completion.?”, and “Can you make a smaller example of assuming map already built an intermediate array?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict call order. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Put selective lazy work before collection. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Pipelines remain lazy until toArray” means the learner can predict the ordinary case, recognise assuming map already built an intermediate array, diagnose the earliest mistaken assumption, recover with “Add logs inside predicate and mapper.” and defend this decision: Put selective lazy work before collection. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Normal generator completion reaches its finally block as the generator finishes. That is the invariant to preserve when names, data or surrounding project details change.

Generator completion and explicit IteratorClose are distinct paths. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is crediting toArray with an abrupt-close rule that was not used. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

let closed=false;
function* g(){try{yield 1}finally{closed=true}}
console.log(g().toArray(), closed)

Read the trace, not just the last line

Trace yield, resume, finally, done and array creation. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “A generator finally block runs on normal exhaustion”, separate contract from coincidence. The contract is “Normal generator completion reaches its finally block as the generator finishes.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Observe ordinary exhaustion separately from thrown next.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “A generator finally block runs on normal exhaustion” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “Normal generator completion reaches its finally block as the generator finishes.” should remain invariant and what observation would expose crediting toArray with an abrupt-close rule that was not used.

Case 2: CCA event feed. Contrast “A generator finally block runs on normal exhaustion” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “Normal generator completion reaches its finally block as the generator finishes.” should remain invariant and what observation would expose crediting toArray with an abrupt-close rule that was not used.

Case 3: science reading pipeline. Stress-test “A generator finally block runs on normal exhaustion” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “Normal generator completion reaches its finally block as the generator finishes.” should remain invariant and what observation would expose crediting toArray with an abrupt-close rule that was not used.

Case 4: revision generator. Explain “A generator finally block runs on normal exhaustion” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “Normal generator completion reaches its finally block as the generator finishes.” should remain invariant and what observation would expose crediting toArray with an abrupt-close rule that was not used.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals crediting toArray with an abrupt-close rule that was not used.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Observe ordinary exhaustion separately from thrown next.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “A generator finally block runs on normal exhaustion”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Normal generator completion reaches its finally block as the generator finishes.?”, and “Can you make a smaller example of crediting toArray with an abrupt-close rule that was not used?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain the finally timing. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Label normal completion and abrupt cleanup precisely. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “A generator finally block runs on normal exhaustion” means the learner can predict the ordinary case, recognise crediting toArray with an abrupt-close rule that was not used, diagnose the earliest mistaken assumption, recover with “Observe ordinary exhaustion separately from thrown next.” and defend this decision: Label normal completion and abrupt cleanup precisely. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Array.from can consume iterable or array-like inputs, while Iterator.prototype.toArray is an iterator method. That is the invariant to preserve when names, data or surrounding project details change.

An iterable collection and its iterator are related but distinct objects. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is using toArray directly on every iterable without obtaining an iterator helper. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

const fromSet=Array.from(new Set([1,2]));
const fromIterator=Iterator.from(new Set([1,2])).toArray();

Read the trace, not just the last line

Trace iterable adaptation and terminal consumption. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “Array.from adapts broader inputs”, separate contract from coincidence. The contract is “Array.from can consume iterable or array-like inputs, while Iterator.prototype.toArray is an iterator method.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Compare a Set with set.values().” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “Array.from adapts broader inputs” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “Array.from can consume iterable or array-like inputs, while Iterator.prototype.toArray is an iterator method.” should remain invariant and what observation would expose using toArray directly on every iterable without obtaining an iterator helper.

Case 2: CCA event feed. Contrast “Array.from adapts broader inputs” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “Array.from can consume iterable or array-like inputs, while Iterator.prototype.toArray is an iterator method.” should remain invariant and what observation would expose using toArray directly on every iterable without obtaining an iterator helper.

Case 3: science reading pipeline. Stress-test “Array.from adapts broader inputs” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “Array.from can consume iterable or array-like inputs, while Iterator.prototype.toArray is an iterator method.” should remain invariant and what observation would expose using toArray directly on every iterable without obtaining an iterator helper.

Case 4: revision generator. Explain “Array.from adapts broader inputs” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “Array.from can consume iterable or array-like inputs, while Iterator.prototype.toArray is an iterator method.” should remain invariant and what observation would expose using toArray directly on every iterable without obtaining an iterator helper.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals using toArray directly on every iterable without obtaining an iterator helper.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Compare a Set with set.values().
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “Array.from adapts broader inputs”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Array.from can consume iterable or array-like inputs, while Iterator.prototype.toArray is an iterator method.?”, and “Can you make a smaller example of using toArray directly on every iterable without obtaining an iterator helper?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Write the explicit helper route. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Choose Array.from for general input conversion and toArray for iterator pipelines. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Array.from adapts broader inputs” means the learner can predict the ordinary case, recognise using toArray directly on every iterable without obtaining an iterator helper, diagnose the earliest mistaken assumption, recover with “Compare a Set with set.values().” and defend this decision: Choose Array.from for general input conversion and toArray for iterator pipelines. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Iterator helpers require a runtime that implements Iterator.prototype.toArray. That is the invariant to preserve when names, data or surrounding project details change.

Language contract and deployment support must both be satisfied. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is debugging a missing method as an iterator-data error. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

console.log(typeof Iterator, typeof Iterator?.prototype?.toArray)

Read the trace, not just the last line

Trace feature check before source consumption. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “Runtime support is a deployment fact”, separate contract from coincidence. The contract is “Iterator helpers require a runtime that implements Iterator.prototype.toArray.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Record engine and version before choosing a fallback.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “Runtime support is a deployment fact” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “Iterator helpers require a runtime that implements Iterator.prototype.toArray.” should remain invariant and what observation would expose debugging a missing method as an iterator-data error.

Case 2: CCA event feed. Contrast “Runtime support is a deployment fact” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “Iterator helpers require a runtime that implements Iterator.prototype.toArray.” should remain invariant and what observation would expose debugging a missing method as an iterator-data error.

Case 3: science reading pipeline. Stress-test “Runtime support is a deployment fact” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “Iterator helpers require a runtime that implements Iterator.prototype.toArray.” should remain invariant and what observation would expose debugging a missing method as an iterator-data error.

Case 4: revision generator. Explain “Runtime support is a deployment fact” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “Iterator helpers require a runtime that implements Iterator.prototype.toArray.” should remain invariant and what observation would expose debugging a missing method as an iterator-data error.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals debugging a missing method as an iterator-data error.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Record engine and version before choosing a fallback.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “Runtime support is a deployment fact”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Iterator helpers require a runtime that implements Iterator.prototype.toArray.?”, and “Can you make a smaller example of debugging a missing method as an iterator-data error?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Design a compatibility gate. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Declare the runtime floor. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Runtime support is a deployment fact” means the learner can predict the ordinary case, recognise debugging a missing method as an iterator-data error, diagnose the earliest mistaken assumption, recover with “Record engine and version before choosing a fallback.” and defend this decision: Declare the runtime floor. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

toArray, spread, Array.from and a manual loop differ in source adaptation, clarity, control and memory policy. That is the invariant to preserve when names, data or surrounding project details change.

Method choice should expose ownership, bounds and output needs. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is using toArray reflexively even when no collection is required. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

// iterator pipeline
const rows=source.filter(valid).take(100).toArray()

Read the trace, not just the last line

Trace reader job to collection form. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.toArray, inspect next() calls, callback arguments, cursor position, return() cleanup and the final completion record; a single final value can hide the mechanism that produced it.

For “Choose the terminal collection form by source and goal”, separate contract from coincidence. The contract is “toArray, spread, Array.from and a manual loop differ in source adaptation, clarity, control and memory policy.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “State source type, maximum size, error policy and required output first.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework result stream. Model “Choose the terminal collection form by source and goal” with a finite iterator of answers, zero-based labels and a test sink. Before touching a tool, state which part of the case corresponds to the input, why “toArray, spread, Array.from and a manual loop differ in source adaptation, clarity, control and memory policy.” should remain invariant and what observation would expose using toArray reflexively even when no collection is required.

Case 2: CCA event feed. Contrast “Choose the terminal collection form by source and goal” with a generator of event records, controlled logging and an early callback failure. Before touching a tool, state which part of the case corresponds to the input, why “toArray, spread, Array.from and a manual loop differ in source adaptation, clarity, control and memory policy.” should remain invariant and what observation would expose using toArray reflexively even when no collection is required.

Case 3: science reading pipeline. Stress-test “Choose the terminal collection form by source and goal” with a bounded prefix of measurements and a one-pass consumer. Before touching a tool, state which part of the case corresponds to the input, why “toArray, spread, Array.from and a manual loop differ in source adaptation, clarity, control and memory policy.” should remain invariant and what observation would expose using toArray reflexively even when no collection is required.

Case 4: revision generator. Explain “Choose the terminal collection form by source and goal” with fresh iterators, deliberate side effects and an asynchronous save boundary. Before touching a tool, state which part of the case corresponds to the input, why “toArray, spread, Array.from and a manual loop differ in source adaptation, clarity, control and memory policy.” should remain invariant and what observation would expose using toArray reflexively even when no collection is required.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals using toArray reflexively even when no collection is required.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: State source type, maximum size, error policy and required output first.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.toArray to support “Choose the terminal collection form by source and goal”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests toArray, spread, Array.from and a manual loop differ in source adaptation, clarity, control and memory policy.?”, and “Can you make a smaller example of using toArray reflexively even when no collection is required?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Choose for bounded pipeline, general iterable conversion and streaming effect. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Prefer the narrowest terminal operation that makes the boundary obvious. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Choose the terminal collection form by source and goal” means the learner can predict the ordinary case, recognise using toArray reflexively even when no collection is required, diagnose the earliest mistaken assumption, recover with “State source type, maximum size, error policy and required output first.” and defend this decision: Prefer the narrowest terminal operation that makes the boundary obvious. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

For JavaScript Iterator.prototype.toArray, start with evidence rather than a label such as careless. Ask for one prediction and one trace. If the first transition is wrong, rebuild the model. If the model is sound but reference use is weak, practise finding the governing contract. If routine cases work but boundaries fail, vary one condition. If explanations transfer, move to a small project.

Punggol family routines are often busy, so use one complete JavaScript Iterator.prototype.toArray prediction–observation–explanation cycle while attention is good. Ten to twenty focused minutes can be enough. Keep a four-line record: concept, prediction, observed difference and next test. Stop when fatigue replaces reasoning.

Use disposable fixtures, temporary directories and test repositories. Backups remain necessary. The activities in this guide are proposed home-learning exercises, not advertised lesson times, branch facilities, school affiliations or outcome guarantees.

1. Prove eager materialisation

Log every next call during toArray. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

2. Observe the shared cursor

Pull once, then collect the remainder. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. Test holes and references

Compare sparse input and shared object identity. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. Audit an error path

Use a custom iterator that throws from next. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. Bound an infinite source

Apply take before toArray. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. Trace a lazy pipeline

Log filter, map and append order. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. Set compatibility policy

Record runtime support and an approved fallback. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. Choose the terminal form

Defend toArray, spread, Array.from or a loop for four jobs. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Frequently asked questions

How long should a practice session be?

Use one complete JavaScript Iterator.prototype.toArray prediction–observation–explanation cycle while attention remains good. Ten to twenty focused minutes can be enough.

Should every option or method be memorised?

No. For JavaScript Iterator.prototype.toArray, memorise governing distinctions and practise retrieving the primary reference. Understanding means predicting and explaining, not reciting a parameter list.

What if the result is correct but the explanation is weak?

Treat it as partial success. Ask for a trace and change one boundary. A reliable model survives controlled variation.

Is the shortest solution the best?

Not automatically. Prefer the solution whose semantics, failure modes and maintenance cost are easiest to justify for the actual project.

When should the official reference be used?

Use it whenever JavaScript Iterator.prototype.toArray syntax, supported values, version behaviour or implementation boundaries matter. The primary source settles the current contract.

How can a parent help without technical expertise?

Ask what was predicted, where the first difference appeared, what evidence matters and which smaller example could isolate it.

How do we test transfer?

Change the context, vocabulary and one boundary. Require the learner to identify the invariant before using a tool.

What should be saved after practice?

Keep the corrected rule, one trace, one boundary case and the next question. Avoid storing pages of unexplained output.

Can these exercises replace backups?

No. Use disposable examples and proper backups. Learning should not endanger schoolwork, repositories or personal data.

What counts as mastery?

The learner can predict, verify, diagnose, recover and justify a choice across more than one context, while knowing when to consult the current reference.

Primary and supporting references

• Primary technical source for JavaScript Iterator.prototype.toArray
• eduKatePunggol: How Studying Works

Return to contents