generics-and-conditionals - typescript Interview Questions | Preplance

1. Build Result<T,E> with helpers map, mapError, match.

Difficulty: MediumType: SubjectiveTopic: Types

Model success and failure without exceptions. map transforms the success value, mapError transforms the error, and match runs the right handler at call site. This leads to clear, explicit error handling.

Example code

type Ok<T> = { ok: true; value: T };
type Err<E> = { ok: false; error: E };
export type Result<T, E> = Ok<T> | Err<E>;

export const ok = <T>(v: T): Result<T, never> => ({ ok: true, value: v });
export const err = <E>(e: E): Result<never, E> => ({ ok: false, error: e });

export const map = <T, U, E>(r: Result<T,E>, f: (x:T)=>U): Result<U,E> =>
  r.ok ? ok(f(r.value)) : r;

export const mapError = <T, E, F>(r: Result<T,E>, g: (e:E)=>F): Result<T,F> =>
  r.ok ? r : err(g(r.error));

export const match = <T,E,R>(r: Result<T,E>, onOk:(v:T)=>R, onErr:(e:E)=>R): R =>
  r.ok ? onOk(r.value) : onErr(r.error);

2. Create a template-literal route type like `/users/${number}/posts/${number}`; add a typed params parser.

Difficulty: MediumType: SubjectiveTopic: API

Use template literal types to model the exact string shape and then parse it with a small runtime function that returns strongly typed params. This catches route mistakes at compile time and gives you typed IDs at runtime.

Example code

type UserPostsRoute = `/users/${number}/posts/${number}`;

function parseUserPosts(r: UserPostsRoute){
  const m = r.match(/^\/users\/(\d+)\/posts\/(\d+)$/);
  if (!m) throw new Error('bad route');
  return { userId: Number(m[1]), postId: Number(m[2]) } as const;
}

const p = parseUserPosts('/users/12/posts/99'); // { userId: 12, postId: 99 }

3. Remap keys of T from camelCase to snake_case at the type level.

Difficulty: HardType: SubjectiveTopic: Types

Split names at capital letters with template literal types and rebuild using underscores. Apply key remapping in a mapped type using “as”. Keep in mind: purely type-level—no runtime rename happens automatically.

Example code

type ToSnake<S extends string> = S extends `${infer H}${infer T}`
  ? H extends Lowercase<H>
    ? `${H}${ToSnake<T>}`
    : `_${Lowercase<H>}${ToSnake<T>}`
  : S;

export type SnakeKeys<T> = {
  [K in keyof T as K extends string ? ToSnake<K> : K]: T[K]
};

type A = { userId: string; isAdmin: boolean };
type B = SnakeKeys<A>; // { user_id: string; is_admin: boolean }

4. Explain NonNullable, Exclude, Extract, and give 1-line uses.

Difficulty: EasyType: SubjectiveTopic: Types

NonNullable<T>: remove null and undefined. Use when you know a value is definitely present. Exclude<T, U>: take T and remove anything assignable to U. Use to filter unions. Extract<T, U>: take T and keep only members assignable to U. Use to intersect unions. Quick mental model: Exclude is “T minus U”; Extract is “T intersect U”; NonNullable is “T without nullish”.

Example code

type A = string | number | null;
type A1 = NonNullable<A>; // string | number

type B = 'a' | 'b' | 'c';
type B1 = Exclude<B, 'b'>; // 'a' | 'c'

type C = 'id' | 42 | true;
type C1 = Extract<C, number>; // 42

5. Generic constraint syntax:

Difficulty: EasyType: MCQTopic: Types

Use “extends” to restrict a generic. Read it aloud as: T must be a subtype of U. This lets you safely use U’s properties inside the generic body.

Example code

function prop<T extends object, K extends keyof T>(obj: T, key: K) {
  return obj[key];
}
// prop(123, 'x') // ❌ 123 is not an object

6. Remove optional modifiers via mapped type:

Difficulty: MediumType: MCQTopic: Types

In mapped types, “-?” removes optional, “+?” adds optional. Similarly, “-readonly” removes readonly and “+readonly” adds it.

Example code

type Requiredify<T> = { [K in keyof T]-?: T[K] };
// { a?: number } -> { a: number }

7. Conditional type form:

Difficulty: EasyType: MCQTopic: Types

A conditional type reads: if T is assignable to U, produce X, otherwise produce Y. It’s purely a type-level if-else.

Example code

type IsString<T> = T extends string ? true : false;
type A = IsString<'hi'>;   // true
type B = IsString<123>;    // false

8. infer is used to…

Difficulty: MediumType: MCQTopic: Types

“infer” lets you pull out a type part from the left side of a conditional. Think: pattern-match a type and bind the inner piece.

Example code

type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
type X = UnwrapPromise<Promise<number>>; // number

9. In type P<T> = T extends Promise<infer U> ? U : T, U is…

Difficulty: EasyType: MCQTopic: Types

The “infer U” captures whatever a Promise resolves to. If T is Promise<string>, U becomes string.

Example code

type P<T> = T extends Promise<infer U> ? U : T;
type A = P<Promise<'ok'>>; // 'ok'
type B = P<number>;        // number

10. Key remapping syntax:

Difficulty: MediumType: MCQTopic: Types

Use “as NewK” in a mapped type to rename keys while iterating over them.

Example code

type PrefixKeys<T> = {
  [K in keyof T as `app_${Extract<K, string>}`]: T[K]
};

11. Which utility makes all props optional?

Difficulty: EasyType: MCQTopic: Types

Partial turns every property into an optional one. Handy for update DTOs and patch operations.

Example code

type User = { id: string; name: string };
type UserUpdate = Partial<User>; // { id?: string; name?: string }

12. Extract function parameters tuple:

Difficulty: EasyType: MCQTopic: Types

Parameters<T> gives you the tuple of argument types for a function type T.

Example code

function f(a: string, b: number) {}
type P = Parameters<typeof f>; // [string, number]

13. Make indexing safer against missing values:

Difficulty: MediumType: MCQTopic: Tooling

With this flag on, reading arr[i] is typed as possibly undefined unless the code proves otherwise. This prevents many out-of-bounds mistakes.

Example code

// tsconfig.json
{
  "compilerOptions": {
    "noUncheckedIndexedAccess": true
  }
}
// const x = arr[10]; // x: T | undefined

14. Template literal types are great for…

Difficulty: MediumType: MCQTopic: Types

Template literal types let you build string types using pieces like number and unions. They enforce string shapes at compile time.

Example code

type UserKey = `user:${number}`;
const k: UserKey = 'user:42'; // ✅
// const bad: UserKey = 'u:42'; // ❌

15. Implement DeepReadonly<T>; discuss recursion and edge cases (functions, Map/Set).

Difficulty: HardType: SubjectiveTopic: Types

Idea: walk the object tree and mark every nested property as readonly. Stop at primitives and functions (functions should stay callable). For Map and Set, you usually mark the container readonly but keep element types unchanged unless you create special helpers. Beware of recursive types: add a recursion limit or accept that very deep types may be slow to check.

Example code

type Primitive = string | number | boolean | bigint | symbol | null | undefined;
export type DeepReadonly<T> =
  T extends Primitive | Function ? T :
  T extends readonly (infer U)[] ? readonly DeepReadonly<U>[] :
  { readonly [K in keyof T]: DeepReadonly<T[K]> };

// Usage
type A = { a: { b: { c: number[] } } };
type R = DeepReadonly<A>; // all nested props and arrays become readonly

Master Interviews
Anywhere, Anytime

Generics & Conditionals – Typescript interview questions

Set overview

Typescript – Generics & Conditionals questions (15)

1. Build Result<T,E> with helpers map, mapError, match.

Continue your preparation

2. Create a template-literal route type like `/users/${number}/posts/${number}`; add a typed params parser.

3. Remap keys of T from camelCase to snake_case at the type level.

4. Explain NonNullable, Exclude, Extract, and give 1-line uses.

5. Generic constraint syntax:

6. Remove optional modifiers via mapped type:

7. Conditional type form:

8. infer is used to…

9. In type P<T> = T extends Promise<infer U> ? U : T, U is…

10. Key remapping syntax:

11. Which utility makes all props optional?

12. Extract function parameters tuple:

13. Make indexing safer against missing values:

14. Template literal types are great for…

15. Implement DeepReadonly<T>; discuss recursion and edge cases (functions, Map/Set).

More sets in Typescript

Explore related subjects

Master Interviews Anywhere, Anytime

Generics & Conditionals – Typescript interview questions

Set overview

1. Build Result<T,E> with helpers map, mapError, match.

Continue your preparation

2. Create a template-literal route type like `/users/${number}/posts/${number}`; add a typed params parser.

3. Remap keys of T from camelCase to snake_case at the type level.

4. Explain NonNullable, Exclude, Extract, and give 1-line uses.

5. Generic constraint syntax:

6. Remove optional modifiers via mapped type:

7. Conditional type form:

8. infer is used to…

9. In type P<T> = T extends Promise<infer U> ? U : T, U is…

10. Key remapping syntax:

11. Which utility makes all props optional?

12. Extract function parameters tuple:

13. Make indexing safer against missing values:

14. Template literal types are great for…

15. Implement DeepReadonly<T>; discuss recursion and edge cases (functions, Map/Set).

More sets in Typescript

Explore related subjects

Master Interviews
Anywhere, Anytime