When a learner can reproduce a familiar example but a small variation causes confusion, the problem is usually an incomplete model rather than a lack of effort. The fastest useful response is to expose the hidden state and test one boundary at a time.

JavaScript Array.prototype.with(index, value) returns a new ordinary Array in which one position is replaced, leaving the source object structurally unchanged. It converts the receiver to an object, snapshots an array-like length, converts the index to an integer-style absolute position, throws RangeError when that position is outside the captured length, and then creates every result index as a data property. Negative indexes count from the end. Reads of unreplaced positions can invoke getters or inherited accessors, sparse holes become explicit undefined entries, and nested objects remain shared because the operation is shallow. Mastery means predicting the exact accepted index, all observable reads, and whether a copying replacement truly matches the program’s identity and compatibility needs. This guide begins with that mechanism, then develops it through worked traces, deliberate mistakes, explained practice and transfer decisions.

The aim is independent reasoning. A learner should be able to predict behaviour, locate the earliest wrong assumption, use a safe diagnostic procedure and defend a design choice in a new project.

Punggol families can use the guide in short sessions around homework, CCAs and rest. The activities are proposed learning exercises, not claims about a physical branch, timetable, class size, fee, school relationship or guaranteed result.

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

Array.prototype.with creates a fresh Array, copying every position except the chosen index where it stores the replacement value. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is describing the method as an in-place assignment with a fluent return value. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for with returns a new array with one replacement, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the with returns a new array with one replacement chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on describing the method as an in-place assignment with a fluent return value. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const original=['read','draft','submit'];
const next=original.with(1,'revise');
console.log(original,next,original===next);

Four purposeful transfer cases

Case 1: homework queue. Predict the rule using one task is replaced without mutating the original list used by the previous screen. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading plan. Contrast the rule using a negative index updates the last title while earlier state remains available. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science readings. Stress-test the rule using sparse positions, undefined readings and nested sample objects are distinguished. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA roster. Explain the rule using an array-like attendance object is copied into an ordinary Array. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers describing the method as an in-place assignment with a fluent return value.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for with returns a new array with one replacement, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from with returns a new array with one replacement?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing describing the method as an in-place assignment with a fluent return value be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library shelf with subclass and species assumptions are tested instead of guessed. Include one ordinary case, one boundary and one deliberate failure caused by describing the method as an in-place assignment with a fluent return value. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For with returns a new array with one replacement, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Index zero selects the first element under ordinary zero-based indexing. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is counting positions from one because the task list is numbered for people. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for A zero index replaces the first position, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the A zero index replaces the first position chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on counting positions from one because the task list is numbered for people. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

console.log(['A','B','C'].with(0,'X'));

Four purposeful transfer cases

Case 1: science readings. Contrast the rule using sparse positions, undefined readings and nested sample objects are distinguished. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA roster. Stress-test the rule using an array-like attendance object is copied into an ordinary Array. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family errands. Explain the rule using getters and length changes reveal the operation’s observable order. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library shelf. Transfer the rule using subclass and species assumptions are tested instead of guessed. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers counting positions from one because the task list is numbered for people.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for A zero index replaces the first position, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from A zero index replaces the first position?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing counting positions from one because the task list is numbered for people be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. Include one ordinary case, one boundary and one deliberate failure caused by counting positions from one because the task list is numbered for people. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For A zero index replaces the first position, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

A negative integer is added to the captured length, so -1 selects the final position. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is treating -1 as a special append instruction. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for A negative index counts from the end, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the A negative index counts from the end chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on treating -1 as a special append instruction. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

console.log(['A','B','C'].with(-1,'X'));

Four purposeful transfer cases

Case 1: family errands. Stress-test the rule using getters and length changes reveal the operation’s observable order. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library shelf. Explain the rule using subclass and species assumptions are tested instead of guessed. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Transfer the rule using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Predict the rule using with is compared with assignment, slice-spread patterns, map and toSpliced. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers treating -1 as a special append instruction.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for A negative index counts from the end, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from A negative index counts from the end?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating -1 as a special append instruction be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with with is compared with assignment, slice-spread patterns, map and toSpliced. Include one ordinary case, one boundary and one deliberate failure caused by treating -1 as a special append instruction. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For A negative index counts from the end, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

For length three, -3 resolves to zero and is valid, while -4 resolves before the array and throws. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is accepting every negative integer by wrapping it repeatedly. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for The negative boundary is exactly minus length, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the The negative boundary is exactly minus length chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on accepting every negative integer by wrapping it repeatedly. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

console.log(['A','B','C'].with(-3,'X'));
try{ ['A','B','C'].with(-4,'X') }catch(e){ console.log(e.name) }

Four purposeful transfer cases

Case 1: test laboratory. Explain the rule using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Transfer the rule using with is compared with assignment, slice-spread patterns, map and toSpliced. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework queue. Predict the rule using one task is replaced without mutating the original list used by the previous screen. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading plan. Contrast the rule using a negative index updates the last title while earlier state remains available. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers accepting every negative integer by wrapping it repeatedly.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for The negative boundary is exactly minus length, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from The negative boundary is exactly minus length?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing accepting every negative integer by wrapping it repeatedly be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework queue with one task is replaced without mutating the original list used by the previous screen. Include one ordinary case, one boundary and one deliberate failure caused by accepting every negative integer by wrapping it repeatedly. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The negative boundary is exactly minus length, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

with only replaces an existing position from zero through length minus one; it does not extend or append. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is using with(array.length,value) as an immutable push operation. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for An index equal to length is out of range, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the An index equal to length is out of range chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using with(array.length,value) as an immutable push operation. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=['A','B'];
try{ a.with(a.length,'C') }catch(e){ console.log(e.name) }

Four purposeful transfer cases

Case 1: homework queue. Transfer the rule using one task is replaced without mutating the original list used by the previous screen. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading plan. Predict the rule using a negative index updates the last title while earlier state remains available. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science readings. Contrast the rule using sparse positions, undefined readings and nested sample objects are distinguished. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA roster. Stress-test the rule using an array-like attendance object is copied into an ordinary Array. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers using with(array.length,value) as an immutable push operation.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for An index equal to length is out of range, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from An index equal to length is out of range?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using with(array.length,value) as an immutable push operation be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny reading plan with a negative index updates the last title while earlier state remains available. Include one ordinary case, one boundary and one deliberate failure caused by using with(array.length,value) as an immutable push operation. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For An index equal to length is out of range, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

After index conversion, a position at or beyond the captured length produces RangeError. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is expecting empty slots to be created up to a distant index. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Positive out-of-range indexes throw before copying, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Positive out-of-range indexes throw before copying chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on expecting empty slots to be created up to a distant index. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

try{ [1,2].with(7,9) }catch(e){ console.log(e.name) }

Four purposeful transfer cases

Case 1: science readings. Predict the rule using sparse positions, undefined readings and nested sample objects are distinguished. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA roster. Contrast the rule using an array-like attendance object is copied into an ordinary Array. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family errands. Stress-test the rule using getters and length changes reveal the operation’s observable order. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library shelf. Explain the rule using subclass and species assumptions are tested instead of guessed. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers expecting empty slots to be created up to a distant index.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Positive out-of-range indexes throw before copying, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from Positive out-of-range indexes throw before copying?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting empty slots to be created up to a distant index be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science readings with sparse positions, undefined readings and nested sample objects are distinguished. Include one ordinary case, one boundary and one deliberate failure caused by expecting empty slots to be created up to a distant index. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Positive out-of-range indexes throw before copying, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The index conversion truncates a finite fractional number toward zero before the range check. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is rounding 1.9 to 2 or -1.9 to -2. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Fractional indexes are converted toward zero, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Fractional indexes are converted toward zero chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on rounding 1.9 to 2 or -1.9 to -2. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

console.log(['A','B','C'].with(1.9,'X'));
console.log(['A','B','C'].with(-1.9,'Y'));

Four purposeful transfer cases

Case 1: family errands. Contrast the rule using getters and length changes reveal the operation’s observable order. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library shelf. Stress-test the rule using subclass and species assumptions are tested instead of guessed. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Explain the rule using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Transfer the rule using with is compared with assignment, slice-spread patterns, map and toSpliced. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers rounding 1.9 to 2 or -1.9 to -2.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Fractional indexes are converted toward zero, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from Fractional indexes are converted toward zero?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing rounding 1.9 to 2 or -1.9 to -2 be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA roster with an array-like attendance object is copied into an ordinary Array. Include one ordinary case, one boundary and one deliberate failure caused by rounding 1.9 to 2 or -1.9 to -2. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Fractional indexes are converted toward zero, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The integer-or-infinity conversion treats NaN as zero. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is expecting NaN to fail the range check automatically. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for NaN converts to zero, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the NaN converts to zero chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on expecting NaN to fail the range check automatically. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

console.log(['A','B'].with(NaN,'X'));

Four purposeful transfer cases

Case 1: test laboratory. Stress-test the rule using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Explain the rule using with is compared with assignment, slice-spread patterns, map and toSpliced. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework queue. Transfer the rule using one task is replaced without mutating the original list used by the previous screen. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading plan. Predict the rule using a negative index updates the last title while earlier state remains available. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers expecting NaN to fail the range check automatically.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for NaN converts to zero, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from NaN converts to zero?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting NaN to fail the range check automatically be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family errands with getters and length changes reveal the operation’s observable order. Include one ordinary case, one boundary and one deliberate failure caused by expecting NaN to fail the range check automatically. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For NaN converts to zero, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Infinity remains infinite through index conversion and cannot identify a finite array position. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is clamping Infinity to the first or last element. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Positive and negative Infinity are out of range, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Positive and negative Infinity are out of range chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on clamping Infinity to the first or last element. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

for(const i of [Infinity,-Infinity]){ try{ [1,2].with(i,9) }catch(e){ console.log(e.name) } }

Four purposeful transfer cases

Case 1: homework queue. Explain the rule using one task is replaced without mutating the original list used by the previous screen. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading plan. Transfer the rule using a negative index updates the last title while earlier state remains available. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science readings. Predict the rule using sparse positions, undefined readings and nested sample objects are distinguished. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA roster. Contrast the rule using an array-like attendance object is copied into an ordinary Array. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers clamping Infinity to the first or last element.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Positive and negative Infinity are out of range, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from Positive and negative Infinity are out of range?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing clamping Infinity to the first or last element be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library shelf with subclass and species assumptions are tested instead of guessed. Include one ordinary case, one boundary and one deliberate failure caused by clamping Infinity to the first or last element. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Positive and negative Infinity are out of range, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The numeric index conversion cannot accept BigInt or Symbol through the required number conversion path. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is treating every value with a printable form as a usable index. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for BigInt and Symbol indexes fail conversion, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the BigInt and Symbol indexes fail conversion chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on treating every value with a printable form as a usable index. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

for(const i of [1n,Symbol('i')]){ try{ [1,2].with(i,9) }catch(e){ console.log(e.name) } }

Four purposeful transfer cases

Case 1: science readings. Transfer the rule using sparse positions, undefined readings and nested sample objects are distinguished. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA roster. Predict the rule using an array-like attendance object is copied into an ordinary Array. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family errands. Contrast the rule using getters and length changes reveal the operation’s observable order. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library shelf. Stress-test the rule using subclass and species assumptions are tested instead of guessed. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers treating every value with a printable form as a usable index.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for BigInt and Symbol indexes fail conversion, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from BigInt and Symbol indexes fail conversion?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating every value with a printable form as a usable index be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. Include one ordinary case, one boundary and one deliberate failure caused by treating every value with a printable form as a usable index. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For BigInt and Symbol indexes fail conversion, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The outer array is new, but unreplaced object values are copied as references rather than cloned. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is calling with an immutable update for the whole object graph. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for The operation is shallow, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the The operation is shallow chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on calling with an immutable update for the whole object graph. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const shared={pages:10}; const a=[shared,'done'];
const b=a.with(1,'revise'); shared.pages=20;
console.log(a[0]===b[0],b[0].pages);

Four purposeful transfer cases

Case 1: family errands. Predict the rule using getters and length changes reveal the operation’s observable order. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library shelf. Contrast the rule using subclass and species assumptions are tested instead of guessed. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Stress-test the rule using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Explain the rule using with is compared with assignment, slice-spread patterns, map and toSpliced. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers calling with an immutable update for the whole object graph.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for The operation is shallow, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from The operation is shallow?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling with an immutable update for the whole object graph be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with with is compared with assignment, slice-spread patterns, map and toSpliced. Include one ordinary case, one boundary and one deliberate failure caused by calling with an immutable update for the whole object graph. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The operation is shallow, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The chosen position receives exactly the replacement reference; with does not merge object properties. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is expecting a partial object to be merged with the previous element. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Replacing an object does not mutate the old object, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Replacing an object does not mutate the old object chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on expecting a partial object to be merged with the previous element. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[{title:'Book',pages:10}];
const b=a.with(0,{pages:20});
console.log(a[0],b[0]);

Four purposeful transfer cases

Case 1: test laboratory. Contrast the rule using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Stress-test the rule using with is compared with assignment, slice-spread patterns, map and toSpliced. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework queue. Explain the rule using one task is replaced without mutating the original list used by the previous screen. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading plan. Transfer the rule using a negative index updates the last title while earlier state remains available. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers expecting a partial object to be merged with the previous element.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Replacing an object does not mutate the old object, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from Replacing an object does not mutate the old object?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting a partial object to be merged with the previous element be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework queue with one task is replaced without mutating the original list used by the previous screen. Include one ordinary case, one boundary and one deliberate failure caused by expecting a partial object to be merged with the previous element. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Replacing an object does not mutate the old object, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The algorithm performs Get for every unreplaced index and creates a data property in the result, so holes are materialised as undefined. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is expecting the sparse structure and property ownership to be preserved. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Sparse holes become explicit undefined entries, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Sparse holes become explicit undefined entries chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on expecting the sparse structure and property ownership to be preserved. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=new Array(3); a[2]='C';
const b=a.with(2,'X');
console.log(0 in a,0 in b,b[0],Object.keys(b));

Four purposeful transfer cases

Case 1: homework queue. Stress-test the rule using one task is replaced without mutating the original list used by the previous screen. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading plan. Explain the rule using a negative index updates the last title while earlier state remains available. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science readings. Transfer the rule using sparse positions, undefined readings and nested sample objects are distinguished. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA roster. Predict the rule using an array-like attendance object is copied into an ordinary Array. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers expecting the sparse structure and property ownership to be preserved.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Sparse holes become explicit undefined entries, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from Sparse holes become explicit undefined entries?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting the sparse structure and property ownership to be preserved be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny reading plan with a negative index updates the last title while earlier state remains available. Include one ordinary case, one boundary and one deliberate failure caused by expecting the sparse structure and property ownership to be preserved. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Sparse holes become explicit undefined entries, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Get on an unreplaced position can find a property through the receiver’s prototype chain. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is checking only own properties when predicting copied values. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Inherited indexed values can be copied, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Inherited indexed values can be copied chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on checking only own properties when predicting copied values. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const proto={0:'inherited'}; const obj=Object.assign(Object.create(proto),{length:2,1:'own'});
const out=Array.prototype.with.call(obj,1,'X');
console.log(out);

Four purposeful transfer cases

Case 1: science readings. Explain the rule using sparse positions, undefined readings and nested sample objects are distinguished. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA roster. Transfer the rule using an array-like attendance object is copied into an ordinary Array. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family errands. Predict the rule using getters and length changes reveal the operation’s observable order. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library shelf. Contrast the rule using subclass and species assumptions are tested instead of guessed. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers checking only own properties when predicting copied values.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Inherited indexed values can be copied, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from Inherited indexed values can be copied?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing checking only own properties when predicting copied values be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science readings with sparse positions, undefined readings and nested sample objects are distinguished. Include one ordinary case, one boundary and one deliberate failure caused by checking only own properties when predicting copied values. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Inherited indexed values can be copied, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Each unreplaced index is read with ordinary Get, so a getter can run while the result is being built. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is calling the method side-effect-free merely because it does not assign to the source. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Getters on unreplaced positions are observable, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Getters on unreplaced positions are observable chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on calling the method side-effect-free merely because it does not assign to the source. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

let reads=0; const a=[0,1];
Object.defineProperty(a,0,{get(){reads++;return 7}});
const b=a.with(1,9); console.log(reads,b);

Four purposeful transfer cases

Case 1: family errands. Transfer the rule using getters and length changes reveal the operation’s observable order. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library shelf. Predict the rule using subclass and species assumptions are tested instead of guessed. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Contrast the rule using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Stress-test the rule using with is compared with assignment, slice-spread patterns, map and toSpliced. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers calling the method side-effect-free merely because it does not assign to the source.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Getters on unreplaced positions are observable, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from Getters on unreplaced positions are observable?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling the method side-effect-free merely because it does not assign to the source be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA roster with an array-like attendance object is copied into an ordinary Array. Include one ordinary case, one boundary and one deliberate failure caused by calling the method side-effect-free merely because it does not assign to the source. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Getters on unreplaced positions are observable, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

When the loop reaches the chosen index, it uses the provided value instead of performing Get on the source position. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is expecting a getter at the replaced index to run before replacement. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for The replaced position is not read, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the The replaced position is not read chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on expecting a getter at the replaced index to run before replacement. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

let reads=0; const a=[0];
Object.defineProperty(a,0,{get(){reads++;return 7}});
const b=a.with(0,9); console.log(reads,b);

Four purposeful transfer cases

Case 1: test laboratory. Predict the rule using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Contrast the rule using with is compared with assignment, slice-spread patterns, map and toSpliced. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework queue. Stress-test the rule using one task is replaced without mutating the original list used by the previous screen. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading plan. Explain the rule using a negative index updates the last title while earlier state remains available. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers expecting a getter at the replaced index to run before replacement.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for The replaced position is not read, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from The replaced position is not read?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting a getter at the replaced index to run before replacement be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family errands with getters and length changes reveal the operation’s observable order. Include one ordinary case, one boundary and one deliberate failure caused by expecting a getter at the replaced index to run before replacement. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The replaced position is not read, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The algorithm reads the array-like length, checks the converted index, creates the target, then processes positions up to that captured length. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming a getter that later changes source.length also resizes the target. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Length is captured before indexed reads, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Length is captured before indexed reads chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming a getter that later changes source.length also resizes the target. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[1,2,3];
Object.defineProperty(a,0,{get(){a.length=1;return 1}});
const b=a.with(2,9); console.log(b.length,b);

Four purposeful transfer cases

Case 1: homework queue. Contrast the rule using one task is replaced without mutating the original list used by the previous screen. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading plan. Stress-test the rule using a negative index updates the last title while earlier state remains available. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science readings. Explain the rule using sparse positions, undefined readings and nested sample objects are distinguished. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA roster. Transfer the rule using an array-like attendance object is copied into an ordinary Array. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming a getter that later changes source.length also resizes the target.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Length is captured before indexed reads, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from Length is captured before indexed reads?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming a getter that later changes source.length also resizes the target be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library shelf with subclass and species assumptions are tested instead of guessed. Include one ordinary case, one boundary and one deliberate failure caused by assuming a getter that later changes source.length also resizes the target. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Length is captured before indexed reads, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The receiver need not be an Array; an object with length and indexed properties can be read and copied into a new Array. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is expecting the result to retain the receiver’s custom prototype and methods. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for The method is generic over array-like objects, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the The method is generic over array-like objects chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on expecting the result to retain the receiver’s custom prototype and methods. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const list={0:'A',1:'B',length:2};
const out=Array.prototype.with.call(list,0,'X');
console.log(out,Array.isArray(out));

Four purposeful transfer cases

Case 1: science readings. Stress-test the rule using sparse positions, undefined readings and nested sample objects are distinguished. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA roster. Explain the rule using an array-like attendance object is copied into an ordinary Array. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family errands. Transfer the rule using getters and length changes reveal the operation’s observable order. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library shelf. Predict the rule using subclass and species assumptions are tested instead of guessed. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers expecting the result to retain the receiver’s custom prototype and methods.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for The method is generic over array-like objects, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from The method is generic over array-like objects?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting the result to retain the receiver’s custom prototype and methods be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. Include one ordinary case, one boundary and one deliberate failure caused by expecting the result to retain the receiver’s custom prototype and methods. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The method is generic over array-like objects, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The specification uses ArrayCreate directly, so even an Array subclass receives an ordinary Array result rather than a species-derived instance. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming all copying array methods follow the same species rule. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Array species is not consulted, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Array species is not consulted chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming all copying array methods follow the same species rule. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

class Shelf extends Array{}
const s=new Shelf('A','B'); const out=s.with(1,'X');
console.log(out instanceof Shelf,Array.isArray(out));

Four purposeful transfer cases

Case 1: family errands. Explain the rule using getters and length changes reveal the operation’s observable order. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library shelf. Transfer the rule using subclass and species assumptions are tested instead of guessed. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Predict the rule using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Contrast the rule using with is compared with assignment, slice-spread patterns, map and toSpliced. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming all copying array methods follow the same species rule.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Array species is not consulted, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from Array species is not consulted?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming all copying array methods follow the same species rule be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with with is compared with assignment, slice-spread patterns, map and toSpliced. Include one ordinary case, one boundary and one deliberate failure caused by assuming all copying array methods follow the same species rule. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Array species is not consulted, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Use with when one existing position changes and preserving the earlier outer array matters; use assignment for intentional mutation, map for value-wide transformation, and toSpliced or spread patterns when length changes. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is forcing every list update through with even when insertion, deletion or validation is the real job. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Choose with for fixed-length copying replacement, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Choose with for fixed-length copying replacement chapter on JavaScript Array.prototype.with(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on forcing every list update through with even when insertion, deletion or validation is the real job. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const current=['plan','draft','check'];
const reviewed=current.with(2,'submit');
console.log(current.join(' > '),reviewed.join(' > '));

Four purposeful transfer cases

Case 1: test laboratory. Transfer the rule using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Predict the rule using with is compared with assignment, slice-spread patterns, map and toSpliced. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework queue. Contrast the rule using one task is replaced without mutating the original list used by the previous screen. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading plan. Stress-test the rule using a negative index updates the last title while earlier state remains available. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers forcing every list update through with even when insertion, deletion or validation is the real job.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Choose with for fixed-length copying replacement, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Array.prototype.with() syntax. For this chapter, useful prompts are: “What did you expect from Choose with for fixed-length copying replacement?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing forcing every list update through with even when insertion, deletion or validation is the real job be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework queue with one task is replaced without mutating the original list used by the previous screen. Include one ordinary case, one boundary and one deliberate failure caused by forcing every list update through with even when insertion, deletion or validation is the real job. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Choose with for fixed-length copying replacement, separate the documented JavaScript Array.prototype.with() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Start with evidence, not 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 syntax fails, practise reference use. If routine cases are correct but boundaries fail, vary ties, defaults, unsupported inputs, ownership or missing paths. If explanations transfer, move to a small project.

Keep a weekly record with four lines: concept, prediction, observed difference and next test. Stop when fatigue replaces reasoning. A smaller case tomorrow is more useful than another hour of copying tonight.

Seek specialist help when cause and effect remain invisible after examples are reduced, when accessibility or data-loss implications are unclear, or when an important repository, database or application state may be at risk. Good support should make the learner’s reasoning more independent.

1. homework queue: model, boundary and recovery

Create a small homework queue using one task is replaced without mutating the original list used by the previous screen. Combine “with returns a new array with one replacement” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

2. reading plan: model, boundary and recovery

Create a small reading plan using a negative index updates the last title while earlier state remains available. Combine “The negative boundary is exactly minus length” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. science readings: model, boundary and recovery

Create a small science readings using sparse positions, undefined readings and nested sample objects are distinguished. Combine “Fractional indexes are converted toward zero” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. CCA roster: model, boundary and recovery

Create a small CCA roster using an array-like attendance object is copied into an ordinary Array. Combine “BigInt and Symbol indexes fail conversion” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. family errands: model, boundary and recovery

Create a small family errands using getters and length changes reveal the operation’s observable order. Combine “Sparse holes become explicit undefined entries” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. library shelf: model, boundary and recovery

Create a small library shelf using subclass and species assumptions are tested instead of guessed. Combine “The replaced position is not read” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. test laboratory: model, boundary and recovery

Create a small test laboratory using NaN, fractions, infinities, symbols, holes and out-of-range indexes expose boundaries. Combine “Array species is not consulted” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. design decision: model, boundary and recovery

Create a small design decision using with is compared with assignment, slice-spread patterns, map and toSpliced. Combine “A zero index replaces the first position” with one later chapter. 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 prediction–observation–explanation cycle while attention remains good. Ten to twenty focused minutes can be enough.

Should every option or function be memorised?

No. Memorise the governing distinctions and practise retrieving the official 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 official documentation be used?

Use it whenever syntax, supported types, SQL dialect behaviour or Git version details matter. Primary documentation 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.

Official and supporting references

• Primary technical documentation for JavaScript Array.prototype.with()
• eduKatePunggol: How Studying Works

Return to contents