Update README.md

Author: mirko-plowtech

README.md

@@ -10,20 +10,6 @@ As a consequence, of the fix, the library also introduce an elegant approach in
 A `deferred action` is an `action` that is not immediately dispatched, but rather scheduled to be dispatched later.
 In contrast with `reducers` (that given an action and the state, provides the new state), a `scheduler` is a function that given the current context and a deferred action, can execute (user defined) side effects, and return (or not) a cleanup/cancellation function associated with.
 
-## Installation
-
-```console
-$ yarn add rescript-react-restate
-```
-
-or
-
-```console
-$ npm install --save rescript-react-restate
-```
-
-Then add `rescript-react-restate` to your `bsconfig.json` `bs-dependencies` field.
-
 ## Handling side effects (Asynchronous actions, logging, etc.)
 
 `Restate` powers up reducers by allow them not just update state, but also defer an action to be dispatched later if is desired. This is useful when you want to handle side effects (like logging, network requests, etc.) after the state has been updated.
@@ -44,36 +30,23 @@ type deferredAction =
   | LogIncrement
   | LogDecrement
 
-// Because of implementation details related on how we clean up the side effects, we need to provide a way to identify each deferred action. In other words, deferred actions, must have a unique identifier.
-module DeferredAction: Restate.HasDeferredAction with type t = deferredAction = {
-  type t = deferredAction
-  let variantId = action =>
-    switch action {
-    | LogIncrement => "LogIncrement"
-    | LogDecrement => "LogDecrement"
-  }
-}
-
-// Instantiate the reducer with your deferred action type
-module RestateReducer = Restate.MakeReducer(DeferredAction)
-
 // A Reducer now can update the state and schedule deferred actions (if they need to)
 let reducer = (state, action) => 
  switch action {
    | Increment =>
-     RestateReducer.UpdateWithDeferred(
+     Restate.UpdateWithDeferred(
        state + 1,
        LogIncrement,
      )
    | Decrement =>
-     RestateReducer.UpdateWithDeferred(
+     Restate.UpdateWithDeferred(
        state - 1,
        LogDecrement,
      )
    }
 
 // A Scheduler handle deferred actions by triggering side effects and returning a cleanup function (if necessary)
-let scheduler: (RestateReducer.self<state, action>, deferredAction) => option<unit=>unit> = 
+let scheduler: (Restate.self<state, action, deferredAction>, deferredAction) => option<unit=>unit> = 
   (self, deferredAction) =>
     switch deferredAction {
     | LogIncrement =>
@@ -88,7 +61,7 @@ let scheduler: (RestateReducer.self<state, action>, deferredAction) => option<un
 
 @react.component
 let make = () => {
-  let (state, send, _defer) = RestateReducer.useReducer(reducer, scheduler, 0)
+  let (state, send, _defer) = Restate.useReducer(reducer, scheduler, 0)
   <div>
     {state->React.int}
     <button onClick={_ => send(Decrement)}> {"-"->React.string} </button>
@@ -101,3 +74,28 @@ let make = () => {
 
 If you'd rather initialize state lazily (if there's some computation you don't want executed at every render for instance), use `useReducerWithMapState` where the first argument is a function taking `unit` and returning the initial state.
 
+## Installation
+
+```console
+$ yarn add rescript-react-restate
+```
+
+or
+
+```console
+$ npm install --save rescript-react-restate
+```
+
+Then add `rescript-react-restate` to your `bsconfig.json` `bs-dependencies` field.
+
+## Development
+
+```console
+nix develop
+
+# Run examples server:
+yarn dev
+
+# Build and watch rescript:
+yarn re:watch
+```