Implementing the assignment or assertion of never at the end of a function is a strategy commonly used in Typescript to ensure exhaustive checks at compile time.
To enable the compiler to recognize this, explicit strings are needed for it to check against when determining if the function returns definitively before the assignment/assertion of never.
Is there a way to introduce a typed variation of Object.freeze that specifically applies to object literals and further up the chain? This would allow for something like the following:
Even more ideally, could an interface be created where the keys automatically match those of each Action.type (as shown in this example)? If such an interface existed, declaring actionMap as that interface could enforce the compile-time check.
Both methods offer solutions to the same issue... given only a discriminated union, is there a method to perform exhaustiveness checks like this at compile time without relying on explicit strings within the function?
interface Increment {
type: 'increment'
}
interface Decrement {
type: 'decrement'
}
type Action = Increment | Decrement
const inc: Increment = { type: 'increment' };
const dec: Decrement = { type: 'decrement' };
//this illustrates a Typescript variation
const actionMap = Object.freeze({
[inc.type]: n => n + 1,
[dec.type]: n => n-1
});
function doAction(action: Action, val: number): number {
if(actionMap[action.type]) {
return actionMap[action.type](val);
}
//this would result in a compile time error if the above check failed
const _exhaustiveCheck: never = action;
}
console.log(doAction(inc, 1));
console.log(doAction(dec, 1));