Breaking out event sink handling into helper functions

[Elforama]

I'm looking at ways to reduce the size of the eventSink lambda passed into the state object. In our current codebase (not using compose state management atm) we delegate action handling to a helper function when there is more than a few lines of logic. For certain screens this is very important because they can have 20+ actions resulting in a huge when statement, making things bloated.

when(action) {
  is SomeAction -> handleSomeAction(action)
  v.s.
  is SomeAction -> {
     // lots of state manipulation here
  }
}

Is there a suggested pattern for delegating the handling of an eventsink action to a method? The main issue I'm struggling with is how this new method would read/write state.

@Composable
fun composeState() {
  var count by remember { mutableStateOf(0) }

  when(action) {
    is SomeAction -> handleSomeAction(action)
   
   //  v.s.

    is SomeAction -> {
       count++
       // do something
       if (count == something) {
          count = count + 10
       }
    }
  }

  fun handleSomeAction(action) {
     // i want to update/read `count` but don't have access
  }

}

[stagg]

Think a general first idea might be at reducing the events to match the different states, trying not to have a singular "Event" type (not necessarily the case here). Next would be splitting any larger state up into smaller sub-states and sort of doing the same thing, associating events with the corresponding state.

For a generally large case where you want to mutate a compose state you could encapsulate the method and MutableState together in a new class. Usually there's a few compose states that can get encapsulated together too.

@Composable
fun composeState() {
  val countState = remember { CountState(0) }
  
  when (action) {
    is SomeAction -> {
      countState.handleSomeAction(action)
    }
  }
}

@Stable
class CountState(initial: Int) {

  private val count = mutableStateOf(initial)

  fun count() = count.value

  fun handleSomeAction(action: SomeAction) {
    count.value++
    // do something
    if (count.value == action.something) {
      count.value += 10
    }
  }
}