Kotlin is a powerful language that introduces many useful features to make development more efficient. One such feature is inline functions, which improve performance by eliminating function call overhead. However, sometimes we need more control over how lambdas behave inside an inline function. That’s where the noinline modifier in Kotlin comes into play.

In this article, we’ll dive deep into the noinline modifier in Kotlin, exploring its purpose, use cases, and practical examples. By the end, you’ll have a clear understanding of when and why to use noinline in your Kotlin code.

What is the noinline Modifier in Kotlin?

Before understanding noinline, let’s first recall what an inline function is.

An inline function in Kotlin is a function where the compiler replaces the function call with the actual function body to reduce the overhead of function calls, especially when dealing with higher-order functions (functions that take other functions as parameters).

However, there are cases where we don’t want certain lambdas to be inlined. This is where the noinline modifier comes in. It tells the compiler not to inline a specific lambda inside an inline function.

inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
    // ...
}

Here, by using noinline, you indicate that the notInlined parameter should not be inlined.

Why Use noinline Modifier in Kotlin?

Using noinline in Kotlin is beneficial in several scenarios:

Passing Lambdas to Another Function

• If you need to store or pass a lambda to another function, it cannot be inlined.
• The compiler removes inlined lambdas at compile time, making it impossible to reference them. The noinline modifier prevents this, allowing the lambda to be passed as an argument.

Avoiding Code Bloat

• Excessive inlining can increase bytecode size, leading to performance issues.
• Marking a lambda as noinline prevents unnecessary duplication in the generated bytecode.

Using Reflection on Lambdas

• If you need to inspect a lambda function using reflection (e.g., ::functionName), it cannot be inlined because inline functions don’t have an actual function reference at runtime.
• The noinline modifier ensures the lambda remains a callable reference.

How to Use noinline Modifier in Kotlin

Let’s start with a simple example to illustrate the use of noinline

inline fun processNumbers(a: Int, b: Int, noinline operation: (Int, Int) -> Int): Int {
    println("Processing numbers...")
    return operation(a, b)
}

fun main() {
    val result = processNumbers(5, 10) { x, y -> x + y }
    println("Result: $result")
}


// OUTPUT

Processing numbers...
Result: 15

Here,

• processNumbers is an inline function, meaning its body (except noinline parts) gets copied directly to the main() function during compilation.
• The lambda function operation is marked as noinline, meaning it will not be inlined.
• Instead, the lambda is converted into an actual function reference, and processNumbers will call it like a regular function.

What If We Remove noinline?

If we remove noinline, like this:

inline fun processNumbers(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    println("Processing numbers...")
    return operation(a, b) // This lambda gets inlined now!
}

Then the call in main():

val result = processNumbers(5, 10) { x, y -> x + y }
println("Result: $result")

Will be inlined at compile-time. The compiled code will look like this:

fun main() {
    println("Processing numbers...")
    val result = (5 + 10) // Lambda is directly inserted
    println("Result: $result")
}

// Expected Output (without noinline)

Processing numbers...
Result: 15

Here,

• The output remains the same, but the function processNumbers no longer exists in the compiled code.
• The lambda { x, y -> x + y } has been directly replaced with (5 + 10).

Key Difference in Bytecode

Let’s look at the actual difference in bytecode to prove how noinline affects inlining.

Case 1: With noinline

• The lambda { x, y -> x + y } is treated as a separate function.
• A new function object is created, and processNumbers calls it dynamically.

This is how the bytecode looks in a simplified way:

public static final int main() {
    Function2<Integer, Integer, Integer> lambda = new Function2<Integer, Integer, Integer>() {
        @Override
        public Integer invoke(Integer x, Integer y) {
            return x + y;
        }
    };
    
    System.out.println("Processing numbers...");
    int result = lambda.invoke(5, 10);
    System.out.println("Result: " + result);
}

• Notice: The lambda is a separate function object (Function2).
• Runtime overhead: There’s an additional function call.

Case 2: Without noinline

• The lambda gets completely removed.
• Its body is inserted directly at the call site.

This is how the bytecode looks in a simplified way:

public static final void main() {
    System.out.println("Processing numbers...");
    int result = 5 + 10;
    System.out.println("Result: " + result);
}

• No lambda function object.
• Zero function call overhead.
• More efficient but increases bytecode size if overused.

When Should You Use noinline?

• When you need to pass a lambda to another function.
• When you want to use a lambda for reflection.
• When excessive inlining increases the bytecode size unnecessarily.

Using noinline ensures better control over how Kotlin optimizes function execution, improving both flexibility and performance.

This is just a part..! Get the full insights here: [Main Article URL]

Conclusion

The noinline modifier in Kotlin gives developers more control over inline functions, ensuring flexibility where inlining is not ideal. We use noinline when we need to:

• Pass a lambda to another function.
• Store a lambda in a variable.
• Avoid excessive code bloat due to unnecessary inlining.

Understanding noinline helps write better-optimized Kotlin code while leveraging the benefits of inline functions where necessary.