Generic function declaration in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple generic function

What is the output of this Kotlin code that uses a generic function to return the input value?

Kotlin

fun <T> identity(value: T): T {
    return value
}

fun main() {
    println(identity(42))
}

A null

B identity(42)

C 42

D Compilation error

💡 Hint

Think about what the function returns when given an integer.

The generic function identity returns the same value it receives. Here, it returns 42, so the output is 42.

🧠 Conceptual

intermediate

Understanding generic function type parameters

In Kotlin, what does the in the function declaration fun echo(item: T): T mean?

A It declares a generic type parameter T that can be any type.

B It specifies that T is always an Int type.

C It restricts the function to only accept String types.

D It is a syntax error and should be removed.

💡 Hint

Generic type parameters allow flexibility in the function input and output types.

The declares a generic type parameter named T. This means the function can accept and return any type specified when called.

❓ Predict Output

advanced

Output of generic function with multiple types

What is the output of this Kotlin code that uses a generic function with two type parameters?

Kotlin

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

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

A 10 and apples

B 10 and 10

C apples and 10

D Compilation error

💡 Hint

Look at how the function combines the two parameters into a string.

The function takes two generic parameters and returns a string combining them. Here it prints "10 and apples".

🔧 Debug

advanced

Identify the error in this generic function declaration

What error does this Kotlin code produce? fun printTwice(value: T) { println(value) println(value) } fun main() { printTwice() }

Kotlin

fun <T> printTwice(value: T) {
    println(value)
    println(value)
}

fun main() {
    printTwice()
}

A Compilation error: Generic type T not specified

B Compilation error: No value passed for parameter 'value'

C Prints two blank lines

D Runtime error: NullPointerException

💡 Hint

Check the function call and its parameters.

The function requires one argument of type T, but the call provides none, causing a compilation error.

🚀 Application

expert

Result of generic function with nullable type and default value

What is the output of this Kotlin code that uses a generic function with a nullable type and a default value?

Kotlin

fun <T> defaultIfNull(value: T?, default: T): T {
    return value ?: default
}

fun main() {
    println(defaultIfNull(null, "Hello"))
    println(defaultIfNull("World", "Hello"))
}

A Compilation error

B null\nWorld

C Hello\nHello

D Hello\nWorld

💡 Hint

The Elvis operator ?: returns the left value if not null, otherwise the right value.

The function returns the default value if the input is null. So first line prints "Hello", second prints "World".

Practice

1. What is the purpose of declaring a generic function in Kotlin using <T> before the function name?

easy

A. To declare a function that returns a string only

B. To restrict the function to only work with integers

C. To make the function run faster

D. To allow the function to work with any type specified when called

Solution

1. Step 1: Understand generic type declaration

   Declaring <T> before a function name means the function can accept any type as input.

2. Step 2: Purpose of generic functions

   This makes the function reusable for different data types without rewriting it for each type.

3. Final Answer:

   To allow the function to work with any type specified when called -> Option D

4. Quick Check:

   Generic functions = reusable for any type [OK]

Hint: Generic <T> means any type can be used [OK]

Common Mistakes:

• Thinking generic restricts to one type
• Confusing generic with function overloading
• Assuming generic improves speed automatically

2. Which of the following is the correct syntax to declare a generic function named printItem that takes a parameter of any type T in Kotlin?

easy

A. fun <T> printItem(item: T) { println(item) }

B. fun printItem<T>(item) { println(item) }

C. fun printItem(T item) { println(item) }

D. fun printItem(item: <T>) { println(item) }

Solution

1. Step 1: Identify correct generic syntax

   In Kotlin, generic type parameters are declared before the function name using <T>.

2. Step 2: Check parameter declaration

   The parameter must specify its type as T, so item: T is correct.

3. Final Answer:

   fun <T> printItem(item: T) { println(item) } -> Option A

4. Quick Check:

   Generic syntax = <T> before function name [OK]

Hint: Generic type <T> goes before function name [OK]

Common Mistakes:

• Placing <T> after function name
• Not specifying parameter type as T
• Using parentheses incorrectly around <T>

3. What will be the output of the following Kotlin code?

fun <T> identity(value: T): T {
    return value
}

fun main() {
    println(identity(123))
    println(identity("Hello"))
}

medium

A. 123
123

B. 123
Hello

C. Hello
Hello

D. Compilation error

Solution

1. Step 1: Understand the generic function behavior

   The function identity returns the same value it receives, regardless of type.

2. Step 2: Trace the calls in main()

   Calling identity(123) returns 123, and identity("Hello") returns "Hello".

3. Final Answer:

   123 Hello -> Option B

4. Quick Check:

   Generic function returns input value [OK]

Hint: Generic function returns input as is [OK]

Common Mistakes:

• Expecting type conversion
• Thinking output repeats first call
• Assuming compilation error due to mixed types

4. Identify the error in this Kotlin generic function declaration:

fun printValue<T>(value: T) {
    println(value)
}

medium

A. Generic type parameter <T> must be declared before the function name

B. Parameter type cannot be generic

C. Function must return a value

D. println cannot print generic types

Solution

1. Step 1: Check generic syntax rules

   In Kotlin, generic type parameters must be declared before the function name, not after.

2. Step 2: Analyze the given code

   The code declares printValue<T>, which is incorrect syntax.

3. Final Answer:

   Generic type parameter <T> must be declared before the function name -> Option A

4. Quick Check:

   Generic <T> goes before function name [OK]

Hint: Place <T> before function name, not after [OK]

Common Mistakes:

• Putting <T> after function name
• Assuming generic parameters go in parentheses
• Thinking generic functions must return a value

5. You want to write a generic function swap that swaps two elements in a mutable list at given indices. Which of the following is the correct Kotlin function declaration and implementation?

hard

A. fun swap<T>(list: MutableList<T>, i: Int, j: Int) {
val temp = list[i]
list[i] = list[j]
list[j] = temp
}

B. fun <T> swap(list: List<T>, i: Int, j: Int) {
val temp = list[i]
list[i] = list[j]
list[j] = temp
}

C. fun <T> swap(list: MutableList<T>, i: Int, j: Int) {
val temp = list[i]
list[i] = list[j]
list[j] = temp
}

D. fun swap(list: MutableList<Any>, i: Int, j: Int) {
val temp = list[i]
list[i] = list[j]
list[j] = temp
}

Solution

1. Step 1: Correct generic syntax and parameter types

   The generic type parameter <T> must be declared before the function name. The list must be mutable to allow swapping.

2. Step 2: Verify implementation correctness

   The function swaps elements at indices i and j using a temporary variable, which is correct.

3. Final Answer:

   fun <T> swap(list: MutableList<T>, i: Int, j: Int) { val temp = list[i]; list[i] = list[j]; list[j] = temp } -> Option C

4. Quick Check:

   Generic swap needs <T> before name and MutableList<T> [OK]

Hint: Use <T> before function and MutableList<T> for mutability [OK]

Common Mistakes:

• Putting <T> after function name
• Using immutable List instead of MutableList
• Using MutableList<Any> losing type safety