A modern programming language that makes developers happier.

kotlinlang

<https://developer.android.com/jetpack/androidx/releases/compose-compiler#1.5.0|Compose Compiler 1.5.0 with Kotlin 1.9.0 support is here!>

&gt; • <https://kotlinlang.org/docs/functions.html#named-arguments|Named arguments> for `@Composable` lambda calls have been deprecated. This feature is relying on internal compiler APIs and will not be supported by K2.
WHAAAT? What does this mean exactly? Just that I can't do this?
```val comp = @Composable { a: String -&gt; 
    ....
}```
Or does that mean that I can't even do this?
```@Composable
fun MyComposable(body: @Composable (a: String) -&gt; Unit) {}```
I guess that is the same thing but I use that! :disappointed: That's normal Kotlin feature so this seems like a significant omission.

no, it means that if you have
```@Composable
fun MyComposable(body: @Composable (a: String) -&gt; Unit)```
you can no longer use
```body(a = "")```
but must use the positional
```body("")```
instead. which is normal Kotlin to begin with, `NAMED_ARGUMENTS_NOT_ALLOWED` on all non-composable lambdas

Ah, I see. That's not that bad and thanks for the clarification :sweat_smile: I was panicking a bit

Would be nice if that was supported in Kotlin :grin:

<https://youtrack.jetbrains.com/issue/KT-31345/Support-named-argument-syntax-for-function-types-callable-references>

and even though it would be nice in some use cases, I think it leads to some language design questions that would need to be answered, such as what should
```fun f(a: Int, b: Int)
fun g(b: Int, a: Int)
for (h in listOf(::f, ::g)) {
    h(1, 2)
    h(a = 1, b = 2)```
 do…

I found the content of this link is different when language is not English. When i set Chinese, can not find 1.5.0.

it's not just Chinese, all the translations are several months out of date