Challenge 3: Write DeepAwaited — Possible Solution
====================================================================

type DeepAwaited<T> = T extends Promise<infer U> ? DeepAwaited<U> : T;

// --- Usage ---

type A = DeepAwaited<Promise<number>>;                     // number
type B = DeepAwaited<Promise<Promise<Promise<string>>>>;   // string
type C = DeepAwaited<boolean>;                              // boolean (base case — not a Promise at all)

// Demonstrating the recursion step by step for
// DeepAwaited<Promise<Promise<Promise<string>>>>:
//
//   DeepAwaited<Promise<Promise<Promise<string>>>>
//     -> extends Promise<infer U>? yes, U = Promise<Promise<string>>
//     -> recurse: DeepAwaited<Promise<Promise<string>>>
//        -> extends Promise<infer U>? yes, U = Promise<string>
//        -> recurse: DeepAwaited<Promise<string>>
//           -> extends Promise<infer U>? yes, U = string
//           -> recurse: DeepAwaited<string>
//              -> extends Promise<infer U>? NO — base case, return string
//
// Each recursive step peels off exactly one layer of Promise<...> until
// the type underneath is no longer a Promise at all.

WHY THIS WORKS
--------------
- The true branch calls DeepAwaited<U> on itself — TypeScript's type
  checker supports this kind of self-recursion in conditional types,
  evaluating it much like a recursive function would at runtime, just
  entirely at compile time.
- The false branch (`: T`) is the base case: once T is no longer a
  Promise, the recursion stops and the current T is returned as-is.
- Without a base case that eventually stops matching `Promise<infer U>`,
  a recursive conditional type like this would exceed TypeScript's
  recursion depth limit and produce a compiler error — the base case here
  is guaranteed to terminate because each step strictly unwraps one level
  of Promise, and a real type can only be nested so many Promises deep.