tunjid · tunjid · Feb 13, 2024 · Feb 13, 2024 · Feb 13, 2024 · Feb 13, 2024
diff --git a/...com/tunjid/mutator/ActionStateProducer.kt → ...Main/kotlin/com/tunjid/mutator/Mutator.kt b/...com/tunjid/mutator/ActionStateProducer.kt → ...Main/kotlin/com/tunjid/mutator/Mutator.kt
@@ -38,17 +38,17 @@ interface ActionStateProducer<Action : Any, State : Any> : StateProducer<State>
 /**
  * Syntactic sugar for creating a [Mutation]
  */
-inline fun <State> mutation(noinline mutation: State.() -> State): Mutation<State> = mutation
+inline fun <State> mutationOf(noinline mutation: State.() -> State): Mutation<State> = mutation
 
 /**
  * Identity [Mutation] function; semantically a no op [Mutation]
  */
-fun <State : Any> identity(): Mutation<State> = mutation { this }
+fun <State : Any> identity(): Mutation<State> = mutationOf { this }
 
 /**
  * Combines two [Mutation] instances into a single [Mutation]
  */
-operator fun <T : Any> Mutation<T>.plus(other: Mutation<T>) = mutation<T> inner@{
+operator fun <T : Any> Mutation<T>.plus(other: Mutation<T>) = mutationOf<T> inner@{
     val result = this@plus(this@inner)
     other.invoke(result)
 }
diff --git a/coroutines/src/commonMain/kotlin/com/tunjid/mutator/coroutines/ActionStateFlowProducer.kt b/coroutines/src/commonMain/kotlin/com/tunjid/mutator/coroutines/ActionStateFlowProducer.kt
@@ -51,14 +51,14 @@ typealias SuspendingStateHolder<State> = StateHolder<suspend () -> State>
 fun <Action : Any, State : Any> CoroutineScope.actionStateFlowProducer(
     initialState: State,
     started: SharingStarted = SharingStarted.WhileSubscribed(DEFAULT_STOP_TIMEOUT_MILLIS),
-    mutationFlows: List<Flow<Mutation<State>>> = listOf(),
+    inputs: List<Flow<Mutation<State>>> = listOf(),
     stateTransform: (Flow<State>) -> Flow<State> = { it },
     actionTransform: SuspendingStateHolder<State>.(Flow<Action>) -> Flow<Mutation<State>> = { emptyFlow() }
 ): ActionStateProducer<Action, StateFlow<State>> = ActionStateFlowProducer(
     coroutineScope = this,
     initialState = initialState,
     started = started,
-    mutationFlows = mutationFlows,
+    inputs = inputs,
     stateTransform = stateTransform,
     actionTransform = actionTransform
 )
@@ -67,7 +67,7 @@ private class ActionStateFlowProducer<Action : Any, State : Any>(
     coroutineScope: CoroutineScope,
     initialState: State,
     started: SharingStarted,
-    mutationFlows: List<Flow<Mutation<State>>>,
+    inputs: List<Flow<Mutation<State>>>,
     stateTransform: (Flow<State>) -> Flow<State> = { it },
     actionTransform: SuspendingStateHolder<State>.(Flow<Action>) -> Flow<Mutation<State>>
 ) : ActionStateProducer<Action, StateFlow<State>>,
@@ -86,7 +86,7 @@ private class ActionStateFlowProducer<Action : Any, State : Any>(
             initialState = initialState,
             started = started,
             stateTransform = stateTransform,
-            mutationFlows = mutationFlows + actionTransform(stateReader, actions.receiveAsFlow())
+            inputs = inputs + actionTransform(stateReader, actions.receiveAsFlow())
         )
 
     override val accept: (Action) -> Unit = { action ->

diff --git a/coroutines/src/commonMain/kotlin/com/tunjid/mutator/coroutines/FlowMutationExt.kt b/coroutines/src/commonMain/kotlin/com/tunjid/mutator/coroutines/FlowMutationExt.kt
@@ -17,7 +17,7 @@
 package com.tunjid.mutator.coroutines
 
 import com.tunjid.mutator.Mutation
-import com.tunjid.mutator.mutation
+import com.tunjid.mutator.mutationOf
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.FlowCollector
 import kotlinx.coroutines.flow.flatMapConcat
@@ -33,7 +33,7 @@ import kotlinx.coroutines.flow.mapLatest
 inline fun <T, State> Flow<T>.mapToMutation(
     crossinline mapper: State.(T) -> State
 ): Flow<Mutation<State>> =
-    map { mutation { mapper(it) } }
+    map { mutationOf { mapper(it) } }
 
 /**
  * Maps the latest emission of [T] into a single mutation of [State]
@@ -42,7 +42,7 @@ inline fun <T, State> Flow<T>.mapToMutation(
 inline fun <T, State> Flow<T>.mapLatestToMutation(
     crossinline mapper: State.(T) -> State
 ): Flow<Mutation<State>> =
-    mapLatest { mutation { mapper(it) } }
+    mapLatest { mutationOf { mapper(it) } }
 
 /**
  * Maps each emission of [T] into multiple mutations of [State]

diff --git a/coroutines/src/commonMain/kotlin/com/tunjid/mutator/coroutines/StateFlowProducer.kt b/coroutines/src/commonMain/kotlin/com/tunjid/mutator/coroutines/StateFlowProducer.kt
@@ -33,12 +33,12 @@ import kotlinx.coroutines.launch
 fun <State : Any> CoroutineScope.stateFlowProducer(
     initialState: State,
     started: SharingStarted = SharingStarted.WhileSubscribed(),
-    mutationFlows: List<Flow<Mutation<State>>>
+    inputs: List<Flow<Mutation<State>>>
 ) = StateFlowProducer(
     scope = this,
     initialState = initialState,
     started = started,
-    mutationFlows = mutationFlows
+    inputs = inputs
 )
 
 /**
@@ -48,14 +48,14 @@ class StateFlowProducer<State : Any> internal constructor(
     private val scope: CoroutineScope,
     initialState: State,
     started: SharingStarted = SharingStarted.WhileSubscribed(),
-    mutationFlows: List<Flow<Mutation<State>>>
+    inputs: List<Flow<Mutation<State>>>
 ) : StateProducer<StateFlow<State>> {
     private val parallelExecutedTasks = MutableSharedFlow<Flow<Mutation<State>>>()
 
     override val state = scope.produceState(
         initialState = initialState,
         started = started,
-        mutationFlows = mutationFlows + parallelExecutedTasks.flatMapMerge(
+        inputs = inputs + parallelExecutedTasks.flatMapMerge(
             concurrency = Int.MAX_VALUE,
             transform = { it }
         )

diff --git a/coroutines/src/commonMain/kotlin/com/tunjid/mutator/coroutines/StateProduction.kt b/coroutines/src/commonMain/kotlin/com/tunjid/mutator/coroutines/StateProduction.kt
@@ -31,14 +31,14 @@ import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 
 /**
- * Produces a [StateFlow] by merging [mutationFlows] and reducing them into an
+ * Produces a [StateFlow] by merging [inputs] and reducing them into an
  * [initialState] state within [this] [CoroutineScope]
  */
 fun <State : Any> CoroutineScope.produceState(
     initialState: State,
     started: SharingStarted,
     stateTransform: (Flow<State>) -> Flow<State> = { it },
-    mutationFlows: List<Flow<Mutation<State>>>
+    inputs: List<Flow<Mutation<State>>>
 ): StateFlow<State> {
     // Set the seed for the state
     var seed = initialState
@@ -47,7 +47,7 @@ fun <State : Any> CoroutineScope.produceState(
     return stateTransform(
         flow {
             emitAll(
-                merge(*mutationFlows.toTypedArray())
+                merge(*inputs.toTypedArray())
                     // Reduce into the seed so if resubscribed, the last value of state is persisted
                     // when the flow pipeline is started again
                     .reduceInto(seed)

diff --git a/coroutines/src/commonTest/kotlin/com/tunjid/mutator/coroutines/FlowMutationStreamKtTest.kt b/coroutines/src/commonTest/kotlin/com/tunjid/mutator/coroutines/FlowMutationStreamKtTest.kt
@@ -16,7 +16,7 @@
 
 package com.tunjid.mutator.coroutines
 
-import com.tunjid.mutator.mutation
+import com.tunjid.mutator.mutationOf
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.asFlow
@@ -210,14 +210,14 @@ class FlowMutationStreamKtTest {
                 when (val type = type()) {
                     is Split.Action.Regular -> type.flow
                         .map {
-                            mutation { copy(regularCount = regularCount + 1) }
+                            mutationOf { copy(regularCount = regularCount + 1) }
                         }
 
                     is Split.Action.Delayed -> type.flow
                         .map {
                             // Delay when processing this action
                             delay(1000)
-                            mutation { copy(delayedCount = delayedCount + 1) }
+                            mutationOf { copy(delayedCount = delayedCount + 1) }
                         }
                 }
             }

diff --git a/coroutines/src/commonTest/kotlin/com/tunjid/mutator/coroutines/State.kt b/coroutines/src/commonTest/kotlin/com/tunjid/mutator/coroutines/State.kt
@@ -17,7 +17,7 @@
 package com.tunjid.mutator.coroutines
 
 import com.tunjid.mutator.Mutation
-import com.tunjid.mutator.mutation
+import com.tunjid.mutator.mutationOf
 
 data class State(
     val count: Double = 0.0
@@ -41,8 +41,8 @@ sealed class DoubleAction : Action() {
 
 val Action.mutation: Mutation<State>
     get() = when (this) {
-        is IntAction.Add -> mutation { copy(count = count + value) }
-        is IntAction.Subtract -> mutation { copy(count = count - value) }
-        is DoubleAction.Divide -> mutation { copy(count = count / value) }
-        is DoubleAction.Multiply -> mutation { copy(count = count * value) }
+        is IntAction.Add -> mutationOf { copy(count = count + value) }
+        is IntAction.Subtract -> mutationOf { copy(count = count - value) }
+        is DoubleAction.Divide -> mutationOf { copy(count = count / value) }
+        is DoubleAction.Multiply -> mutationOf { copy(count = count * value) }
     }
diff --git a/coroutines/src/commonTest/kotlin/com/tunjid/mutator/coroutines/StateProductionKtTest.kt b/coroutines/src/commonTest/kotlin/com/tunjid/mutator/coroutines/StateProductionKtTest.kt
@@ -18,7 +18,7 @@ package com.tunjid.mutator.coroutines
 
 import app.cash.turbine.test
 import com.tunjid.mutator.Mutation
-import com.tunjid.mutator.mutation
+import com.tunjid.mutator.mutationOf
 import com.tunjid.mutator.plus
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -60,7 +60,7 @@ class StateProductionKtTest {
         val state = scope.produceState(
             initialState = State(),
             started = SharingStarted.WhileSubscribed(),
-            mutationFlows = listOf(
+            inputs = listOf(
                 eventMutations
             )
         )
@@ -79,7 +79,7 @@ class StateProductionKtTest {
         val state = scope.produceState(
             initialState = State(),
             started = SharingStarted.WhileSubscribed(),
-            mutationFlows = listOf(
+            inputs = listOf(
                 eventMutations
             )
         )
@@ -105,14 +105,14 @@ class StateProductionKtTest {
         val state = scope.produceState(
             initialState = State(),
             started = SharingStarted.WhileSubscribed(),
-            mutationFlows = listOf(
+            inputs = listOf(
                 eventMutations,
                 flow {
                     delay(1000)
-                    emit(mutation { copy(count = 3.0) })
+                    emit(mutationOf { copy(count = 3.0) })
 
                     delay(1000)
-                    emit(mutation { copy(count = 7.0) })
+                    emit(mutationOf { copy(count = 7.0) })
                 }
             )
         )
@@ -135,13 +135,13 @@ class StateProductionKtTest {
 
     @Test
     fun test_state_change_addition() {
-        val additionMutation = mutation<State> {
+        val additionMutation = mutationOf<State> {
             copy(count = count + 1)
         } +
-                mutation {
+                mutationOf {
                     copy(count = count + 1)
                 } +
-                mutation {
+                mutationOf {
                     copy(count = count + 1)
                 }
 

diff --git a/demo/src/commonMain/kotlin/com/tunjid/mutator/demo/snails/Snail10.kt b/demo/src/commonMain/kotlin/com/tunjid/mutator/demo/snails/Snail10.kt
@@ -36,7 +36,7 @@ import com.tunjid.mutator.demo.udfvisualizer.Event
 import com.tunjid.mutator.demo.udfvisualizer.Marble
 import com.tunjid.mutator.demo.udfvisualizer.UDFVisualizer
 import com.tunjid.mutator.demo.udfvisualizer.udfVisualizerStateHolder
-import com.tunjid.mutator.mutation
+import com.tunjid.mutator.mutationOf
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.currentCoroutineContext
@@ -70,16 +70,16 @@ class Snail10StateHolder(
     private val speed: Flow<Speed> = scope.speedFlow()
 
     private val speedChanges: Flow<Mutation<Snail10State>> = speed
-        .map { mutation { copy(speed = it) } }
+        .map { mutationOf { copy(speed = it) } }
 
     private val progressChanges: Flow<Mutation<Snail10State>> = speed
         .toInterval()
-        .map { mutation { copy(progress = (progress + 1) % 100) } }
+        .map { mutationOf { copy(progress = (progress + 1) % 100) } }
 
     private val stateProducer = scope.stateFlowProducer(
         initialState = Snail10State(),
         started = SharingStarted.WhileSubscribed(),
-        mutationFlows = listOf(
+        inputs = listOf(
             speedChanges,
             progressChanges,
         )

diff --git a/demo/src/commonMain/kotlin/com/tunjid/mutator/demo/snails/Snail11.kt b/demo/src/commonMain/kotlin/com/tunjid/mutator/demo/snails/Snail11.kt
@@ -37,7 +37,7 @@ import com.tunjid.mutator.demo.udfvisualizer.Marble
 import com.tunjid.mutator.demo.udfvisualizer.Event
 import com.tunjid.mutator.demo.udfvisualizer.UDFVisualizer
 import com.tunjid.mutator.demo.udfvisualizer.udfVisualizerStateHolder
-import com.tunjid.mutator.mutation
+import com.tunjid.mutator.mutationOf
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
@@ -86,17 +86,17 @@ class Snail11StateHolder(
     private val speed: Flow<Speed> = scope.speedFlow()
 
     private val speedChanges: Flow<Mutation<Snail11State>> = speed
-        .map { mutation { copy(speed = it) } }
+        .map { mutationOf { copy(speed = it) } }
 
     private val progressChanges: Flow<Mutation<Snail11State>> = speed
         .toInterval()
-        .map { mutation { copy(progress = (progress + 1) % 100) } }
+        .map { mutationOf { copy(progress = (progress + 1) % 100) } }
 
 
     private val mutator = scope.actionStateFlowProducer<Action, Snail11State>(
         initialState = Snail11State(),
         started = SharingStarted.WhileSubscribed(),
-        mutationFlows = listOf(
+        inputs = listOf(
             speedChanges,
             progressChanges
         ),
@@ -117,25 +117,25 @@ class Snail11StateHolder(
 
     private fun Flow<Action.SetColor>.colorMutations(): Flow<Mutation<Snail11State>> =
         mapLatest {
-            mutation { copy(colorIndex = it.index) }
+            mutationOf { copy(colorIndex = it.index) }
         }
 
     private fun Flow<Action.SetProgress>.progressMutations(): Flow<Mutation<Snail11State>> =
         mapLatest {
-            mutation { copy(progress = it.progress) }
+            mutationOf { copy(progress = it.progress) }
         }
 
     private fun Flow<Action.SetMode>.modeMutations(): Flow<Mutation<Snail11State>> =
         flatMapLatest { (isDark, startColors) ->
             flow {
-                emit(mutation { copy(isDark = isDark) })
+                emit(mutationOf { copy(isDark = isDark) })
                 emitAll(
                     interpolateColors(
                         startColors = startColors.map(Color::argb).toIntArray(),
                         endColors = MutedColors.colors(isDark).map(Color::argb).toIntArray()
                     )
                         .map { (progress, colors) ->
-                            mutation {
+                            mutationOf {
                                 copy(
                                     colorInterpolationProgress = progress,
                                     colors = colors

diff --git a/demo/src/commonMain/kotlin/com/tunjid/mutator/demo/snails/Snail5.kt b/demo/src/commonMain/kotlin/com/tunjid/mutator/demo/snails/Snail5.kt
@@ -35,7 +35,7 @@ import com.tunjid.mutator.demo.udfvisualizer.Marble
 import com.tunjid.mutator.demo.udfvisualizer.Event
 import com.tunjid.mutator.demo.udfvisualizer.UDFVisualizer
 import com.tunjid.mutator.demo.udfvisualizer.udfVisualizerStateHolder
-import com.tunjid.mutator.mutation
+import com.tunjid.mutator.mutationOf
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -62,11 +62,11 @@ class Snail5StateHolder(
     private val speed: Flow<Speed> = scope.speedFlow()
 
     private val speedChanges: Flow<Mutation<Snail5State>> = speed
-        .map { mutation { copy(speed = it) } }
+        .map { mutationOf { copy(speed = it) } }
 
     private val progressChanges: Flow<Mutation<Snail5State>> = speed
         .toInterval()
-        .map { mutation { copy(progress = (progress + 1) % 100) } }
+        .map { mutationOf { copy(progress = (progress + 1) % 100) } }
 
     private val changeEvents = MutableSharedFlow<Mutation<Snail5State>>()
 

diff --git a/demo/src/commonMain/kotlin/com/tunjid/mutator/demo/snails/Snail6.kt b/demo/src/commonMain/kotlin/com/tunjid/mutator/demo/snails/Snail6.kt
@@ -35,7 +35,7 @@ import com.tunjid.mutator.demo.udfvisualizer.Marble
 import com.tunjid.mutator.demo.udfvisualizer.Event
 import com.tunjid.mutator.demo.udfvisualizer.UDFVisualizer
 import com.tunjid.mutator.demo.udfvisualizer.udfVisualizerStateHolder
-import com.tunjid.mutator.mutation
+import com.tunjid.mutator.mutationOf
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -61,11 +61,11 @@ class Snail6StateHolder(
     private val speed: Flow<Speed> = scope.speedFlow()
 
     private val speedChanges: Flow<Mutation<Snail6State>> = speed
-        .map { mutation { copy(speed = it) } }
+        .map { mutationOf { copy(speed = it) } }
 
     private val progressChanges: Flow<Mutation<Snail6State>> = speed
         .toInterval()
-        .map { mutation { copy(progress = (progress + 1) % 100) } }
+        .map { mutationOf { copy(progress = (progress + 1) % 100) } }
 
     private val changeEvents = MutableSharedFlow<Mutation<Snail6State>>()