remember { mutableStateOf() } – A cheat sheet

If I make an interface of val properties, and implement it with a class that delegates these to a Compose State/MutableState, I'll not get the observability for Composable functions because, and the only way through is to expose State<T> instead of T, right?

So what actually happens when the following code is executed:

var text by remember { mutableStateOf("") }

1) A new object of the type MutableState<String> is created. This object holds the value (in our case empty string). And whenever the value changes, MutableState tells Android to recompose the UI.
2) Thanks to remember, the object of the MutableState is cashed and therefore will not get recreated every recomposition.
3) by tells the compiler to "link" var text with the value that the MutableState object holds. Whenever our text is updated, that value will be updated either automatically.

🙏 Correct me if I'm wrong

There's also this form.

@Composable
fun MyField() {
    val (text, setText) = remember { mutableStateOf("") }
    TextField(text, setText)
}

It really makes me wish they'd have an overload which just takes MutableState<String> so that I can just pass the state object itself, or some kind of adapter.

For whatever reason, Jetpack Compose seem to really love passing the value and the way to update the value as two different thingies, when they could have been bundled together as a single concept.

"remembered values can be notified when they enter and leave a composition": can you give a pointer what you are referring to?