Typescript: A resource to better grok the lack of errors when using types, interfaces, unions, intersections.

[AJamesPhillips]

Are there simple guide phrases / mnemonics people to use to remind themselves a type is not going to do be as restrictive as what they think it will be? Like the is-a / has-a for helping choosing classes or interfaces?

I always expect more assistance from my typings than they actually afford, for example, and "Why does TypeScript not raise a warning when an interface is overridden", and "Typescript type for limiting assignment". This has led me to keep typings as simple as possible for now and rely more on tests to catch type errors. It's not a complaint. I think the TypeScript team are doing an excellent job of building a type system for Javascript that isn't cripplingly pedantic or onerous to use and allows the expression of an incredibly power ("dangerously" so at times) language. But I was hoping someone might point towards some resource for understanding types better. I know this is a shifting landscape too so perhaps this isn't possible until things settle and Typescript sees improvements less frequently.

This is a question. I tried asking it on stackoverflow and it was closed (not unreasonably).

[RyanCavanaugh]

Some mnemonics I just made up:

• If your type is all-optional, you're likely to fall
• An unused generic is poison like arsenic
• Identical classes are stubborn like asses
• A Fish & Car can both swim and drive far, but a (need union type rhyme here)
• Type aliases look nominal but are only a new label

[AJamesPhillips]

That's excellent thanks Ryan. I am closing this but don't let it put anyone off adding / editing 👍

There's something in this example that needs to be extracted from this union but union is rhyme poor! "Fish & Car can both ... and ..." has us covered along way though.

type MaybeOneOrTheOther = ({
    first: number;
    orTheOther?: undefined;
} | {
    first?: undefined;
    orTheOther: string;
} | {
    first?: undefined;
    orTheOther?: undefined;
});

var result: MaybeOneOrTheOther = {};           // ✓ valid
result = { first: 1 };                         // ✓ valid
result = { orTheOther: "other" };              // ✓ valid
result = { first: 1, orTheOther: "other" };    // ✓ error - both defined
result = { first: 1, orTheOther: 3 };          // ✓ error - one defined correctly, the other wrong type
result = { first: 1, unknown: "bad" };         // ✓ error - one defined correctly, additional unknown also provided

"If your type is all-optional, you're likely to fall" so favour something: string | undefined over something?: string;