Radox

lift :: forall r dunno action label. Cons label action dunno r => HasLabel action label => IsSymbol label => action -> Variant r

When we dispatch an action, we need to first lift it into our main Variant type Thus, to dispatch an Up action we'd do dispatch (lift Up)

emptyStore :: forall actionType stateType. stateType -> RadoxStore actionType stateType

Things like React Context require us to provide a starting value, this allows us to pass one without using Effect.

createStore :: forall actionType stateType. stateType -> Listeners stateType -> CombinedReducer actionType stateType -> Effect (RadoxStore actionType stateType)

This creates a new Radox store

initialState is how our state looks when we start

listeners are an array of stateType -> Effect Unit functions that will be sent the new state everything it is updated

'rootReduceris the function that takes ouractionTypeand astateTypeand returns the newstateType`

This returns a RadoxStore, which has a dispatch function for sending new actions and a getState function

update :: forall actionType stateType. Ref stateType -> Listeners stateType -> Effect stateType -> CombinedReducer actionType stateType -> actionType -> Effect Unit

This takes our action runs it through the reducers, updates listeners with the result And then updates the ref with the new value Note actionType must have have been lift-ed into the Variant for use here

getState :: forall stateType. Ref stateType -> Effect stateType

Read the current state this is saved in the mutable Ref and returns it

data ReducerReturn stateType

Type of return value from reducer

Constructors

• NoOp
• UpdateState stateType
• UpdateStateAndRunEffect stateType (Aff Unit)
• RunEffect (Aff Unit)

type Reducer actionType stateType = actionType -> stateType -> stateType

Type for a reducer that does need to trigger any side effects

type RadoxStore combinedActionType stateType = { dispatch :: Dispatcher combinedActionType, getState :: Effect stateType, state :: stateType }

Type of store shared around so that the state can be accessed without needing Effect

type RadoxEffects combinedActionType stateType = { dispatch :: combinedActionType -> Effect Unit, getState :: Effect stateType, state :: stateType }

type Listeners stateType = Array (stateType -> Effect Unit)

A Listener is a function that takes the new state and returns Effect Unit (so that it can use it to do something interesting, hopefully)

type EffectfulReducer actionType stateType combinedActionType = RadoxEffects combinedActionType stateType -> actionType -> stateType -> ReducerReturn stateType

Type for any user-created Reducer function that takes an Action for a specific reducer, the entire state, and returns a new copy of the state

type Dispatcher combinedActionType = combinedActionType -> Effect Unit

A Dispatcher is the function that allows different parts of our app to send actions to the reducers and make Things Happen.

type CombinedReducer combinedActionType stateType = RadoxEffects combinedActionType stateType -> stateType -> combinedActionType -> ReducerReturn stateType

Type for the user-created Combined Reducer function, that takes a Variant of any action, and pipes it to the correct Reducer function, then returns the new state

class HasLabel a (p :: Symbol) | a -> p

Typeclass that links any given Action sum type to the label it holds in the Combined Reducer / variant