@Composable
fun DisplayFoo(
    fooId: String,
    getFoo: suspend (String) -> Foo,
    edit: suspend (…) -> Unit,
)

@Composable
fun DisplayFoo(
    fooId: String,
    getFoo: suspend (String) -> Foo,
    edit: (…) -> Unit,
) {
    var foo by remember { mutableStateOf<Foo?>(null) }
    var refreshCounter by remember { mutableStateOf(0) }

    LaunchedEffect(fooId, refreshCounter) {
        delay(300) // debounce refresh requests in quick succession
        foo = getFoo(fooId)
    }

    foo?.let {
        // let's imagine there's an actual UI here
        // this should probably be another component which takes raw data as input to separate concerns
        Text(foo)
    }

    Button(onClick = {
       edit(…)
       refreshCounter++ // it was edited, please refresh the value
    }) { Text("Edit") }
}

• it knows how to request the full contents

• it knows how to edit the object

getFoo

@Composable
fun DisplayFoo(
    foo: Foo,
    refresh: () -> Unit,
) {
    Text(foo)

    Button(onClick = {
        refresh()
    }) { Text("Edit") }
}

refresh

getFoo

class FooViewModel() : ViewModel() {
    private val _foo = MutableStateFlow<Foo?>(null)
    val foo: StateFlow<Foo?> = _foo

    fun loadFoo(fooId: String) {
        viewModelScope.launch {
            _foo.value = getFoo(fooId)
        }
    }

    fun editFoo(fooId: String) {
        viewModelScope.launch {
            editFoo(fooId)
            _foo.value = getFoo(fooId)
        }
    }
}

@Composable
fun DisplayFoo(fooId: String, viewModel: FooViewModel) {
    val foo by viewModel.foo.collectAsState()

    LaunchedEffect(fooId) {
        viewModel.loadFoo(fooId)
    }

    foo?.let {
        // Display the UI here.
        Text(foo)
    }

    Button(onClick = {
        viewModel.editFoo(fooId)
    }) { 
        Text("Edit") 
    }
}

t's not in your example

remember { FooViewModel() }

You can take Lucas' example, inline the class, and you get my version

main

WeakMap<String, Foo>

getFoo

refreshCounter

Molecule is a library to write business logic in Composable functions and export them as flows to the surrounding non-UI code (e.g. an HTTP backend), it's the exact opposite of the point you're making