Checkpoint: Weekly Summary

Create a report from session records. The report function should count only completed sessions and should not edit or reorder the input. This combines array element types, readonly contracts, iteration and a fresh result object.

Write the input and output shapes first. A report has two numeric fields: completedCount and completedMinutes. Naming both makes the caller’s job clearer than returning an unexplained pair of numbers.

During implementation, keep the accumulated values local to the function. Do not reach into a global array. The function should give the same answer for the same input, including an empty list. This makes it easier to test and reuse.

Before opening a hint, manually calculate the expected report for the supplied records. Then check the compiler and run the code. Include the unchanged input in your observations: readonly declarations communicate the rule, while an output comparison checks the behavior of this implementation.

Predict, check, then run

Before running, write down the output and explain which information the checker knows. Click Check types first, then Check & run.

const minutes: readonly number[] = [10, 20, 0];
let total = 0;

for (const value of minutes) {
  total += value;
}

console.log(total);

30

Acceptance cases before you code

Write a small test plan before implementing readonly report inputs. These cases extend the brief; they are not a second worked solution. Predict the expected behavior independently, then test through the public function. A good ordinary example and a good boundary example should catch different possible mistakes.

After the core task passes, deliberately break one rule and identify the case that notices it. Restore the implementation and explain the failure in terms of the contract, not the number of assertions. If a case requires a concept you have not recalled, revisit the relevant lesson before opening the solution.

Your turn

// Define the shapes, implement the accumulator, and test full and empty lists.

type Session = {
  readonly topic: string;

  readonly minutes: number;

  readonly done: boolean;
};

type Report = {
  completedCount: number;

  completedMinutes: number;
};

function summarize(sessions: readonly Session[]): Report {
  let completedCount = 0;
  let completedMinutes = 0;

  for (const session of sessions) {
    if (session.done) {
      completedCount += 1;
      completedMinutes += session.minutes;
    }
  }

  return { completedCount, completedMinutes };
}

const sessions: Session[] = [
  { topic: "Types", minutes: 25, done: true },
  { topic: "DOM", minutes: 40, done: false },
  { topic: "Loops", minutes: 10, done: true }
];
const report = summarize(sessions);

console.log(report.completedCount);
console.log(report.completedMinutes);
console.log(summarize([]).completedMinutes);

2
35
0

Change it and explain it

Test all-incomplete records and a completed zero-minute record. Check that the original list still has the same values and order. Explain why a readonly array alone would not have made mutable record properties readonly.