doc: methods's comments

src/commonMain/kotlin/dev/mcatta/polpetta/ReducerFactory.kt

@@ -21,9 +21,11 @@ public abstract class ReducerFactory<A : Action, S : State, E : SideEffect>(
     private val _sideEffectFactory = sideEffectFactory
 
     /**
-     * Return the [Reducer] bond to the action [action]
+     * Return the [Reducer] bond to the action [action] and [FromState]
+     *
      * @param action
-     * @throws IllegalStateException in case that action doesn't have any Reducers
+     * @param fromState
+     * @return Reducer if matches the pair
      */
     internal fun <FromState : S> getReducer(
         action: A,
@@ -35,6 +37,7 @@ public abstract class ReducerFactory<A : Action, S : State, E : SideEffect>(
 
     /**
      * Define a [Reducer]'s body for the defined action [A]
+     *
      * @param block
      */
     public inline fun <reified RA : A, reified FromState : S> on(
@@ -45,6 +48,7 @@ public abstract class ReducerFactory<A : Action, S : State, E : SideEffect>(
 
     /**
      * Define a [Reducer]'s body for the defined action with class [KClass]
+     *
      * @param kClassAction
      * @param kClassFromState
      * @param block

src/commonMain/kotlin/dev/mcatta/polpetta/SideEffectFactory.kt

@@ -10,6 +10,11 @@ public class SideEffectFactory<E : SideEffect> {
     private val _sideEffectFlow: MutableStateFlow<E?> = MutableStateFlow(null)
     public val sideEffectFlow: StateFlow<E?> = _sideEffectFlow.asStateFlow()
 
+    /**
+     * Dispatch a [sideEffect]
+     *
+     * @param sideEffect
+     */
     public suspend fun sideEffect(sideEffect: E) {
         _sideEffectFlow.emit(sideEffect)
     }

src/commonMain/kotlin/dev/mcatta/polpetta/StateStore.kt

@@ -1,6 +1,5 @@
 package dev.mcatta.polpetta
 
-import dev.mcatta.polpetta.core.Reducer
 import dev.mcatta.polpetta.operators.Action
 import dev.mcatta.polpetta.operators.SideEffect
 import dev.mcatta.polpetta.operators.State
@@ -38,18 +37,32 @@ public abstract class StateStore<A : Action, S : State, E : SideEffect>(
             .map { action ->
                 val currentState = _stateFlow.value
 
-                _reducerFactory.getReducer(
-                    action = action,
-                    fromState = currentState
-                )?.reduce(currentState = StateModifier.of(currentState))
+                reduceState(action, currentState)
             }
             .filterNotNull()
             .onEach { newState -> _stateFlow.value = newState }
             .launchIn(coroutineScope)
     }
 
+    /**
+     * Reduce the [currentState] into a new one based on the [action] and the [currentState] itself.
+     * In case this pair is not defined into the [ReducerFactory] class this will return null
+     *
+     * @param action
+     * @param currentState
+     * @return new state or null
+     */
+    private suspend fun reduceState(
+        action: A,
+        currentState: S
+    ): S? = _reducerFactory.getReducer(
+        action = action,
+        fromState = currentState
+    )?.reduce(currentState = StateModifier.of(currentState))
+
     /**
      * Dispatch an action that trigger a Reducer
+     *
      * @return true if the Action si defined
      */
     public suspend fun dispatchAction(action: A): Unit = _reducerQueue.send(action)

src/commonMain/kotlin/dev/mcatta/polpetta/core/Reducer.kt

@@ -12,5 +12,10 @@ internal fun interface Reducer<S : State> {
 
 /**
  * This method allows to create an [Reducer]
+ *
+ * @param block function's body
+ * @return Reducer function
  */
-internal fun <S : State> reducer(block: suspend (StateModifier<S>) -> S) = Reducer(block)
+internal fun <S : State> reducer(
+    block: suspend (StateModifier<S>) -> S
+) = Reducer(block)

src/commonMain/kotlin/dev/mcatta/polpetta/core/ReducerFactoryBuilder.kt

@@ -6,6 +6,7 @@ import kotlin.reflect.KClass
 
 /**
  * Reducer Factory Builder used to wrap the Reduce function based on an action
+ *
  * @param kClassAction action type
  * @param handler reducer
  */

src/commonMain/kotlin/dev/mcatta/polpetta/operators/SideEffect.kt

@@ -1,3 +1,6 @@
 package dev.mcatta.polpetta.operators
 
+/**
+ * Side Effect definition
+ */
 public interface SideEffect

src/commonMain/kotlin/dev/mcatta/polpetta/operators/StateModifier.kt

@@ -10,6 +10,7 @@ public class StateModifier<FromState : State> private constructor(
     public companion object {
         /**
          * Smart constructor for the StateModifier creation
+         *
          * @param state
          */
         public fun <FromState : State> of(
@@ -24,22 +25,28 @@ public class StateModifier<FromState : State> private constructor(
 
     /**
      * Change the current state with new properties
+     *
      * @param mutator mutator callback
+     * @return the mutated [FromState]
      */
     public suspend fun mutate(
         mutator: suspend FromState.() -> FromState
     ): FromState = mutator(getAndCheck())
 
     /**
      * Change the current state into a new one
+     *
      * @param transformer transformer callback
+     * @return a new state that inherited from [State]
      */
     public suspend fun <ToState : State> transform(
         transformer: suspend FromState.() -> ToState
     ): ToState = transformer(getAndCheck())
 
     /**
      * This function get the current state and validate is value
+     *
+     * @return the current state or throws an exception
      */
     @Suppress("UNCHECKED_CAST")
     private fun <CS : FromState> getAndCheck(): CS {