Default generic types in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of function with default generic type

What is the output of the following TypeScript code?

Typescript

function identity<T = string>(value: T): T {
  return value;
}

const result = identity(123);
console.log(typeof result);

A "undefined"

B "string"

C "object"

D "number"

💡 Hint

The generic type defaults only if no type is inferred or specified.

The function is called with a number argument (123). TypeScript infers T as number, so the default string is ignored. The typeof result is 'number'.

❓ Predict Output

intermediate

Default generic type usage in class

What will be the type of the property value in the following TypeScript class instance?

Typescript

class Box<T = boolean> {
  value: T;
  constructor(value: T) {
    this.value = value;
  }
}

const box = new Box(42);
// What is the type of box.value?

A number

B boolean

C string

D any

💡 Hint

TypeScript infers generic types from constructor arguments if possible.

The generic type T is inferred as number from the argument 42, so box.value is of type number, not the default boolean.

🔧 Debug

advanced

Identify the error with default generic type usage

Which option will cause a TypeScript error when compiling this code?

Typescript

function wrap<T = string>(value: T): { wrapped: T } {
  return { wrapped: value };
}

const result = wrap();

A No error, result is { wrapped: string } with value undefined

B No error, result is { wrapped: undefined }

C Error: Expected 1 argument, but got 0

D Error: Type 'undefined' is not assignable to type 'string'

💡 Hint

Default generic types do not provide default function arguments.

The function wrap requires one argument. The default generic type only applies to the type parameter, not the function parameter. Calling wrap() without arguments causes a compile error.

🧠 Conceptual

advanced

Effect of default generic types on type inference

Consider the function merge below. What is the type of result when calling merge({a: 1})?

Typescript

function merge<T = { a: number }, U = { b: string }>(obj1: T, obj2?: U): T & U {
  return { ...obj1, ...obj2 } as T & U;
}

const result = merge({ a: 1 });

A { a: number } & { b: string }

B { a: number } & undefined

C { a: number }

D Error: Argument of type '{ a: number; }' is not assignable to parameter of type '{ a: number; } & { b: string; }'

💡 Hint

Optional parameters can be omitted, so U is not inferred and defaults apply.

T is inferred as { a: number } from obj1. U defaults to { b: string } because obj2 is optional and omitted. The return type is explicitly T & U, so the type of result is { a: number } & { b: string }.

❓ Predict Output

expert

Complex default generic types with constraints

What is the output of this TypeScript code when compiled and run with Node.js?

Typescript

function processItem<T extends { id: number } = { id: number; name: string }>(item: T): string {
  return `ID: ${item.id}`;
}

console.log(processItem({ id: 10, name: "Test" }));
console.log(processItem({ id: 20 }));

A ID: 10\nError: Property 'name' is missing in second call

B ID: 10\nID: 20

C Error: Argument of type '{ id: number; }' is not assignable to parameter of type '{ id: number; name: string; }'

D ID: 10\nID: undefined

💡 Hint

Default generic types with constraints allow narrower types to be passed.

The generic type T defaults to { id: number; name: string } but can be any type extending { id: number }. Both calls pass valid objects. The function returns the id property as string for both calls.

Practice

1.

What is the main purpose of default generic types in TypeScript?

easy

A. To provide a fallback type when no type argument is specified

B. To enforce a specific type always

C. To disable generics in a function

D. To convert types to strings automatically

Solution

1. Step 1: Understand generic types

   Generic types allow functions or classes to work with any type specified by the user.

2. Step 2: Role of default generic types

   Default generic types provide a fallback type if the user does not specify one explicitly.

3. Final Answer:

   To provide a fallback type when no type argument is specified -> Option A

4. Quick Check:

   Default generic types = fallback type [OK]

Hint: Defaults fill in missing generic types automatically [OK]

Common Mistakes:

• Thinking default generics enforce a fixed type
• Confusing default generics with type conversion
• Believing default generics disable generics

2.

Which of the following is the correct syntax to set a default generic type T to string in a function?

function example<T = string>()

easy

A. function example<T extends string>()

B. function example<T: string>()

C. function example<T = string>()

D. function example<T? = string>()

Solution

1. Step 1: Recall TypeScript generic syntax

   Default generic types use the equals sign (=) to assign a fallback type.

2. Step 2: Analyze options

   function example<T = string>() uses <T = string> which is correct syntax for default generic types.

3. Final Answer:

   function example<T = string>() -> Option C

4. Quick Check:

   Default generic syntax uses = [OK]

Hint: Use = to assign default generic types [OK]

Common Mistakes:

• Using colon (:) instead of equals (=)
• Adding question mark (?) incorrectly
• Confusing extends with default assignment

3.

What will be the output of the following TypeScript code?

function wrap<T = number>(value: T): T[] {
  return [value];
}

const result = wrap('hello');
console.log(result);

medium

A. ["number"]

B. ["hello"]

C. ["value"]

D. Type error

Solution

1. Step 1: Understand default generic type usage

   The function wrap has a default generic type T = number, but the caller passes a string 'hello', so T becomes string.

2. Step 2: Analyze function output

   The function returns an array containing the passed value, so it returns ["hello"].

3. Final Answer:

   ["hello"] -> Option B

4. Quick Check:

   Explicit type overrides default generic [OK]

Hint: Passed type overrides default generic type [OK]

Common Mistakes:

• Assuming default generic always applies
• Expecting a type error for different type
• Confusing value with type name

4.

Identify the error in this TypeScript code using default generic types:

function identity<T = number>(arg: T): T {
  return arg.length;
}

medium

A. Property 'length' may not exist on type 'T'

B. No error, code is correct

C. Return type should be number, not T

D. Default generic type cannot be 'number'

Solution

1. Step 1: Analyze the generic type and usage

   The generic type T defaults to number, but number does not have a length property.

2. Step 2: Identify the error

   Accessing arg.length causes a TypeScript error because length may not exist on type T.

3. Final Answer:

   Property 'length' may not exist on type 'T' -> Option A

4. Quick Check:

   Accessing unknown properties on generic types causes errors [OK]

Hint: Check if generic type supports accessed properties [OK]

Common Mistakes:

• Ignoring property existence on generic types
• Thinking default generic restricts properties
• Assuming no error if default is number

5.

Given this generic function with a default type, how can you call it to get an array of booleans?

function createArray<T = string>(length: number, value: T): T[] {
  return Array(length).fill(value);
}

Choose the correct call:

hard

A. createArray<boolean>(true, 3)

B. createArray(3, 'true')

C. createArray<number>(3, true)

D. createArray<boolean>(3, true)

Solution

1. Step 1: Understand default generic and call signature

   The function defaults T to string, but to get an array of booleans, we must specify T = boolean.

2. Step 2: Analyze options

   createArray<boolean>(3, true) explicitly sets T to boolean and passes true as value, which matches the type.

3. Final Answer:

   createArray<boolean>(3, true) -> Option D

4. Quick Check:

   Specify generic type to override default [OK]

Hint: Specify generic type to override default generic [OK]

Common Mistakes:

• Relying on default generic without specifying type
• Passing arguments in wrong order
• Mismatching generic type and value type