Functions

type User = { id: number; name: string };
type Row = { id: number; full_name: string };

// No return type: the typo becomes part of the inferred type
function toUserInferred(row: Row) {
  return { id: row.id, nmae: row.full_name };
}
const a: User = toUserInferred({ id: 1, full_name: "Ada" }); // ❌ Property 'name' is missing in type '{ id: number; nmae: string; }' but required in type 'User'.

// Explicit return type: the typo is caught inside the function
function toUser(row: Row): User {
  return { id: row.id, nmae: row.full_name }; // ❌ Object literal may only specify known properties, and 'nmae' does not exist in type 'User'.
}

function sum(...nums: number[]): number {
  return nums.reduce((total, n) => total + n, 0);
}
sum();        // 0
sum(1, 2, 3); // 6
sum(1, "2");  // ❌ Argument of type 'string' is not assignable to parameter of type 'number'.

type BinaryOp = (a: number, b: number) => number;

const multiply: BinaryOp = (x, y) => x * y;   // x and y are number from context
const firstOnly: BinaryOp = (x) => x;         // fewer parameters is fine
const tooMany: BinaryOp = (x: number, y: number, z: number) => x; // ❌ Type '(x: number, y: number, z: number) => number' is not assignable to type 'BinaryOp'.

type LogArgs = [level: "info" | "warn", message: string, data?: object];

function log(...args: LogArgs) {
  const [level, message, data] = args;
  console[level](message, data ?? "");
}

log("info", "server started");
log("warn", "slow query", { ms: 812 });
log("debug", "x"); // ❌ Argument of type '"debug"' is not assignable to parameter of type '"info" | "warn"'.

function combine(a: number, b: number): number;
function combine(a: string, b: string): string;
function combine(a: number | string, b: number | string): number | string {
  if (typeof a === "number" && typeof b === "number") return a + b;
  return `${a}${b}`;
}

const total = combine(3, 4);       // type: number
const label = combine("a", "b");   // type: string
total.toFixed(2);                  // fine
combine(3, "x");                   // ❌ No overload matches this call.

function combine(a, b) {
    if (typeof a === "number" && typeof b === "number")
        return a + b;
    return `${a}${b}`;
}

function describe(x: unknown): string;
function describe(x: string): "text";
function describe(x: unknown): string {
  return typeof x === "string" ? "text" : "other";
}

const d = describe("hi"); // type: string — the first overload won

function parse(input: string): object;
function parse(input: Uint8Array): object; // ❌ This overload signature is not compatible with its implementation signature.
function parse(input: string): object {
  return JSON.parse(input);
}

function double(x: number): number;
function double(x: string): string;
function double(x: number | string): number | string {
  return typeof x === "number" ? `${x * 2}` : x + x; // bug: string for a number input
}

const d = double(4); // type: number, runtime value: "8"
d.toFixed(1);        // compiles — TypeError at runtime: d.toFixed is not a function

type ShapeProps = {
  circle: { radius: number };
  square: { side: number };
  rect: { width: number; height: number };
};

function area<K extends keyof ShapeProps>(kind: K, props: ShapeProps[K]): number {
  const p = props as ShapeProps[keyof ShapeProps];
  if ("radius" in p) return Math.PI * p.radius ** 2;
  if ("side" in p) return p.side ** 2;
  return p.width * p.height;
}

area("circle", { radius: 2 });           // ≈ 12.57
area("rect", { width: 2, height: 3 });   // 6
area("square", { radius: 2 });           // ❌ Object literal may only specify known properties, and 'radius' does not exist in type '{ side: number; }'.

function combine<T extends string | number>(a: T, b: T): T {
  return ((a as any) + b) as T;
}

const n = combine(3, 4);  // type: 3 | 4 — not number!
combine(3, "x");          // ❌ Argument of type '"x"' is not assignable to parameter of type '3'.

async function getName(): Promise<string> {
  return "Ada";
}

async function bad(): string { // ❌ The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<string>'?
  return "Ada";
}

function forgotAwait() {
  const name = getName();
  return name.toUpperCase(); // ❌ Property 'toUpperCase' does not exist on type 'Promise<string>'.
}

const p = new Promise((resolve) => setTimeout(() => resolve(42), 10));
// const p: Promise<unknown>
const typed = new Promise<number>((resolve) => setTimeout(() => resolve(42), 10));
// const typed: Promise<number>

type User = { id: number; name: string };
type Post = { title: string };

async function getUser(id: number): Promise<User> {
  return { id, name: "Ada" };
}
async function getPosts(userId: number): Promise<Post[]> {
  return [{ title: `Post by ${userId}` }];
}

async function loadProfile(id: number) {
  const [user, posts] = await Promise.all([getUser(id), getPosts(id)]);
  // user: User, posts: Post[]
  return { name: user.name, postCount: posts.length };
}
// loadProfile: (id: number) => Promise<{ name: string; postCount: number }>

type Profile = Awaited<ReturnType<typeof loadProfile>>;
// type Profile = { name: string; postCount: number }

function onClick(event) {
    console.log(this.textContent, event.clientX);
}

class Counter {
  count = 0;
  increment() {
    this.count++;
  }
  safeIncrement(this: Counter) {
    this.count++;
  }
  arrowIncrement = () => {
    this.count++;
  };
}

const counter = new Counter();
const inc = counter.increment;
inc(); // compiles — TypeError at runtime: Cannot read properties of undefined (reading 'count')

const safe = counter.safeIncrement;
safe(); // ❌ The 'this' context of type 'void' is not assignable to method's 'this' of type 'Counter'.

const arrow = counter.arrowIncrement;
arrow(); // fine at compile time and at runtime — this is captured

class QueryBuilder {
  protected parts: string[] = [];
  where(clause: string): this {
    this.parts.push(`WHERE ${clause}`);
    return this;
  }
}

class PagedQueryBuilder extends QueryBuilder {
  limit(n: number): this {
    this.parts.push(`LIMIT ${n}`);
    return this;
  }
}

const q = new PagedQueryBuilder().where("active").limit(10);
// q: PagedQueryBuilder