noinline

Let’s now extend our example with some logging on the main() function:

fun main() {
    println("START main()")
    doOnDebug {
        println("I'm on debug ¯\\_(ツ)_/¯")
    }
    println("END main()")
}

And let’s add some logging to doOnDebug as well. For doOnDebug, since it's a util function, we also want to specify which logger to use.

For the sake of simplicity, a logger will be just a simple function:

logger: (String) -> Unit

So we can extend the doOnDebug with invocations of this logger.

Moreover, we also want to flush it at the end of the function. Let’s assume we invoke a flush function:

inline fun doOnDebug(
    logger: (String) -> Unit,
    block: () -> Unit
) {
    if (Env.DEBUG) {
        logger("[LOG] Running doOnDebug...")
        block()
        logger("[LOG] Flushing the log...")
        flush(logger)
    }
}

fun flush(logger: (String) -> Unit) { 
    // Flush the logger here
}

As it is right now, this code won’t compile. It will fail with the following error message:

Illegal usage of inline-parameter 'logger' in 'public inline fun doOnDebug(logger: (String) -> Unit = ..., block: () -> Unit): Unit defined in root package in file File.kt'. Add 'noinline' modifier to the parameter declaration

The error message suggests we add the noinline keyword to the loggerparameter. Adding this will make the code compile:

inline fun doOnDebug(
    noinline logger: (String) -> Unit,

Why is this needed?

As previously mentioned, the inline keyword affects the function body and all the lambda parameters. In our example, logger is inlined as well.

Inlining a lambda limits what you can do with it. You can only invoke it. If you wish to store it in a variable or pass them to another function (as we do for the flush function) you need to tell the compiler to avoid inlining it.

If we try to run, the console output now will be:

START main()
[LOG] Running doOnDebug...
I'm on debug ¯\_(ツ)_/¯
[LOG] Flushing the log...
END main()

To recap, the noinline keyword is a mechanism to prevent the inlining of a specific lambda parameter of an inline function. It's useful if you wish to pass the lambda around or store it in a variable.

The full example until here is available in this playground:

crossinline

Let’s go back to the call site, and complicate our function a bit more.

First, we add a times: Int = 1 parameters, to allow repeating the lambda multiple times:

inline fun doOnDebug(
    noinline logger: (String) -> Unit,
    times : Int = 1,
    block: () -> Unit
) {
    if (Env.DEBUG) {
        logger("[LOG] Running doOnDebug...")
        repeat(times) {
            logger("[LOG] Iteration #$it...")
            block()
        }
        logger("[LOG] Flushing the log...")
        flush(logger)
    }
}

Then, our code contains a katakana symbol: ツ. Let’s say we want to play defensive and avoid printing if the terminal doesn’t support UTF-8.

Let’s update the doOnDebug call site like this:

doOnDebug {
    if(!Env.UTF8_SUPPORT) {
        return
    }
    println("I'm on debug ¯\\_(ツ)_/¯")
}

As long as Env.UTF8_SUPPORT is true, everything goes smoothly. Here is what is printed on the console:

START main()
[LOG] Running doOnDebug...
[LOG] Iteration #0...
I'm on debug ¯\_(ツ)_/¯
[LOG] Flushing the log...
END main()

But if you try to change Env.UTF8_SUPPORT to false, this will happen:

START main()
[LOG] Running doOnDebug...
[LOG] Iteration #0...

Seems like the execution terminated at the return, but the flushing of the logger and END main() line are missing 🧐.

Time to (de)-bug

To fully understand what is going on, let’s introduce a bug 🐛.

Instead of Env.UTF8_SUPPORT returning always either true or false, let's call Random. We can introduce some flakiness by letting Env.UTF8_SUPPORTreturn true only 80% of the times:

val UTF8_SUPPORT : Boolean get() = Random.nextInt(5) != 0

Now let’s try to call doOnDebug with repeat = 10 and see what's the output on the console. We expect to see on the average ~9 shrug on the screen:

Run main()
[LOG] Running doOnDebug
[LOG] Iteration 0
¯\_(ツ)_/¯
[LOG] Iteration 1
¯\_(ツ)_/¯
[LOG] Iteration 2

What happens instead is that in my run, after two iterations, UTF8_SUPPORTis false and the whole execution is halted.

What is happening here?

Given that the lambda parameter of doOnReturn is inlined, also the returnis inlined at the call site. This means that in the resulting code, that returnis causing a return of the outer function, the main().

This is called a non-local return in Kotlin.

To prevent this behavior we can mark the parameter block as crossinline. This keyword prevents non-local returns in the specified lambda parameter.

If we try to apply it to our function:

inline fun doOnDebug(
    noinline logger: (String) -> Unit,
    times: Int = 1,
    crossinline block: () -> Unit

We will see that our code will not compile anymore with the following error message:

'return' is not allowed here

The IDE autocompletion is also suggesting you to use a labeled return: return@doOnDebug. That will make sure your return will apply only to the doOnDebug function and not to the main() function.

IntelliJ suggesting a labelled return

Tags: Kotlin,Kotlin Beginners,Android App Development,Android,Software Development

View original article at: 

Originally published: July 08, 2020