[Grade School] Can't use Readonly<> types for later tests

[sfre-coop]

I think the right way to turn off modification would be to use Readonly<> generics, which would enforce the requirement during compilation. Unfortunatly, using them also means that the tests don't compile. Not sure how to get out of this.

And thanks for all the work.

[github-actions]

Hello. Thanks for opening an issue on Exercism. We are currently in a phase of our journey where we have paused community contributions to allow us to take a breather and redesign our community model. You can learn more in this blog post. As such, all issues and PRs in this repository are being automatically closed.

That doesn't mean we're not interested in your ideas, or that if you're stuck on something we don't want to help. The best place to discuss things is with our community on the Exercism Community Forum. You can use this link to copy this into a new topic there.

---

Note: If this issue has been pre-approved, please link back to this issue on the forum thread and a maintainer or staff member will reopen it.

[SleeplessByte]

@sfre-coop could you post your solution so I can look into what exactly is failing?

[sfre-coop]

type Student = string
type Grade = number;
type Students = ReadonlyArray<Student>

// Ideally this would user Readonly<> generics but that stops the tests from compiling.
type Roster = Record<Grade, Students>

export class GradeSchool {
  private _roster:  Roster = {}
  roster() : Roster {
    return this._roster
  }

  add(student: Student, grade: Grade) : void {
    this.remove(student);
    this._roster[grade] = [...this.grade(grade), student].sort()
  }

  private remove(student: string) : void {
    for (let g in this._roster) {
      let students = this._roster[g]
      if (students.includes(student)) {
        this._roster[g] = students.filter(s => s !== student)
        break
      }
    }
  }

  grade(grade: Grade): Students {
    return this._roster[grade] || []
  }
}

[sfre-coop]

If you try this solution, then the calls to push at lines 68 and 75 in the tests don't compile.

[SleeplessByte]

That's correct, because you cannot push to a readonly array!

readonly T[] and ReadonlyArray<T> are often used to signal one of two things:

• this function will not mutate that parameter
• callers of this function may not mutate the result

Neither is true for this exercise as the goal is to return a result that may be mutated, because it was safely disconnected from the source data (by duplicating it). Therefore, readonly isn't a good fit for this exercise.

Let me know if this explanation makes sense or you'd like further elaboration or examples.

[sfre-coop]

OK. I didn't see that in the text. My implementation disabled the call to push(), which passes the test.

[SleeplessByte]

Yes, the text doesn't explicitly say what I said in my post, because the tests say nothing about the internal immutability or lack thereof. We only test two things:

1. 'roster cannot be modified outside of module' meaning you cannot mutate the roster inside the school without using add.
2. 'roster cannot be modified outside of module using grade()' meaning you cannot mutate a grade inside the roster, inside the school without using add

Neither says that the result must be read-only, only that nothing (including the result) may cause the internals to change.

---

Regardless of what the text says @sfre-coop, in your posted solution you denote:

// Ideally this would user Readonly<> generics but that stops the tests from compiling.
type Roster = Record<Grade, Students>

But that would mean that you cannot type your internal roster as Roster because then add and remove would never work. This would fail compilation inside the solution (ignoring the tests). Does that make sense?