@NoLiveLiterals
@Composable
fun DonationForm() {
  var selected by remember { mutableStateOf(values[1]) }
  val coroutineScope = rememberCoroutineScope()
  
  val clientSecret = coroutineScope.async { startDonation(selected.toLong().times(100)) }

Hey guys! How to make

clientSecret

render again everytime

selected

is changed?

selected

gets it's state correctly, but

clientSecret

is being calculated only once (and not recalculating on recomposition)

Hmm, try this?

var clientSecret by remember { mutableStateOf(1L) }
coroutineScope.launch {
  clientSecret = startDonation(selected.toLong().times(100))
}

lol

I'd assume selected.run compiles to the same thing as your first case (run being an inline fun)

I'll try again. My assumption was tthat with

selected.run

I'd trigger recomposition because

selected

would change inside a @Compose function

But run is not "Composable

It isn't, but i'm inside

DonationForm

Then I think my proposed solution is less hacky

what about

derivedState

? Or

remember(selected)

?

Your method works, @Big Chungus

derivedState

updates the calculation if a state used inside the calculation block was changed. alternative using selected as a key for

remember

will result into the same behavior: if the key of remember was changed, the calculation will be executed again. Difference between remember and derivedState is optimization, in

derivedState

the compiler knows, the reason for recalculation was this state change, so it the recalculation can be scheduled right after the change of the state (change, recalculation, recomposing), and not after changing, recomposing and recalculation and recomposing again.

In general you don't want to perform side effects like launching async work directly from compositions. Use effect handlers.