Redox

type Interp dsl state eff = Free dsl (state -> state) -> state -> Aff eff state

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) (Fiber (redox :: RedoxStore (read :: ReadRedox | e) | eff) Unit)

Dispatch function which does not handle store updates. That's useful if the interpreter is updating the store. You can use Redox.Utils.mkIncInterp and Redox.Utils.runSubscriptions to create such an interpreter.

dispatch :: forall e eff dsl state. (Error -> Eff (redox :: RedoxStore (read :: ReadRedox, write :: WriteRedox | e) | eff) Unit) -> Interp dsl state (redox :: RedoxStore (read :: ReadRedox, write :: WriteRedox | e) | eff) -> Store state -> Free dsl (state -> state) -> Eff (redox :: RedoxStore (read :: ReadRedox, write :: WriteRedox | e) | eff) (Fiber (redox :: RedoxStore (read :: ReadRedox, write :: WriteRedox | e) | eff) Unit)

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 your DSL.

_dispatch :: forall e eff dsl state. (Either Error 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) (Fiber (redox :: RedoxStore (read :: ReadRedox | e) | eff) Unit)

data WriteRedox :: Effect

Effect for writing to the store

type WriteOnlyRedox = (write :: WriteRedox)

newtype SubscriptionId

Constructors

• SubscriptionId Int

Instances

• Newtype SubscriptionId _
• Eq SubscriptionId
• Ord SubscriptionId

data SubscribeRedox :: Effect

Effect for (un)subscribing to the store

data Store :: Type -> Type

data RedoxStore :: Row Effect -> Effect

type ReadWriteSubscribeRedox = (read :: ReadRedox, subscribe :: SubscribeRedox, write :: WriteRedox)

type ReadWriteRedox = (read :: ReadRedox, write :: WriteRedox)

data ReadRedox :: Effect

Effect for reading state of the store or retreaving store subscribers.

type ReadOnlyRedox = (read :: ReadRedox)

type REDOX = RedoxStore CreateReadWriteSubscribeRedox

data CreateRedox :: Effect

Effect for creating Redox Store

type CreateReadWriteSubscribeRedox = (create :: CreateRedox, read :: ReadRedox, subscribe :: SubscribeRedox, write :: WriteRedox)

unsubscribe :: forall eff e state m. MonadEff (redox :: RedoxStore (subscribe :: SubscribeRedox | e) | eff) m => Store state -> SubscriptionId -> m Unit

Remove a subscription with a given id.

subscribe :: forall eff' eff e state m. MonadEff (redox :: RedoxStore (subscribe :: SubscribeRedox | e) | eff) m => Store state -> (state -> Eff eff' Unit) -> m 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 :: forall eff e state m. MonadEff (redox :: RedoxStore (write :: WriteRedox | e) | eff) m => Store state -> state -> m (Store state)

runStoreSubscriptions :: forall eff e state m. MonadEff (redox :: RedoxStore (read :: ReadRedox | e) | eff) m => Store state -> m Unit

performRedoxEff :: forall e a. Eff (redox :: RedoxStore e) a -> a

modifyStore :: forall eff e state' state m. MonadEff (redox :: RedoxStore (read :: ReadRedox, write :: WriteRedox | e) | eff) m => (state -> state') -> Store state -> m (Store state')

mkStoreG :: forall state. state -> Store state

Make store outside of Eff monad (global).

mkStore :: forall eff e state m. MonadEff (redox :: RedoxStore (create :: CreateRedox | e) | eff) m => state -> m (Store state)

getSubscriptions :: forall eff e state m. MonadEff (redox :: RedoxStore (read :: ReadRedox | e) | eff) m => Store state -> m (Array (state -> Eff (redox :: RedoxStore (read :: ReadRedox | e) | eff) Unit))

Get subscriptions.

getState :: forall eff e state m. MonadEff (redox :: RedoxStore (read :: ReadRedox | e) | eff) m => Store state -> m state

runSubscriptions :: forall f state. Functor f => Store state -> Cofree f state -> Cofree f state

Run subscriptions on each leaf of the Cofree interpreter. You'll likely want to use mkIncInterp first so that the subscriptions run on the updated state.

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. Note that it does not run subscriptions. Use runSubscriptions for that.

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 a 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...

compose :: forall b a g f. Functor f => Functor g => Cofree f a -> Cofree g b -> Cofree (Product f g) (Tuple a b)

Compose two interpreters. Check out an example

addLogger :: forall f state. Functor f => (state -> String) -> Cofree f state -> Cofree f state

Add logger to the interpreter which logs updates on each leaf.

Note that leaves of the cofree interpreter might be visited more often than when subsciptions run. If you are using dispatch without mkIncInterp or runSubscriptions the store will be updated only when leaves of Free DSL are reached, while this logger will log on every leaf of your cofree interpreter.