在使用通用初始值设定项 function 时，如何让 typescript 正确推断类型？

Question

I have a function that may take a parameter in the form of a callable like this:

type Initial<T> = T | PromiseLike<T> | (() => T) | (() => PromiseLike<T>)

const usePromise = <T>(initial: Initial<T>): T => {
  let result: unknown = null
  
  /* ... */
  
  return result as T
}

If the type of initial is something like Promise<number> or PromiseLike<number> , typescript correctly infers the type of T as number . However, if initial is of a function type like () => PromiseLike<number> , typescript infers T as PromiseLike<number> . For example:

// good:
const initial1 = new Promise<number>(() => null)
const result1 = usePromise(initial1)  // result1: number (OK)

// bad:
const initial2: () => PromiseLike<number> = () => new Promise(() => null)
const result2 = usePromise(initial2)  // result2: PromiseLike<number> (ERROR, should be number)

Note: obviously these promises would never resolve nor reject, but this question is purely about the type inference.

How do I get typescript to also correctly infer the type in the second example?

Answer 1

The union presents multiple valid inference targets. The singular T type is allways valid and TypeScript propably does not put in the computation effort to see that (() => PromiseLike<T>) is also a valid target. We need to explicitly give an inference order to make the compiler examine more specific types like (() => PromiseLike<T>) first. I would suggest the use of overloads.

The overloads are resolved in order. The first overload is examined before the second one etc...

type Initial<T> = T | PromiseLike<T> | (() => T) | (() => PromiseLike<T>)

function usePromise<T>(initial: (() => PromiseLike<T>)): T
function usePromise<T>(initial: (() => T)): T
function usePromise<T>(initial: PromiseLike<T>): T
function usePromise<T>(initial: T): T
function usePromise<T>(initial: Initial<T>): T {
  let result: unknown = null
  
  /* ... */
  
  return result as T
}

---

Playground