When a learner says “find the first matching value”, the sentence hides several decisions: what counts as a match, whether the source is consumed, what happens to a generator after success, and how no result differs from finding the value undefined.

JavaScript Iterator.prototype.find() consumes values in order, calls a predicate with each value and a zero-based counter, returns the first value whose predicate result is truthy, and closes the iterator before that successful return. If the iterator ends first, it returns undefined. Mastery means tracing those steps instead of treating find as a harmless array lookup.

This guide teaches the terminal contract, counter, truthiness, IteratorClose, thrown errors, one-shot sources, lazy pipelines, infinite streams, array contrasts, runtime support and tool choice through worked examples and explained practice.

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.find consumes an iterator and returns a value or undefined rather than another iterator. That is the invariant to preserve when names, data or surrounding project details change.

The method settles one search by advancing the source. 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 a lazy reusable helper after find returns. 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([3,8,10]);
console.log(it.find(x=>x%2===0));

Read the trace, not just the last line

Trace iterator position before each predicate and after return. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “find is a terminal iterator search”, separate contract from coincidence. The contract is “Iterator.prototype.find consumes an iterator and returns a value or undefined rather than another iterator.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Capture the iterator, call find once and inspect next only as a diagnostic.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “find is a terminal iterator search” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.prototype.find consumes an iterator and returns a value or undefined rather than another iterator.” should remain invariant and what observation would expose expecting a lazy reusable helper after find returns.

Case 2: CCA media catalogue. Contrast “find is a terminal iterator search” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.prototype.find consumes an iterator and returns a value or undefined rather than another iterator.” should remain invariant and what observation would expose expecting a lazy reusable helper after find returns.

Case 3: science investigation archive. Stress-test “find is a terminal iterator search” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.prototype.find consumes an iterator and returns a value or undefined rather than another iterator.” should remain invariant and what observation would expose expecting a lazy reusable helper after find returns.

Case 4: revision-note builder. Explain “find is a terminal iterator search” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.prototype.find consumes an iterator and returns a value or undefined rather than another iterator.” should remain invariant and what observation would expose expecting a lazy reusable helper after find returns.

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 a lazy reusable helper after find returns.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Capture the iterator, call find once and inspect next only as a diagnostic.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “find is a terminal iterator search”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Iterator.prototype.find consumes an iterator and returns a value or undefined rather than another iterator.?”, and “Can you make a smaller example of expecting a lazy reusable helper after find returns?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict the returned value and the later next 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

Use find when the desired product is the first matching value. 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 “find is a terminal iterator search” means the learner can predict the ordinary case, recognise expecting a lazy reusable helper after find returns, diagnose the earliest mistaken assumption, recover with “Capture the iterator, call find once and inspect next only as a diagnostic.” and defend this decision: Use find when the desired product is the first matching value. 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 predicate is called with value and a counter beginning at zero. That is the invariant to preserve when names, data or surrounding project details change.

The counter reflects consumption order, not random-access storage. 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 counter an array index for every iterable. 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.from(new Set(["a","b"])).find((v,i)=>i===1)

Read the trace, not just the last line

Trace pair creation before truthiness conversion. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “The predicate receives value and counter”, separate contract from coincidence. The contract is “The predicate is called with value and a counter beginning at zero.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Log pairs from a Set or generator.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “The predicate receives value and counter” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “The predicate is called with value and a counter beginning at zero.” should remain invariant and what observation would expose calling the counter an array index for every iterable.

Case 2: CCA media catalogue. Contrast “The predicate receives value and counter” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “The predicate is called with value and a counter beginning at zero.” should remain invariant and what observation would expose calling the counter an array index for every iterable.

Case 3: science investigation archive. Stress-test “The predicate receives value and counter” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “The predicate is called with value and a counter beginning at zero.” should remain invariant and what observation would expose calling the counter an array index for every iterable.

Case 4: revision-note builder. Explain “The predicate receives value and counter” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “The predicate is called with value and a counter beginning at zero.” should remain invariant and what observation would expose calling the counter an array index for every iterable.

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 counter an array index for every iterable.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Log pairs from a Set or 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.find to support “The predicate receives value and counter”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The predicate is called with value and a counter beginning at zero.?”, and “Can you make a smaller example of calling the counter an array index for every iterable?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict the pair that produces the match. 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 the counter only for traversal-relative criteria. 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 predicate receives value and counter” means the learner can predict the ordinary case, recognise calling the counter an array index for every iterable, diagnose the earliest mistaken assumption, recover with “Log pairs from a Set or generator.” and defend this decision: Use the counter only for traversal-relative criteria. 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

find applies ToBoolean to the predicate result and returns the associated source value. That is the invariant to preserve when names, data or surrounding project details change.

The returned object is not the predicate 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 returning a score number and expecting that score to be returned. 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 value=Iterator.from([{n:0},{n:2}]).find(x=>x.n)

Read the trace, not just the last line

Trace candidate, predicate result, Boolean conversion and return. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “The first truthy result wins”, separate contract from coincidence. The contract is “find applies ToBoolean to the predicate result and returns the associated source value.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Separate predicate result from candidate value in the trace.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “The first truthy result wins” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “find applies ToBoolean to the predicate result and returns the associated source value.” should remain invariant and what observation would expose returning a score number and expecting that score to be returned.

Case 2: CCA media catalogue. Contrast “The first truthy result wins” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “find applies ToBoolean to the predicate result and returns the associated source value.” should remain invariant and what observation would expose returning a score number and expecting that score to be returned.

Case 3: science investigation archive. Stress-test “The first truthy result wins” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “find applies ToBoolean to the predicate result and returns the associated source value.” should remain invariant and what observation would expose returning a score number and expecting that score to be returned.

Case 4: revision-note builder. Explain “The first truthy result wins” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “find applies ToBoolean to the predicate result and returns the associated source value.” should remain invariant and what observation would expose returning a score number and expecting that score to be returned.

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 returning a score number and expecting that score to be returned.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Separate predicate result from candidate value in the trace.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “The first truthy result wins”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests find applies ToBoolean to the predicate result and returns the associated source value.?”, and “Can you make a smaller example of returning a score number and expecting that score to be returned?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain which object 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

Prefer explicit Boolean predicates when truthiness could surprise a reviewer. 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 first truthy result wins” means the learner can predict the ordinary case, recognise returning a score number and expecting that score to be returned, diagnose the earliest mistaken assumption, recover with “Separate predicate result from candidate value in the trace.” and defend this decision: Prefer explicit Boolean predicates when truthiness could surprise a reviewer. 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 falsy predicate result advances find to the next iterator value. That is the invariant to preserve when names, data or surrounding project details change.

Zero, empty string, null, undefined and NaN can all mean no match. 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 returning an index where zero should count as a valid match. 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.from(["first","second"]).find((v,i)=>i===0)

Read the trace, not just the last line

Trace why Boolean(0) differs from i===0. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Falsy results continue the search”, separate contract from coincidence. The contract is “A falsy predicate result advances find to the next iterator value.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Compare the intended condition explicitly rather than returning a possibly falsy payload.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Falsy results continue the search” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “A falsy predicate result advances find to the next iterator value.” should remain invariant and what observation would expose returning an index where zero should count as a valid match.

Case 2: CCA media catalogue. Contrast “Falsy results continue the search” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “A falsy predicate result advances find to the next iterator value.” should remain invariant and what observation would expose returning an index where zero should count as a valid match.

Case 3: science investigation archive. Stress-test “Falsy results continue the search” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “A falsy predicate result advances find to the next iterator value.” should remain invariant and what observation would expose returning an index where zero should count as a valid match.

Case 4: revision-note builder. Explain “Falsy results continue the search” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “A falsy predicate result advances find to the next iterator value.” should remain invariant and what observation would expose returning an index where zero should count as a valid match.

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 returning an index where zero should count as a valid match.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Compare the intended condition explicitly rather than returning a possibly falsy payload.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Falsy results continue the search”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A falsy predicate result advances find to the next iterator value.?”, and “Can you make a smaller example of returning an index where zero should count as a valid match?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Repair a predicate that returns i. 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 predicates that communicate the criterion 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 “Falsy results continue the search” means the learner can predict the ordinary case, recognise returning an index where zero should count as a valid match, diagnose the earliest mistaken assumption, recover with “Compare the intended condition explicitly rather than returning a possibly falsy payload.” and defend this decision: Use predicates that communicate the criterion 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

If IteratorStepValue reports done before a match, find returns undefined. That is the invariant to preserve when names, data or surrounding project details change.

No-match is represented by a value that may also appear in the source. 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 undefined as proof that no predicate ever matched. 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 result=Iterator.from([1,3]).find(x=>x%2===0)

Read the trace, not just the last line

Trace both false predicate results and the done step. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Exhaustion returns undefined”, separate contract from coincidence. The contract is “If IteratorStepValue reports done before a match, find returns undefined.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Track whether undefined is a possible candidate and consider a manual tagged result.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Exhaustion returns undefined” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “If IteratorStepValue reports done before a match, find returns undefined.” should remain invariant and what observation would expose treating undefined as proof that no predicate ever matched.

Case 2: CCA media catalogue. Contrast “Exhaustion returns undefined” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “If IteratorStepValue reports done before a match, find returns undefined.” should remain invariant and what observation would expose treating undefined as proof that no predicate ever matched.

Case 3: science investigation archive. Stress-test “Exhaustion returns undefined” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “If IteratorStepValue reports done before a match, find returns undefined.” should remain invariant and what observation would expose treating undefined as proof that no predicate ever matched.

Case 4: revision-note builder. Explain “Exhaustion returns undefined” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “If IteratorStepValue reports done before a match, find returns undefined.” should remain invariant and what observation would expose treating undefined as proof that no predicate ever matched.

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 undefined as proof that no predicate ever matched.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Track whether undefined is a possible candidate and consider a manual tagged result.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Exhaustion returns undefined”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests If IteratorStepValue reports done before a match, find returns undefined.?”, and “Can you make a smaller example of treating undefined as proof that no predicate ever matched?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict the result for odd numbers only. 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 the built-in when undefined ambiguity is acceptable or impossible. 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 “Exhaustion returns undefined” means the learner can predict the ordinary case, recognise treating undefined as proof that no predicate ever matched, diagnose the earliest mistaken assumption, recover with “Track whether undefined is a possible candidate and consider a manual tagged result.” and defend this decision: Use the built-in when undefined ambiguity is acceptable or impossible. 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 the source yields undefined and the predicate accepts it, find still returns undefined. That is the invariant to preserve when names, data or surrounding project details change.

The same JavaScript value can encode success or failure. 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 writing result===undefined as a universal no-match test. 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 result=Iterator.from([undefined]).find(()=>true)

Read the trace, not just the last line

Trace successful predicate and returned undefined separately. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “A matched undefined is ambiguous”, separate contract from coincidence. The contract is “If the source yields undefined and the predicate accepts it, find still returns undefined.” 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 predicate domain that excludes undefined or a manual loop returning {found,value}.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “A matched undefined is ambiguous” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “If the source yields undefined and the predicate accepts it, find still returns undefined.” should remain invariant and what observation would expose writing result===undefined as a universal no-match test.

Case 2: CCA media catalogue. Contrast “A matched undefined is ambiguous” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “If the source yields undefined and the predicate accepts it, find still returns undefined.” should remain invariant and what observation would expose writing result===undefined as a universal no-match test.

Case 3: science investigation archive. Stress-test “A matched undefined is ambiguous” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “If the source yields undefined and the predicate accepts it, find still returns undefined.” should remain invariant and what observation would expose writing result===undefined as a universal no-match test.

Case 4: revision-note builder. Explain “A matched undefined is ambiguous” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “If the source yields undefined and the predicate accepts it, find still returns undefined.” should remain invariant and what observation would expose writing result===undefined as a universal no-match test.

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 writing result===undefined as a universal no-match test.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use a predicate domain that excludes undefined or a manual loop returning {found,value}.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “A matched undefined is ambiguous”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests If the source yields undefined and the predicate accepts it, find still returns undefined.?”, and “Can you make a smaller example of writing result===undefined as a universal no-match test?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Design a tagged alternative. 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 clarity over compactness when undefined is legitimate data. 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 matched undefined is ambiguous” means the learner can predict the ordinary case, recognise writing result===undefined as a universal no-match test, diagnose the earliest mistaken assumption, recover with “Use a predicate domain that excludes undefined or a manual loop returning {found,value}.” and defend this decision: Choose clarity over compactness when undefined is legitimate data. 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 predicate is truthy, find performs IteratorClose before returning the matched value. That is the invariant to preserve when names, data or surrounding project details change.

Generators and custom iterators can release resources immediately. 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 the untested suffix remains available after success. 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(){try{yield 2;yield 5;yield 8}finally{console.log("closed")}}
console.log(g().find(x=>x>3))

Read the trace, not just the last line

Trace yield, predicate, close, finally and return. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “A successful match closes the iterator”, separate contract from coincidence. The contract is “When the predicate is truthy, find performs IteratorClose before returning the matched value.” 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 generator with finally and inspect the order of logs.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “A successful match closes the iterator” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “When the predicate is truthy, find performs IteratorClose before returning the matched value.” should remain invariant and what observation would expose assuming the untested suffix remains available after success.

Case 2: CCA media catalogue. Contrast “A successful match closes the iterator” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “When the predicate is truthy, find performs IteratorClose before returning the matched value.” should remain invariant and what observation would expose assuming the untested suffix remains available after success.

Case 3: science investigation archive. Stress-test “A successful match closes the iterator” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “When the predicate is truthy, find performs IteratorClose before returning the matched value.” should remain invariant and what observation would expose assuming the untested suffix remains available after success.

Case 4: revision-note builder. Explain “A successful match closes the iterator” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “When the predicate is truthy, find performs IteratorClose before returning the matched value.” should remain invariant and what observation would expose assuming the untested suffix remains available after success.

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 the untested suffix remains available after success.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use a generator with finally and inspect the order of logs.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “A successful match closes the iterator”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests When the predicate is truthy, find performs IteratorClose before returning the matched value.?”, and “Can you make a smaller example of assuming the untested suffix remains available after success?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict the log 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

Do not plan to resume the same iterator after a successful find. 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 successful match closes the iterator” means the learner can predict the ordinary case, recognise assuming the untested suffix remains available after success, diagnose the earliest mistaken assumption, recover with “Use a generator with finally and inspect the order of logs.” and defend this decision: Do not plan to resume the same iterator after a successful find. 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 no match exists, find reaches done and returns undefined through normal exhaustion. That is the invariant to preserve when names, data or surrounding project details change.

This differs from explicit IteratorClose on a match. 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 custom return to be called after 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

Iterator.from([1,3,5]).find(x=>x%2===0)

Read the trace, not just the last line

Trace all next and predicate calls through done. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Natural exhaustion is not early success”, separate contract from coincidence. The contract is “When no match exists, find reaches done and returns undefined through normal exhaustion.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Instrument next and return separately.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Natural exhaustion is not early success” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “When no match exists, find reaches done and returns undefined through normal exhaustion.” should remain invariant and what observation would expose expecting custom return to be called after ordinary done.

Case 2: CCA media catalogue. Contrast “Natural exhaustion is not early success” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “When no match exists, find reaches done and returns undefined through normal exhaustion.” should remain invariant and what observation would expose expecting custom return to be called after ordinary done.

Case 3: science investigation archive. Stress-test “Natural exhaustion is not early success” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “When no match exists, find reaches done and returns undefined through normal exhaustion.” should remain invariant and what observation would expose expecting custom return to be called after ordinary done.

Case 4: revision-note builder. Explain “Natural exhaustion is not early success” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “When no match exists, find reaches done and returns undefined through normal exhaustion.” should remain invariant and what observation would expose expecting custom return to be called after 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 expecting custom return to be called after ordinary done.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Instrument next and return separately.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Natural exhaustion is not early success”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests When no match exists, find reaches done and returns undefined through normal exhaustion.?”, and “Can you make a smaller example of expecting custom return to be called after ordinary done?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Compare cleanup routes for match and no match. 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 iterators so both completion routes leave resources safe. 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 “Natural exhaustion is not early success” means the learner can predict the ordinary case, recognise expecting custom return to be called after ordinary done, diagnose the earliest mistaken assumption, recover with “Instrument next and return separately.” and defend this decision: Design iterators so both completion routes leave resources safe. 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 predicate is not callable, find creates a TypeError and applies iterator-close semantics. That is the invariant to preserve when names, data or surrounding project details change.

Configuration errors can still trigger source cleanup. 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 find(null) and treating it like a predicate returning null. 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

try{Iterator.from([1]).find(null)}catch(e){console.log(e.name)}

Read the trace, not just the last line

Trace callability check, close and thrown completion. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “A non-callable predicate throws and closes”, separate contract from coincidence. The contract is “If predicate is not callable, find creates a TypeError and applies iterator-close semantics.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Validate callbacks and observe cleanup with a disposable custom iterator.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “A non-callable predicate throws and closes” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “If predicate is not callable, find creates a TypeError and applies iterator-close semantics.” should remain invariant and what observation would expose calling find(null) and treating it like a predicate returning null.

Case 2: CCA media catalogue. Contrast “A non-callable predicate throws and closes” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “If predicate is not callable, find creates a TypeError and applies iterator-close semantics.” should remain invariant and what observation would expose calling find(null) and treating it like a predicate returning null.

Case 3: science investigation archive. Stress-test “A non-callable predicate throws and closes” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “If predicate is not callable, find creates a TypeError and applies iterator-close semantics.” should remain invariant and what observation would expose calling find(null) and treating it like a predicate returning null.

Case 4: revision-note builder. Explain “A non-callable predicate throws and closes” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “If predicate is not callable, find creates a TypeError and applies iterator-close semantics.” should remain invariant and what observation would expose calling find(null) and treating it like a predicate returning null.

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 find(null) and treating it like a predicate returning null.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Validate callbacks and observe cleanup with a disposable custom 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.find to support “A non-callable predicate throws and closes”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests If predicate is not callable, find creates a TypeError and applies iterator-close semantics.?”, and “Can you make a smaller example of calling find(null) and treating it like a predicate returning null?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain the difference between null and ()=>null. 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

Validate callback wiring before binding scarce resources when practical. 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 non-callable predicate throws and closes” means the learner can predict the ordinary case, recognise calling find(null) and treating it like a predicate returning null, diagnose the earliest mistaken assumption, recover with “Validate callbacks and observe cleanup with a disposable custom iterator.” and defend this decision: Validate callback wiring before binding scarce resources when practical. 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 abrupt predicate completion closes the iterator and propagates the error. That is the invariant to preserve when names, data or surrounding project details change.

Failure to decide is not the same as an ordinary non-match. 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 catching every predicate error and returning false silently. 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

g().find(x=>{if(x===5)throw new Error("parse");return false})

Read the trace, not just the last line

Trace error creation before IteratorClose. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Thrown predicate errors close the source”, separate contract from coincidence. The contract is “An abrupt predicate completion closes the iterator and propagates the error.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Let unexpected errors propagate or convert only named expected conditions.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Thrown predicate errors close the source” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “An abrupt predicate completion closes the iterator and propagates the error.” should remain invariant and what observation would expose catching every predicate error and returning false silently.

Case 2: CCA media catalogue. Contrast “Thrown predicate errors close the source” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “An abrupt predicate completion closes the iterator and propagates the error.” should remain invariant and what observation would expose catching every predicate error and returning false silently.

Case 3: science investigation archive. Stress-test “Thrown predicate errors close the source” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “An abrupt predicate completion closes the iterator and propagates the error.” should remain invariant and what observation would expose catching every predicate error and returning false silently.

Case 4: revision-note builder. Explain “Thrown predicate errors close the source” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “An abrupt predicate completion closes the iterator and propagates the error.” should remain invariant and what observation would expose catching every predicate error and returning false silently.

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 catching every predicate error and returning false silently.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Let unexpected errors propagate or convert only named expected conditions.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Thrown predicate errors close the source”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests An abrupt predicate completion closes the iterator and propagates the error.?”, and “Can you make a smaller example of catching every predicate error and returning false silently?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Compare a false result with a thrown error on the same value. 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 false for expected non-match and throw for exceptional inability to evaluate. 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 “Thrown predicate errors close the source” means the learner can predict the ordinary case, recognise catching every predicate error and returning false silently, diagnose the earliest mistaken assumption, recover with “Let unexpected errors propagate or convert only named expected conditions.” and defend this decision: Use false for expected non-match and throw for exceptional inability to evaluate. 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

Iterators usually represent mutable traversal state rather than replayable collections. That is the invariant to preserve when names, data or surrounding project details change.

A second find call can see no 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 interpreting the second undefined as confirmation of the original search. 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([2,4]);
console.log(it.find(x=>x===4));
console.log(it.find(()=>true))

Read the trace, not just the last line

Trace the first early close and the empty second call. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “The source is one-shot state”, separate contract from coincidence. The contract is “Iterators usually represent mutable traversal state rather than replayable collections.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Create a new iterator for each independent query or materialise intentionally.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “The source is one-shot state” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “Iterators usually represent mutable traversal state rather than replayable collections.” should remain invariant and what observation would expose interpreting the second undefined as confirmation of the original search.

Case 2: CCA media catalogue. Contrast “The source is one-shot state” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “Iterators usually represent mutable traversal state rather than replayable collections.” should remain invariant and what observation would expose interpreting the second undefined as confirmation of the original search.

Case 3: science investigation archive. Stress-test “The source is one-shot state” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “Iterators usually represent mutable traversal state rather than replayable collections.” should remain invariant and what observation would expose interpreting the second undefined as confirmation of the original search.

Case 4: revision-note builder. Explain “The source is one-shot state” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “Iterators usually represent mutable traversal state rather than replayable collections.” should remain invariant and what observation would expose interpreting the second undefined as confirmation of the original search.

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 interpreting the second undefined as confirmation of the original search.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Create a new iterator for each independent query or materialise intentionally.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “The source is one-shot state”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Iterators usually represent mutable traversal state rather than replayable collections.?”, and “Can you make a smaller example of interpreting the second undefined as confirmation of the original search?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain why the second call cannot return 2. 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

Do not hide repeated-search requirements inside a one-shot API. 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 one-shot state” means the learner can predict the ordinary case, recognise interpreting the second undefined as confirmation of the original search, diagnose the earliest mistaken assumption, recover with “Create a new iterator for each independent query or materialise intentionally.” and defend this decision: Do not hide repeated-search requirements inside a one-shot API. 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

map, filter, take and drop remain lazy until find pulls values. That is the invariant to preserve when names, data or surrounding project details change.

Only the demanded prefix is transformed. 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 claiming map eagerly processed the entire source first. 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.from([1,2,3,4]).map(x=>x*10).find(x=>x>=30)

Read the trace, not just the last line

Trace source and mapped values up to 30. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Lazy pipelines feed find on demand”, separate contract from coincidence. The contract is “map, filter, take and drop remain lazy until find pulls values.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Log each stage and observe interleaved work.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Lazy pipelines feed find on demand” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “map, filter, take and drop remain lazy until find pulls values.” should remain invariant and what observation would expose claiming map eagerly processed the entire source first.

Case 2: CCA media catalogue. Contrast “Lazy pipelines feed find on demand” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “map, filter, take and drop remain lazy until find pulls values.” should remain invariant and what observation would expose claiming map eagerly processed the entire source first.

Case 3: science investigation archive. Stress-test “Lazy pipelines feed find on demand” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “map, filter, take and drop remain lazy until find pulls values.” should remain invariant and what observation would expose claiming map eagerly processed the entire source first.

Case 4: revision-note builder. Explain “Lazy pipelines feed find on demand” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “map, filter, take and drop remain lazy until find pulls values.” should remain invariant and what observation would expose claiming map eagerly processed the entire source first.

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 claiming map eagerly processed the entire source first.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Log each stage and observe interleaved work.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Lazy pipelines feed find on demand”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests map, filter, take and drop remain lazy until find pulls values.?”, and “Can you make a smaller example of claiming map eagerly processed the entire source first?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict how many values are mapped. 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

Order helpers to reduce unnecessary work while preserving semantics. 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 “Lazy pipelines feed find on demand” means the learner can predict the ordinary case, recognise claiming map eagerly processed the entire source first, diagnose the earliest mistaken assumption, recover with “Log each stage and observe interleaved work.” and defend this decision: Order helpers to reduce unnecessary work while preserving semantics. 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

find can terminate on an infinite iterator when a matching value eventually appears. That is the invariant to preserve when names, data or surrounding project details change.

A no-match claim would require exhaustion that never comes. 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 searching an endless source for an impossible value without a bound. 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++}
console.log(naturals().find(n=>n===100))

Read the trace, not just the last line

Trace why reaching 100 is finite but proving absence is not. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Infinite iterators can finish on a match”, separate contract from coincidence. The contract is “find can terminate on an infinite iterator when a matching value eventually appears.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use take, a deadline or cancellation when termination is not guaranteed.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Infinite iterators can finish on a match” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “find can terminate on an infinite iterator when a matching value eventually appears.” should remain invariant and what observation would expose searching an endless source for an impossible value without a bound.

Case 2: CCA media catalogue. Contrast “Infinite iterators can finish on a match” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “find can terminate on an infinite iterator when a matching value eventually appears.” should remain invariant and what observation would expose searching an endless source for an impossible value without a bound.

Case 3: science investigation archive. Stress-test “Infinite iterators can finish on a match” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “find can terminate on an infinite iterator when a matching value eventually appears.” should remain invariant and what observation would expose searching an endless source for an impossible value without a bound.

Case 4: revision-note builder. Explain “Infinite iterators can finish on a match” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “find can terminate on an infinite iterator when a matching value eventually appears.” should remain invariant and what observation would expose searching an endless source for an impossible value without a bound.

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 searching an endless source for an impossible value without a bound.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use take, a deadline or cancellation when termination is not guaranteed.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Infinite iterators can finish on a match”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests find can terminate on an infinite iterator when a matching value eventually appears.?”, and “Can you make a smaller example of searching an endless source for an impossible value without a bound?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Bound a search for a value that will not appear. 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

State the bound instead of implying proof about an infinite future. 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 can finish on a match” means the learner can predict the ordinary case, recognise searching an endless source for an impossible value without a bound, diagnose the earliest mistaken assumption, recover with “Use take, a deadline or cancellation when termination is not guaranteed.” and defend this decision: State the bound instead of implying proof about an infinite future. 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.prototype.find uses indexed array semantics, while Iterator.prototype.find pulls sequential protocol values and closes on success. That is the invariant to preserve when names, data or surrounding project details change.

Sparse arrays and reuse can produce different traces. 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 transferring array-hole intuition to an iterator of undefined 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

const a=Array(3);
console.log(a.values().find(x=>x===undefined))

Read the trace, not just the last line

Trace callback count rather than only the shared undefined output. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Array.find and iterator.find consume differently”, separate contract from coincidence. The contract is “Array.prototype.find uses indexed array semantics, while Iterator.prototype.find pulls sequential protocol values and closes on success.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Count predicate calls on a sparse array and on its values iterator.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Array.find and iterator.find consume differently” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “Array.prototype.find uses indexed array semantics, while Iterator.prototype.find pulls sequential protocol values and closes on success.” should remain invariant and what observation would expose transferring array-hole intuition to an iterator of undefined values.

Case 2: CCA media catalogue. Contrast “Array.find and iterator.find consume differently” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “Array.prototype.find uses indexed array semantics, while Iterator.prototype.find pulls sequential protocol values and closes on success.” should remain invariant and what observation would expose transferring array-hole intuition to an iterator of undefined values.

Case 3: science investigation archive. Stress-test “Array.find and iterator.find consume differently” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “Array.prototype.find uses indexed array semantics, while Iterator.prototype.find pulls sequential protocol values and closes on success.” should remain invariant and what observation would expose transferring array-hole intuition to an iterator of undefined values.

Case 4: revision-note builder. Explain “Array.find and iterator.find consume differently” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “Array.prototype.find uses indexed array semantics, while Iterator.prototype.find pulls sequential protocol values and closes on success.” should remain invariant and what observation would expose transferring array-hole intuition to an iterator of undefined 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 transferring array-hole intuition to an iterator of undefined values.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Count predicate calls on a sparse array and on its values 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.find to support “Array.find and iterator.find consume differently”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Array.prototype.find uses indexed array semantics, while Iterator.prototype.find pulls sequential protocol values and closes on success.?”, and “Can you make a smaller example of transferring array-hole intuition to an iterator of undefined values?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Compare a holey array method with a.values().find. 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 the source abstraction whose semantics match the 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 “Array.find and iterator.find consume differently” means the learner can predict the ordinary case, recognise transferring array-hole intuition to an iterator of undefined values, diagnose the earliest mistaken assumption, recover with “Count predicate calls on a sparse array and on its values iterator.” and defend this decision: Choose the source abstraction whose semantics match the 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

Iterator.from converts a generic iterable or iterator into an iterator-helper-compatible receiver. That is the invariant to preserve when names, data or surrounding project details change.

A plain array is not itself the iterator consumed by Iterator.prototype.find. 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 find with an array as this. 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 hit=Iterator.from(records).find(isReady)

Read the trace, not just the last line

Trace conversion before the terminal call. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Iterator.from makes the boundary explicit”, separate contract from coincidence. The contract is “Iterator.from converts a generic iterable or iterator into an iterator-helper-compatible receiver.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use Iterator.from or array.values before searching.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Iterator.from makes the boundary explicit” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.from converts a generic iterable or iterator into an iterator-helper-compatible receiver.” should remain invariant and what observation would expose borrowing find with an array as this.

Case 2: CCA media catalogue. Contrast “Iterator.from makes the boundary explicit” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.from converts a generic iterable or iterator into an iterator-helper-compatible receiver.” should remain invariant and what observation would expose borrowing find with an array as this.

Case 3: science investigation archive. Stress-test “Iterator.from makes the boundary explicit” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.from converts a generic iterable or iterator into an iterator-helper-compatible receiver.” should remain invariant and what observation would expose borrowing find with an array as this.

Case 4: revision-note builder. Explain “Iterator.from makes the boundary explicit” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “Iterator.from converts a generic iterable or iterator into an iterator-helper-compatible receiver.” should remain invariant and what observation would expose borrowing find with an array as this.

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 find with an array as this.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use Iterator.from or array.values before searching.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Iterator.from makes the boundary explicit”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Iterator.from converts a generic iterable or iterator into an iterator-helper-compatible receiver.?”, and “Can you make a smaller example of borrowing find with an array as this?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain why conversion improves generic code. 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 conversion visible at API boundaries. 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 “Iterator.from makes the boundary explicit” means the learner can predict the ordinary case, recognise borrowing find with an array as this, diagnose the earliest mistaken assumption, recover with “Use Iterator.from or array.values before searching.” and defend this decision: Make conversion visible at API boundaries. 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 for-of loop can return index, diagnostics or a tagged found state that built-in find does not provide. That is the invariant to preserve when names, data or surrounding project details change.

Result shape should match the reader job. 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 forcing every search into find then reconstructing lost context. 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 i=0;for(const value of source){if(test(value,i))return {found:true,value,index:i};i++}

Read the trace, not just the last line

Trace break or return cleanup on the iterator. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Manual loops can return richer evidence”, separate contract from coincidence. The contract is “A for-of loop can return index, diagnostics or a tagged found state that built-in find does not provide.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Write a loop when the caller needs more than the first value.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Manual loops can return richer evidence” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “A for-of loop can return index, diagnostics or a tagged found state that built-in find does not provide.” should remain invariant and what observation would expose forcing every search into find then reconstructing lost context.

Case 2: CCA media catalogue. Contrast “Manual loops can return richer evidence” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “A for-of loop can return index, diagnostics or a tagged found state that built-in find does not provide.” should remain invariant and what observation would expose forcing every search into find then reconstructing lost context.

Case 3: science investigation archive. Stress-test “Manual loops can return richer evidence” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “A for-of loop can return index, diagnostics or a tagged found state that built-in find does not provide.” should remain invariant and what observation would expose forcing every search into find then reconstructing lost context.

Case 4: revision-note builder. Explain “Manual loops can return richer evidence” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “A for-of loop can return index, diagnostics or a tagged found state that built-in find does not provide.” should remain invariant and what observation would expose forcing every search into find then reconstructing lost context.

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 forcing every search into find then reconstructing lost context.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Write a loop when the caller needs more than the first value.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Manual loops can return richer evidence”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A for-of loop can return index, diagnostics or a tagged found state that built-in find does not provide.?”, and “Can you make a smaller example of forcing every search into find then reconstructing lost context?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Build a tagged search for undefined values. 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 find for the simple value job and a loop for richer contracts. 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 “Manual loops can return richer evidence” means the learner can predict the ordinary case, recognise forcing every search into find then reconstructing lost context, diagnose the earliest mistaken assumption, recover with “Write a loop when the caller needs more than the first value.” and defend this decision: Prefer find for the simple value job and a loop for richer contracts. 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

Predicates can mutate external state, but a search is easier to verify when the predicate is pure. That is the invariant to preserve when names, data or surrounding project details change.

Early stopping means later side effects never occur. 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 find as a substitute for processing every record. 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 chosen=Iterator.from(items).find(isEligible)
if(chosen) chosen.selected=true

Read the trace, not just the last line

Trace predicate observations before mutation. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Side effects make search harder to reason about”, separate contract from coincidence. The contract is “Predicates can mutate external state, but a search is easier to verify when the predicate is pure.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Separate selection from later mutation.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Side effects make search harder to reason about” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “Predicates can mutate external state, but a search is easier to verify when the predicate is pure.” should remain invariant and what observation would expose using find as a substitute for processing every record.

Case 2: CCA media catalogue. Contrast “Side effects make search harder to reason about” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “Predicates can mutate external state, but a search is easier to verify when the predicate is pure.” should remain invariant and what observation would expose using find as a substitute for processing every record.

Case 3: science investigation archive. Stress-test “Side effects make search harder to reason about” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “Predicates can mutate external state, but a search is easier to verify when the predicate is pure.” should remain invariant and what observation would expose using find as a substitute for processing every record.

Case 4: revision-note builder. Explain “Side effects make search harder to reason about” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “Predicates can mutate external state, but a search is easier to verify when the predicate is pure.” should remain invariant and what observation would expose using find as a substitute for processing every record.

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 find as a substitute for processing every record.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Separate selection from later mutation.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Side effects make search harder to reason about”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Predicates can mutate external state, but a search is easier to verify when the predicate is pure.?”, and “Can you make a smaller example of using find as a substitute for processing every record?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Refactor a predicate that modifies every tested item. 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 forEach or a full loop when every item truly needs processing. 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 “Side effects make search harder to reason about” means the learner can predict the ordinary case, recognise using find as a substitute for processing every record, diagnose the earliest mistaken assumption, recover with “Separate selection from later mutation.” and defend this decision: Use forEach or a full loop when every item truly needs processing. 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 custom iterator can implement return so successful find and errors release resources. That is the invariant to preserve when names, data or surrounding project details change.

IteratorClose depends on protocol cooperation. 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 wrapping a file or cursor with next only. 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={next(){return {value:1,done:false}},return(){console.log("release");return {done:true}},[Symbol.iterator](){return this}}

Read the trace, not just the last line

Trace next, predicate and return. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Custom iterators should implement return”, separate contract from coincidence. The contract is “A custom iterator can implement return so successful find and errors release resources.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Make return idempotent, mark done and release the resource.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Custom iterators should implement return” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “A custom iterator can implement return so successful find and errors release resources.” should remain invariant and what observation would expose wrapping a file or cursor with next only.

Case 2: CCA media catalogue. Contrast “Custom iterators should implement return” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “A custom iterator can implement return so successful find and errors release resources.” should remain invariant and what observation would expose wrapping a file or cursor with next only.

Case 3: science investigation archive. Stress-test “Custom iterators should implement return” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “A custom iterator can implement return so successful find and errors release resources.” should remain invariant and what observation would expose wrapping a file or cursor with next only.

Case 4: revision-note builder. Explain “Custom iterators should implement return” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “A custom iterator can implement return so successful find and errors release resources.” should remain invariant and what observation would expose wrapping a file or cursor with next only.

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 wrapping a file or cursor with next only.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Make return idempotent, mark done and release the resource.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Custom iterators should implement return”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A custom iterator can implement return so successful find and errors release resources.?”, and “Can you make a smaller example of wrapping a file or cursor with next only?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Trigger one success and one thrown predicate. 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 generators when possible and test custom return explicitly. 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 “Custom iterators should implement return” means the learner can predict the ordinary case, recognise wrapping a file or cursor with next only, diagnose the earliest mistaken assumption, recover with “Make return idempotent, mark done and release the resource.” and defend this decision: Use generators when possible and test custom return explicitly. 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 are in current ECMAScript, but target runtimes can differ. That is the invariant to preserve when names, data or surrounding project details change.

One recent Node test does not prove every classroom browser. 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 claiming universal support from a local console. 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

if(typeof Iterator?.prototype?.find==="function"){
  // native route
}

Read the trace, not just the last line

Trace capability detection before choosing an implementation. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Runtime support belongs in deployment planning”, separate contract from coincidence. The contract is “Iterator helpers are in current ECMAScript, but target runtimes can differ.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Check supported runtimes or provide a reviewed manual-loop fallback.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Runtime support belongs in deployment planning” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “Iterator helpers are in current ECMAScript, but target runtimes can differ.” should remain invariant and what observation would expose claiming universal support from a local console.

Case 2: CCA media catalogue. Contrast “Runtime support belongs in deployment planning” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “Iterator helpers are in current ECMAScript, but target runtimes can differ.” should remain invariant and what observation would expose claiming universal support from a local console.

Case 3: science investigation archive. Stress-test “Runtime support belongs in deployment planning” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “Iterator helpers are in current ECMAScript, but target runtimes can differ.” should remain invariant and what observation would expose claiming universal support from a local console.

Case 4: revision-note builder. Explain “Runtime support belongs in deployment planning” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “Iterator helpers are in current ECMAScript, but target runtimes can differ.” should remain invariant and what observation would expose claiming universal support from a local console.

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 claiming universal support from a local console.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Check supported runtimes or provide a reviewed manual-loop 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.find to support “Runtime support belongs in deployment planning”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Iterator helpers are in current ECMAScript, but target runtimes can differ.?”, and “Can you make a smaller example of claiming universal support from a local console?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Plan for an older browser. 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 native find where supported and document fallback differences. 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 belongs in deployment planning” means the learner can predict the ordinary case, recognise claiming universal support from a local console, diagnose the earliest mistaken assumption, recover with “Check supported runtimes or provide a reviewed manual-loop fallback.” and defend this decision: Prefer native find where supported and document fallback differences. 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

find returns a first value; some returns a Boolean; filter returns a lazy matching sequence; a loop can collect diagnostics. That is the invariant to preserve when names, data or surrounding project details change.

The operation should mirror the question. 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 find then coercing the value only to answer whether any match exists. 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 firstReady=Iterator.from(students).find(s=>s.ready)

Read the trace, not just the last line

Trace result type, consumption and cleanup requirements. Write the trace as a sequence of labelled states. For JavaScript Iterator.prototype.find, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Choose find by the result you need”, separate contract from coincidence. The contract is “find returns a first value; some returns a Boolean; filter returns a lazy matching sequence; a loop can collect diagnostics.” 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 desired result type before selecting the method.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Choose find by the result you need” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “find returns a first value; some returns a Boolean; filter returns a lazy matching sequence; a loop can collect diagnostics.” should remain invariant and what observation would expose using find then coercing the value only to answer whether any match exists.

Case 2: CCA media catalogue. Contrast “Choose find by the result you need” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “find returns a first value; some returns a Boolean; filter returns a lazy matching sequence; a loop can collect diagnostics.” should remain invariant and what observation would expose using find then coercing the value only to answer whether any match exists.

Case 3: science investigation archive. Stress-test “Choose find by the result you need” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “find returns a first value; some returns a Boolean; filter returns a lazy matching sequence; a loop can collect diagnostics.” should remain invariant and what observation would expose using find then coercing the value only to answer whether any match exists.

Case 4: revision-note builder. Explain “Choose find by the result you need” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “find returns a first value; some returns a Boolean; filter returns a lazy matching sequence; a loop can collect diagnostics.” should remain invariant and what observation would expose using find then coercing the value only to answer whether any match exists.

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 find then coercing the value only to answer whether any match exists.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Write the desired result type before selecting the method.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise JavaScript Iterator.prototype.find to support “Choose find by the result you need”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests find returns a first value; some returns a Boolean; filter returns a lazy matching sequence; a loop can collect diagnostics.?”, and “Can you make a smaller example of using find then coercing the value only to answer whether any match exists?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Map four questions to find, some, filter and a loop. 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 the narrowest method that preserves required evidence and replay 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 “Choose find by the result you need” means the learner can predict the ordinary case, recognise using find then coercing the value only to answer whether any match exists, diagnose the earliest mistaken assumption, recover with “Write the desired result type before selecting the method.” and defend this decision: Choose the narrowest method that preserves required evidence and replay 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

For JavaScript Iterator.prototype.find, 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.find 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. Trace the first match

Log candidates, predicate results and the returned source value. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

2. Expose undefined ambiguity

Compare a matched undefined with an exhausted no-match search. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. Observe generator closure

Use finally and verify cleanup precedes the returned match. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. Search a lazy pipeline

Log map and find stages until the first match. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. Bound an infinite search

Use take to define a finite no-match window. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. Compare sparse sources

Count predicate calls for an array and its values iterator. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. Implement custom cleanup

Add idempotent return and trigger success and error. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. Choose the right search tool

Solve first-value, any-match, all-matches and full-diagnostic 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.find 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.find, 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.find 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.find
• eduKatePunggol: How Studying Works

Return to contents