How TypeScript infers generic types - Practice Exercises

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this TypeScript code with generics?

Consider this TypeScript function that uses a generic type. What will be the output when calling identity(42)?

Typescript

function identity<T>(arg: T): T {
  return arg;
}

console.log(identity(42));

A 42

B "42"

C undefined

D Type error at compile time

💡 Hint

TypeScript infers the generic type from the argument passed.

The generic type is inferred as number because 42 is a number. The function returns the same value, so output is 42.

❓ Predict Output

intermediate

What type does TypeScript infer here?

Given this function call, what type does TypeScript infer for T?

Typescript

function wrapInArray<T>(value: T): T[] {
  return [value];
}

const result = wrapInArray('hello');

A never[]

B string[]

C any[]

D number[]

💡 Hint

Look at the argument passed to the function.

The argument is a string, so T is inferred as string. The function returns an array of T, so result is string[].

❓ Predict Output

advanced

What is the output of this generic function with multiple parameters?

What will this code print when run?

Typescript

function merge<T, U>(obj1: T, obj2: U): T & U {
  return {...obj1, ...obj2};
}

const merged = merge({name: 'Alice'}, {age: 30});
console.log(merged);

A Type error: incompatible types

B { name: 'Alice' }

C { age: 30 }

D { name: 'Alice', age: 30 }

💡 Hint

The function combines two objects using spread syntax.

The function merges two objects into one. The result has properties from both inputs.

❓ Predict Output

advanced

What error does this code raise due to incorrect generic inference?

What error will this TypeScript code produce?

Typescript

function firstElement<T>(arr: T[]): T {
  return arr[0];
}

const result = firstElement([]);
console.log(result);

A Type error: Argument of type 'never[]' is not assignable to parameter of type 'T[]'.

B Error: Element implicitly has an 'any' type because type '[]' has no elements.

C undefined

D null

💡 Hint

TypeScript infers the empty array as never[], causing a type mismatch.

TypeScript treats the empty array literal as never[] in this generic context, which is not assignable to T[], resulting in a compile-time type error.

🧠 Conceptual

expert

Which option best describes how TypeScript infers generic types in this scenario?

Given a generic function with multiple parameters, how does TypeScript infer the generic types when called with different argument types?

A TypeScript requires explicit generic type annotations when multiple parameters have different types.

B TypeScript infers the generic types by using the first argument's type for all generic parameters.

C TypeScript infers each generic type parameter independently based on the corresponding argument's type.

D TypeScript cannot infer generic types if there are multiple parameters and throws a compile error.

💡 Hint

Think about how TypeScript matches each generic parameter to each argument.

TypeScript infers each generic type parameter separately from the corresponding argument's type, allowing flexible generic functions.