Type constraints with upper bounds in Kotlin - Step-by-Step Execution

Concept Flow - Type constraints with upper bounds

Define generic type T

↓

Set upper bound: T must be subtype of SomeClass

↓

Use T in function or class

↓

Call function with argument of type T or subtype

↓

Compile-time check: argument type fits upper bound?

Yes No↓

Run function

↓

Function logic uses T safely

↓

End

This flow shows how Kotlin checks that a generic type T respects an upper bound before running the function.

Execution Sample

Kotlin

fun <T : Number> doubleValue(value: T): Double {
    return value.toDouble() * 2
}

val result = doubleValue(10)

This function accepts any type T that is a subtype of Number and doubles its value.

Execution Table

Step	Action	Type of T	Check Upper Bound	Result	Output
1	Call doubleValue with 10	Int	Int <: Number? Yes	Pass
2	Inside function: value.toDouble()	Int	N/A	Convert 10 to 10.0
3	Multiply 10.0 * 2	Double	N/A	Result 20.0
4	Return 20.0	Double	N/A	Function ends	20.0

💡 Function ends after returning doubled value; type T confirmed as subtype of Number.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
value	N/A	10 (Int)	10 (Int)	10 (Int)	N/A
result	N/A	N/A	N/A	N/A	20.0 (Double)

Key Moments - 3 Insights

Why must the argument type be a subtype of Number?

Because the function declares <T : Number>, Kotlin enforces this at compile time (see execution_table step 1). Passing a type outside this bound causes a compile error.

What happens if we try to call doubleValue with a String?

The compiler rejects it immediately since String is not a subtype of Number, so the check in step 1 fails and the function does not run.

Why can we safely call toDouble() on value inside the function?

Because T is guaranteed to be a subtype of Number, which has the toDouble() method, so the call is safe (see step 2).

Visual Quiz - 3 Questions

Look at the execution_table, what is the type of T at step 1?

A String

B Int

C Double

D Any

💡 Hint

Check the 'Type of T' column in execution_table row for step 1.

At which step does the function convert the value to Double?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table for step 2.

If we try to call doubleValue("text"), what happens?

A Function runs and returns 0.0

B Function runs but throws runtime error

C Compile error due to type constraint

D Function runs and returns "texttext"

💡 Hint

Refer to key_moments about type constraint enforcement at compile time.

Concept Snapshot

fun <T : UpperBound> functionName(param: T) { ... }
- T must be subtype of UpperBound
- Compiler checks this before running
- Allows safe use of UpperBound methods on T
- Prevents passing incompatible types
- Enables flexible, type-safe generic code

Full Transcript

This visual trace shows how Kotlin uses type constraints with upper bounds in generics. The generic type T is declared with an upper bound Number, meaning T must be a subtype of Number. When calling the function doubleValue with an Int argument, Kotlin checks that Int is a subtype of Number and allows the call. Inside the function, it safely calls toDouble() on value because Number defines this method. The function doubles the value and returns a Double. If a type outside the bound, like String, is used, the compiler rejects the call. This ensures type safety and lets us write generic code that can use methods of the upper bound type.