I apologize if this has been asked already, but wanted to double check here. what are the effective differences between the two (apart from one being a composable function) ?

// Using derivedStateOf
fun nameA(name: String): State<String> {
    return derivedStateOf { "Hello $name" } 
}

// Using rememberUpdatedState
@Composable
fun nameA(name: String): State<String> {
    return rememberUpdatedState("Hello $name")
}

Technically any State implementation can be used outside of the compose world. It’s highly suitable for view models to replace LiveData i believe. By adding a “rememberUpdatedState”, you’re now tying the internally created state object to the composition context so that when configuration changes like rotation happen that require rebuilding the entire view, the state gets remembered and repopulated.

derivedStateOf

only runs the calculation when the states (

name

here) read in the lambda change.

rememberUpdatedState

runs the calculation on every recomposition. Also if you are using

derivedStateOf

in a composable function, you should always

remember

it.

ok. my bad @Albert Chang you are correct.

derivedStateOf

 only runs the calculation when the states (

name

 here) read in the lambda change. 

rememberUpdatedState

 runs the calculation on every recomposition

important distinction 👍🏼 so basically, with usage we’re looking at:

// Using derivedStateOf + usage
@Composable
fun Content(name: String) {
    val greeting by remember { greeting(name) }
    Text(greeting)
}

fun greeting(name: String): State<String> {
    return derivedStateOf { "Hello $name" } 
}

// Using rememberUpdatedState + usage
@Composable
fun Content(name: String) {
    val greeting by greeting(name)
    Text(greeting)
}

@Composable
fun greeting(name: String): State<String> {
    return rememberUpdatedState("Hello $name")
}

Your derivedStateOf example probably doesn't do what you're intending it to do above. derivedStateOf is invalidated when snapshot state it reads is invalidated, and parameters aren't snapshot state.

Oh! I recall reading/watching something that explained how, under the hood, function parameters get treated as snapshot state…is that still true?

now I'm curious where you heard that from, if that were the case we wouldn't need

rememberUpdatedState

🙂

let me try to find that…it could also very well be that i misunderstood whatever it was 🙈