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.

Practice

1. What is the main benefit of using reified type parameters in Kotlin inline functions?

easy

A. They improve performance by avoiding inline expansion.

B. They allow access to the actual type at runtime inside the function.

C. They enable functions to be called without specifying type arguments.

D. They automatically convert types to strings.

Solution

1. Step 1: Understand reified type parameters

   Reified type parameters let you use the real type inside an inline function at runtime, unlike normal generics which erase type info.

2. Step 2: Identify the main benefit

   This means you can do type checks and casts safely inside the function using the actual type.

3. Final Answer:

   They allow access to the actual type at runtime inside the function. -> Option B

4. Quick Check:

   Reified = real type access [OK]

Hint: Reified means real type info available at runtime [OK]

Common Mistakes:

• Thinking reified improves performance by avoiding inline
• Believing reified removes need for type arguments
• Confusing reified with automatic type conversion

2. Which of the following is the correct syntax to declare an inline function with a reified type parameter T in Kotlin?

easy

A. inline fun myFunction() { }

B. inline fun <T> myFunction() { }

C. fun inline myFunction() { }

D. fun inline myFunction() { }

Solution

1. Step 1: Recall syntax for inline with reified

   The correct syntax places inline before the function and reified before the type parameter inside angle brackets.

2. Step 2: Check each option

   inline fun myFunction() { } correctly uses inline fun <reified T> myFunction(). Others have wrong order or missing keywords.

3. Final Answer:

   inline fun <reified T> myFunction() { } -> Option A

4. Quick Check:

   inline + reified before T = correct syntax [OK]

Hint: Put 'inline' before fun and 'reified' before type param [OK]

Common Mistakes:

• Placing 'reified' after the type parameter
• Writing 'fun inline' instead of 'inline fun'
• Omitting 'inline' keyword

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

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

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

medium

A. false\nfalse\nfalse

B. true\nfalse\ntrue

C. false\ntrue\nfalse

D. true\ntrue\ntrue

Solution

1. Step 1: Understand the function behavior

   The function checks if the given value is of type T using the reified type parameter for runtime type check.

2. Step 2: Evaluate each println call

   First call: isString<String>("hello") -- "hello" is String -> true.
   Second call: isString<Int>(123) -- 123 is Int -> true.
   Third call: isString<Double>(123.0) -- 123.0 is Double -> true.
   Output: true\ntrue\ntrue.

3. Final Answer:

   true\ntrue\ntrue -> Option D

4. Quick Check:

   All type checks match = true true true [OK]

Hint: Reified lets 'is' check real type at runtime [OK]

Common Mistakes:

• Assuming type erasure causes false results
• Mixing up types in the is check
• Ignoring that reified allows runtime type check

4. Identify the error in the following Kotlin code snippet:

fun  printTypeName() {
    println(T::class.simpleName)
}

fun main() {
    printTypeName<String>()
}

medium

A. Missing type argument when calling printTypeName.

B. T::class.simpleName is not a valid expression.

C. Cannot use reified type parameter in a non-inline function.

D. Function printTypeName must return a value.

Solution

1. Step 1: Check function declaration

   The function uses reified type parameter but is not marked inline. This is not allowed in Kotlin.

2. Step 2: Understand Kotlin rules for reified

   Reified type parameters require the function to be inline to preserve type info at runtime.

3. Final Answer:

   Cannot use reified type parameter in a non-inline function. -> Option C

4. Quick Check:

   Reified requires inline function [OK]

Hint: Reified always needs inline keyword [OK]

Common Mistakes:

• Forgetting to mark function as inline
• Thinking reified works in normal functions
• Misunderstanding T::class usage

5. You want to create a generic inline function createInstance that returns a new instance of type T using its no-argument constructor. Which of the following implementations correctly uses reified type parameters to achieve this?

hard

A. inline fun createInstance(): T = T::class.java.newInstance()

B. fun createInstance(): T = T::class.java.getDeclaredConstructor().newInstance()

C. inline fun <T> createInstance(): T = T::class.java.newInstance()

D. inline fun createInstance(): T = T()

Solution

1. Step 1: Understand how to create instance with reified

   Using reified lets us access T::class.java at runtime to call newInstance() for no-arg constructor.

2. Step 2: Check each option

   inline fun createInstance(): T = T::class.java.newInstance() uses inline and reified correctly and calls newInstance().
   fun createInstance(): T = T::class.java.getDeclaredConstructor().newInstance() is not inline, so reified is invalid.
   inline fun <T> createInstance(): T = T::class.java.newInstance() lacks reified, so T::class is invalid.
   inline fun createInstance(): T = T() tries to call T() which is invalid syntax in Kotlin.

3. Final Answer:

   inline fun <reified T> createInstance(): T = T::class.java.newInstance() -> Option A

4. Quick Check:

   Inline + reified + newInstance() = correct instance creation [OK]

Hint: Use inline + reified + T::class.java.newInstance() [OK]

Common Mistakes:

• Omitting inline with reified
• Trying to call T() directly
• Using reified without inline