Functions & generics.
Write it once. Work with any type.

// ─── Named function declaration ───────────────
function add(a: number, b: number): number {
return a + b;
}
// ↑ param types ↑ return type

// ─── Arrow function ───────────────────────────
const multiply = (a: number, b: number): number => a * b;

// ─── Function type alias ─────────────────────
type MathOp = (a: number, b: number) => number;
const subtract: MathOp = (a, b) => a - b;
// ↑ a and b are inferred from MathOp — no annotations needed

// ─── The compiler catches wrong calls ────────
add(1, 2); // ✅ 3
// add('1', '2'); // ❌ string not assignable to number
// add(1); // ❌ Expected 2 arguments, but got 1
// add(1, 2, 3); // ❌ Expected 2 arguments, but got 3

// ─── Return type is inferred, but writing it
// on exported functions is best practice
export function double(n: number): number {
return n * 2;
}

console.log(add(1, 2));

// ─── Optional parameter with ? ────────────────
function greet(name: string, greeting?: string): string {
// greeting: string | undefined inside the function
return ${greeting ?? 'Hello'}, ${name}!;
}

greet('Alice'); // ✅ uses fallback
greet('Alice', 'Hi'); // ✅ uses provided greeting
// greet(); // ❌ name is required

// ─── Default parameter with = ─────────────────
function greet2(name: string, greeting = 'Hello'): string {
// greeting: string inside the function (never undefined)
return ${greeting}, ${name}!;
}

greet2('Bob'); // ✅ 'Hello, Bob!'
greet2('Bob', 'Hey'); // ✅ 'Hey, Bob!'

// ─── The key difference ──────────────────────
// optional: type is T | undefined, must narrow before use
// default: type is T, can use directly

// ─── Where it bites you ──────────────────────
// Optional can't come before required:
// function bad(a?: number, b: number) {} // ❌
// Default can come anywhere:
function ok(a = 1, b: number) { return a + b; }

console.log(greet('Alice'));
console.log(greet2('Bob'));

// ─── Overload signatures (no body) ────────────
function parse(input: string): number;
function parse(input: number): string;
// ─── Implementation signature (broad) ─────────
function parse(input: string | number): string | number {
if (typeof input === 'string') {
return parseInt(input, 10);
}
return String(input);
}

// Callers get the specific return type:
const a = parse('42'); // a: number
const b = parse(42); // b: string

// ─── The modern alternative: unions + guards ──
// For most cases, this is simpler than overloads:
type Parsed = T extends string ? number : string;

function parse2extends string | number>(input: T): Parsed {
if (typeof input === 'string') {
return parseInt(input, 10) as Parsed;
}
return String(input) as Parsed;
}

// ─── When overloads are actually right ────────
// DOM APIs, event handlers, and builder functions with
// fundamentally different shapes per call often need overloads.
// For simple "input type A → output type B" cases,
// unions + generic guards are cleaner.

console.log(a, b);

// ─── The problem: any loses type info ─────────
function firstAny(arr: any[]): any {
return arr[0];
}
const a = firstAny(['x', 'y']);
// a: any — no autocomplete, no type checking

// ─── The solution: generic  ────────────────
function first(arr: T[]): T | undefined {
return arr[0];
}

const b = first(['x', 'y']); // b: string | undefined
const c = first([1, 2, 3]); // c: number | undefined
const d = first([{ id: 1 }, { id: 2 }]);
// d: { id: number } | undefined — full shape preserved

// ─── Explicit type argument ──────────────────
const e = first<string>(['x', 'y']); // explicit: string | undefined
// Usually unnecessary — inference handles it

// ─── Multiple type params ────────────────────
function pair(a: A, b: B): [A, B] {
return [a, b];
}
const p = pair('x', 1); // [string, number]

// ─── Generic with transformation ─────────────
function map(arr: T[], fn: (item: T) => U): U[] {
return arr.map(fn);
}

const lengths = map(['a', 'bb', 'ccc'], s => s.length);
// lengths: number[] — U inferred from the callback

console.log(b, c, p, lengths);

// ─── Without a constraint ────────────────────
function lenBad(x: T): number {
// return x.length; // ❌ Property 'length' does not exist on type 'T'
return 0;
}

// ─── With a constraint ───────────────────────
function lenextends { length: number }>(x: T): number {
return x.length; // ✅ T is guaranteed to have .length
}

len('hello'); // ✅ 5 — strings have length
len([1, 2, 3]); // ✅ 3 — arrays have length
// len(42); // ❌ number doesn't have length

// ─── Constraint with keyof ───────────────────
function getextends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}

const user = { name: 'Alice', age: 28 };
const n = get(user, 'name'); // string
const g = get(user, 'age'); // number
// get(user, 'email'); // ❌ 'email' is not a key of user

// ─── Constraint to a known union ─────────────
type Sortable = string | number;
function sortextends Sortable>(arr: T[]): T[] {
return [...arr].sort();
}
sort([3, 1, 2]); // ✅
// sort([{ x: 1 }]); // ❌ object not Sortable

// ─── Constraint to an interface ──────────────
interface HasId { id: string }
function findByIdextends HasId>(items: T[], id: string): T | undefined {
return items.find(i => i.id === id);
}

console.log(len('hello'), n, g);