Implement a simplified version of ReturnType using a conditional type and infer, and explain how infer differs from a plain extends check.

A strong answer covers: type MyReturnType = F extends (...args: any[]) => infer R ? R : never; extends alone only checks structural compatibility; infer additionally captures a piece of the matched type for reuse in the true branch; Awareness that this is how many built-in utility types (ReturnType, Parameters, Awaited) are actually implemented.

Lesson 15 of 80

Conditional Types & infer

An if/else statement that runs at the type level instead of the value level — and `infer` is how it captures a piece of a type to reuse, instead of just checking it.

14 min read

Check your understanding

Every option explains itself — why the right one is right, and why each wrong one is wrong. Miss one and it comes back later on a spaced-repetition schedule.

Question 1 of 2

In `type ElementType<T> = T extends (infer U)[] ? U : never;`, what does `infer U` actually do, beyond checking that T is an array?

It captures the matched array's element type and makes it available as U in the true branchIt only checks whether T is an array, identically to a plain extends check with no captureIt converts T into a union of all its possible element types across the whole codebase

Stuck? Ask the AI tutor

Hints without spoilers, and a plain explanation of why a wrong answer was wrong — answered only from this lesson. Free account, no card.

Interview questions on Conditional Types & infer

What interviewers actually ask about this, and what a strong answer has to cover.

Implement a simplified version of ReturnType<F> using a conditional type and infer, and explain how infer differs from a plain extends check.

A strong answer covers

type MyReturnType<F> = F extends (...args: any[]) => infer R ? R : never
extends alone only checks structural compatibility; infer additionally captures a piece of the matched type for reuse in the true branch
Awareness that this is how many built-in utility types (ReturnType, Parameters, Awaited) are actually implemented

Likely follow-ups

What does distribution over unions mean for a conditional type, and how would you opt out of it?
How would you implement a simplified Awaited<T> that unwraps a Promise?
Why does the false branch of a conditional type often resolve to never, and what does that accomplish inside a union?

Practice these with the AI interviewer →

The plain-language idea

type IsString<T> = T extends string ? "yes" : "no";

type A = IsString<"hello">;  // "yes"
type B = IsString<42>;       // "no"

T extends U ? X : Y reads exactly like a ternary, but entirely in type-space: "if T is assignable to U, resolve to type X, otherwise resolve to type Y." This is how generic utility types make real decisions based on what type they were given, instead of behaving identically for every input.

`infer`: capturing a piece of the type you're checking

type ElementType<T> = T extends (infer U)[] ? U : never;

type A = ElementType<string[]>;  // string
type B = ElementType<number>;    // never — number doesn't extend an array at all

infer U inside the extends clause doesn't just check "is this an array" — it captures whatever the element type turns out to be, and makes it available as U on the true branch. This is exactly how TypeScript's built-in ReturnType<F> works: T extends (...args: any[]) => infer R ? R : never — check that it's a function, then capture and return whatever its return type is.

Conditional types: if/else for types themselvesStep 1 of 3

type IsString<T> = T extends string ? true : false; — a type-level if/else.

What people usually miss

Watch out

Conditional types distribute over unions automatically. IsString<"a" | 42> doesn't check the whole union at once — it applies the check to each member separately and unions the results, unless you deliberately wrap the type in [T] to opt out of that behavior.
This is how most of the "advanced" built-in utility types are actually built — ReturnType, Parameters, Awaited, Exclude, Extract are all conditional types with infer, not special compiler primitives.
never in the false branch is a common, deliberate pattern — "if this doesn't match the shape I'm checking for, produce never," which then naturally filters out of a union (since a union with never in it just drops that member).

Why this matters in interviews

Implementing a simplified version of ReturnType<F> or Awaited<T> is exactly the kind of advanced-TypeScript exercise senior interviews use — it directly checks whether conditional types and infer are things you actually understand, not just utility types you've memorized the names of.