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 Intl.PluralRules selects a locale-sensitive grammatical category for a number. The category—zero, one, two, few, many or other—is an instruction for choosing an already translated message pattern, not a universal mathematical test and not a formatter that writes the final sentence. Mastery means negotiating the intended locale, choosing cardinal or ordinal rules, accounting for digit-rounding options, providing an other fallback, testing the categories the runtime reports, and treating selectRange() as a capability that must be checked in the deployed environment. 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.

PluralRules maps a numeric input to a locale rule category; it does not translate nouns or assemble a sentence. 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 adding an s whenever the returned category is not one. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Plural categories are grammatical selectors, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Plural categories are grammatical selectors chapter on JavaScript Intl.PluralRules, 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 adding an s whenever the returned category is not one. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const pr=new Intl.PluralRules('en');
console.log(pr.select(1),pr.select(2));

Four purposeful transfer cases

Case 1: homework counter. Predict the rule using a dashboard chooses a translated message for completed questions. 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 tracker. Contrast the rule using book and page counts use locale-specific cardinal categories. 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 display. Stress-test the rule using rounded measurements select a message without rewriting the number. 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 registration. Explain the rule using place labels use ordinal categories where the locale supports them. 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 adding an s whenever the returned category is not one.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Plural categories are grammatical selectors, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Plural categories are grammatical selectors?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing adding an s whenever the returned category is not one be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue with a message dictionary covers every reported category and an other fallback. Include one ordinary case, one boundary and one deliberate failure caused by adding an s whenever the returned category is not one. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Plural categories are grammatical selectors, separate the documented JavaScript Intl.PluralRules 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 requested locale list is resolved against locale data available in the implementation. 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 every arbitrary language tag is supported exactly as requested. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for The constructor negotiates locale, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the The constructor negotiates locale chapter on JavaScript Intl.PluralRules, 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 every arbitrary language tag is supported exactly as requested. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const pr=new Intl.PluralRules(['fr-SG','fr']);
console.log(pr.resolvedOptions().locale);

Four purposeful transfer cases

Case 1: science display. Contrast the rule using rounded measurements select a message without rewriting the number. 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 registration. Stress-test the rule using place labels use ordinal categories where the locale supports them. 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 planner. Explain the rule using day ranges choose a range category only when the runtime exposes selectRange. 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 catalogue. Transfer the rule using a message dictionary covers every reported category and an other fallback. 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 every arbitrary language tag is supported exactly as requested.
• 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 constructor negotiates locale, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from The constructor negotiates locale?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming every arbitrary language tag is supported exactly as requested 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 locales, decimals, negatives, special numbers and unsupported range methods are recorded. Include one ordinary case, one boundary and one deliberate failure caused by assuming every arbitrary language tag is supported exactly as requested. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The constructor negotiates locale, separate the documented JavaScript Intl.PluralRules 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

Without type ordinal, the object applies cardinal quantity rules. 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 default rules for first, second and third labels. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Cardinal is the default type, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Cardinal is the default type chapter on JavaScript Intl.PluralRules, 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 default rules for first, second and third labels. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.PluralRules('en').select(2)

Four purposeful transfer cases

Case 1: family planner. Stress-test the rule using day ranges choose a range category only when the runtime exposes selectRange. 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 catalogue. Explain the rule using a message dictionary covers every reported category and an other fallback. 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 locales, decimals, negatives, special numbers and unsupported range methods are recorded. 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. 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 default rules for first, second and third labels.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Cardinal is the default type, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Cardinal is the default type?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using default rules for first, second and third labels 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. Include one ordinary case, one boundary and one deliberate failure caused by using default rules for first, second and third labels. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Cardinal is the default type, separate the documented JavaScript Intl.PluralRules 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

type ordinal selects rules intended for ordinal positions when the locale defines distinctions. 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 ordinal output for item counts. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Ordinal rules are explicit, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Ordinal rules are explicit chapter on JavaScript Intl.PluralRules, 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 ordinal output for item counts. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const ord=new Intl.PluralRules('en',{type:'ordinal'});
[1,2,3,4].map(n=>ord.select(n))

Four purposeful transfer cases

Case 1: test laboratory. Explain the rule using locales, decimals, negatives, special numbers and unsupported range methods are recorded. 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. 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 counter. Predict the rule using a dashboard chooses a translated message for completed questions. 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 tracker. Contrast the rule using book and page counts use locale-specific cardinal categories. 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 ordinal output for item counts.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Ordinal rules are explicit, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Ordinal rules are explicit?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using ordinal output for item counts be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework counter with a dashboard chooses a translated message for completed questions. Include one ordinary case, one boundary and one deliberate failure caused by using ordinal output for item counts. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Ordinal rules are explicit, separate the documented JavaScript Intl.PluralRules 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

select converts and rounds according to the object’s options, then returns one of the standard category labels. 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 select to return a Boolean or the input number. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for select returns a category string, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the select returns a category string chapter on JavaScript Intl.PluralRules, 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 select to return a Boolean or the input number. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const category=new Intl.PluralRules('ar').select(2);

Four purposeful transfer cases

Case 1: homework counter. Transfer the rule using a dashboard chooses a translated message for completed questions. 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 tracker. Predict the rule using book and page counts use locale-specific cardinal categories. 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 display. Contrast the rule using rounded measurements select a message without rewriting the number. 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 registration. Stress-test the rule using place labels use ordinal categories where the locale supports them. 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 select to return a Boolean or the input number.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for select returns a category string, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from select returns a category string?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting select to return a Boolean or the input number be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny reading tracker with book and page counts use locale-specific cardinal categories. Include one ordinary case, one boundary and one deliberate failure caused by expecting select to return a Boolean or the input number. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For select returns a category string, separate the documented JavaScript Intl.PluralRules 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 label one does not universally mean the number equals exactly one; locale grammar and visible fraction digits govern the result. 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 writing a one category check as a language-independent equality test. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Category names are not numeric equality, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Category names are not numeric equality chapter on JavaScript Intl.PluralRules, 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 writing a one category check as a language-independent equality test. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const fr=new Intl.PluralRules('fr');
console.log(fr.select(0),fr.select(1));

Four purposeful transfer cases

Case 1: science display. Predict the rule using rounded measurements select a message without rewriting the number. 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 registration. Contrast the rule using place labels use ordinal categories where the locale supports them. 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 planner. Stress-test the rule using day ranges choose a range category only when the runtime exposes selectRange. 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 catalogue. Explain the rule using a message dictionary covers every reported category and an other fallback. 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 writing a one category check as a language-independent equality test.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Category names are not numeric equality, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Category names are not numeric equality?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing writing a one category check as a language-independent equality test be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science display with rounded measurements select a message without rewriting the number. Include one ordinary case, one boundary and one deliberate failure caused by writing a one category check as a language-independent equality test. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Category names are not numeric equality, separate the documented JavaScript Intl.PluralRules 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

Fractional operands participate in locale plural rules and may select a different category from nearby integers. 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 testing only 0, 1 and 2 and declaring coverage complete. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Decimals can follow different rules, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Decimals can follow different rules chapter on JavaScript Intl.PluralRules, 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 testing only 0, 1 and 2 and declaring coverage complete. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const pr=new Intl.PluralRules('en');
[1,1.2,2].map(n=>pr.select(n))

Four purposeful transfer cases

Case 1: family planner. Contrast the rule using day ranges choose a range category only when the runtime exposes selectRange. 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 catalogue. Stress-test the rule using a message dictionary covers every reported category and an other fallback. 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 locales, decimals, negatives, special numbers and unsupported range methods are recorded. 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. 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 testing only 0, 1 and 2 and declaring coverage complete.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Decimals can follow different rules, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Decimals can follow different rules?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing testing only 0, 1 and 2 and declaring coverage complete be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA registration with place labels use ordinal categories where the locale supports them. Include one ordinary case, one boundary and one deliberate failure caused by testing only 0, 1 and 2 and declaring coverage complete. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Decimals can follow different rules, separate the documented JavaScript Intl.PluralRules 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

Minimum and maximum fraction digits or significant digits can change the rounded representation used for rule selection. 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 formatting with one policy and selecting a message with an unrelated policy. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Digit options influence selection, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Digit options influence selection chapter on JavaScript Intl.PluralRules, 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 formatting with one policy and selecting a message with an unrelated policy. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const pr=new Intl.PluralRules('en',{minimumFractionDigits:1});
console.log(pr.select(1));

Four purposeful transfer cases

Case 1: test laboratory. Stress-test the rule using locales, decimals, negatives, special numbers and unsupported range methods are recorded. 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. 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 counter. Transfer the rule using a dashboard chooses a translated message for completed questions. 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 tracker. Predict the rule using book and page counts use locale-specific cardinal categories. 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 formatting with one policy and selecting a message with an unrelated policy.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Digit options influence selection, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Digit options influence selection?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing formatting with one policy and selecting a message with an unrelated policy be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family planner with day ranges choose a range category only when the runtime exposes selectRange. Include one ordinary case, one boundary and one deliberate failure caused by formatting with one policy and selecting a message with an unrelated policy. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Digit options influence selection, separate the documented JavaScript Intl.PluralRules 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

resolvedOptions reports the chosen locale, type, digit settings and pluralCategories supported by the resolved rules. 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 guessing defaults from another Intl formatter. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for resolvedOptions documents the active policy, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the resolvedOptions documents the active policy chapter on JavaScript Intl.PluralRules, 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 guessing defaults from another Intl formatter. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const o=new Intl.PluralRules('pl').resolvedOptions();
console.log(o.type,o.pluralCategories);

Four purposeful transfer cases

Case 1: homework counter. Explain the rule using a dashboard chooses a translated message for completed questions. 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 tracker. Transfer the rule using book and page counts use locale-specific cardinal categories. 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 display. Predict the rule using rounded measurements select a message without rewriting the number. 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 registration. Contrast the rule using place labels use ordinal categories where the locale supports them. 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 guessing defaults from another Intl formatter.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for resolvedOptions documents the active policy, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from resolvedOptions documents the active policy?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing guessing defaults from another Intl formatter be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue with a message dictionary covers every reported category and an other fallback. Include one ordinary case, one boundary and one deliberate failure caused by guessing defaults from another Intl formatter. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For resolvedOptions documents the active policy, separate the documented JavaScript Intl.PluralRules 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 reported pluralCategories array identifies categories the resolved locale may return under the object’s rules. 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 shipping a dictionary with only one and other for every language. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for pluralCategories drive dictionary checks, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the pluralCategories drive dictionary checks chapter on JavaScript Intl.PluralRules, 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 shipping a dictionary with only one and other for every language. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const cats=new Intl.PluralRules('ar').resolvedOptions().pluralCategories;

Four purposeful transfer cases

Case 1: science display. Transfer the rule using rounded measurements select a message without rewriting the number. 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 registration. Predict the rule using place labels use ordinal categories where the locale supports them. 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 planner. Contrast the rule using day ranges choose a range category only when the runtime exposes selectRange. 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 catalogue. Stress-test the rule using a message dictionary covers every reported category and an other fallback. 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 shipping a dictionary with only one and other for every language.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for pluralCategories drive dictionary checks, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from pluralCategories drive dictionary checks?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing shipping a dictionary with only one and other for every language 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 locales, decimals, negatives, special numbers and unsupported range methods are recorded. Include one ordinary case, one boundary and one deliberate failure caused by shipping a dictionary with only one and other for every language. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For pluralCategories drive dictionary checks, separate the documented JavaScript Intl.PluralRules 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 static method returns requested locales supported without falling back to the runtime default. 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 constructing one object and inferring that every locale in a product is available. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for supportedLocalesOf is a support probe, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the supportedLocalesOf is a support probe chapter on JavaScript Intl.PluralRules, 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 constructing one object and inferring that every locale in a product is available. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

Intl.PluralRules.supportedLocalesOf(['en','ar','zz-ZZ'])

Four purposeful transfer cases

Case 1: family planner. Predict the rule using day ranges choose a range category only when the runtime exposes selectRange. 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 catalogue. Contrast the rule using a message dictionary covers every reported category and an other fallback. 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 locales, decimals, negatives, special numbers and unsupported range methods are recorded. 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. 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 constructing one object and inferring that every locale in a product is available.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for supportedLocalesOf is a support probe, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from supportedLocalesOf is a support probe?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing constructing one object and inferring that every locale in a product is available 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. Include one ordinary case, one boundary and one deliberate failure caused by constructing one object and inferring that every locale in a product is available. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For supportedLocalesOf is a support probe, separate the documented JavaScript Intl.PluralRules 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

NumberFormat formats the visible number while PluralRules selects the message category; their digit policies should align. 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 PluralRules to insert grouping, digits or unit text. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Formatting remains a separate responsibility, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Formatting remains a separate responsibility chapter on JavaScript Intl.PluralRules, 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 PluralRules to insert grouping, digits or unit text. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const n=1.5;
const text=new Intl.NumberFormat('fr').format(n);
const key=new Intl.PluralRules('fr').select(n);

Four purposeful transfer cases

Case 1: test laboratory. Contrast the rule using locales, decimals, negatives, special numbers and unsupported range methods are recorded. 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. 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 counter. Explain the rule using a dashboard chooses a translated message for completed questions. 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 tracker. Transfer the rule using book and page counts use locale-specific cardinal categories. 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 PluralRules to insert grouping, digits or unit text.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Formatting remains a separate responsibility, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Formatting remains a separate responsibility?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting PluralRules to insert grouping, digits or unit text be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework counter with a dashboard chooses a translated message for completed questions. Include one ordinary case, one boundary and one deliberate failure caused by expecting PluralRules to insert grouping, digits or unit text. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Formatting remains a separate responsibility, separate the documented JavaScript Intl.PluralRules 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

Category sets vary by locale, and other is the durable fallback when a specific pattern is unavailable. 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 letting a missing category render undefined to families. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Every map needs an other fallback, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Every map needs an other fallback chapter on JavaScript Intl.PluralRules, 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 letting a missing category render undefined to families. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const msg=messages[key] ?? messages.other;

Four purposeful transfer cases

Case 1: homework counter. Stress-test the rule using a dashboard chooses a translated message for completed questions. 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 tracker. Explain the rule using book and page counts use locale-specific cardinal categories. 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 display. Transfer the rule using rounded measurements select a message without rewriting the number. 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 registration. Predict the rule using place labels use ordinal categories where the locale supports them. 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 letting a missing category render undefined to families.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Every map needs an other fallback, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Every map needs an other fallback?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing letting a missing category render undefined to families be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny reading tracker with book and page counts use locale-specific cardinal categories. Include one ordinary case, one boundary and one deliberate failure caused by letting a missing category render undefined to families. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Every map needs an other fallback, separate the documented JavaScript Intl.PluralRules 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

Two locales may return different categories for the same numeric input because their grammatical rules differ. 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 copying an English conditional into another locale. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Locales can classify the same number differently, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Locales can classify the same number differently chapter on JavaScript Intl.PluralRules, 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 copying an English conditional into another locale. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

for(const l of ['en','fr','ar']) console.log(l,new Intl.PluralRules(l).select(0));

Four purposeful transfer cases

Case 1: science display. Explain the rule using rounded measurements select a message without rewriting the number. 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 registration. Transfer the rule using place labels use ordinal categories where the locale supports them. 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 planner. Predict the rule using day ranges choose a range category only when the runtime exposes selectRange. 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 catalogue. Contrast the rule using a message dictionary covers every reported category and an other fallback. 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 copying an English conditional into another locale.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Locales can classify the same number differently, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Locales can classify the same number differently?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing copying an English conditional into another locale be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science display with rounded measurements select a message without rewriting the number. Include one ordinary case, one boundary and one deliberate failure caused by copying an English conditional into another locale. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Locales can classify the same number differently, separate the documented JavaScript Intl.PluralRules 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

Ordinal categories can select complete phrases or suffix patterns, but the correct form is language-specific. 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 concatenating English suffixes after a number in every locale. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Ordinal labels need full message patterns, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Ordinal labels need full message patterns chapter on JavaScript Intl.PluralRules, 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 concatenating English suffixes after a number in every locale. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const key=new Intl.PluralRules('en',{type:'ordinal'}).select(23);

Four purposeful transfer cases

Case 1: family planner. Transfer the rule using day ranges choose a range category only when the runtime exposes selectRange. 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 catalogue. Predict the rule using a message dictionary covers every reported category and an other fallback. 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 locales, decimals, negatives, special numbers and unsupported range methods are recorded. 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. 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 concatenating English suffixes after a number in every locale.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Ordinal labels need full message patterns, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Ordinal labels need full message patterns?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing concatenating English suffixes after a number in every locale be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA registration with place labels use ordinal categories where the locale supports them. Include one ordinary case, one boundary and one deliberate failure caused by concatenating English suffixes after a number in every locale. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Ordinal labels need full message patterns, separate the documented JavaScript Intl.PluralRules 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

select converts its input to Number; NaN, Infinity and negative values therefore need an application policy and observed runtime tests. 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 allowing nonsensical counts into user-facing messages because select still returns a category. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Special numeric inputs need tests, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Special numeric inputs need tests chapter on JavaScript Intl.PluralRules, 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 allowing nonsensical counts into user-facing messages because select still returns a category. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const pr=new Intl.PluralRules('en');
[NaN,Infinity,-1].map(x=>pr.select(x))

Four purposeful transfer cases

Case 1: test laboratory. Predict the rule using locales, decimals, negatives, special numbers and unsupported range methods are recorded. 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. 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 counter. Stress-test the rule using a dashboard chooses a translated message for completed questions. 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 tracker. Explain the rule using book and page counts use locale-specific cardinal categories. 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 allowing nonsensical counts into user-facing messages because select still returns a category.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Special numeric inputs need tests, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Special numeric inputs need tests?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing allowing nonsensical counts into user-facing messages because select still returns a category be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family planner with day ranges choose a range category only when the runtime exposes selectRange. Include one ordinary case, one boundary and one deliberate failure caused by allowing nonsensical counts into user-facing messages because select still returns a category. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Special numeric inputs need tests, separate the documented JavaScript Intl.PluralRules 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

Current ECMA-402 defines selectRange(start,end), but not every deployed engine necessarily implements it. 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 selectRange unguarded because a current specification includes it. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for selectRange is capability-sensitive, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the selectRange is capability-sensitive chapter on JavaScript Intl.PluralRules, 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 selectRange unguarded because a current specification includes it. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

if(typeof pr.selectRange==='function') console.log(pr.selectRange(1,2));

Four purposeful transfer cases

Case 1: homework counter. Contrast the rule using a dashboard chooses a translated message for completed questions. 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 tracker. Stress-test the rule using book and page counts use locale-specific cardinal categories. 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 display. Explain the rule using rounded measurements select a message without rewriting the number. 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 registration. Transfer the rule using place labels use ordinal categories where the locale supports them. 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 selectRange unguarded because a current specification includes it.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for selectRange is capability-sensitive, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from selectRange is capability-sensitive?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling selectRange unguarded because a current specification includes it be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue with a message dictionary covers every reported category and an other fallback. Include one ordinary case, one boundary and one deliberate failure caused by calling selectRange unguarded because a current specification includes it. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For selectRange is capability-sensitive, separate the documented JavaScript Intl.PluralRules 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 object supplies no noun, inflection table or translation service. 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 the category name itself as visible text. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for PluralRules does not translate words, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the PluralRules does not translate words chapter on JavaScript Intl.PluralRules, 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 the category name itself as visible text. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const pattern=messages[pr.select(count)] ?? messages.other;

Four purposeful transfer cases

Case 1: science display. Stress-test the rule using rounded measurements select a message without rewriting the number. 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 registration. Explain the rule using place labels use ordinal categories where the locale supports them. 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 planner. Transfer the rule using day ranges choose a range category only when the runtime exposes selectRange. 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 catalogue. Predict the rule using a message dictionary covers every reported category and an other fallback. 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 the category name itself as visible text.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for PluralRules does not translate words, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from PluralRules does not translate words?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using the category name itself as visible text 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 locales, decimals, negatives, special numbers and unsupported range methods are recorded. Include one ordinary case, one boundary and one deliberate failure caused by using the category name itself as visible text. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For PluralRules does not translate words, separate the documented JavaScript Intl.PluralRules 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

Tests should cover every supported locale, reported category, relevant digit policy and boundary 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 approving an interface after checking only English 1 and 2. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for A matrix is stronger than one example, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the A matrix is stronger than one example chapter on JavaScript Intl.PluralRules, 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 approving an interface after checking only English 1 and 2. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

for(const locale of locales){
 const pr=new Intl.PluralRules(locale,options);
 console.log(locale,pr.resolvedOptions().pluralCategories);
}

Four purposeful transfer cases

Case 1: family planner. Explain the rule using day ranges choose a range category only when the runtime exposes selectRange. 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 catalogue. Transfer the rule using a message dictionary covers every reported category and an other fallback. 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 locales, decimals, negatives, special numbers and unsupported range methods are recorded. 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. 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 approving an interface after checking only English 1 and 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 A matrix is stronger than one example, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from A matrix is stronger than one example?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing approving an interface after checking only English 1 and 2 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. Include one ordinary case, one boundary and one deliberate failure caused by approving an interface after checking only English 1 and 2. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For A matrix is stronger than one example, separate the documented JavaScript Intl.PluralRules 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

Intl objects can be reused for repeated selections when their locale and options are identical; use them for localized messages, not mathematical branching. 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 constructing a new object per table cell or replacing domain validation with grammar categories. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Cache by locale and options, then choose deliberately, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Cache by locale and options, then choose deliberately chapter on JavaScript Intl.PluralRules, 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 constructing a new object per table cell or replacing domain validation with grammar categories. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const cache=new Map();
function rules(key,make){if(!cache.has(key))cache.set(key,make());return cache.get(key)}

Four purposeful transfer cases

Case 1: test laboratory. Transfer the rule using locales, decimals, negatives, special numbers and unsupported range methods are recorded. 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. 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 counter. Contrast the rule using a dashboard chooses a translated message for completed questions. 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 tracker. Stress-test the rule using book and page counts use locale-specific cardinal categories. 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 constructing a new object per table cell or replacing domain validation with grammar categories.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Cache by locale and options, then choose deliberately, 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 Intl.PluralRules syntax. For this chapter, useful prompts are: “What did you expect from Cache by locale and options, then choose deliberately?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing constructing a new object per table cell or replacing domain validation with grammar categories be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework counter with a dashboard chooses a translated message for completed questions. Include one ordinary case, one boundary and one deliberate failure caused by constructing a new object per table cell or replacing domain validation with grammar categories. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Cache by locale and options, then choose deliberately, separate the documented JavaScript Intl.PluralRules 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 counter: model, boundary and recovery

Create a small homework counter using a dashboard chooses a translated message for completed questions. Combine “Plural categories are grammatical selectors” 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 tracker: model, boundary and recovery

Create a small reading tracker using book and page counts use locale-specific cardinal categories. Combine “Ordinal rules are explicit” 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 display: model, boundary and recovery

Create a small science display using rounded measurements select a message without rewriting the number. Combine “Decimals can follow different rules” 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 registration: model, boundary and recovery

Create a small CCA registration using place labels use ordinal categories where the locale supports them. Combine “pluralCategories drive dictionary checks” 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 planner: model, boundary and recovery

Create a small family planner using day ranges choose a range category only when the runtime exposes selectRange. Combine “Every map needs an other fallback” 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 catalogue: model, boundary and recovery

Create a small library catalogue using a message dictionary covers every reported category and an other fallback. Combine “Special numeric inputs need tests” 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 locales, decimals, negatives, special numbers and unsupported range methods are recorded. Combine “A matrix is stronger than one example” 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 PluralRules is compared with NumberFormat, ListFormat and hand-written English-only branching. Combine “The constructor negotiates locale” 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 Intl.PluralRules
• eduKatePunggol: How Studying Works

Return to contents