I was playing around with generics in typescript v4.0.2 and came across this oddity. Why does the compiler complain that T is not a string after I have narrowed it as such?
function foo<T>(arg: T): T {
if (typeof arg === "string") {
return "hello"
}
return arg
}
The error is:
Type 'string' is not assignable to type 'T'.
'T' could be instantiated with an arbitrary type which could be unrelated to 'string'.
This function signature:
foo<T>(arg: T): T
Returns the same type as its argument. This means if you pass in the string "Sebastian", you expect to get "Sebastian" back, not just any string. But the way you have written this function, it would return "hello" instead, which has a different string literal type.
To support this logic, I think function overloads are what you want. You would create a special call signature just for strings that returns strings, then a generic call signature that handles all other argument types.
function foo(arg: string): "hello"
function foo<T>(arg: T): T
function foo<T>(arg: T): T | "hello" {
if (typeof arg === "string") {
return "hello"
}
return arg
}
const a = foo('testing') // type: "hello"
const b = foo(123) // type: 123
const c = foo(123 as number) // type: number
const d = foo({ abc: 123 }) // type: { abc: 123 }
foo(Math.random() < 0.5 ? "bar" : 2) returns "bar" | 2 when you probably want "hello" | 2. Personally I'd have just one call signature, foo<T>(arg: T): T extends string ? "hello" : T;. You can still use the foo<T>(arg: T): T | "hello" implementation signature, though. Like this
function foo(arg: string): string; function foo<T>(arg: T): T;
foo<"bar">("bar")?const bar = "bar"; foo(bar);typeof xwill give you at runtime, so I'm not sure that ""bar"is only a type ofstring" is a fruitful line of reasoning. If what you are trying to do is returnstringwhenT extends stringandTotherwise, then you will end up needing either conditional types or overloads, each of which has drawbacks. I wonder what your use cases are though.