api: optimize state property accessor to be inline

Author: Nek-12

benchmarks/src/jvmMain/kotlin/pro/respawn/flowmvi/benchmarks/Main.kt

@@ -0,0 +1,22 @@
+package pro.respawn.flowmvi.benchmarks
+
+import kotlinx.coroutines.awaitCancellation
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.yield
+import pro.respawn.flowmvi.benchmarks.setup.BenchmarkIntent.Increment
+import pro.respawn.flowmvi.benchmarks.setup.optimized.optimizedStore
+
+fun main() = runBlocking {
+    println(ProcessHandle.current().pid())
+    val store = optimizedStore(this)
+    launch {
+        while (isActive) {
+            store.intent(Increment)
+            yield()
+        }
+    }
+    awaitCancellation()
+    Unit
+}

compose/src/commonMain/kotlin/pro/respawn/flowmvi/compose/dsl/ComposeDsl.kt

@@ -18,6 +18,7 @@ import pro.respawn.flowmvi.api.MVIIntent
 import pro.respawn.flowmvi.api.MVIState
 import pro.respawn.flowmvi.api.SubscriberLifecycle
 import pro.respawn.flowmvi.api.SubscriptionMode
+import pro.respawn.flowmvi.dsl.state
 import pro.respawn.flowmvi.dsl.subscribe
 import pro.respawn.flowmvi.util.immediateOrDefault
 import kotlin.jvm.JvmName

core/src/commonMain/kotlin/pro/respawn/flowmvi/StoreImpl.kt

@@ -1,10 +1,13 @@
+@file:OptIn(InternalFlowMVIAPI::class)
+
 package pro.respawn.flowmvi
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.launch
+import pro.respawn.flowmvi.annotation.InternalFlowMVIAPI
 import pro.respawn.flowmvi.annotation.NotIntendedForInheritance
 import pro.respawn.flowmvi.api.ActionProvider
 import pro.respawn.flowmvi.api.ActionReceiver
@@ -105,8 +108,8 @@ internal class StoreImpl<S : MVIState, I : MVIIntent, A : MVIAction>(
     }
 
     // region contract
-    override val state: S by stateModule::state
     override val name by config::name
+    override val states by stateModule::states
     override val actions: Flow<A> by _actions::actions
     override fun send(action: A) = _actions.send(action)
     override suspend fun emit(intent: I) = intents.emit(intent)

core/src/commonMain/kotlin/pro/respawn/flowmvi/annotation/InternalFlowMVIAPI.kt

@@ -1,9 +1,10 @@
 package pro.respawn.flowmvi.annotation
 
 private const val Message = """
-This API is internal to the library.
-Do not use this API directly as public API already exists for the same thing.
-If you have the use-case for this api you can't avoid, please submit an issue.
+This API is internal to the library and is exposed for performance reasons.
+Do NOT use this API directly as public API already exists for the same thing.
+If you have the use-case for this api you can't avoid, please submit an issue BEFORE you use it. 
+This API may be removed, changed or change behavior without prior notice at any moment.
 """
 
 /**

core/src/commonMain/kotlin/pro/respawn/flowmvi/api/ImmediateStateReceiver.kt

@@ -1,19 +1,17 @@
 package pro.respawn.flowmvi.api
 
+import kotlinx.coroutines.flow.StateFlow
+import pro.respawn.flowmvi.annotation.InternalFlowMVIAPI
+
 /**
  * [StateReceiver] version that can only accept immediate state updates. It is recommended to use [StateReceiver] and
  * its methods if possible. See the method docs for details
  */
-public interface ImmediateStateReceiver<S : MVIState> {
+public interface ImmediateStateReceiver<S : MVIState> : StateProvider<S> {
 
     @FlowMVIDSL
     public fun compareAndSet(old: S, new: S): Boolean
 
-    /**
-     * Obtain the current value of state in an unsafe manner.
-     * It is recommended to always use [StateReceiver.withState] or [StateReceiver.updateState] as obtaining this value can lead
-     * to data races when the state transaction changes the value of the state previously obtained.
-     */
-    @DelicateStoreApi
-    public val state: S
+    @InternalFlowMVIAPI
+    override val states: StateFlow<S>
 }

core/src/commonMain/kotlin/pro/respawn/flowmvi/api/ImmutableStore.kt

@@ -2,15 +2,18 @@ package pro.respawn.flowmvi.api
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+import pro.respawn.flowmvi.annotation.InternalFlowMVIAPI
 import pro.respawn.flowmvi.api.lifecycle.ImmutableStoreLifecycle
 import pro.respawn.flowmvi.api.lifecycle.StoreLifecycle
 
 /**
  * A [Store] that does not allow sending intents.
  * @see Store
  */
-public interface ImmutableStore<out S : MVIState, in I : MVIIntent, out A : MVIAction> : ImmutableStoreLifecycle {
+public interface ImmutableStore<out S : MVIState, in I : MVIIntent, out A : MVIAction> :
+    ImmutableStoreLifecycle,
+    StateProvider<S> {
 
     /**
      *  The name of the store. Used for debugging purposes and when storing multiple stores in a collection.
@@ -48,17 +51,8 @@ public interface ImmutableStore<out S : MVIState, in I : MVIIntent, out A : MVIA
      */
     public fun CoroutineScope.subscribe(block: suspend Provider<S, I, A>.() -> Unit): Job
 
-    /**
-     * Obtain the current state in an unsafe manner.
-     * This property is not thread-safe and parallel state updates will introduce a race condition when not
-     * handled properly.
-     * Such race conditions arise when using multiple data streams such as [Flow]s.
-     *
-     * Accessing the state this way will **circumvent ALL plugins**.
-     */
-    @DelicateStoreApi
-    public val state: S
-
+    @InternalFlowMVIAPI
+    override val states: StateFlow<S>
     override fun hashCode(): Int
     override fun equals(other: Any?): Boolean
 }

core/src/commonMain/kotlin/pro/respawn/flowmvi/api/StateProvider.kt

@@ -1,6 +1,5 @@
 package pro.respawn.flowmvi.api
 
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.StateFlow
 
 /**
@@ -10,20 +9,7 @@ import kotlinx.coroutines.flow.StateFlow
 public interface StateProvider<out S : MVIState> {
 
     /**
-     * A flow of  states to be handled by the subscriber.
+     * A flow of  states to be rendered by the subscriber.
      */
     public val states: StateFlow<S>
-
-    /**
-     * Obtain the current state in an unsafe manner.
-     * This property is not thread-safe and parallel state updates will introduce a race condition when not
-     * handled properly.
-     * Such race conditions arise when using multiple data streams such as [Flow]s.
-     *
-     * Accessing and modifying the state this way will **circumvent ALL plugins** and will not make state updates atomic.
-     *
-     * Consider accessing state via [StateReceiver.withState] or [StateReceiver.updateState] instead.
-     */
-    @DelicateStoreApi
-    public val state: S
 }

core/src/commonMain/kotlin/pro/respawn/flowmvi/api/Store.kt

@@ -20,4 +20,5 @@ public interface Store<out S : MVIState, in I : MVIIntent, out A : MVIAction> :
 
     // override with a mutable return type
     override fun start(scope: CoroutineScope): StoreLifecycle
+
 }

core/src/commonMain/kotlin/pro/respawn/flowmvi/dsl/StateDsl.kt

@@ -5,6 +5,7 @@ import pro.respawn.flowmvi.api.FlowMVIDSL
 import pro.respawn.flowmvi.api.ImmediateStateReceiver
 import pro.respawn.flowmvi.api.MVIState
 import pro.respawn.flowmvi.api.PipelineContext
+import pro.respawn.flowmvi.api.StateProvider
 import pro.respawn.flowmvi.api.StateReceiver
 import pro.respawn.flowmvi.api.StoreConfiguration
 import pro.respawn.flowmvi.exceptions.InvalidStateException
@@ -14,6 +15,19 @@ import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 import kotlin.jvm.JvmName
 
+/**
+ * Obtain the current state in an unsafe manner.
+ *
+ * This property is not thread-safe and parallel state updates will introduce a race condition when not
+ * handled properly.
+ * Such race conditions arise when using multiple data streams such as [Flow]s.
+ *
+ * Accessing and modifying the state this way will **circumvent ALL plugins** and will not make state updates atomic.
+ *
+ * Consider accessing state via [StateReceiver.withState] or [StateReceiver.updateState] instead.
+ */
+public inline val <S : MVIState> StateProvider<S>.state get() = states.value
+
 /**
  * A function that obtains current state and updates it atomically (in the thread context), and non-atomically in
  * the coroutine context, which means it can cause races when you want to update states in parallel.

core/src/commonMain/kotlin/pro/respawn/flowmvi/modules/StateModule.kt

@@ -1,33 +1,31 @@
+@file:OptIn(InternalFlowMVIAPI::class)
+
 package pro.respawn.flowmvi.modules
 
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.sync.Mutex
-import pro.respawn.flowmvi.api.DelicateStoreApi
+import pro.respawn.flowmvi.annotation.InternalFlowMVIAPI
 import pro.respawn.flowmvi.api.ImmediateStateReceiver
 import pro.respawn.flowmvi.api.MVIAction
 import pro.respawn.flowmvi.api.MVIIntent
 import pro.respawn.flowmvi.api.MVIState
 import pro.respawn.flowmvi.api.PipelineContext
-import pro.respawn.flowmvi.api.StateProvider
 import pro.respawn.flowmvi.dsl.updateStateImmediate
 import pro.respawn.flowmvi.util.withReentrantLock
 
 internal class StateModule<S : MVIState, I : MVIIntent, A : MVIAction>(
     initial: S,
     atomic: Boolean,
     private val transform: (suspend PipelineContext<S, I, A>.(old: S, new: S) -> S?)?
-) : StateProvider<S>, ImmediateStateReceiver<S> {
+) : ImmediateStateReceiver<S> {
 
     @Suppress("VariableNaming")
     private val _states = MutableStateFlow(initial)
     override val states: StateFlow<S> = _states.asStateFlow()
     private val mutex = if (atomic) Mutex() else null
 
-    @DelicateStoreApi
-    override val state: S by states::value
-
     override fun compareAndSet(expect: S, new: S) = _states.compareAndSet(expect, new)
 
     suspend inline fun withState(

core/src/jvmTest/kotlin/pro/respawn/flowmvi/test/store/StoreStatesTest.kt

@@ -7,6 +7,7 @@ import kotlinx.coroutines.awaitCancellation
 import pro.respawn.flowmvi.dsl.LambdaIntent
 import pro.respawn.flowmvi.dsl.intent
 import pro.respawn.flowmvi.dsl.send
+import pro.respawn.flowmvi.dsl.state
 import pro.respawn.flowmvi.dsl.updateStateImmediate
 import pro.respawn.flowmvi.test.subscribeAndTest
 import pro.respawn.flowmvi.util.TestAction

test/src/commonMain/kotlin/pro/respawn/flowmvi/test/StoreTestScope.kt

@@ -1,8 +1,9 @@
 package pro.respawn.flowmvi.test
 
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.withTimeout
-import pro.respawn.flowmvi.api.DelicateStoreApi
+import pro.respawn.flowmvi.annotation.InternalFlowMVIAPI
 import pro.respawn.flowmvi.api.MVIAction
 import pro.respawn.flowmvi.api.MVIIntent
 import pro.respawn.flowmvi.api.MVIState
@@ -14,14 +15,14 @@ import kotlin.test.assertIs
 /**
  * A class which implements a dsl for testing [Store].
  */
+@OptIn(InternalFlowMVIAPI::class)
 public class StoreTestScope<S : MVIState, I : MVIIntent, A : MVIAction> @PublishedApi internal constructor(
     public val provider: Provider<S, I, A>,
     public val store: Store<S, I, A>,
     public val timeoutMs: Long = 3000L,
 ) : Store<S, I, A> by store, Provider<S, I, A> by provider {
 
-    @OptIn(DelicateStoreApi::class)
-    override val state: S by store::state
+    override val states: StateFlow<S> by provider::states
     override fun hashCode(): Int = store.hashCode()
     override fun equals(other: Any?): Boolean = store == other
     override suspend fun emit(intent: I): Unit = store.emit(intent)

test/src/commonMain/kotlin/pro/respawn/flowmvi/test/plugin/TestPipelineContext.kt

@@ -4,8 +4,12 @@ package pro.respawn.flowmvi.test.plugin
 
 import kotlinx.atomicfu.atomic
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
 import pro.respawn.flowmvi.annotation.ExperimentalFlowMVIAPI
+import pro.respawn.flowmvi.annotation.InternalFlowMVIAPI
 import pro.respawn.flowmvi.annotation.NotIntendedForInheritance
 import pro.respawn.flowmvi.api.DelicateStoreApi
 import pro.respawn.flowmvi.api.MVIAction
@@ -15,21 +19,21 @@ import pro.respawn.flowmvi.api.PipelineContext
 import pro.respawn.flowmvi.api.StoreConfiguration
 import pro.respawn.flowmvi.api.StorePlugin
 import pro.respawn.flowmvi.api.lifecycle.StoreLifecycle
+import pro.respawn.flowmvi.dsl.state
 import pro.respawn.flowmvi.dsl.updateStateImmediate
 import pro.respawn.flowmvi.test.TestStoreLifecycle
 import pro.respawn.flowmvi.test.ensureStarted
 
-@OptIn(ExperimentalFlowMVIAPI::class, NotIntendedForInheritance::class)
+@OptIn(ExperimentalFlowMVIAPI::class, NotIntendedForInheritance::class, InternalFlowMVIAPI::class)
 internal class TestPipelineContext<S : MVIState, I : MVIIntent, A : MVIAction> @PublishedApi internal constructor(
     override val config: StoreConfiguration<S>,
     val plugin: StorePlugin<S, I, A>,
 ) : PipelineContext<S, I, A>, StoreLifecycle by TestStoreLifecycle(config.coroutineContext[Job]) {
 
     override val coroutineContext by config::coroutineContext
 
-    private var _state = atomic(config.initial)
-    override val state by _state::value
-
+    private val _state = MutableStateFlow(config.initial)
+    override val states: StateFlow<S> = _state.asStateFlow()
     override fun compareAndSet(old: S, new: S): Boolean = _state.compareAndSet(old, new)
 
     @DelicateStoreApi
@@ -54,7 +58,7 @@ internal class TestPipelineContext<S : MVIState, I : MVIIntent, A : MVIAction> @
 
     override suspend fun updateState(transform: suspend S.() -> S) = with(plugin) {
         ensureStarted()
-        updateStateImmediate { onState(state, state.transform()) ?: this }
+        updateStateImmediate { onState(this, transform()) ?: this }
     }
 
     override suspend fun withState(block: suspend S.() -> Unit) {