Reified type parameters with inline in Kotlin - Step-by-Step Execution

Concept Flow - Reified type parameters with inline

Call inline function with reified type T

↓

Compiler keeps type info of T

↓

Use type T inside function (e.g., is, class check)

↓

Function executes with real type info

↓

Return or print result based on T

The inline function keeps the actual type T at runtime, allowing type checks and casts inside the function.

Execution Sample

Kotlin

inline fun <reified T> isString(value: Any): Boolean {
    return value is T
}

fun main() {
    println(isString<String>("hello"))
    println(isString<Int>(123))
    println(isString<String>(123))
}

This code checks if a value is of type T using a reified type parameter inside an inline function.

Execution Table

Step	Function Call	T Type	Value	Check (value is T)	Result	Output
1	isString<String>("hello")	String	"hello"	"hello" is String	true	true
2	isString<Int>(123)	Int	123	123 is Int	true	true
3	isString<String>(123)	String	123	123 is String	false	false
4	End of main	-	-	-	-	Program ends

💡 All calls complete; program ends after printing results.

Variable Tracker

Variable	Start	Call 1	Call 2	Call 3	Final
T	-	String	Int	String	-
value	-	"hello"	123	123	-
Result	-	true	true	false	-

Key Moments - 2 Insights

Why can we use 'value is T' inside the function?

Because the function is inline with a reified type parameter, the compiler keeps the actual type T at runtime, allowing 'is' checks (see execution_table rows 1-3).

What happens if the function was not inline and T was not reified?

The type T would be erased at runtime, so 'value is T' would cause a compile error or not work, unlike the inline reified case shown in the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output when calling isString<String>("hello")?

A true

B false

C Compile error

D null

💡 Hint

Check execution_table row 1 under Output column.

At which step does the check 'value is T' return false?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at execution_table row 3 under Check and Result columns.

If the function was not inline, what would happen to the 'value is T' check?

A It would work the same

B It would always return true

C It would cause a compile error

D It would always return false

💡 Hint

Refer to key_moments explanation about non-inline functions.

Concept Snapshot

inline fun <reified T> allows using T's type at runtime
Use 'value is T' inside such functions
Compiler keeps T info due to inline
Enables safe type checks and casts
Without inline, T is erased at runtime

Full Transcript

This example shows how Kotlin's inline functions with reified type parameters keep the actual type information at runtime. The function isString uses 'value is T' to check if the value matches the type T. Because the function is inline and T is reified, the compiler replaces T with the real type during compilation. The execution table shows calls with different types and values, and the results of the type checks. Key moments clarify why reified is needed and what happens without it. The visual quiz tests understanding of outputs and behavior changes if inline is removed.