Top 30 Generics Interview Questions and Answers

Question 1

Which getProperty signature both rejects invalid keys at compile time and returns the exact type of the requested property?

Accepted Answer

Two generics T and K where K extends keyof T and the return type is T[K]

Answer

A single generic T with the key typed as string and the return type set to any

Answer

Two generics T and K where K is unconstrained and the return type is T[K]

Answer

A single generic T with the key typed as keyof T and returning T[keyof T]

Question 2

What is the primary benefit of defining a Rust trait, such as Summary with a summarize method, and implementing it for multiple distinct types?

Accepted Answer

It allows writing generic functions that can operate on any type that fulfills the Summary contract, promoting code reuse.

Answer

It enforces that all implementing types must have the exact same internal data structure to support the summarize method.

Answer

It enables types to inherit data fields and state directly from the trait definition, similar to class inheritance.

Answer

It automatically provides a default implementation for the summarize method if one is not explicitly defined by the implementing type.

Question 3

When writing a swap function in Swift, what advantage does using a generic placeholder T provide over accepting parameters of type Any?

Accepted Answer

Generics enforce that both parameters are the same concrete type and avoid runtime casting

Answer

Generics use runtime boxing to share a single machine code implementation across all types

Answer

Generics automatically convert value types to reference types during the swap

Answer

Generics allow swapping two values of unrelated types in a single function call

Question 4

What primary problem do Dart generics address in software development?

Accepted Answer

Allowing code to operate on different data types without sacrificing compile-time type safety.

Answer

Enabling dynamic type inference for variables at runtime.

Answer

Reducing the overall memory consumption of data structures.

Answer

Automating the generation of boilerplate code for common data operations.

Question 5

What is the primary reason to use an associated type within a Swift protocol?

Accepted Answer

To enable the protocol to refer to a type whose concrete definition is only known by conforming types.

Answer

To ensure that all types conforming to the protocol use the same specific type for a particular element.

Answer

To permit the protocol itself to be used directly as a concrete type for variables and collections.

Answer

To allow the protocol to inherit generic parameters from a superclass or parent protocol.

Question 6

What is the primary implication of declaring a generic type parameter with the `out` modifier, as in `interface Source<out T>`?

Accepted Answer

It allows an instance of `Source` to be used where `Source` is expected.

Answer

It restricts the type `T` to only be used as a parameter in the class's methods.

Answer

It allows an instance of `Source` to be used where `Source` is expected.

Answer

It ensures that instances of the `Source` class are immutable.

Question 7

What is the primary type-system benefit of declaring an interface as Producer<out T> when T only appears in return positions?

Accepted Answer

It lets Producer be used where Producer is expected without caller-side wildcards.

Answer

It allows Producer to be safely assigned to a variable of type Producer.

Answer

It makes the class immutable by preventing any state modifications.

Answer

It enforces an upper inheritance bound on T so only subtypes of a specific class may be used.

Question 8

To maximize type flexibility for a generic interface DataSink<T> that exclusively consumes elements of type T, which variance modifier should be used?

Accepted Answer

in T

Answer

T (no modifier)

Answer

reified T

Answer

out T

Question 9

What is the fundamental reason Kotlin's `reified` type parameters must be used with `inline` functions?

Accepted Answer

The inline mechanism enables the compiler to replace the generic type parameter with the actual type at the call site before JVM type erasure occurs.

Answer

inline functions ensure that reified types are stored in a special runtime type information table accessible by reflection.

Answer

reified parameters require inline to bypass the JVM's type erasure mechanism entirely, making generics available at runtime.

Answer

inline functions allow the compiler to generate and pass a Class object for the reified type implicitly at runtime.

Question 10

Why can a reified type parameter be checked with is T at runtime despite JVM type erasure?

Accepted Answer

The compiler substitutes the concrete type into the inlined body at each call site.

Answer

The compiler passes the type's Class object implicitly as a hidden parameter.

Answer

Type erasure is globally disabled for functions declared with the reified modifier.

Answer

The JVM retains generic type metadata specifically for reified parameters.

Question 11

What is the core mechanism that allows a `reified` type parameter to be accessible at runtime in a Kotlin `inline` function?

Accepted Answer

The compiler copies the function's body and the actual type argument directly into the location where the function is called.

Answer

The `reified` keyword generates special bytecode that the JVM uses to reconstruct the erased type information at runtime.

Answer

The Kotlin runtime maintains a special registry of reified types that can be queried when the function is executed.

Answer

A hidden `Class` object for the generic type is automatically passed as a parameter, making it available inside the function.

Question 12

Which approach correctly gives a polymorphic Typography component type-safe props so that disabled is rejected when as is h1 but to is accepted when as is a custom Link?

Accepted Answer

constrain the generic C to React.ElementType and intersect Omit, 'color'> with the component's own props

Answer

constrain the generic C to keyof JSX.IntrinsicElements and type the remaining props as ComponentPropsWithoutRef<C>

Answer

type the as prop as string and spread all received props onto the element

Answer

filter out invalid keys at runtime with a prop filtering utility before spreading them to the element

Question 13

Which TypeScript structure should you choose to make an ApiResponse<T> that cannot simultaneously hold both data and error properties?

Accepted Answer

A union of two interfaces sharing a status literal, one generic branch with data: T and the other with error: { code; message; }

Answer

A single interface with optional data?: T and error?: { code; message; } alongside status: string

Answer

A generic interface using a boolean isError flag with optional data?: T and error?: { code; message; }

Answer

A single interface with required data: T and error: { code; message; } and status: "success" | "error"

Question 14

What is the primary reason Kotlin's MutableList is invariant, while List is covariant?

Accepted Answer

MutableList allows elements of type E to be both added to and retrieved from the list, requiring E to be used in both 'in' and 'out' positions.

Answer

MutableList is a mutable data structure, and mutability inherently prevents the application of variance modifiers for type safety.

Answer

MutableList needs to support Java's ? super T wildcards, which conflicts with Kotlin's declaration-site out variance.

Answer

The MutableList interface is designed to prevent accidental runtime type casting errors, which declaration-site variance cannot guarantee.

Question 15

What is the fundamental reason Kotlin's reified type parameters are exclusively usable with inline functions?

Accepted Answer

The compiler uses inline functions to substitute the actual type argument directly into the function's bytecode at the call site.

Answer

Inline functions are required to access the private members of the generic type T at runtime.

Answer

Inline functions ensure that the generic type's Class object is implicitly passed as a hidden argument.

Answer

Reified types introduce runtime performance penalties that only inline functions can mitigate through optimization.

Question 16

What return type does fetchItem<T extends boolean>(..., includeHistory: T): T extends true ? ExtendedItem : BaseItem yield when includeHistory is a plain boolean variable?

Accepted Answer

The type resolves to ExtendedItem | BaseItem because boolean encompasses both true and false

Answer

The caller must use a const assertion or const type parameter to compile the call

Answer

TypeScript infers the variable as a literal true or false and returns exactly ExtendedItem or BaseItem

Answer

The return type collapses to BaseItem because boolean does not extend true

Question 17

Given a type `Mapish = { [k: string]: boolean; }`, what type does `keyof Mapish` evaluate to?

Accepted Answer

string | number

Answer

string

Answer

number

Answer

unknown

Question 18

What is the most significant problem that TypeScript Conditional Types are designed to solve in generic programming?

Accepted Answer

Enabling a single generic function to have a return type that adapts based on its input type, reducing the need for multiple overloads.

Answer

Simplifying the declaration of fixed, non-generic type aliases for complex object structures.

Answer

Preventing runtime errors by strictly validating primitive type assignments.

Answer

Allowing type definitions to be evaluated and changed at runtime based on data values.

Question 19

When building a single TypeScript handler for mixed form inputs, which strategy correctly preserves type safety when extracting values from checkboxes, text inputs, and selects?

Accepted Answer

Narrow event.target with instanceof checks and branch on element.type to read .checked or .value.

Answer

Rely on event.currentTarget because it always refers to the specific input that triggered the event.

Answer

Cast event.target to any and use a configuration map to decide which property to read.

Answer

Type the event as ChangeEvent<HTMLInputElement | HTMLSelectElement> and read event.target.value on every branch.

Question 20

When a nil pointer is boxed into an interface{}, why does a subsequent nil check on that interface return false?

Accepted Answer

The interface value carries type information, so it is not nil

Answer

Bare type assertions on such interfaces always panic at runtime

Answer

The any alias stores nil pointers using a different internal representation

Answer

The boxed pointer must be unwrapped with a type assertion before nil can be detected

Question 21

Why does the standard library make Item an associated type on Iterator rather than a generic parameter Iterator<Item>?

Accepted Answer

Because a type yields exactly one element type, so associated types keep next() inference unambiguous

Answer

Because generic trait parameters are not allowed in the standard library

Answer

Because associated types permit a type to implement Iterator many times

Answer

Because associated types compile faster than generic parameters

Question 22

In a generic fetchJson wrapper, why is it critical to check response.ok before returning res.json() as Promise<T>?

Accepted Answer

Because fetch resolves even on 4xx/5xx statuses, so skipping the check would return an error payload incorrectly typed as T.

Answer

Because fetch rejects its promise on HTTP error statuses, and the ok check is needed to intercept the rejection before parsing.

Answer

Because TypeScript generics require runtime type guards; without checking ok, the compiler cannot verify that the JSON payload matches T.

Answer

Because response.json() throws a SyntaxError when the server returns an error status, and ok prevents the exception.

Question 23

Which TypeScript signature correctly refactors firstElement to preserve the array's element type while returning a single element?

Accepted Answer

function firstElement<T>(arr: T[]): T

Answer

function firstElement(arr: any[]): any

Answer

function firstElement<T>(arr: T[]): T[]

Answer

function firstElement(arr: unknown[]): unknown

Question 24

Which TypeScript signature preserves the specific input type while safely allowing access to a length property in a generic utility function?

Accepted Answer

function logLength<T extends { length: number }>(arg: T): T { console.log(arg.length); return arg; }

Answer

function logLength(arg: { length: number }): { length: number } { console.log(arg.length); return arg; }

Answer

function logLength(arg: any): any { console.log(arg.length); return arg; }

Answer

function logLength<T>(arg: T): T { console.log(arg.length); return arg; }

Question 25

In getProperty<T, K extends keyof T>(obj: T, key: K), what is the effect of changing the return type from T[K] to T[keyof T]?

Accepted Answer

The return type widens to a union of all property types in T instead of the specific type for the provided key.

Answer

TypeScript would infer the return type as any since K becomes unused in the function signature.

Answer

The function would only accept keys that are present on every object subtype of T.

Answer

Invalid keys would no longer trigger compile-time errors because the return type no longer uses K.

Question 26

What is the main risk of declaring separate generic parameters on getState and setState instead of one class-level T?

Accepted Answer

The methods could be invoked with unrelated types, so getState and setState no longer agree on the state type.

Answer

The constructor would default the private field to implicit any, erasing type safety.

Answer

The private field would need to be typed as unknown to accommodate both independent type parameters.

Answer

Callers would be forced to explicitly pass type arguments to every method call.

Question 27

What is the main type-safety benefit of making fetchJSON generic with rather than having it return Promise?

Accepted Answer

It lets the caller decide the expected response shape for compile-time checking without changing the wrapper code.

Answer

It requires the wrapper to hardcode every possible response shape so the compiler can check them all.

Answer

It causes response.json() to preserve the original server-side type instead of returning Promise<any>.

Answer

It enables TypeScript to emit runtime validation that ensures the JSON matches the interface T.

Question 28

Using function merge<T, U>(a: T, b: U): T & U { return { ...a, ...b }; }, what is the runtime value of a key present in both objects?

Accepted Answer

The value from b, since b is spread last and overwrites a's key

Answer

The value from a, since a is spread first and takes precedence

Answer

A TypeScript compile error because the keys conflict

Answer

A combined object holding both values under that key

Question 29

What is the primary type-system purpose of resolving to never in the false branch of MyReturnType<T>?

Accepted Answer

It prevents non-function types from being silently assignable by making invalid usages immediately unassignable

Answer

It tells TypeScript to infer the return type from the nearest overload instead of the last one

Answer

It serves as a recursive base case for extracting return types from nested function types

Answer

It indicates that the type computation should be deferred until runtime when the actual value is known

Question 30

What is the primary advantage of using TypeScript generics?

Accepted Answer

It enables the creation of reusable components that maintain type safety across different data types.

Answer

It strictly enforces that a function only works with a single, predefined data type.

Answer

It allows functions to operate on any data type, bypassing strict type checking for flexibility.

Answer

It optimizes runtime performance by pre-compiling type information into more efficient code.