Typescript - 如何在未调用的 function 中推断泛型？

Question

See the example below; it should be working by all reasonable interpretation of the code. Does anybody have any insight on why it doesn't?

TS-playground link

const func_returnsInput = (input: string) : Promise<string> => Promise.resolve(input);

type returnsInput_T = <T>(data: T) => Promise<T>;

const test: returnsInput_T = func_returnsInput;

**ERROR**
Type '(input: string) => Promise<string>' is not assignable to type 'returnsInput_T'.
  Types of parameters 'input' and 'data' are incompatible.
    Type 'T' is not assignable to type 'string'.(2322)

Answer 1

The type signature of func_returnsInput is:

const func_returnsInput: (input: string) => Promise<string>

That is specifically a function that accepts a string (and only a string ) and returns a Promise<string> . You could change the implementation slightly and it would still conform to the annotated type signature:

const func_returnsInput = (input: string): Promise<string> =>
    Promise.resolve(input.toUpperCase());

The fact that the implementation doesn't do that is not important to the compiler. It considers the call signature to be the externally-viewable type of the function, and any specific implementation to be hidden. If someone hands me func_returnsInput , all I know is that it takes a string and returns a Promise<string> . If I were to feed it, say, a number , then I have done something wrong.

---

Contrast that now with the type ReturnsInput_T :

type ReturnsInput_T = <T>(data: T) => Promise<T>;

That is a generic call signature with a generic type parameter T . The type parameter may be specified at will by the caller of the function, not by the implementer of the function. The type ReturnsInput_T is a function that accepts any value the caller wants (say, a number ), and then returns a Promise of the same data type (so, Promise<number> ).

If it helps, you can think of a generic call signature as an infinite intersection of all possible types for T . You can't write that out, but it behaves like

type ReturnsInput_T_Infinite =
    & ((data: string) => Promise<string>) 
    & ((data: number) => Promise<number>)
    & ((data: boolean) => Promise<boolean>)
    & ((data: Date) => Promise<Date>)
    & ((data: null) => Promise<null>)
    // & ...

---

Now it hopefully makes sense why you cannot assign func_returnsInput to a value of type ReturnsInput :

const test: ReturnsInput_T = func_returnsInput; // error!
// Type 'T' is not assignable to type 'string'.

test(123); // no error

If test is truly of type ReturnsInput_T , then I should be allowed to call test(123) , or test(false) or test(new Date()) or anything I want, and get back a Promise of the same data type. But func_returnsInput cannot be known to do that by the compiler (even if the implementation happens to do this).

And so you get an error!

Playground link to code

Answer 2

I think the problem is that you want to use the type of a function that takes a generic with a function that takes explicitly a string. The following works for me:

type returnsInput_T = <T>(data: T) => Promise<T>;


function func_returnsInput<T>(input: T) {
    return Promise.resolve(input)
}

const test: returnsInput_T = func_returnsInput; 

Hope it helped