Inline functions and performance in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of inline function with lambda

What is the output of this Kotlin code using an inline function with a lambda parameter?

Kotlin

inline fun operate(x: Int, operation: (Int) -> Int): Int {
    return operation(x)
}

fun main() {
    val result = operate(5) { it * 2 }
    println(result)
}

A 10

B 5

C 25

D Compilation error

💡 Hint

Think about what the lambda does to the input number.

The inline function 'operate' takes an integer and a lambda that doubles it. So 5 * 2 = 10 is printed.

🧠 Conceptual

intermediate

Effect of inline on function call overhead

Which statement best describes the effect of marking a function as inline in Kotlin?

A It eliminates the function call overhead by copying the function body at call sites.

B It makes the function run on a separate thread automatically.

C It prevents the function from being called recursively.

D It disables all optimizations for the function.

💡 Hint

Think about what 'inline' means in terms of code generation.

Inlining copies the function body to the call site, removing the overhead of a function call.

🔧 Debug

advanced

Why does this inline function cause a compilation error?

Consider this Kotlin code snippet. Why does it cause a compilation error?

Kotlin

inline fun runTwice(action: () -> Unit) {
    action()
    action()
}

fun main() {
    var x = 0
    runTwice { x += 1 }
    println(x)
}

A The function 'runTwice' must be marked 'noinline' for this lambda.

B Inline functions cannot accept lambdas as parameters.

C The lambda must return a value, but it returns Unit.

D Cannot modify 'val' captured in lambda; 'x' should be 'var'.

💡 Hint

Check the mutability of the variable 'x' used inside the lambda.

The variable 'x' is declared as 'val' (immutable), but the lambda tries to increment it, causing a compilation error.

❓ Predict Output

advanced

Output of inline function with crossinline lambda

What is the output of this Kotlin code using an inline function with a crossinline lambda?

Kotlin

inline fun runCrossinline(crossinline block: () -> Unit) {
    val runnable = Runnable {
        block()
    }
    runnable.run()
}

fun main() {
    runCrossinline { println("Hello from crossinline") }
}

A No output

B Compilation error due to crossinline usage

C Hello from crossinline

D Runtime exception

💡 Hint

Crossinline prevents non-local returns but allows lambda execution inside Runnable.

The crossinline lambda is executed inside Runnable.run(), printing the message successfully.

🧠 Conceptual

expert

Why use inline functions with reified type parameters?

Why are inline functions required to use reified type parameters in Kotlin?

A Because reified types allow the function to run on the JVM bytecode level only.

B Because type information is erased at runtime, inlining preserves it for reified types.

C Because inline functions cannot have generic parameters unless reified.

D Because reified types disable inlining to preserve type safety.

💡 Hint

Think about how Kotlin handles generic types at runtime and what inlining does.

Kotlin erases generic types at runtime, but marking a function inline with reified type parameters keeps type info available inside the function.