Why does TypeScript reject a static member that references the class type parameter, as in `class Box<T> { static empty: T }`, and what do you write instead when you want a static factory for a generic class?

## The error ```typescript class Box<T> { // static empty: T; // error: Static members cannot reference class type parameters. // static make(v: T): Box<T> // same error } ``` The message is literal and worth memorizing: *static members cannot reference class type parameters*. It applies to static fields, static method signatures and static accessors alike. ## Why the rule exists A class declaration produces two things: an **instance type** (`Box<T>`, what `new Box(...)` gives you) and a **static side** (the constructor object `Box` itself, which carries the statics). The type parameter is part of the instance type — it is chosen when you instantiate. The static side is not parameterized: there is exactly one `Box` object in the program, shared by every instantiation. So ask what `static empty: T` would even mean. Code elsewhere writes `Box<string>` and `Box<number>`; both refer to the same runtime `Box` and therefore the same `Box.empty` slot. There is no per-instantiation copy of a static to hold a per-instantiation type. Rather than pretend otherwise and produce an unsound type, the checker refuses the declaration. This is a real difference from languages where generics are reified: in C#, `Box<string>` and `Box<int>` genuinely have separate static storage, so a static field typed `T` is meaningful there. TypeScript's type layer is erased, so it is not. ## What is in scope where The class type parameter *is* in scope for: - instance property types and their initializers, - constructor parameter and body types, - instance method parameter and return types, - the heritage clause: `class Store<T> extends Base<T> implements Repository<T> {}`. It is **not** in scope for anything on the static side. ## The fixes **1. Give the static its own type parameter.** A static method may declare parameters of its own; they are bound per call, which is exactly what a factory wants: ```typescript class Box<T> { value: T; constructor(value: T) { this.value = value; } static of<U>(value: U): Box<U> { return new Box(value); } } const b = Box.of("hi"); // Box<string> ``` Naming it `U` rather than `T` is not cosmetic — it emphasises that this is a *different*, independently chosen parameter that happens to feed the same class. **2. Use a standalone factory function.** Nothing forces the factory to be a static at all: ```typescript function box<U>(value: U): Box<U> { return new Box(value); } ``` This is often the cleaner answer in a module-based codebase, and it sidesteps the static side entirely. **3. Type the static with a concrete instantiation.** The rule bans the bare parameter, not the class: ```typescript class Box<T> { value: T; constructor(value: T) { this.value = value; } static readonly EMPTY_STRING_BOX: Box<string> = new Box(""); } ``` That compiles, because `Box<string>` is a finished type with nothing unresolved in it. **4. Move the member to the instance side.** If the thing genuinely depends on `T`, it usually belongs on instances, where `T` is bound. A `clone(): Box<T>` instance method is unproblematic. ## The related trap: `new` inside a generic Candidates often reach for statics because they want "a default value of type `T`". There is no such thing — the checker cannot conjure a value for an arbitrary type parameter, and there is no runtime token for `T` to construct from. If you need to build a `T`, the caller must supply either a value or a factory (`() => T`), because the type argument has been erased by the time the code runs. ## What interviewers listen for That you separate the instance type from the static side and explain the sharing argument in one sentence, rather than reciting the error text. The strongest answers add the erasure point — one constructor object exists at runtime, so per-instantiation statics are not representable — and then produce the `static of<U>` fix without hesitation, because that shape appears in real container and builder APIs.