[TypeScript] Infer the Return Type of a Generic Function Type Parameter

When working with conditionals types, within the “extends” expression, we can use the “infer” keyword to either get the type of the elements of an array, or even to get the return type of a function. We can use this to build a “FnReturnType” type, that will give us the return type of the function passed in as the generic parameter.

infer: Typescript can tell the type by itself:

// typescript knows its return type is number
function generateId(seed: number) { 
    return seed + 5
}

// typescript knows its return type is string
function generateId(seed: number) { 
    return seed + "5"
}

If we have one function, its param type is depend on another function's return type, to make type safety, we have to use Unit type:

function generateId(seed: number) { 
    return seed + "5"
}
function lookupEntity(id: string | number ) { 
} 
lookupEntity(generateId(3))

This works, but not good enough, because, unit type can be huge when it grows... 

So better typescript can infer the return type and change based on that, to do that we can use conditional type again:

type CustomReturnType<T> = T extends (...args: any[]) => infer U ? U : never;
type Id = CustomReturnType<typeof generateId>;

function generateId(seed: number) { 
    return seed + "5"
}
function lookupEntity(id: string | number ) { 
} 
lookupEntity(generateId(3))

So 'CustomReturnType should be the infer return type, return type is String then it is String, if number then it is number.

function generateId(seed: number) { 
    return seed + "5"
}
type Id = CustomReturnType<typeof generateId>; // Id is string

function generateId(seed: number) { 
    return seed + 5
}
type Id = CustomReturnType<typeof generateId>; // Id is number

Now we can use Id type as param's type:

type Id = CustomReturnType<typeof generateId>;

function lookupEntity(id: Id ) { 
} 

Actually TypesScript already build it 'ReturnType', works the same the 'CustomReturnType' we just build.

type Id = ReturnType<typeof generateId>;

function lookupEntity(id: Id ) { 
} 

Knowing this, it is usefully to build a nested infer type:

type UnpackPromise<T> = T extends Promise<infer K>[] ? K : any;
const arr = [Promise.resolve(true)];

type ExpectedBoolean = UnpackPromise<typeof arr>; // Able to know that the value we passed into the promise is boolean