What is

map

analog for

MutableState

?

Map as in a data structure or map as in a functional map operation?

functional map operation

Any function that performs a computation using a mutableStateOf input will work, no need to create a pipeline of wrappers

class MyViewModel : ViewModel() {
var string by mutableState("1")
val int get() = string.toInt()
}

Like this?

Yep, any reads of

string

are tracked, and the getter reads

string

Really? I thought it works only in composable functions

It's part of a lower level snapshot tracking system than composable functions. If you want to do your own observation of snapshot state in a similar way, see

snapshotFlow {}

I am really surprised that this works with no composable functions. I don't understand how is it even possible.

https://cs.android.com/androidx/platform/frameworks/support/+/androidx-master-dev:compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/snapshots/Snapshot.kt if you'd like to poke around at how it works

This is super interesting, im going to deep dive into it

the other neat thing it gets you is global consistency for thread safety. When you take a snapshot and work within it, even if it changes on another thread you're always working with consistent state from the point when you took that snapshot

@Adam Powell I want to officially declare - you are freaking wizards. I created a bridge property between state property and composable functions using reflection.

class StateHolder {
    var state by mutableStateOf(0)

    var stateBridgeProperty: Int
        get() {
            val clazz = Class.forName("ru.rpuxa.composeexperiments.StateHolder")
            val method = clazz.getMethod("getState")
            val value = method.invoke(this) as Int
            return value
        }
        set(value) {
            val clazz = Class.forName("ru.rpuxa.composeexperiments.StateHolder")
            val method = clazz.declaredMethods.find { it.name == "setState" }!!
            method.invoke(this, value)
        }
}

Then I created two composable functions that just count number of clicks

val first = StateHolder()
val second = StateHolder()

@Composable
fun MyTest() {
    Log.d("MyDebug", "First function recomposed")
    Column {
        Text(text = first.stateBridgeProperty.toString())
        Button(onClick = {
            first.stateBridgeProperty++
        }) {
            Text("++")
        }
    }
}

@Composable
fun MyTest2() {
    Log.d("MyDebug", "Second function recomposed")
    Column {
        Text(text = second.stateBridgeProperty.toString())
        Button(onClick = {
            second.stateBridgeProperty++
        }) {
            Text("++")
        }
    }
}

I have a question - when I click the first button HOW do you understand you need to recompose first function and don't touch second? I understand you see that

first.state

changed but you must have no idea that

first.stateBridgeProperty

connected with

first.state

and therefore you must not know you need to recompose first function.

it's the methods on the

SnapshotMutableState

object that perform the tracking. In the case of your reflection example above, those methods still get called so the tracking still happens: https://cs.android.com/androidx/platform/frameworks/support/+/androidx-master-dev:compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/MutableState.kt;l=293?q=SnapshotMutableState

Hm, I am starting to understand something

The implementation of

snapshotFlow

might be illustrative: https://cs.android.com/androidx/platform/frameworks/support/+/androidx-master-dev:compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/snapshots/SnapshotFlow.kt;l=64

Hi! As I understand, derivedStateOf is what you are looking for.

Not necessarily. derivedStateOf creates an additional caching object that interacts a bit differently with the snapshot system. Usually you don't need it vs the simpler approach of just computing based on state inputs when needed