Adding support for atomic updates for two or more state field updates

[PatilShreyas]

Currently, the code generated by Mutekt looks like this.

As of v1.0.0-alpha02, it doesn't support atomic or transactional updates with two or more state fields. In this open discussion, we'll try to finalise an approach for supporting it (from issue #9).

So if model looks like this

interface ExampleState {
    val field1: Boolean
    val field2: String
    val field3: Int
}

The mutable model can have a method like follows:

public interface MutableExampleState : ExampleState, StateFlowable<ExampleState> {
    // Override fields

    fun update(mutate: MutableExampleState.() -> Unit)
}

Implementation of the mutable model interface can have the following changes:

private class MutableExampleStateImpl(
    field1: Boolean,
    field2: String,
    field3: Int,
) : MutableExampleState {
    // 🔴 1. To track transaction status of transaction with reactivity
    private val transactionInProgress = MutableStateFlow<Boolean>(false)
    //...

    // 🔴 2. Implement function to update states in transaction
    override fun update(mutate: MutableExampleState.() -> Unit) {
        while (true) {
            // If other transaction is started in between, wait for its completion and
            // then only proceed for the current.
            if (transactionInProgress.compareAndSet(expect = false, update = true)) {
                mutate()
                transactionInProgress.update { false }
                return
            }
        }
    }

    private val _immutableStateFlowImpl : StateFlow<ExampleState> = object : StateFlow<ExampleState> {
        public override val `value`: ExampleState
            get() = ImmutableExampleState(
                field1 = _field1.value,
                field2 = _field2.value,
                field3 = _field3.value,
            )
        
        // 🔴 3. Change the implementation of collect and take care of collection while in transaction
        public override suspend fun collect(collector: FlowCollector<ExampleState>): Nothing = coroutineScope {
            combine(transactionInProgress, _field1, _field2, _field3) { params ->
                val isTransactionRunning = params[0] as Boolean
                if (!isTransactionRunning) {
                    value
                } else {
                    null
                }
            }.filterNotNull().stateIn(this).collect(collector)
         }
    }

Example of updating values atomically:

val _state = MutableExampleState(false, "String", 0)

// 🔴 4. Use this method only to update values in transaction
_state.update {
    field1 = false
    field2 = "Example"
    field3 = 100
}

Explanation of these changes:

1. Create a MutableStateFlow to track the transaction's status to update the state fields with reactivity.
2. Implement a method to update fields atomically which makes sets the transaction flow's value to true, then executes the lambda block in which developers can mutate the fields and then finally finishes the transaction flow by setting the value to `false.
3. In the collect{} of StateFlow's implementation, listen to transactionInProgress as well. If the transaction is currently in progress and if we receive any state field changes, simply return a null. Else, emits value (which is implemented for calculating value on demand). Here, we are not creating an instance of state using fields which are passed in the combine(). Finally, filtering non-null values.
4. Use the method update{} of the model to update fields in a transaction which will trigger only single emission of state despite different CoroutineDispatcher behaviours.

Question for discussion:

1. Till the transaction is going on, the collector is blocked (because of null value filtration). Should we block StateFlow collector?
2. How failure should be handled if anything goes wrong in the lambda of update{}? How to rollback? Or do we even need to care of this?

[CherryPerry]

What do you think about changing the whole approach and have only one MutableStateFlow with the final value only? So you can avoid all these workarounds.

class StateImpl(val someProperty: Int): MutableState {

  // TODO hide me with just StateFlow
  val state = MutableStateFlow<State>(ImmutableState(someProperty))

  var someProperty: Int
    get() = state.value.someProperty
    set(value) { state.update { it.copy(someProperty = value) } }

  fun update(mutate: MutableState.() -> Unit) {
     state.update { currentState ->
         val changeTracker = object: MutableState {
             // just keep track of updated properties and then combine them with currentState
             var someProperty: Int = currentState.someProperty
         }
         mutate(changeTracker)
         ImmutableState(changeTracker.someProperty) // keeps the current value or update with a new value
     }
  }

}

I think it should be fairly easy to generate proper copy(...) methods and changeTracker for all properties.

[PatilShreyas]

For simply copying mechanism, I would encourage devs not to use this library since it can be easily implemented without the help of this library.

[PatilShreyas]

This approach has been released in v1.0.0-alpha03