TypeScript

let a: any; let u: unknown; let s: string;
s = a; // ok
u = a; // ok
a = u; // ok
s = u; // error: unknown is not assignable to string
if (typeof u === "string") s = u; // ok after narrowing

type Point = { x: number; y: number };
const p3 = { x: 1, y: 2, z: 3 };
const p: Point = p3;            // ok (structural)
const q: Point = { x: 1, y: 2, z: 3 }; // error: excess property 'z'

interface Patch { nickname?: string }
const a: Patch = {};                      // ok
const b: Patch = { nickname: undefined }; // error only with exactOptionalPropertyTypes

const ROLES = ["admin", "staff", "customer"] as const;
type Role = (typeof ROLES)[number]; // "admin" | "staff" | "customer"
const cfg = { retries: 3 } as const; // { readonly retries: 3 }

const CreateOrder = z.object({ sku: z.string(), qty: z.number().int().positive() });
type CreateOrder = z.infer<typeof CreateOrder>;
app.post("/orders", (req, res) => {
  const body = CreateOrder.parse(req.body); // throws ZodError -> 400
  // body is CreateOrder from here on
});

type MyPartial<T> = { [K in keyof T]?: T[K] };
type MyPick<T, K extends keyof T> = { [P in K]: T[P] };
type UserPreview = MyPick<User, "id" | "name">;

function assertDefined<T>(v: T, msg: string): asserts v is NonNullable<T> {
  if (v == null) throw new Error(msg);
}
const user = await repo.find(id);
assertDefined(user, "user not found");
user.email; // User, not User | null

type PaymentResult =
  | { status: "succeeded"; chargeId: string }
  | { status: "requires_action"; redirectUrl: string }
  | { status: "failed"; reason: string };

function handle(r: PaymentResult) {
  switch (r.status) {
    case "succeeded": return ok(r.chargeId);
    case "requires_action": return redirect(r.redirectUrl);
    case "failed": return fail(r.reason);
    default: { const _never: never = r; throw new Error("unhandled"); }
  }
}

type Route = { path: string; auth: boolean };
const routes = {
  home: { path: "/", auth: false },
  orders: { path: "/orders", auth: true },
} satisfies Record<string, Route>;
routes.orders.path; // ok, key "orders" is known
routes.nope;        // error — would be allowed with ': Record<string, Route>'

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
  return items.map((i) => i[key]);
}
const emails = pluck(users, "email"); // string[]
pluck(users, "emali"); // error

interface UpdateProfile { name: string }
const body = { name: "A", role: "admin" };
const dto: UpdateProfile = body; // compiles
await db.user.update({ where: { id }, data: { ...dto } }); // role leaks through at runtime

class Animal { name = "" }
class Dog extends Animal { bark() {} }
interface A { handle(x: Animal): void }      // method shorthand: bivariant
interface B { handle: (x: Animal) => void }  // property: contravariant under strict
const onlyDogs = (d: Dog) => d.bark();
const a: A = { handle: onlyDogs }; // compiles (unsound): a.handle(new Animal()) crashes
const b: B = { handle: onlyDogs }; // error

type IsString<T> = T extends string ? true : false;
type A = IsString<string | number>;  // ?
type B = IsString<never>;            // ?
type ToArray<T> = T extends unknown ? T[] : never;
type C = ToArray<string | number>;   // ?
type IsStringStrict<T> = [T] extends [string] ? true : false;
type D = IsStringStrict<string | number>; // ?

type Events = { orderCreated: { id: string }; orderPaid: { id: string; amount: number } };
type Handlers = {
  [K in keyof Events as `on${Capitalize<string & K>}`]: (payload: Events[K]) => void;
};
// { onOrderCreated: (p: {id: string}) => void; onOrderPaid: (p: {...}) => void }

type Params<P extends string> =
  P extends `${string}:${infer Name}/${infer Rest}`
    ? { [K in Name | keyof Params<`/${Rest}`>]: string }
    : P extends `${string}:${infer Name}`
      ? { [K in Name]: string }
      : {};
type X = Params<"/tenants/:tenantId/orders/:orderId">;
// { tenantId: string; orderId: string }

export const OrderStatus = { Pending: "pending", Paid: "paid", Shipped: "shipped" } as const;
export type OrderStatus = (typeof OrderStatus)[keyof typeof OrderStatus];
const s: OrderStatus = "paid"; // ok, works with JSON from DB

// src/types/express.d.ts
import type { AuthUser } from "../auth/types";
declare global {
  namespace Express {
    interface Request { user?: AuthUser; tenantId?: string }
  }
}
export {};

const cache: Record<string, User> = {};
function email(id: string) {
  return cache[id].email; // compiles; TypeError at runtime on a miss
}

function find(id: string): Promise<User | null>;
function find(ids: string[]): Promise<User[]>;
function find(x: string | string[]) { /* impl */ return null as any; }
declare const v: string | string[];
find(v); // error: no overload matches a union argument

function createFSM<S extends string>(states: S[], initial: NoInfer<S>) { /* ... */ }
createFSM(["idle", "loading"], "idle");   // ok
createFSM(["idle", "loading"], "crashed"); // error (without NoInfer, S would widen)

interface User { id: string; email: string }
function isUser(x: unknown): x is User {
  return typeof x === "object" && x !== null && "id" in x;
}
const payload: unknown = await res.json();
if (isUser(payload)) {
  sendMail(payload.email.toLowerCase());
}

type Invoice = { id: string; total: number };
async function getInvoice(id: string): Promise<Invoice> {
  const r = await fetch(`/api/invoices/${id}`);
  return (await r.json()) as Invoice;
}
const inv = await getInvoice("1");
render(inv.total + 100); // "1000100"

const ids: (string | undefined)[] = ["a", undefined, "b"];
const a = ids.filter(Boolean);                 // (string | undefined)[]
const b = ids.filter((x) => x !== undefined);  // string[] on TS >= 5.5
const c = ids.filter((x): x is string => !!x); // string[] on any version

class Base {
  constructor(data: Record<string, unknown>) { Object.assign(this, data); }
}
class Order extends Base {
  id!: string;
  total!: number;
}
new Order({ id: "o1", total: 10 }).id; // undefined after the upgrade

declare const brand: unique symbol;
type Brand<T, B> = T & { readonly [brand]: B };
type TenantId = Brand<string, "TenantId">;
type ProductId = Brand<string, "ProductId">;
function getProduct(tenant: TenantId, id: ProductId) { /* ... */ }
getProduct(productId, tenantId); // compile error — swapped

class Animal { name = "" }
class Dog extends Animal { bark() {} }
class Cat extends Animal { meow() {} }
const dogs: Dog[] = [new Dog()];
const animals: Animal[] = dogs;
animals.push(new Cat());
dogs[1].bark(); // TypeError at runtime

type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
type CheckoutError = { kind: "OUT_OF_STOCK"; sku: string } | { kind: "PRICE_CHANGED" };
async function checkout(cart: Cart): Promise<Result<Order, CheckoutError>> { /* ... */ }

type TenantScoped<T> = { readonly tenantId: TenantId } & T;
interface OrderRepo {
  findById(ctx: TenantCtx, id: OrderId): Promise<Order | null>;
  list(ctx: TenantCtx, q: OrderQuery): Promise<Order[]>;
}