In TypeScript, `function make<T extends { name: string }>(): T { return { name: "anon" }; }` fails with "'{ name: string; }' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{ name: string; }'". What is the compiler protecting against, and how do you fix it?

## Reading the error literally The message names both halves of the situation: ``` Type '{ name: string; }' is not assignable to type 'T'. '{ name: string; }' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{ name: string; }'. ``` The first clause concedes your value fits the constraint. The second explains why that is not enough. ## Who chooses `T` A type parameter is chosen by the **caller**, at the call site, and the function body is checked once for every possible choice. The constraint sets a *lower bound*: `T` must be at least `{ name: string }`, and may be anything narrower. ```ts declare function make<T extends { name: string }>(): T; const u = make<{ name: string; id: number }>(); u.id.toFixed(); // the signature promised this exists ``` If the body were allowed to return `{ name: "anon" }`, that call would hand back an object with no `id`, and `u.id.toFixed()` would throw at runtime with no assertion anywhere in sight. The compiler is protecting the caller's side of a promise the signature made. The same reasoning explains a second, equally common form of the error — assigning to something *of* type `T`: ```ts function reset<T extends { a: number }>(x: T): T { // x = { a: 0 }; // Error TS2322: '{ a: number; }' is assignable to the constraint of type 'T', // but 'T' could be instantiated with a different subtype. return x; } ``` ## The structural diagnosis A type parameter that appears **only in the return position** is the shape that triggers this. There is nothing for inference to work from, so the caller must either annotate `T` explicitly or let it fall back to the constraint — and the body has no material to build a `T` out of. Whenever you hit this error, check first whether the generic is doing anything at all. ## Four ways out, in order of preference ### 1. Return the concrete type If the function really does build one fixed shape, say so: ```ts function make(): { name: string } { return { name: "anon" }; } ``` Callers who need a richer type now get an honest error at *their* site instead of a silent lie. ### 2. Derive the result from an argument Give the function a `T` to work with, and the type parameter starts carrying real information: ```ts function stamp<T extends { name: string }>(x: T): T & { createdAt: number } { return { ...x, createdAt: Date.now() }; } ``` Spreading a value of generic type produces `T & { createdAt: number }`, which *is* assignable to the declared return type, so this compiles with no assertion. ### 3. Let the caller supply the value A factory can take the construction step as a parameter: ```ts function makeWith<T extends { name: string }>(create: () => T): T { return create(); } ``` Whoever picks `T` is now also responsible for producing a matching value — which is exactly where that obligation belongs. ### 4. Assert, and own the consequence ```ts function makeUnsafe<T extends { name: string }>(): T { return { name: "anon" } as T; } ``` This compiles because `as` is an unchecked claim, not a conversion — it performs no runtime test and emits nothing. You have moved the unsoundness from a compile error in your file to a possible `undefined` in the caller's. It is defensible only behind a boundary that genuinely validates, and it deserves a comment saying why. ## Where the pattern legitimately appears The library shape it resembles is `JSON.parse` returning `any`, or a fetch wrapper declared `<T>(url: string): Promise<T>`. Those are the same unsound bargain wearing a nicer signature: the type parameter is a *request*, not a proof, and nothing checks the payload. That is a deliberate ergonomic tradeoff, and the honest version of it validates at the boundary — a parser or schema check that narrows to the claimed type — rather than asserting on faith. ## What to say in the interview Name the rule in one sentence — *the caller chooses `T`, so the body can consume a `T` but cannot produce one* — then show that you reach for a signature change before an assertion. Interviewers ask this because the reflexive fix is `as T`, and the difference between a candidate who knows why it compiles and one who thinks it fixed something is the whole point of the question.