Side effect is retaining old value from returned composable is this expected? and how to avoid this?

@Composable
fun foo(): Int {
    var counter by mutableStateOf(0)
    LaunchedEffect(Unit) {
        while (true) {
            delay(500)
            counter++
            println("Foo: $counter")
        }
    }
    return counter
}

@Composable
fun bar() {
    val foo = foo()
    LaunchedEffect(Unit) {
        while (true) {
            delay(500)
            println("Bar: $foo")
        }
    }
}

Output in thread, but the the second composable will always returns: "Bar: 0"

I suspect it is related with the key of your

LaunchedEffect

oh your're correct, but why my key need to be changed? If I have long running effect that shouldn't be canceled, it will be canceled when the key change, how to workaround this?

I am not sure what are you trying to achieve, but could you return

State<Int>

from the

foo()

method? Also I would change

bar()

method a bit 🤔

@Composable
fun foo(): State<Int> {
    val counter = remember { mutableStateOf(0) }
    LaunchedEffect(Unit) {
        while (true) {
            delay(500)
            counter.value++
            println("Foo: ${counter.value}")
        }
    }
    return counter
}

@Composable
fun bar() {
    val foo = foo()
    LaunchedEffect(foo) {
        println("Bar: $foo")
    }
}

@Oleksandr Balan does that make a difference? I have this code, where there's 1 flow that listening to user event. When

event.submit

it's running a long running operation. It using

couponState

value which in the long running operation logic. However if I I put that in the key, there's a change that the

submit

coroutines is canceled because the LaunchedEffect is restarted

@Composable
    fun couponStatePresenter(event: Flow<Event>) {
        ...
    }

    @Composable
    override fun present(event: Flow<Event>): UIState {
        ...
        val couponState = couponStatePresenter(couponEvent)

        var submitResult: UIState.SubmitResult by remember { mutableStateOf(UIState.SubmitResult.Idle) }
        LaunchedEffect(Unit) {
            event.collect {
                when (it) {
                    is Event.Submit -> {
                        submitResult = UIState.SubmitResult.Submitting

                        if (!it.forceSubmit) {
                            if (couponState.isValidationFailed) {
                                submitResult = UIState.SubmitResult.RequireUserActionDialog(
                                    "Invalid Coupon",
                                    "Your coupon is invalid, do you want to clear and continue the booking?",
                                    actionPrimary = "YES"
                                )
                                return@collect
                            }
                        }

                        delay(2000) // Pretend API Call
                        submitResult = UIState.SubmitResult.Success
                    }
                    ...
                }
            }
        }
        ...
    }

the flow event should be part of the key as well

@Benoit Quenaudon but it never changes? Sure i think adding it won't hurt. Thanks