A modern programming language that makes developers happier.

kotlinlang

In my ViewModel, when an event listener is triggered: `onUserSelect(userId: Int)`  I want it to offer an event to a broadcastchannel named `userSelectEvents: BroadCastChannel&lt;UserSelectEvent&gt;`. The flow `selectedUsers` should depend on this, so I'm probably looking to some kind of building a reducer. This is my idea, is it good?

sounds fine, this is a super common pattern

So let's say we have the following:
```class ViewModel {
    val selectedUserIds: Flow&lt;List&lt;Int&gt;&gt; = ...
    fun onUserSelect(userId: Int) {
        ...
    }
}```
How would you implement this?

What’s the relationship between `onUserSelect` and the lists emitted from `selectedUserIds`? Do newly-selected IDs just get appended to the list?

you’d probably want a `ConflatedBroadcastChannel`, since it lets you access the current value (`value` property). Then you can just get the current list, append, and offer the new list.

Ah didn't see the value property. But wouldn't it be cleaner and more declarative if the onUserSelect method did something like selectUserEvents.offer(Event(id)).
Then: `selectedUserIds = selectUserEvents.map { userEventsToSelectedUserIds(it)  } 

what does `userEventsToSelectedUserIds` do? how are you accumulating the list of user IDs?

Nevermind that, your first suggestion does the trick well.

Let's say we now have a `onSaveButtonClick()` method that sends a network call with the `selectedUserIds` . Should I get it's value by using the `.value` of the `ConflatedBroadcastChannel` or should I launch a coroutine and call `.collect` on the `Flow`?

Is this method also in your ViewModel? If so then using the value property would be the most straightforward and communicate your intent clearly. If not, you can get the latest value using `selectedUserIds.first()`.

Given the following:
```private val _selectedUserIds = ConflatedBroadcastChannel&lt;List&lt;Int&gt;&gt;(emptyList())
private val selectedUserIds: Flow&lt;List&lt;Int&gt;&gt; = _selectedUserIds.asFlow()```
A `onSaveButtonClick()` method should send a network call with the value of selectedUserIds
Should I get it's value by using the `.value` of the `ConflatedBroadcastChannel` or should I launch a coroutine and call `.collect()` on the `Flow`? What's the difference?

Allright, didn't know the .first() method on Flow

Wouldn't it make more sense to be named as `.last()`, since it represents the last emitted value?

```/**
 * The terminal operator that returns the first element emitted by the flow and then cancels flow's collection.
 * Throws [NoSuchElementException] if the flow was empty.
 */
public suspend fun &lt;T&gt; Flow&lt;T&gt;.first(): T {```

The doc states here that it returns the first emitted element.