Basic Types & Annotations

A rest parameter must be typed as an array or a tuple, and must be the last parameter. An array type such as ...args: number[] accepts any number of arguments; a tuple type such as ...args: [x: number, y: number] pins the exact arity and names each position.

The inferred return type is Promise<number>. Annotating it as number is a compile error: an async function's declared return type must be a promise type, so the correct annotation is Promise<number>.

Contextual typing. The callback sits in a position whose expected type is already known — the declared signature of the map callback — so its parameter takes its type from there. The standalone arrow has no expected type, so nothing constrains its parameter.

In a function type expression every parameter must be named and annotated separately. (string) => void declares one parameter named string whose type is implicitly any — not a string parameter. The correct form is (message: string) => void.

Only lowercase object means "non-primitive": it accepts arrays, functions and class instances and rejects every primitive. The type {} means "anything except null and undefined", so strings and numbers satisfy it, and Object behaves essentially the same way.

They do different jobs. as const pins inference: literal types are kept and everything becomes readonly. satisfies checks the literal against a type without replacing the inferred type. Written together, as const satisfies T both pins the values and validates the shape.

A parameter typed true accepts only the value true, not any truthy value. The type boolean behaves as the union true | false, so true is assignable to boolean but a value typed boolean is not assignable to true.

An implicit any is the type the compiler falls back to when it can infer nothing — typically an unannotated parameter, an uninitialised member, or an untyped import. The noImplicitAny option turns those silent fallbacks into errors, and it is on under strict.

string | never reduces to string and string & never reduces to never. Because never is the empty set of values, it disappears from a union and swallows an intersection — and intersecting two incompatible property types leaves that property with no possible value.

TypeScript deliberately lets a function returning any type be assigned to a function type whose return type is void. The return value is simply ignored — at the call site the result is still typed void, so it cannot be used.

It guarantees only that the function body cannot call mutating array methods or assign to indices, and only while type checking. It is shallow, so element objects stay mutable; it is erased at runtime; and the caller still holds a mutable reference to the same array.

A tuple is an ordinary array at runtime, so it inherits Array's methods, and push is typed to accept the tuple's element types. The length guarantee covers assignment and indexing, not mutation. Annotating the value as readonly [number, number] removes push and the other mutators.

Inlining a const enum member requires reading the declaration that defines it, which is a whole-program operation. isolatedModules promises every file can be transpiled alone, and an ambient declaration emits no runtime object to fall back on, so the compiler rejects it. Ship a plain enum instead.

Declare a frozen-shape object with as const for the runtime side, then derive the type from it with an indexed access over its own keys. You get the same member-style call sites and an iterable object, and you lose the enum's nominal behaviour.

Mostly yes: annotating what inference already knows adds noise and can silently launder an any, because any is assignable to every type. Annotations earn their place on declarations inference cannot resolve — empty collections, uninitialised or nullish-initialised variables, and exported values.

No. A const assertion is a compile-time constraint that is erased at emit — it produces no runtime protection. Direct writes are rejected by the checker, but any alias typed as mutable, any cast, or any untyped consumer can still change the object. Runtime immutability needs a runtime mechanism.

Type each boundary value as unknown at the point it enters, then validate it into a real type inside one wrapper per boundary, so no any crosses into application code. Assertions do not count — they check nothing at runtime.

Calling a method on a union of array types combines the candidate signatures, and the parameter types intersect: string & number, which is never. No argument satisfies both element types, so every call is rejected. Fix by widening the element type or narrowing the array first.

An async callback returns Promise<void>, and a callback type declared to return void accepts a function returning any type. Nothing consumes the promise, so forEach returns before the work finishes and any rejection becomes an unhandled rejection.

Decide from constraints, not taste: does the value cross a serialization boundary, is it needed at runtime, and does the build require erasable syntax. Then change the type layer while freezing the stored values, and migrate on touch rather than all at once.

Prefer undefined internally, because optional properties and parameters already produce it, and convert null to undefined at the boundaries where JSON brings it in. Keep null only where you genuinely need a third state meaning "explicitly cleared".

Labels are documentation for humans and tooling: they show in editor hints and become the parameter names when the tuple is used as a rest parameter list. They do not affect type identity or assignability. The rule is all-or-nothing — every element must be labelled, or none.

A constant member is a literal or an expression the compiler can fold at compile time; anything else, such as a function call, is computed. A computed member must be numeric, forces the next member to have its own initializer, and is rejected inside a const enum.

The symbol type covers all symbols interchangeably; a unique symbol is a subtype tied to one specific declaration, so the checker can tell it apart from every other symbol. It is only allowed on const declarations and readonly static properties.

A union absorbs members that are subtypes of another member, and every string literal type is a subtype of string, so the literals are reduced away and only string remains. Writing (string & {}) instead of string blocks that reduction and keeps editor suggestions.

An optional never property forbids a key: it can only be absent or explicitly undefined. Paired across the branches of a union, it makes two properties mutually exclusive, so an object supplying both matches neither branch.