`flow collectAsState initialState ` requires an initial stat

Question

`flow collectAsState initialState ` requires an initial state when not using a `StateFlow lt T gt ` How can we avoid having this initial state For example I would like to have a composable not be considered ready until the `Flow lt T gt ` emits By ready I mean shown to the user Is something like this possible The idea would be something like `fragment postponeEnterTransition ` <https developer android com reference androidx fragment app Fragment postponeEnterTransition |link> which allows the `Fragment` to asynchronously load its data before appearing to the user This way an initial state would not need to be provided and only fully loaded data need be displayed

zak.taccardi · Answer

this would allow Compose to avoid displaying a bad loading state where an old screen continues to be shown until the new screen is ready and loaded <https reactjs org docs concurrent mode intro html intentional loading sequences>

dimsuz · Answer

can t you make a composable which renders your no state state Like an empty `Surface` or something like this

zak.taccardi · Answer

the idea is that I would actually want to avoid even showing the no state state at all

dimsuz · Answer

but what would you show I mean that screen is always in some state so no state is a state Or perhaps I misunderstood your case

zak.taccardi · Answer

like I would want to show `ComposableA` while `ComposableB` is still in its no state loading state

dimsuz · Answer

Ah I see Maybe something like ```flow collectAsState Optional None filter it is None ``` but this can probably be considered a work around slightly smiling face

zak.taccardi · Answer

well it s Kotlin so we can use nulls

zak.taccardi · Answer

but I don t want to deal with `State lt T gt ` at all just `State lt T gt `

dimsuz · Answer

in Rx we have ` filterSome` which works like this ```myStream Observable lt Optional lt T gt gt filterSome Observable lt T gt map value T gt do something ``` So `filterSome` does the necessary casting inside Perhaps something like this can be done here

Adam Powell · Answer

`val thing = flow observeAsState null value return`

Adam Powell · Answer

we ve had a bunch of discussions around what it might mean to allow a ` Composable suspend fun` and what kinds of fallback display constructs that might entail if it suspends rather than completes but any of that is going to be post 1 0 stuff

Adam Powell · Answer

you might be able to have some fun with a ```flow lt Composable gt Unit gt ``` and ```flow observeAsState Fallback value ```

Halil Ozercan · Answer

I kinda understand the point of always requiring an initial state but what annoyed me was mapping a `StateFlow` to another `Flow` Since it becomes a regular `Flow` `collectAsState` expects an initial state but in reality it already has an initial state

Adam Powell · Answer

There s a StateFlow implementation that omits that initial parameter already <https cs android com androidx platform frameworks support + androidx master dev compose runtime runtime src commonMain kotlin androidx compose runtime FlowAdapter kt l=40 q=FlowAdapter>

Halil Ozercan · Answer

``` Composable inline fun lt T R gt StateFlow lt T gt collectMap context CoroutineContext = Dispatchers Main crossinline block T gt R State lt R gt = map it block collectAsState value block context ``` This was what I had come up with smile looks similar

zak.taccardi · Answer

< Adam Powell> what happens if you `return` out of a composeable before rendering anything

Adam Powell · Answer

nothing special it simply doesn t emit any UI

Adam Powell · Answer

< Halil Ozercan> be careful with that it s missing a `remember` slightly smiling face

Adam Powell · Answer

assembling flow or rx operator chains in a composable function gets a little bit fun doing it correctly for the above looks like ```remember this map it block collectAsState ```

Adam Powell · Answer

otherwise you get a new instance of the operator chain each time you recompose which means ` collectAsState` will cancel the old collection and launch a new one

Ricardo C. · Answer

gt There s a StateFlow implementation that omits that initial parameter already we need this on Flow though It s very easy to land on Flow after applying some operators to StateFlow And I m also not sure if we should be exposing StateFlow instead of Flow as it kinda seems we re leaking implementation details

Adam Powell · Answer

There is no initial value to use on `Flow` slightly smiling face we can t know it will emit without suspending until we try it and beginning collection is a side effect that happens deferred once a composition lands not synchronously

gildor · Answer

It s fine to expose StateFlow because it has different contract comparing to Flow it provides value also it read only So works perfectly for cases flow with default value such as this one

Halil Ozercan · Answer

Sorry if this is poking an already closed thread but it s still hard for me to getting used to this approach ```remember commentsViewModel isCommentHidden comment id collectAsState initial = false ``` Although I understand how remember works and its general functionality in composables I feel like subscribing to a flow shouldn t require me to be careful about that this call ` collect` will be re executed in case of recomposition Is there any plan in the future like introducing a new API for flow subscriptions without a need for `remember`

Adam Powell · Answer

the subscriptions don t need `remember` the assembly does

Adam Powell · Answer

and perhaps making things worse for your example the code there likely isn t correct you need a key to tell remember when to recalculate

Adam Powell · Answer

it s likely to be something more like ```remember commentsViewModel comment id commentsViewModel isCommentHidden comment id collectAsState initial = false ```

Adam Powell · Answer

to your point though yes I ve been playing with some related API shapes that would make assembly+collection at the same call site a bit less unsightly

Adam Powell · Answer

it would look more like ```val current by produceState initial = false commentsViewModel comment id commentsViewModel isCommentHidden comment id collect setValue it ```

Adam Powell · Answer

more generalized assemble the flow outside of composition in a suspending block where you also collect it instead and as a result you re on the other side of what compose

Adam Powell · Answer

but you lose the snazzy one liner and it still doesn t solve the case where someone calls ```MyComposable flow map thing it ``` instead of ```MyComposable remember flow flow map thing it ```

Adam Powell · Answer

some other things can help out a bit in that area as well though for example something like ```flow rememberLet it map thing it collectAsState initial ```

Adam Powell · Answer

which helps in not breaking the fluent chain

Adam Powell · Answer

but since your viewmodel example calls a function that returns a flow presumably a new instance each time both the viewmodel and the comment id are probably required as remember keys

Halil Ozercan · Answer

```flow rememberLet it map thing it collectAsState initial ``` This looks way more fluent and recognizable My example resides in an item view keyed of a list so I didn t think I needed to use viewModel instance and id as arguments to remember I m not sure how `LazyFor` operates but if my first item gets deleted would the first composable gets recomposed with second item s properties or does it just leave the UI If former is the case remember should definitely receive those arguments

Adam Powell · Answer

The lazy UI composables all internally use a `key` so individual items won t get recomposed for content with a different identity Sometimes you can situationally omit these things when using remember if you know exactly how they ll be used but it s a potential surprise for later if you use them elsewhere and those assumptions no longer hold