Hook(react): useReducer (#11)

* feat: useReducer

* test: useReducer

* demo: useReducer

app/src/main/java/me/pavi2410/useCompose/app/screens/ExampleScreen.kt

@@ -10,12 +10,14 @@ sealed class ExampleScreen(
 ) {
     object Counter : ExampleScreen("counter", "Counter", { CounterExample() })
     object Context : ExampleScreen("context", "Context", { ContextExample() })
+    object Reducer : ExampleScreen("reducer", "Reducer", { ReducerExample() })
     object Network : ExampleScreen("network", "Network", { NetworkExample() })
 }
 
 val exampleScreens
     get() = listOf(
         ExampleScreen.Counter,
         ExampleScreen.Context,
+        ExampleScreen.Reducer,
         ExampleScreen.Network
     )

app/src/main/java/me/pavi2410/useCompose/app/screens/ReducerExample.kt

@@ -0,0 +1,37 @@
+package me.pavi2410.useCompose.app.screens
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material.Button
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import me.pavi2410.useCompose.react.useReducer
+
+data class MyState(val count: Int)
+data class MyAction(val type: String)
+
+val initialState = MyState(0)
+
+@Composable
+fun ReducerExample() {
+    Column {
+        val (state, dispatch) = useReducer<MyState, MyAction>(initialState) { state, action ->
+            when (action.type) {
+                "increment" -> state.copy(count = state.count + 1)
+                "decrement" -> state.copy(count = state.count - 1)
+                else -> throw Error()
+            }
+        }
+
+        Text("Count: ${state.count}")
+        Button(onClick = {
+            dispatch(MyAction("increment"))
+        }) {
+            Text("+")
+        }
+        Button(onClick = {
+            dispatch(MyAction("decrement"))
+        }) {
+            Text("-")
+        }
+    }
+}

react/src/androidTest/java/me/pavi2410/useCompose/react/HooksTest.kt

@@ -103,4 +103,39 @@ class HooksTest {
         composeTestRule.onNodeWithTag("outer").assertTextEquals("context value is outer")
         composeTestRule.onNodeWithTag("inner").assertTextEquals("context value is inner")
     }
-}
+
+    @Test
+    fun useReducerTest() {
+        val initialState = MyState(0)
+
+        // Start the app
+        composeTestRule.setContent {
+            Surface(color = MaterialTheme.colors.background) {
+                Column {
+                    val (state, dispatch) = useReducer<MyState, MyAction>(initialState) { state, action ->
+                        when (action.type) {
+                            "increment" -> state.copy(count = state.count + 1)
+                            "decrement" -> state.copy(count = state.count - 1)
+                            else -> throw Error()
+                        }
+                    }
+
+                    Text("Count: ${state.count}")
+                    Button(onClick = {
+                        dispatch(MyAction("increment"))
+                    }) {
+                        Text("+")
+                    }
+                    Button(onClick = {
+                        dispatch(MyAction("decrement"))
+                    }) {
+                        Text("-")
+                    }
+                }
+            }
+        }
+    }
+}
+
+data class MyState(val count: Int)
+data class MyAction(val type: String)

react/src/main/java/me/pavi2410/useCompose/react/hooks.kt

@@ -55,10 +55,26 @@ fun <T> createContext(initialValue: T): ReactContext<T> {
 /**
  * A React-ish hook that returns the current value for that context.
  *
- * @see [useEffect](https://reactjs.org/docs/hooks-effect.html)
+ * @see [useContext](https://reactjs.org/docs/hooks-reference.html#usecontext)
  */
 @SuppressLint("ComposableNaming")
 @Composable
 fun <T> useContext(context: ReactContext<T>): T {
     return context.LocalCtx.current
+}
+
+/**
+ * A hook from React that allows you to create a state machine using a [reducer] function.
+ *
+ * @see [useReducer](https://reactjs.org/docs/hooks-reference.html#usereducer)
+ */
+@Composable
+fun <S, A> useReducer(initialState: S, reducer: (S, A) -> S): Pair<S, (A) -> Unit> {
+    var thisState by remember { mutableStateOf(initialState) }
+
+    fun dispatch(action: A) {
+        thisState = reducer(thisState, action)
+    }
+
+    return Pair(thisState, ::dispatch)
 }