{"id":265,"date":"2025-03-21T14:10:07","date_gmt":"2025-03-21T06:10:07","guid":{"rendered":"https:\/\/blog.newstrong.xyz\/?p=265"},"modified":"2025-03-21T14:10:07","modified_gmt":"2025-03-21T06:10:07","slug":"prefer-function-reference-over-lambda-in-kotlin-wrong","status":"publish","type":"post","link":"https:\/\/newstrong.top\/index.php\/2025\/03\/21\/prefer-function-reference-over-lambda-in-kotlin-wrong\/","title":{"rendered":"Prefer Function Reference over Lambda in Kotlin? Wrong!"},"content":{"rendered":"

Using\u00a0lambda<\/a>\u00a0as callback is very common in Jetpack compose, but do you know you can also use\u00a0function reference<\/a>\u00a0to replace the lambda?<\/p>\n

When I first heard about this function reference, I thought the function reference must be better. Unlike anonymous function \/ lambda, it just a function pointer or reference to a function. It should run faster and use less memory, as it doesn’t allocate extra memory. So I replaced lambda with function reference whenever is possible. Well, I was wrong!<\/p>\n

After doing some researches, it turns out that\u00a0function reference\u00a0still allocates extra memory just like what lambda does, and it also\u00a0runs 2x slower than lambda. Before we look into why, let’s understand their usages and differences first with examples below.<\/p>\n

<\/a>Lambda (call the object’s function)<\/h2>\n

Let’s say you have\u00a0Screen<\/code>\u00a0and\u00a0ViewModel<\/code>\u00a0classes below. The\u00a0id<\/code>\u00a0is used to identify a different instance of\u00a0ViewModel<\/code>.<\/p>\n

class Screen(private val callback: () -> Unit) {\n    fun onClick() = callback()\n}\n\nclass ViewModel(var id: String) {\n    fun screenOnClick() {\n        println("ViewModel$id onClick() is called!")\n    }\n\n    fun screenOnClickDoNothing() {}\n}\n<\/code><\/pre>\n
In\u00a0main()<\/code>, it creates the\u00a0ViewModel<\/code>\u00a0object. Then, you pass in the lambda callback parameter –\u00a0{ viewModel.screenOnClick() }<\/code>\u00a0to\u00a0Screen<\/code>‘s constructor.<\/p>\n
fun main() {\n    var viewModel = ViewModel("1")\n    val screen = Screen {\n        viewModel.screenOnClick()\n    }\n    viewModel = ViewModel("2")\n    screen.onClick()\n}\n<\/code><\/pre>\n
\n
viewModel.screenOnClick()<\/code>\u00a0is the object’s function.<\/p>\n<\/blockquote>\n
To demonstrate the difference between lambda and function reference, you update the\u00a0viewModel<\/code>\u00a0variable with another new instance of\u00a0ViewModel<\/code>\u00a0–\u00a0viewModel = ViewModel("2")<\/code>\u00a0before calling\u00a0screen.onClick()<\/code>.<\/p>\n
\n
Calling\u00a0screen.onClick()<\/code>\u00a0is to simulate screen callback<\/p>\n<\/blockquote>\n
Here is the output:<\/p>\n
ViewModel2 onClick() is called!\n<\/code><\/pre>\n
Please note that\u00a0ViewModel2 is called instead of ViewModel1. It looks like lambda holds the reference to the\u00a0viewModel<\/code>\u00a0variable. When the variable is updated, it is automatically reflected.<\/p>\n
<\/a>Object’s Function Reference<\/h2>\n
Let’s replace the lambda with a function reference –\u00a0viewModel::screenOnClick<\/code>. The code looks like this.<\/p>\n
fun main() {\n    var viewModel = ViewModel("1")\n    val screen = Screen(callback = viewModel::screenOnClick)\n    viewModel = ViewModel("2")\n    screen.onClick()\n}\n<\/code><\/pre>\n
Here is the output<\/p>\n
Copy<\/p>\n
Copy<\/p>\n
ViewModel1 onClick() is called!\n<\/code><\/pre>\n
Please note that\u00a0ViewModel1 is called instead of ViewModel2. It looks like the function reference is caching the\u00a0ViewModel<\/code>\u00a0instance when it is called. Thus, it is the old\u00a0ViewModel<\/code>\u00a0instance and not the updated one. Wrong!<\/p>\n
If you don’t replace the\u00a0viewModel<\/code>\u00a0instance but modifying\u00a0ViewModel.id<\/code>\u00a0directly instead,<\/p>\n
fun main() {\n    var viewModel = ViewModel("1")\n    val screen = Screen(callback = viewModel::screenOnClick)\n    viewModel.id = "2"\n    screen.onClick()\n}\n<\/code><\/pre>\n
you get the updated value.<\/p>\n
ViewModel2 onClick() is called!\n<\/code><\/pre>\n
This tells you that function reference doesn’t cache the\u00a0ViewModel<\/code>\u00a0instance, but holding its reference. If the original\u00a0viewModel<\/code>\u00a0is replaced, the\u00a0Screen<\/code>\u00a0still holds the old reference of the\u00a0ViewModel<\/code>. Thus, it prints out the value of that old reference.<\/p>\n
<\/a>Performance Test (Object’s Function)<\/h2>\n
Let’s run some performance tests.<\/p>\n
This is the lambda test that creating\u00a0Screen<\/code>\u00a01 billions times.<\/p>\n
fun lambdaTest() {\n    val viewModel = ViewModel("1")\n\n    val timeMillis = measureTimeMillis {\n        repeat(1_000_000_000) {\n            val screen = Screen {\n                viewModel.screenOnClickDoNothing()\n            }\n\n            screen.onClick()\n        }\n    }\n    println("lambdaTest: ${timeMillis\/1000f} seconds")\n}\n<\/code><\/pre>\n
The output show it runs ~2.4 seconds.<\/p>\n
lambdaTest: 2.464 seconds\n<\/code><\/pre>\n
Now, it is function reference’s turn.<\/p>\n
fun funRefTest() {\n\n    val viewModel = ViewModel("1")\n\n    val timeMillis = measureTimeMillis {\n        repeat(1_000_000_000) {\n            val screen = Screen(\n                callback = viewModel::screenOnClickDoNothing\n            )\n\n            screen.onClick()\n        }\n    }\n    println("funRefTest: ${timeMillis\/1000f} seconds")\n}\n<\/code><\/pre>\n
The output shows it runs 5.2 seconds.<\/p>\n
funRefTest: 5.225 seconds\n<\/code><\/pre>\n
This concludes that\u00a0lambda runs ~2x faster than function reference. Why? Let’s look at the decompiled code.<\/p>\n
<\/a>Decompiled Code In Java<\/h2>\n
Let’s look at the decompiled code in Java. This is the simplified version without the\u00a0measureTimeMillis<\/code>\u00a0and\u00a0repeat<\/code>\u00a0code.<\/p>\n
lambdaTest()<\/p>\n
public static final void lambdaTest() {\n  final ViewModel viewModel = new ViewModel();\n  Screen screen = new Screen((Function0)(new Function0() {\n\n     public Object invoke() {\n        this.invoke();\n        return Unit.INSTANCE;\n     }\n\n     public final void invoke() {\n        viewModel.screenOnClickDoNothing();\n     }\n  }));\n  screen.onClick();\n}\n<\/code><\/pre>\n
funRefTest()<\/p>\n
public static final void funRefTest() {\n  ViewModel viewModel = new ViewModel();\n  Screen screen = new Screen((Function0)(new Function0(viewModel) {\n\n     public Object invoke() {\n        this.invoke();\n        return Unit.INSTANCE;\n     }\n\n     public final void invoke() {\n        ((ViewModel)this.receiver).screenOnClickDoNothing();\n     }\n  }));\n  screen.onClick();\n}\n<\/code><\/pre>\n
Few important things here:<\/p>\n