Lying Arrays
Programmers are often drawn towards lists without hesitation (arrays, or whatever) even when dealing with business logic that needs at least n items to be present, accepting the cost of runtime validation everywhere. Programmers are making arrays lie.
...
if (players.length < 2) {
throw new Error("A game of tic-tac-toe needs at least 2 players!")
}
...
This is my personal grudge — even in typed languages there is logically incorrect modeling everywhere. Type safety should really be thought as logic safety.
type TicTacToePlayers = Player[] // YEE, TYPE-SAFE LANGUAGE
So, why not fix the problem before it even becomes one? No runtime checks, please.
Lists with n+ elements
Nothing keeps us from defining the right tool for the job.
The problem could be solved with various language-dependent data structures, but if looking to solve it in a language-agnostic manner, this is what can be done:
// bad(ish)
type TicTacToePlayers = Player[]
// good(ish)
type TicTacToePlayers = {
first: Player
second: Player
rest: Player[]
}
Instead of defining players as just an array, we can go ham, and enforce the minimum player count already on type level.
Runtime checks no longer required! Faulty state made impossible and the model actually reflects business logic constraints.
Its also easily serializable. No tricks attached.
const players: TicTacToePlayers = {
first: createPlayer(), // ts happy
second: createPlayer(), // ts happy
rest: [] // ts happy
}
There is really no way to create an invalid set of players as long as the types are followed — and that is nice.
The atleast-2-items-array can be easily made generic, and nothing is restraining from going beyond 2 items.
type NonEmptyArray<T> = {
first: T
rest: T[]
}
type AtLeast2Array<T> = NonEmptyArray<T> & { second: T }
type AtLeast3Array<T> = AtLeast2Array<T> & { third: T }
Rationale
Programs are about collecting, transforming, and/or displaying data. Often, when building applications, the model (i.e., types) is an afterthought. Modeling can help eliminate the need for tests that handle impossible states and make programs reflect reality.
Writing code with correct models reduces the amount of needed unit tests, runtime checks and most importantly it reduces mental overhead.