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.

Practice

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

easy

A. They automatically optimize memory usage for large data.

B. They allow functions to run asynchronously.

C. They enable functions to be called from Java code.

D. They reduce the overhead of function calls by copying code at call sites.

Solution

1. Step 1: Understand what inline functions do

   Inline functions copy their code directly to the place where they are called, avoiding the usual function call overhead.

2. Step 2: Identify the main benefit

   This copying reduces the overhead of calling small functions repeatedly, improving performance.

3. Final Answer:

   They reduce the overhead of function calls by copying code at call sites. -> Option D

4. Quick Check:

   Inline functions reduce call overhead [OK]

Hint: Inline means copy code to call site to run faster [OK]

Common Mistakes:

• Thinking inline makes functions asynchronous
• Believing inline optimizes memory for large data
• Confusing inline with Java interoperability

2. Which of the following is the correct syntax to declare an inline function in Kotlin?

easy

A. fun inline myFunction() { println("Hello") }

B. inline fun myFunction() { println("Hello") }

C. fun myFunction() inline { println("Hello") }

D. fun myFunction() { inline println("Hello") }

Solution

1. Step 1: Recall Kotlin inline function syntax

   The keyword inline must appear before fun in the function declaration.

2. Step 2: Check each option

   inline fun myFunction() { println("Hello") } correctly places inline before fun. Others place it incorrectly or inside the function body.

3. Final Answer:

   inline fun myFunction() { println("Hello") } -> Option B

4. Quick Check:

   inline keyword before fun [OK]

Hint: inline keyword always comes before fun keyword [OK]

Common Mistakes:

• Placing inline after fun keyword
• Putting inline inside function body
• Using inline as a function modifier incorrectly

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

inline fun greet(name: () -> String) {
    println("Hello, ${name()}")
}

fun main() {
    greet { "Alice" }
}

medium

A. Hello, Alice

B. Hello, name

C. Compilation error due to inline function

D. Hello, () -> String

Solution

1. Step 1: Understand the inline function call

   The function greet takes a lambda returning a String and prints "Hello, " plus the lambda result.

2. Step 2: Evaluate the lambda passed

   The lambda returns "Alice", so the print statement outputs "Hello, Alice".

3. Final Answer:

   Hello, Alice -> Option A

4. Quick Check:

   Lambda returns "Alice" so output is Hello, Alice [OK]

Hint: Inline copies lambda code, output matches lambda return [OK]

Common Mistakes:

• Confusing lambda with string literal
• Expecting compilation error from inline
• Printing lambda type instead of result

4. Identify the error in this Kotlin code using inline functions:

inline fun calculate(operation: () -> Int) {
    return operation()
}

fun main() {
    val result = calculate { 5 + 3 }
    println(result)
}

medium

A. Cannot return a value from an inline function with Unit return type.

B. Inline functions cannot have return statements.

C. The function calculate should specify a return type.

D. Lambda passed to calculate must not return Int.

Solution

1. Step 1: Check function signature and return usage

   The function calculate uses return operation() but does not declare a return type.

2. Step 2: Kotlin requires explicit return type if function returns a value

   Since operation() returns Int, calculate must declare : Int as return type.

3. Final Answer:

   The function calculate should specify a return type. -> Option C

4. Quick Check:

   Function returns Int but lacks return type [OK]

Hint: Declare return type if function returns a value [OK]

Common Mistakes:

• Assuming inline forbids return statements
• Ignoring missing return type causes error
• Thinking lambda return type is restricted

5. You want to improve performance by inlining a function that takes two lambdas: one for success and one for failure. Which Kotlin code correctly uses inline functions to avoid creating lambda objects and improve speed?

hard

A. inline fun process(success: () -> Unit, noinline failure: () -> Unit) {
success()
failure()
}

B. fun process(success: () -> Unit, failure: () -> Unit) {
success()
failure()
}

C. inline fun process(noinline success: () -> Unit, failure: () -> Unit) {
success()
failure()
}

D. inline fun process(success: () -> Unit, failure: () -> Unit) {
success()
failure()
}

Solution

1. Step 1: Understand inline with multiple lambdas

   Inlining copies code of lambdas to call site, but lambdas marked noinline are not inlined and keep normal object overhead.

2. Step 2: Identify which lambdas to inline or not

   To avoid creating lambda objects for the success lambda, it should be inlined. If failure lambda is large or stored, mark it noinline to avoid code bloat.

3. Step 3: Check options

   inline fun process(success: () -> Unit, noinline failure: () -> Unit) { success() failure() } correctly marks failure as noinline and success as inline, improving performance while controlling code size.

4. Final Answer:

   inline fun process(success: () -> Unit, noinline failure: () -> Unit) { success() failure() } -> Option A

5. Quick Check:

   Use noinline for lambdas not to inline [OK]

Hint: Use noinline to exclude lambdas from inlining [OK]

Common Mistakes:

• Inlining all lambdas causing code bloat
• Not using noinline for stored lambdas
• Forgetting to mark function inline