Inline Functions
In this page:
inline fun functionName(action: () -> Unit) {
// body and lambda are copied to the call site
action()
}Declaring an Inline Function
Adding inline before fun tells the compiler to insert the function's compiled code directly at each call site instead of a normal function call, which avoids extra lambda object allocation for its function-type parameters.
Example: Declaring an Inline Function
inline fun measureAndRun(action: () -> Unit) {
// Declare a read-only variable `start`, set to `System.currentTimeMillis()`
val start = System.currentTimeMillis()
action()
// Declare a read-only variable `time`, set to `System.currentTimeMillis() - start`
val time = System.currentTimeMillis() - start
// Print "Took ${time}ms" to the console, with a trailing newline
println("Took ${time}ms")
}
// Entry point: execution of the program starts here
fun main() {
measureAndRun {
// Print "Doing some work" to the console, with a trailing newline
println("Doing some work")
}
}Login to try C/C++/Java/PHP code in the editor
Why Inlining Avoids Overhead
Normally, passing a lambda creates an object implementing a function interface behind the scenes; inlining removes that indirection entirely by copying the lambda's code straight into the call site.
Example: Why Inlining Avoids Overhead
inline fun repeatAction(times: Int, action: (Int) -> Unit) {
// Loop over `0 until times`, binding each item to `i`
for (i in 0 until times) {
action(i)
}
}
// Entry point: execution of the program starts here
fun main() {
repeatAction(3) { index ->
// Print "Iteration $index" to the console, with a trailing newline
println("Iteration $index")
}
}Login to try C/C++/Java/PHP code in the editor
Non-Local Returns Require inline
A plain return inside a lambda passed to a function is only allowed when that function is inline, because the lambda's code becomes part of the calling function itself after inlining.
Example: Non-Local Returns Require inline
inline fun findFirst(numbers: List<Int>, predicate: (Int) -> Boolean): Int? {
// Loop over `numbers`, binding each item to `n`
for (n in numbers) {
if (predicate(n)) return n
}
// Return `null` from this function
return null
}
// Entry point: execution of the program starts here
fun main() {
// Declare a read-only variable `result`, set to `findFirst(listOf(1, 2, 3, 4)) { it > 2 }`
val result = findFirst(listOf(1, 2, 3, 4)) { it > 2 }
// Print "First match: $result" to the console, with a trailing newline
println("First match: $result")
}Login to try C/C++/Java/PHP code in the editor
noinline and crossinline
noinline marks one specific lambda parameter as excluded from inlining (useful if it needs to be stored or passed elsewhere), while crossinline allows inlining a lambda but forbids it from performing a non-local return.
Example: noinline and crossinline
inline fun runTasks(crossinline first: () -> Unit, noinline second: () -> Unit) {
// Declare a read-only variable `wrapped`, set to `Runnable { first() }`
val wrapped = Runnable { first() }
wrapped.run()
second()
}
// Entry point: execution of the program starts here
fun main() {
runTasks({ println("First task") }, { println("Second task") })
}Login to try C/C++/Java/PHP code in the editor
- Marking a huge function
inlineexpecting a performance win, when inlining large functions can actually bloat compiled code without meaningful benefit. - Forgetting that a non-local
returninside a lambda only works because the enclosing function accepting that lambda isinline. - Using
noinlineorcrossinlineincorrectly on lambda parameters that don't need those special behaviors.
inline funtells the compiler to substitute the function's body (and its lambda parameters) directly at each call site.- Inlining avoids the runtime overhead of creating a separate object for each lambda passed to the function.
- Non-local returns from a lambda are only possible because the function receiving it is inlined.
noinlinemarks a specific lambda parameter as exempt from inlining, andcrossinlineforbids non-local returns from a specific inlined lambda.
Chapter Quiz — Complete all 6 topics to unlock
0/6 topics done
Complete these topics first: