Generic constraints with where clause in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Output of a generic function with where clause filtering

What is the output of the following Kotlin function when called with a list of integers [1, 2, 3, 4, 5]?

Kotlin

fun <T> filterAndDouble(items: List<T>): List<T> where T : Number, T : Comparable<T> {
    return items.filter { it.toDouble() > 2 }.map { (it.toDouble() * 2) as T }
}

val result = filterAndDouble(listOf(1, 2, 3, 4, 5))
println(result)

A [2, 4, 6, 8, 10]

B Compilation error due to casting

C [6, 8, 10]

D [3, 4, 5]

💡 Hint

Consider how casting from Double to T works in Kotlin generics.

The cast '(it.toDouble() * 2) as T' is unsafe because T is a generic type constrained to Number and Comparable, but Kotlin cannot guarantee the cast from Double to T at runtime, causing a ClassCastException or compilation error.

📝 Syntax

intermediate

Identify the correct syntax for generic constraints with where clause

Which of the following Kotlin function declarations correctly uses a where clause to constrain generic types?

A fun <T> process(item: T : CharSequence, T : Comparable<T>) { println(item.length) }

B fun <T where T : CharSequence, T : Comparable<T>> process(item: T) { println(item.length) }

C fun <T> process(item: T) where T : CharSequence, T : Comparable<T> { println(item.length) }

D fun <T : CharSequence, T : Comparable<T>> process(item: T) { println(item.length) }

💡 Hint

Remember the correct placement of the where clause in Kotlin generic declarations.

Option C correctly places the where clause after the generic parameter list to specify multiple constraints. Options A, B, and C have syntax errors or incorrect constraint placements.

❓ optimization

advanced

Optimize generic function with multiple constraints and filtering

Given this Kotlin function, which option optimizes it to avoid unnecessary casting and improve type safety?

Kotlin

fun <T> sumIfGreaterThan(items: List<T>, threshold: T): Double where T : Number, T : Comparable<T> {
    return items.filter { it > threshold }.sumOf { it.toDouble() }
}

A Return List<T> instead of Double to avoid sumOf

B Change return type to Double and keep code as is

C Change generic constraint to only Number and remove Comparable

D Use 'items.filter { it.toDouble() > threshold.toDouble() }.sumOf { it.toDouble() }' and keep constraints

💡 Hint

Think about how to compare generic numbers safely.

Comparing generic types with '>' requires Comparable, but comparing their Double values is safer and avoids issues with generic comparisons. Option D converts both to Double for comparison and summation, improving safety and correctness.

🔧 Debug

advanced

Debug the compilation error in generic function with where clause

Why does the following Kotlin function cause a compilation error?

Kotlin

fun <T> printLength(item: T) where T : CharSequence, T : Comparable<T> {
    println(item.length)
}

printLength(123)

A Because 123 is Int and does not satisfy CharSequence constraint

B Because Comparable<T> constraint is missing

C Because where clause syntax is incorrect

D Because item.length is not accessible for generic T

💡 Hint

Check the type of argument passed and the constraints on T.

The function requires T to be CharSequence and Comparable, but 123 is an Int which does not implement CharSequence, causing a compilation error.

🧠 Conceptual

expert

Understanding the purpose of where clause in Kotlin generics

What is the main purpose of using a where clause in Kotlin generic functions or classes?

A To specify multiple constraints on a generic type when simple syntax is insufficient

B To declare default values for generic types

C To restrict generic types to only nullable types

D To enable runtime type checking of generic parameters

💡 Hint

Think about why Kotlin allows where clauses beyond simple generic constraints.

The where clause allows specifying multiple constraints on a generic type parameter, especially when the simple colon syntax cannot express all constraints clearly.