I have a question on state hoisting. With testing ...

# compose

[Thomas]

I have a question on state hoisting. With testing code:

@Composable
fun F() {
    val state = remember { mutableStateOf("Test") }
    A(state)
    B(state.value)
    /* ... */
}

@Composable
fun A(state: State<String>) {
    Text(text = state.value)
}

@Composable
fun B(value: String) {
    Text(text = value)
}

Can we claim that A is always better than B, because when `state`'s value changes B(state.value) causes F to recompose, while A(state) does not cause F to recompose?

Or does it even matter in practice?

[Stylianos Gakis]

If you do end up wanting to defer the read, do fun A(getState: () -> String) instead of passing the State around.
Other than that, if you always do it it's just gonna be clunky in the API and in many cases you won't even get any performance benefit from it.
So I'd say do it only when you know you need it, not always.

[marcinmoskala]

I think it can be said that assuming A and B need this value in a nested composable, then you can assume that A will always be doing less composition than B, so it will be more efficient.

[marcinmoskala]

Using function type () -> String would secure and generalize it, so I agree it would be beneficial.

[Stylianos Gakis]

See previous discussion on this:
https://kotlinlang.slack.com/archives/CJLTWPH7S/p1650315243517129?thread_ts=1650289906.051689&cid=CJLTWPH7S