There are few reasons, the obvious reason is: optimal developer experience
An intelligence type do the most work for you, it is more automate and you write less code
But there is one very important reason: it does not work well with union
to understand this, observe the below example:
type SomeType = { name: string; quantity: number; }; const someFunc = <Key extends keyof SomeType>( key: Key, value: SomeType[Key], ) => { // ... }; // not explicit generics someFunc("name", "John") // OK someFunc("name", 10) // Error as desired someFunc("quantity", "John") // Error as desired someFunc("quantity", 10) // OK // explicit generics someFunc<"name" | "quantity">("name", 10) // wrong, but no error 
now, to be fair, this is not developers fault and should be not developers responsibility
ideally TS should handle case like this correctly, but unfortunately we don't have much option
except with this magic utility...
type UnionToIntersection<U> = (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true type SomeType = { name: string; quantity: number; }; const someFunc = <Key extends keyof SomeType>( key: IsUnion<Key> extends true ? "No Union!":Key, value: SomeType[Key], ) => { // ... }; someFunc<"name" | "quantity">("name", 10) // error as expected // still works as normal someFunc("name", "John") // OK someFunc("name", 10) // Error as desired someFunc("quantity", "John") // Error as desired someFunc("quantity", 10) // OK 
Though this is a legit solution, it is not the best solution. As you can see it only warn you about union but do nothing to the other value type. Ideal solution is to show error on the value 10.
it is also not fun to do this every time, so please avoid explicit function generic if possible
Top comments (0)