Redox
- Package
- purescript-redox
- Repository
- coot/purescript-redox
Re-exports from Redox.Free
#dispatchP Source
dispatchP :: forall e eff dsl state. (Error -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) Unit) -> Interp dsl state (redox :: RedoxStore (read :: ReadRedox | e) | eff) -> Store state -> Free dsl (state -> state) -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) (Canceler (redox :: RedoxStore (read :: ReadRedox | e) | eff))
Dispatch function which does not handle store updates. That's useful if
the interpreter is updating the store. You can use
Redox.Utils.mkIncInterp
to create such interpreter.
#dispatch Source
dispatch :: forall e eff dsl state. (Error -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) Unit) -> Interp dsl state (redox :: RedoxStore (read :: ReadRedox | e) | eff) -> Store state -> Free dsl (state -> state) -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) (Canceler (redox :: RedoxStore (read :: ReadRedox | e) | eff))
Dispatch dsl commands that will be interpreted in Aff monad. You have to write your own DSL for the state changes and an interpreter for it. Check out purescript-dsl-example or see the tests. This is useful if you want to have a batch dispatch that dispatches all the commands at once when the interpreter finished running over the commands.
#_dispatch Source
_dispatch :: forall e eff dsl state. (Error -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) Unit) -> (state -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) Unit) -> Interp dsl state (redox :: RedoxStore (read :: ReadRedox | e) | eff) -> Store state -> Free dsl (state -> state) -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) (Canceler (redox :: RedoxStore (read :: ReadRedox | e) | eff))
Re-exports from Redox.Store
#WriteRedox Source
data WriteRedox :: Effect
Effect for writing to the store
#WriteOnlyRedox Source
type WriteOnlyRedox = (write :: WriteRedox)
#SubscriptionId Source
#SubscribeRedox Source
data SubscribeRedox :: Effect
Effect for (un)subscribing to the store
#ReadWriteSubscribeRedox Source
type ReadWriteSubscribeRedox = (read :: ReadRedox, subscribe :: SubscribeRedox, write :: WriteRedox)
#ReadWriteRedox Source
type ReadWriteRedox = (read :: ReadRedox, write :: WriteRedox)
#ReadOnlyRedox Source
type ReadOnlyRedox = (read :: ReadRedox)
#CreateRedox Source
data CreateRedox :: Effect
Effect for creating Redox Store
#unsubscribe Source
unsubscribe :: forall eff e state. Store state -> SubscriptionId -> Eff (redox :: RedoxStore (subscribe :: SubscribeRedox | e) | eff) Unit
Remove a subscription with a given id.
#subscribe Source
subscribe :: forall eff' eff e state. Store state -> (state -> Eff eff' Unit) -> Eff (redox :: RedoxStore (subscribe :: SubscribeRedox | e) | eff) SubscriptionId
Subscribe to store updates. Note that store updates are not run by the store itself. That is left to dispatch or the DSL interpreter. It returns id of the subscribed callback. You can use it to remove the subscription.
#setState Source
setState :: forall eff e state. Store state -> state -> Eff (redox :: RedoxStore (write :: WriteRedox | e) | eff) (Store state)
#performRedoxEff Source
performRedoxEff :: forall e a. Eff (redox :: RedoxStore e) a -> a
#mkStore Source
mkStore :: forall eff e state. state -> Eff (redox :: RedoxStore (create :: CreateRedox | e) | eff) (Store state)
Make store with initial state. Store is a mutable container with a subscription mechanism.
#mapStore Source
mapStore :: forall eff e state' state. (state -> state') -> Store state -> Eff (redox :: RedoxStore (read :: ReadRedox, write :: WriteRedox | e) | eff) (Store state')
#getSubs Source
getSubs :: forall eff e state. Store state -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) (Array (state -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) Unit))
Get subscriptions.
#getState Source
getState :: forall eff e state. Store state -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) state
Re-exports from Redox.Utils
#mkIncInterp Source
mkIncInterp :: forall f state. Functor f => Store state -> Cofree f state -> Cofree f state
Make interpreter which updates the store on every step of computation.
You have to supply the store and interperter of type Cofree f state
.
Check out tests how you can use it.
#hoistCofree' Source
hoistCofree' :: forall state f. Functor f => (f (Cofree f state) -> f (Cofree f state)) -> Cofree f state -> Cofree f state
A version of hoistCofree
, where nat
does not need to come from natural
transformation.
This corresponds to
applyMiddleware
in the redux library.
You can use this function to add effects to your interpreter, like
logging, optimistic updates, undo/redo stack, delayed actions...
For example a simple logger:
addLogger
:: forall state f
. (Functor f)
=> Cofree f state
-> Cofree f state
addLogger interp = hoistCofree' nat interp
where
nat :: f (Cofree f state) -> f (Cofree f state)
nat fa = g <$> fa
g :: Cofree f state -> Cofree f state
g cof = unsafePerformEff do
-- Control.Comonad.Cofree.head
log $ unsafeCoerce (head cof)
pure cof
- Modules
- Redox
- Redox.
Free - Redox.
Store - Redox.
Utils