Functions — Parameters, Returns and Overloads

Functions are where a program's behaviour lives, and their types are the contracts that say what may go in and what comes out. TypeScript lets you type parameters, return values, optional and default arguments, variable-length argument lists, and even multiple distinct call shapes for one function through overloads. This matters because a function signature is the most reused contract in any codebase: every caller depends on it, so getting it precise means a typo, a missing argument, or a misused return value is caught at the call site rather than deep inside the implementation. A loosely typed function poisons everything downstream, because callers receive vague types and lose all checking. Mastering parameters, returns, and overloads turns each function into a small, enforced API — one that documents its own usage and rejects misuse before the code ever runs.

Analogy🏏Cricket

🏏 Think of it like cricket: Picture how a scoreboard operator constructs every display string from fixed components in a strict format — a batter's line is always built as `${name} ${runs} (${balls})`, never improvised. The format is a template with slots, and only values that fit each slot are allowed. Just as the scoreboard builds each line by filling a fixed template with the right pieces, a template literal type builds a string type by filling a pattern with other types. Just as a stray entry that does not match the format — text where runs should go — is rejected by the operator, a string that does not match the template literal type is rejected by the compiler. Just as the format guarantees every line is readable and consistent, the template type guarantees every string matches the intended shape. This reveals why template literal types matter: strings in software follow patterns just like scoreboard lines, and encoding the pattern into the type makes every malformed string an immediate error.