Multiple type parameters in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a generic function with two type parameters

What is the output of this Kotlin code?

Kotlin

fun <A, B> pairToString(a: A, b: B): String {
    return "Pair: $a and $b"
}

fun main() {
    println(pairToString(10, "apples"))
}

A Pair: apples and 10

B 10 apples

C Pair: 10 and apples

D Compilation error

💡 Hint

Look at the order of parameters and how they are used in the string.

The function takes two parameters of any types A and B, then returns a string showing them in the order they were passed. So it prints "Pair: 10 and apples".

🧠 Conceptual

intermediate

Understanding multiple type parameters in Kotlin classes

Which statement correctly describes the following Kotlin class declaration? class Box(val first: A, val second: B)

A Box can hold two values of any types specified when creating an instance.

B Box can only hold values of the same type for both first and second.

C Box requires A and B to be subclasses of the same parent class.

D Box can only hold primitive types like Int and String.

💡 Hint

Think about what type parameters mean in Kotlin generics.

The class Box has two type parameters A and B, so it can hold two values of any types independently specified when creating an instance.

❓ Predict Output

advanced

Output of a generic function swapping two values

What is the output of this Kotlin code?

Kotlin

fun <X, Y> swap(pair: Pair<X, Y>): Pair<Y, X> {
    return Pair(pair.second, pair.first)
}

fun main() {
    val original = Pair("hello", 42)
    val swapped = swap(original)
    println(swapped)
}

A (42, hello)

B (hello, 42)

C Compilation error due to type mismatch

D ("42", "hello")

💡 Hint

The function swaps the first and second values in the pair.

The swap function returns a new Pair with the second and first values swapped, so the output is (42, hello).

🔧 Debug

advanced

Identify the error in this generic function with multiple type parameters

What error does this Kotlin code produce when compiled? fun combine(a: T, b: U): T { return b } fun main() { println(combine(5, "test")) }

A Type inference failed for T and U

B Unresolved reference: combine

C No error, prints "test"

D Type mismatch: inferred type is U but T was expected

💡 Hint

Look at the return type and the returned value types.

The function declares it returns type T but tries to return b of type U, causing a type mismatch error.

📝 Syntax

expert

Correct syntax for a Kotlin function with multiple type parameters and constraints

Which option shows the correct syntax for a Kotlin function with two type parameters where T must be a Number and U must be a Comparable of U?

A fun <T : Number, U : Comparable> compareValues(a: T, b: U): Int { return b.compareTo(b) }

B fun <T : Number, U : Comparable<U>> compareValues(a: T, b: U): Int { return b.compareTo(b) }

C fun <T Number, U Comparable<U>> compareValues(a: T, b: U): Int { return b.compareTo(b) }

D fun <T, U> compareValues(a: T : Number, b: U : Comparable<U>): Int { return b.compareTo(b) }

💡 Hint

Look for correct use of colon and angle brackets for constraints.

Option B correctly uses colon to specify constraints on type parameters inside angle brackets.

Practice

1. What does it mean when a Kotlin function has <T, U> before its name?

easy

A. The function is limited to only one type parameter named T or U.

B. The function can only accept types T or U but not both at the same time.

C. The function uses two different type parameters, T and U, to work with multiple types.

D. The function automatically converts types T and U to String.

Solution

1. Step 1: Understand type parameters in Kotlin

   Type parameters like <T, U> allow a function to accept multiple types, making it flexible.

2. Step 2: Interpret the meaning of <T, U>

   Having <T, U> means the function can work with two different types, T and U, independently.

3. Final Answer:

   The function uses two different type parameters, T and U, to work with multiple types. -> Option C

4. Quick Check:

   Multiple type parameters = flexible function types [OK]

Hint: Multiple type parameters mean multiple flexible types [OK]

Common Mistakes:

• Thinking it limits to only one type at a time
• Assuming automatic type conversion happens
• Confusing type parameters with actual types

2. Which of the following is the correct syntax to declare a Kotlin function with two type parameters named T and U?

easy

A. fun myFunction(param1: T, param2: U) {}

B. fun myFunction(param1: T, param2: U) {}

C. fun myFunction(param1: T, param2: U) {}

D. fun myFunction(param1: T, param2: U) {}

Solution

1. Step 1: Recall Kotlin generic function syntax

   Type parameters are declared immediately after the fun keyword inside angle brackets, separated by commas.

2. Step 2: Check each option's syntax

   fun myFunction(param1: T, param2: U) {} correctly uses <T, U> after fun and before the function name, matching Kotlin syntax.

3. Final Answer:

   fun <T, U> myFunction(param1: T, param2: U) {} -> Option A

4. Quick Check:

   Type parameters go after fun with commas [OK]

Hint: Type parameters come right after fun, separated by commas [OK]

Common Mistakes:

• Missing comma between type parameters
• Placing type parameters after function name
• Putting type parameters after parameter list

3. What is the output of this Kotlin code?

fun <T, U> pairToString(pair: Pair<T, U>): String {
    return "${pair.first} and ${pair.second}"
}

fun main() {
    val result = pairToString(Pair(10, "cats"))
    println(result)
}

medium

A. Compilation error

B. Pair(10, cats)

C. cats and 10

D. 10 and cats

Solution

1. Step 1: Understand the function behavior

   The function takes a Pair with types T and U, then returns a string combining first and second values.

2. Step 2: Trace the main function call

   pairToString is called with Pair(10, "cats"), so pair.first = 10 and pair.second = "cats".

3. Final Answer:

   10 and cats -> Option D

4. Quick Check:

   pair.first + " and " + pair.second = "10 and cats" [OK]

Hint: Read pair.first and pair.second values carefully [OK]

Common Mistakes:

• Swapping first and second values
• Expecting Pair's default toString output
• Thinking it causes a compilation error

4. Identify the error in this Kotlin function declaration:

fun <T, U> combine(a: T, b: U): T {
    return b
}

medium

A. Return type T does not match returned value b of type U.

B. Missing comma between T and U in type parameters.

C. Function must return type U instead of T.

D. No error, the function is correct.

Solution

1. Step 1: Check function return type and return statement

   The function declares return type T but returns b which is of type U.

2. Step 2: Understand type mismatch error

   Returning U where T is expected causes a type mismatch compilation error.

3. Final Answer:

   Return type T does not match returned value b of type U. -> Option A

4. Quick Check:

   Return type must match returned value type [OK]

Hint: Return type must match the returned value type [OK]

Common Mistakes:

• Ignoring type mismatch between T and U
• Assuming Kotlin auto-converts types
• Missing comma in type parameters (not the case here)

5. You want to create a Kotlin generic class Box that can hold two different types of items, T and U. Which of the following class declarations correctly uses multiple type parameters and allows storing and retrieving both items?

hard

A. class Box<T>(val first: T, val second: T) {
fun getFirst(): T = first
fun getSecond(): T = second
}

B. class Box(val first: T, val second: U) {
fun getFirst(): T = first
fun getSecond(): U = second
}

C. class Box {
val first: T
val second: U
}

D. class Box(val first: T, val second: U) {
fun getFirst(): T = first
fun getSecond(): U = second
}

Solution

1. Step 1: Check correct multiple type parameter declaration

   class Box(val first: T, val second: U) { fun getFirst(): T = first fun getSecond(): U = second } declares class Box with <T, U> and constructor parameters of types T and U, which is correct.

2. Step 2: Verify methods to retrieve both items

   class Box(val first: T, val second: U) { fun getFirst(): T = first fun getSecond(): U = second } provides getFirst() returning T and getSecond() returning U, matching stored types.

3. Final Answer:

   class Box<T, U>(val first: T, val second: U) { fun getFirst(): T = first fun getSecond(): U = second } -> Option B

4. Quick Check:

   Multiple type parameters with matching properties and methods [OK]

Hint: Use and matching properties for both types [OK]

Common Mistakes:

• Using only one type parameter for both items
• Not declaring type parameters in class header
• Using undefined types without generics