In TypeScript, what is the difference between `type Mapper = <T>(x: T) => T[]` and `type MapperOf<T> = (x: T) => T[]`?

## Two places a type parameter can live When you name a function type, there are two independent slots for a type parameter, and they mean different things: ```ts type Mapper = <T>(x: T) => T[]; // parameter on the call signature type MapperOf<T> = (x: T) => T[]; // parameter on the alias ``` The mechanical rule is where the brackets sit relative to the `=`. Left of the `=`, attached to the alias name, means *the code that writes the type* supplies `T`. Right of the `=`, attached to the signature, means *the code that calls the function* supplies `T`. ## The generic call signature `Mapper` is not a generic type — it takes no type arguments, and `Mapper<string>` is an error because there is nothing to fill. What it describes is a single function value that is itself generic. To satisfy it, a function must be valid for **every** `T`: ```ts const wrap: Mapper = (x) => [x]; const nums: number[] = wrap(1); const strs: string[] = wrap("a"); ``` The parameter `x` needs no annotation: it is contextually typed by the signature, so it is `T`. Each call resolves `T` independently, which is why one value serves both lines above. The flip side is that the bar for assignment is high. A concrete function is **not** assignable: ```ts declare const onlyStrings: (x: string) => string[]; // const bad: Mapper = onlyStrings; // Error: Type '(x: string) => string[]' is not assignable to type 'Mapper'. ``` That rejection is the whole point. `Mapper` promises "works for anything"; a string-only function cannot keep that promise, so the checker refuses. ## The generic alias `MapperOf` is a generic type: a small function at the type level that takes a type and produces a type. It cannot appear on its own — every use must supply the argument, and `MapperOf<string>` expands to `(x: string) => string[]`. The function value it describes is entirely ordinary; nothing about it is generic: ```ts const g: MapperOf<string> = (x) => [x]; g("a"); // g(1); // Error: Argument of type 'number' is not assignable to parameter of type 'string'. ``` Here `T` was fixed at the moment you wrote the annotation, by the author of the annotation, not by the caller. ## Choosing between them Ask who legitimately knows the type. If a single stored function value must serve callers of many different types — a generic identity, a generic `pipe`, a generic memoiser you hand around — you need the generic call signature, because the choice must be deferred to each call. If the type is decided once, at the point where the variable, field or parameter is declared — a `Comparator<User>` field on a sorted list, a `Validator<FormValues>` handed to a form — the generic alias is the right tool, and it keeps the function value itself simple. A common mistake is to reach for the alias form and then discover that every consumer has to thread the type argument through by hand, when what was actually wanted was one value that adapts per call. ## Where a generic call signature can appear The signature form is not limited to type aliases. Anywhere a call signature is legal, the type parameter list may sit on it: as a member of an interface or object type, and as a method signature. ```ts interface Wrapper { wrap<T>(x: T): T[]; // generic method signature wrapFn: <T>(x: T) => T[]; // property whose type is a generic function } ``` Both members are generic per call; the interface itself takes no type arguments. Contrast that with `interface Wrapper<T> { ... }`, where the interface is the thing parameterised. ## Both are erased Neither form leaves a trace in the emitted JavaScript. A type alias emits nothing at all, generic or not, and a type parameter list on a signature emits nothing either. The distinction is purely about what the checker will accept: which side of the `=` the brackets sit on changes who is obliged to supply `T`, and therefore which functions are assignable and what each call returns. Nothing about it is observable at runtime, so you can reshape one into the other freely without touching behaviour. ## The quick test Read the type aloud. "`Mapper` is a function that, for any type you like, takes one of those and gives back an array of them." versus "`MapperOf<T>` is, for a given `T`, a function taking a `T` and giving back an array of `T`." The first sentence has the "for any" inside the function; the second has it outside.