Generics

Give each helper a type parameter only for the branch it actually fills: ok<T>(value: T): Result<T, never> and err<E>(error: E): Result<never, E>. Because never is assignable to anything, both results fit the function's declared Result type.

An array literal is inferred as an array of the union of its element types, so both destructured names get value-or-setter. Annotate the return type as a tuple, such as [T, (next: T) => void], or return the literal with as const.

Neither direction is allowed: Cell<T> is invariant because T appears in both an output position (value) and an input position (set). Covariance and contravariance both apply, and only the same type argument satisfies both.

The caller chooses T, not the function, and may choose a subtype requiring more than name. A value that merely satisfies the constraint is therefore not a valid T. Fix the signature — return the concrete type or derive the value from a T the caller passed in.

It compiles but is unsafe. K infers as the union 'a' | 'b', so T[K] widens to string | number and the number 1 is accepted — even though at runtime k may be 'a', writing a number into a property typed string.

Order type parameters by how often callers will specify them, most-specified first, because a caller cannot skip an earlier one to reach a later one. Default the tail so the common reference stays short, and remember that only a new defaulted parameter appended at the end is non-breaking.

Use a type parameter when one uniform rule relates argument to result across an open set of types, and overloads only when a small fixed set of unrelated argument shapes produce unrelated results. Overloads also break on union arguments and on unlisted types.

Parameterize the varying slot: declare one ApiResponse<T> with status, requestId and data of type T, then use ApiResponse<User>, ApiResponse<Order> and so on. It is the wrong model when the variants differ in which fields exist, not just in one field's type.

NoInfer marks a parameter position as check-only: it stops that position from contributing an inference candidate, so the type parameter is fixed by the other arguments and a stray default or fallback argument is reported as an error instead of widening the type.

An array literal only becomes a tuple when something asks for one. Make the parameter a rest parameter and TypeScript infers positionally, or add a const type parameter with a readonly array constraint to infer a readonly tuple of literal element types.

A callback parameter consumes A instead of supplying it, so nothing at the call gives A a candidate and it falls back to unknown. Annotate the parameter, add a constraint, or take the value as an argument.

T appears only in the return type, so each call site asserts rather than proves its row type and the checker has nothing to compare it against. The fix is a signature that forces the type to be produced — returning unknown or requiring a decoder — so every unsafe site becomes a compile error.

A value cannot change its own type parameter, so the implementation needs a type assertion to hand the object back as the new instantiation. Keep that assertion at one boundary, and remember the accumulated type is erased, so build() still validates at runtime.

The helper's parameter is an ordinary, non-generic function type, so passing a generic function instantiates its type parameter once — usually to unknown — and the result is a single concrete component. The standard fix is to assert the wrapped value back to the original signature.

Contravariant method parameters would make generic types unusable: Array puts its element type in parameter positions such as push and indexOf, so an array of a subtype would stop being assignable to an array of its supertype. TypeScript traded soundness for usability.

Constrain to the members the body actually reads, and no more. An over-tight constraint rejects callers whose values would work perfectly at runtime, pushing them into as assertions that relocate unsoundness into their code — and loosening it later changes your published contract.

It requires T to be comparable against itself: any type used here must declare compareTo taking that same type. That is what makes max(a, b) meaningful, since both arguments are T and each must accept the other.

They state a type parameter's variance explicitly: out means covariant, in means contravariant, in out means invariant. TypeScript verifies the declaration against how the parameter is used, and can then relate two instantiations by their type arguments instead of comparing members.

Decide by who bears the burden and what it costs them. Caller-side assertions keep signatures simple but fail silently when forgotten; const type parameters guarantee precision at the price of deeply readonly types everywhere; NoInfer only fixes arguments that should conform, not infer.

Default to a typed options object: one type, one error location, easy to serialize and extend. Reach for an accumulating builder only when later calls must depend on earlier ones — and accept worse diagnostics, slower editors, and a harder deprecation story.

Split the type: give the reading half a parameter that appears only in output positions and the writing half one that appears only in input positions, then have APIs ask for the view they use. Variance annotations only assert existing variance, and casts hide the hazard.

Declare consumer-supplied callbacks as property function types so parameter mismatches fail at compile time, and reserve method shorthand for container-like types whose usability depends on the looser check. The choice fixes whether future parameter widening breaks consumers loudly or fails silently at runtime.