remember gives a composable function memory.

A value computed by remember will be stored in the composition tree, and only be recomputed if the keys to remember change.

You can think of remember as giving storage for a single object to a function the same way a private val property does in an object.

mutableStateOf creates a MutableState<T> which is an observable state holder built into compose.

interface MutableState<T> : State<T> {

override var value: T

}

Any changes to value will automatically recompose any composable functions that read this state.

You declare a MutableState object in a composable three ways:

*val state = remember { mutableStateOf(default) }
*var value by remember { mutableStateOf(default) }
*val (value, setValue) = remember { mutableStateOf(default) }
When creating State<T> (or other stateful objects) in composition, it‘s important to remember it. Otherwise it will be re-initialized every composition.

MutableState<T> similar to MutableLiveData<T>, but integrated with the compose runtime. Since it‘s observable, it will tell compose whenever it‘s updated so compose can recompose any composables that read it.

Column() {
        var name = remember{ ""}
        Text(text = name)
        TextField(value = name, onValueChange = {name= it})
    }


Column() {
        val name = remember{ mutableStateOf("")}
        Text(text = name.value)
        TextField(value = name.value, onValueChange = {name.value = it})
    }