class Data(
    val index: Int,
    val dataFlow: StateFlow<String>
)

private val LocalData = compositionLocalOf<Data>{ error("Missing local data") }


@Composable
fun DataView(){
    val data = LocalData.current
    val text by data.dataFlow.collectAsState()

    println("Displaying $text for index ${data.index}")
    Text(text)
}

fun main(){
    singleWindowApplication(
        state = WindowState(
            width = 800.dp,
            height = 800.dp,
        )
    ) {
        Column {
            var data: Data by remember { mutableStateOf(Data(1, MutableStateFlow("Hello"))) }
            CompositionLocalProvider(LocalData provides data){
                DataView()
            }
            Button(
                onClick = {
                    data = Data(2, MutableStateFlow("World"))
                }
            ){
                Text("Click me")
            }
        }
    }
}

Displaying Hello for index 1
Displaying Hello for index 2
Displaying World for index 2

Data

dataFlow

class Data(
    val index: Int,
    val dataFlow: StateFlow<String>
)

@Composable
fun DataView(data: Data){
    val text by data.dataFlow.collectAsState()

    println("Displaying $text for index ${data.index}")
    Text(text)
}

fun main(){
    singleWindowApplication(
        state = WindowState(
            width = 800.dp,
            height = 800.dp,
        )
    ) {
        Column {
            var data by remember { mutableStateOf(Data(1, MutableStateFlow("Hello"))) }
            DataView(data)
            Button(
                onClick = {
                    data = Data(2, MutableStateFlow("World"))
                }
            ){
                Text("Click me")
            }
        }
    }
}

produceState

@Composable
fun <T> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    @BuilderInference producer: suspend ProduceStateScope<T>.() -> Unit
): State<T> {
    val result = remember { mutableStateOf(initialValue) }
    LaunchedEffect(key1, key2) {
        ProduceStateScopeImpl(result, coroutineContext).producer()
    }
    return result
}

result

value

LaunchedEffect

@Composable
fun <T> StateFlow<T>.fixedCollectAsState(
    context: CoroutineContext = EmptyCoroutineContext
): State<T> = fixedCollectAsState(value, context)


@Composable
fun <T : R, R> Flow<T>.fixedCollectAsState(
    initial: R,
    context: CoroutineContext = EmptyCoroutineContext
): State<R> = fixedProduceStateForCollect(initial, this, context) {
    if (context == EmptyCoroutineContext) {
        collect { value = it }
    } else withContext(context) {
        collect { value = it }
    }
}


@OptIn(ExperimentalTypeInference::class)
@Composable
fun <T> fixedProduceStateForCollect(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    @BuilderInference producer: suspend MutableState<T>.() -> Unit
): State<T> {
    val result = remember(key1, key2) { mutableStateOf(initialValue) }
    LaunchedEffect(key1, key2){
        result.producer()
    }
    return result
}

collectAsState

fixedCollectAsState

StateFlow

collectAsState

fixedCollectAsState

MutableStateFlow(n).collectAsState().value

n

IllegalStateException

for (index in (0 until people.size)) {
    key(people[index]) {
        val person = people[index].collectAsState().value
        PersonUi(person)
        if (person != null){
            val car = person.car.collectAsState().value
            Text("    ${car.model}")
        }
    }
}

result.value = initialValue

initialValue

context

key

remember

@Composable
inline fun <T> key(
    @Suppress("UNUSED_PARAMETER")
    vararg keys: Any?,
    block: @Composable () -> T
) = block()

inline

key(this) {
    result.value = initialValue
}

result.value = initialValue

this