Why Promise.reject().catch(() => 5) valid for Typescript

Question

Could you help me understand why TS compiler doesn't complain about this statement?

Promise.reject().catch(() => 5)

If checking the definition of the handler function inside the catch we can see the piece of code as follows:

interface Promise<T> {
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;

    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
}

It assumes that the handler function returns TResult | PromiseLike<TResult> where TResult = never. And then in my example a handler function returns 5 which is a number. So I could assume that 5 is never | PromiseLike<never>. But it is not the case. A number doesn't have .then function so it's not a PromiseLike. Thanks!

Answer 1

TypeScript doesn't complain because the type parameter TResult in that definition of catch() method just defaults to never. The type parameter TResult is not constrained to never in any way.

Note that the = operator inside a type parameter declaration is a default type argument, while the extends operator inside a type parameter declaration is a type parameter constraint. In general you can have neither or either or both. A type parameter declaration on a call signature like <T extends C = D>(⋯) => ⋯ means that T must be assignable to C, and if T cannot be inferred, it will default to D (which must also be assignable to the constraint C). If you leave out C then it is equivalent to specifying it as the unknown type, and if you leave out D then it is equivalent to specifying it as C. So <TResult = never> is equivalent to <TResult extends unknown = never>, meaning it defaults to never but is not constrained at all.

So: TResult will only fall back to never in the event that it cannot be inferred from the input, such as if the onrejected argument is not supplied. But you did supply an onrejected argument of () => 5. And thus TypeScript was able to infer the TResult type argument as number, because () => 5 is a valid ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null. You can verify this by hovering over the catch call in an IntelliSense-enabled IDE:

Promise.reject().catch(() => 5)
// (method) Promise<never>.catch<number>(
//    onrejected?: ((reason: any) => number | PromiseLike<number>) | null | undefined
// ): Promise<number>

So everything's working as expected and intended here.

Answer 2

Since the callback function returns a value of 5, the new promise created by catch() is resolved with that value. Meaning, the new promise created by catch() is resolved with the value of 5 because the callback function returns that value.