Jetpack Compose Kotlin 说

Question

I'm passing a lambda to a composable to trigger on Modifier.clickable but the compiler warns that "The expression is unused"

Why would this be happening and how to correct it? Very weird?

Screenshot of compiler warning

@Composable
fun MainScreen(dateVM: DateViewModel = DateViewModel(), dateList: List<DateList>) {

    val dayIndexState = remember {
        mutableStateOf(0)
    }

    Column {
        ShowDateScroll(dateIndex = dayIndexState.value) {
            newDateIndex -> dayIndexState.value = newDateIndex
        }
    }
}

@Composable
fun ShowDateScroll(
    dateIndex: Int,
    dateIndexUpdate: (newIndexState: Int) -> Unit
) {
    LazyRow(
        modifier = Modifier
            .fillMaxWidth()
            .background(Color.LightGray),
        horizontalArrangement = Arrangement.spacedBy(25.dp)
    ) {
        items(items = dateList, itemContent = { dateItem ->
            Column(
                horizontalAlignment = Alignment.CenterHorizontally,
                modifier = Modifier
                    .clickable(
                        role = Role.Button
                    ) {
                        dateIndexUpdate
                    }
            ) {
                Text(
                    text = dateItem.dow
                )
                Text(
                    text = dateItem.day.toString(),
                )
            }
        })
    }
}

Answer 1

the code you passed in the trailing lambda will never execute.

A trailing lambda itself is a function, if you just write down another function name nothing will happen. Compare to:

fun function() {}
fun other() {
  function
}

If you never use the function / invoke it. Thus it is unused.

In order to invoke the code you have different options: Replace the trailing lambda with the function reference

Modifier.clickable(
  role = Role.Button,
  onClick = dateIndexUpdate,
)

Another way is to invoke the function:

Modifier.clickable(
  role = Role.Button,
) {
  dateIndexUpdate()
  /* or */
  dateIndexUpdate.invoke()
}

In your code the second option can be used with clickable because you need to provide the parameter:

Modifier.clickable(
  role = Role.Button,
) {
  dateIndexUpdate(dateIndex)
  /* or */
  dateIndexUpdate.invoke(dateIndex)
}

Not sure if it is the correct index, you need to adjust it for your code.

Answer 2

Because you are just referencing the method. You must invoke it to use it. Like dateIndexUpdate(...) . Add the new index state in the parameter, or whatever your use case is