Generic constraints with where clause in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a generic function with a constraint using the where clause.

Kotlin

fun <T> checkValue(value: T) where T : [1] {
    println(value)
}

Drag options to blanks, or click blank then click option'

ANumber

BString

CAny

DList

Attempts:

3 left

💡 Hint

Common Mistakes

Using a class like String which is not a numeric type.

Not using the where clause properly.

Using Any which does not constrain the type.

The generic type T is constrained to Number using the where clause, so only types that inherit from Number are allowed.

2fill in blank

medium

Complete the code to declare a generic function with two constraints using the where clause.

Kotlin

fun <T> process(item: T) where T : Comparable<T>, T : [1] {
    println(item)
}

Drag options to blanks, or click blank then click option'

ACharSequence

BNumber

CList

DAny

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-numeric type like CharSequence.

Not including both constraints properly.

Using Any which does not constrain the type.

The generic type T is constrained to both Comparable<T> and Number, so it must be a numeric type that can be compared.

3fill in blank

hard

Fix the error in the generic function declaration by completing the where clause correctly.

Kotlin

fun <T> compareValues(a: T, b: T) where T : [1], T : Comparable<T> {
    println(if (a > b) a else b)
}

Drag options to blanks, or click blank then click option'

AAny

BString

CNumber

DList

Attempts:

3 left

💡 Hint

Common Mistakes

Using Any which does not guarantee comparability.

Using String which is not numeric.

Omitting the where clause.

The function requires T to be a Number and also implement Comparable<T> to use the comparison operator.

4fill in blank

hard

Fill both blanks to declare a generic function with constraints that T must be a Number and implement Comparable.

Kotlin

fun <T> maxValue(a: T, b: T) where T : [1], T : [2] {
    println(if (a > b) a else b)
}

Drag options to blanks, or click blank then click option'

ANumber

BCharSequence

CComparable<T>

DList

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the order of constraints incorrectly.

Using non-numeric or non-comparable types.

Omitting one of the constraints.

The generic type T must be a Number and implement Comparable<T> to allow comparison.

5fill in blank

hard

Fill all three blanks to declare a generic function with constraints that T must be a Number, implement Comparable, and also implement CharSequence.

Kotlin

fun <T> complexCheck(item: T) where T : [1], T : [2], T : [3] {
    println(item)
}

Drag options to blanks, or click blank then click option'

ANumber

BComparable<T>

CCharSequence

DList

Attempts:

3 left

💡 Hint

Common Mistakes

Using incompatible types together.

Omitting one or more constraints.

Mixing up the order of constraints.

The generic type T must be a Number, implement Comparable<T>, and also implement CharSequence to satisfy all constraints.

Practice

1. What is the main purpose of using a where clause in Kotlin generic constraints?

easy

A. To override a generic type with a specific type

B. To specify multiple constraints on a generic type clearly

C. To create a new class without generics

D. To declare a generic function without any constraints

Solution

1. Step 1: Understand generic constraints

   Generic constraints limit what types a generic can accept to ensure safety and functionality.

2. Step 2: Role of where clause

   The where clause allows specifying multiple or complex constraints on a generic type clearly and separately from the main declaration.

3. Final Answer:

   To specify multiple constraints on a generic type clearly -> Option B

4. Quick Check:

   where clause = multiple constraints [OK]

Hint: Remember: where clause adds multiple constraints clearly [OK]

Common Mistakes:

• Thinking where clause removes constraints
• Confusing where clause with type declaration
• Using where clause to override types

2. Which of the following is the correct syntax to add multiple constraints using a where clause in Kotlin?

easy

A. fun <T> example(item: T) where T : Comparable<T>, T : Serializable { }

B. fun <T> example(item: T : Comparable<T>, T : Serializable) { }

C. fun <T> example(item: T) : where T Comparable<T>, Serializable { }

D. fun <T> example(item: T) where T Comparable<T> and Serializable { }

Solution

1. Step 1: Recall correct where clause syntax

   The where clause follows the generic parameter list and uses commas to separate constraints.

2. Step 2: Validate each option

   fun <T> example(item: T) where T : Comparable<T>, T : Serializable { } correctly uses where T : Comparable<T>, T : Serializable. Others have syntax errors or misplaced keywords.

3. Final Answer:

   fun <T> example(item: T) where T : Comparable<T>, T : Serializable { } -> Option A

4. Quick Check:

   Correct where syntax = fun <T> example(item: T) where T : Comparable<T>, T : Serializable { } [OK]

Hint: Use commas to separate constraints in where clause [OK]

Common Mistakes:

• Using colons inside parameter list instead of where clause
• Adding 'and' instead of commas between constraints
• Placing where clause after function body

3. Given the code below, what will be the output?

fun <T> printFirst(item: T) where T : List<String>, T : Comparable<T> {
    println(item[0])
}

fun main() {
    val list = listOf("apple", "banana")
    printFirst(list)
}

medium

A. Runtime error

B. banana

C. apple

D. Compilation error due to constraints

Solution

1. Step 1: Analyze constraints on T

   The function requires T to be both List<String> and Comparable<T>.

2. Step 2: Check if listOf<String> satisfies constraints

   List<String> does not implement Comparable<List<String>>, so it fails the constraint.

3. Final Answer:

   Compilation error due to constraints -> Option D

4. Quick Check:

   List<String> not Comparable = compilation error [OK]

Hint: Check if all constraints are met by the argument type [OK]

Common Mistakes:

• Assuming List<String> is Comparable
• Ignoring constraint errors at compile time
• Expecting runtime error instead of compile error

4. Identify the error in the following Kotlin function using a where clause:

fun <T> compareItems(a: T, b: T) where T : Comparable {
    return a.compareTo(b) > 0
}

medium

A. Missing generic type parameter in Comparable constraint

B. Incorrect return type for the function

C. where clause should be after the function body

D. compareTo function does not exist

Solution

1. Step 1: Check the constraint syntax

   The constraint T : Comparable is incomplete; Comparable requires a type parameter.

2. Step 2: Correct constraint usage

   It should be T : Comparable<T> to specify T can be compared to itself.

3. Final Answer:

   Missing generic type parameter in Comparable constraint -> Option A

4. Quick Check:

   Comparable requires type parameter [OK]

Hint: Always specify type parameter for Comparable in constraints [OK]

Common Mistakes:

• Omitting type parameter in Comparable
• Placing where clause incorrectly
• Assuming compareTo is undefined

5. You want to write a generic function that accepts any type T which must be both a Collection of Int and implement Iterable. Which is the correct way to declare the function with a where clause?

hard

A. fun <T> process(items: T) where T : Collection<Int>, Iterable<Int> { /*...*/ }

B. fun <T> process(items: T) where T : Collection, T : Iterable<Int> { /*...*/ }

C. fun <T> process(items: T) where T : Collection<Int>, T : Iterable<Int> { /*...*/ }

D. fun <T> process(items: T) where T : Collection<Int> and Iterable<Int> { /*...*/ }

Solution

1. Step 1: Understand constraints needed

   The type T must be a Collection of Int and also implement Iterable of Int.

2. Step 2: Correct where clause syntax

   Use commas to separate constraints and specify full generic types: T : Collection<Int>, T : Iterable<Int>.

3. Final Answer:

   fun <T> process(items: T) where T : Collection<Int>, T : Iterable<Int> { /*...*/ } -> Option C

4. Quick Check:

   Multiple constraints separated by commas = fun <T> process(items: T) where T : Collection<Int>, T : Iterable<Int> { /*...*/ } [OK]

Hint: Separate constraints with commas and repeat type parameter [OK]

Common Mistakes:

• Omitting type parameter in Collection
• Using 'and' instead of commas
• Not repeating T for each constraint