How do you use `infer` to build deep `Awaited`, `ReturnType` and `Unwrap` utilities?

Q: How do you use `infer` to build deep `Awaited`, `ReturnType` and `Unwrap` utilities?

**Target Audience:** Developers who know what `infer` does and want to write their own recursive utility types for real code. **Difficulty:** Hard **TypeScript version:** Every type claim below was checked by TypeScript 5.4.5 with `--strict`; the 4.5 release fact is cited, not run. > **How to read this doc:** Every idea is explained in plain language first, then tagged with `📌 Interview term:` so you also learn the exact words an interviewer expects. Type claims are checked by `tsc` (an `Equal ` line or a `// @ts-expect-error` line), and the **Verified** section quotes the real output in full. This page is the applied follow-up to [What does the infer keyword do?](/interview-question/what-does-the-infer-keyword-do) (the basics of `infer`) and [What is the Awaited utility type?](/interview-question/what-is-the-awaited-utility-type) (the built-in). Here we build our own. ## 1. Why This Even Matters — A Story First Think of Russian nesting dolls. Your friend hands you a doll and

The problem

Question presented to candidate: "Using infer, build me a deep version of Awaited, a ReturnType that sees through curried functions, and a general Unwrap that peels promises, arrays and functions. Then tell me where these break."

What a strong answer should cover:

The recipe: a conditional type whose true branch calls itself on the inferred part (T extends PromiseLike<infer V> ? DeepAwaited<V> : T), with the false branch as the base case
Ordering several infer checks in one chain (promise, then array, then function) and choosing what non-matching types return
Distribution: a naked T unwraps each union member separately; [T] extends [...] tests the union as a whole
Practical use: mapping an API client to its resolved data with Awaited<ReturnType<...>>, and typing arguments with infer P
Limits: deep unwraps are greedy, special inputs (any, never, unknown), and the instantiation depth limit (error TS2589); tail-recursive conditional types (TypeScript 4.5) go much deeper

Clarifying questions expected:

Should Unwrap stop at arrays and functions, or only peel promises?
Should a union be unwrapped member by member, or treated as one type?

Code / implementation expected: Yes — write the recursive utilities and show them on nested input.

infer
utility-types

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Developers who know what infer does and want to write their own recursive utility types for real code. Difficulty: Hard TypeScript version: Every type claim below was checked by TypeScript 5.4.5 with --strict; the 4.5 release fact is cited, not run.

How to read this doc: Every idea is explained in plain language first, then tagged with 📌 Interview term: so you also learn the exact words an interviewer expects. Type claims are checked by tsc (an Equal line or a // @ts-expect-error line), and the Verified section quotes the real output in full.

This page is the applied follow-up to What does the infer keyword do? (the basics of infer) and What is the Awaited utility type? (the built-in). Here we build our own.

1. Why This

The solution is hidden so you can try first

10 min read · 11 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

TypeScriptDeep Awaited, FinalReturn, Unwrap and distribution

Practice

TypeScriptTyping an API client with ApiData and Args

Practice

Discussion

Other approaches, follow-ups and how it went in real interviews.

Sign in to join the discussion.

No comments yet. Share how you would answer it.

The solution is hidden so you can try first

Keep your momentum going.