Proposal: AsyncReturnType

[dylang]

Reason

TypeScript provides ReturnType to infer what type a function returns, but it isn't as as useful when functions return a promise and you want to know what type the promise resolves to.

Proposal

ResolvedType which returns the type of a function that returns a promise, but also works if the function is not a promise.

Example

// Silly simple example
const asyncFunction = async (n: number) => n * 2;

// We have this today
type AsyncFunctionReturns = ReturnType<typeof asyncFunction>;
// => Promise<number>

// This is the proposal
type AsyncFunctionReturns = ResolvedType<typeof asyncFunction>;
// => number

Proof of concept

Not tested extensively, may have bugs!

// For any function, return the returnType or promiseResolved type.
export type ResolvedValue<FuncPromOrValue> = FuncPromOrValue extends (...args: any) => any
    ? ReturnType<FuncPromOrValue> extends Promise<infer Result> // Is a function.
        ? Result // Is a promise, return result from Promise.
        : ReturnType<FuncPromOrValue> // Non-promise function, return result.
    : FuncPromOrValue; // Not a promise or function, return type.

Existing work

I haven't seen anything like this before, but that doesn't mean it doesn't exist. I'm not fluent with other typed languages to know if there's a reason this doesn't exist or better way to implement it.

[BendingBender]

What's the practical difference to #42 (apart from the fact that ResolvedType is a combination of ReturnType and the proposed Unpromise)?

[sindresorhus]

@dylang ⬆️

[fregante]

What's the practical difference to #42

I think that's difference. It's just a combination of them:

Unpromise<ReturnType<typeof asyncFunction>>
ResolvedType<typeof asyncFunction>

Funny thing is that all the examples in #38 and #42 are exactly:

Unpromise<ReturnType<typeof asyncFunction>>

So perhaps ResolvedType makes more sense than a standalone Unpromise.

---

Also maybe it should be called AsyncReturnType instead of ResolvedType

[fregante]

This is what I'm using currently:

type Unpromise<MaybePromise> = MaybePromise extends Promise<infer Type> ? Type : MaybePromise;
type AsyncReturnType<T extends (...args: any) => any> = Unpromise<ReturnType<T>>

You can probably merge the two and avoid Unpromise but I don't know how 😳

[sindresorhus]

I still think Unpromise makes sense as an independent building block.

PR welcome for AsyncReturnType.

[sindresorhus]

Relevant TypeScript issue: microsoft/TypeScript#28105

[fregante]

@sindresorhus I think that's more about Unpromise and AsyncReturnType

A PR for that issue has been opened: microsoft/TypeScript#35998

[resynth1943]

PR welcome for AsyncReturnType.

@sindresorhus Since you're accepting PRs for this, do you want me to submit one for this after PromiseValue has been merged?

[sindresorhus]

@resynth1943 Yes. That would be great. 🙌

[resynth1943]

Gotcha. When you get a chance, @sindresorhus, could you check out #75?