feat(dispatch-queue): Add dispatch queue and substate support

Author: tizoc

src/action/enabling_condition.rs

@@ -7,4 +7,3 @@ pub trait EnablingCondition<State> {
         true
     }
 }
-

src/dispatcher.rs

@@ -0,0 +1,70 @@
+use crate::EnablingCondition;
+use std::collections::VecDeque;
+
+pub struct Dispatcher<Action, State> {
+    queue: VecDeque<AnyAction<Action, State>>,
+}
+
+impl<Action, State> Dispatcher<Action, State> {
+    pub fn new() -> Self {
+        Self {
+            queue: VecDeque::new(),
+        }
+    }
+
+    pub fn push<T>(&mut self, action: T)
+    where
+        T: 'static + EnablingCondition<State> + Into<Action> + Clone + Send,
+    {
+        let wrapped_action = AnyAction::<Action, State>::new(action);
+        self.queue.push_back(wrapped_action);
+    }
+
+    pub(crate) fn pop(&mut self) -> Option<AnyAction<Action, State>> {
+        self.queue.pop_front()
+    }
+
+    pub(crate) fn push_front(&mut self, other: Dispatcher<Action, State>) {
+        other
+            .queue
+            .into_iter()
+            .rev()
+            .for_each(|action| self.queue.push_front(action));
+    }
+}
+
+trait ActionConvertible<A, S>: EnablingCondition<S> {
+    fn convert(&self) -> A;
+}
+
+pub(crate) struct AnyAction<A, S> {
+    inner: Box<dyn ActionConvertible<A, S> + Send>,
+}
+
+impl<A, S> AnyAction<A, S> {
+    fn new<T>(action: T) -> Self
+    where
+        T: 'static + ActionConvertible<A, S> + Send,
+    {
+        Self {
+            inner: Box::new(action),
+        }
+    }
+
+    pub fn is_enabled(&self, state: &S, time: crate::Timestamp) -> bool {
+        self.inner.is_enabled(state, time)
+    }
+
+    pub fn convert(&self) -> A {
+        self.inner.convert()
+    }
+}
+
+impl<T, A, S> ActionConvertible<A, S> for T
+where
+    T: Clone + Into<A> + EnablingCondition<S>,
+{
+    fn convert(&self) -> A {
+        self.clone().into()
+    }
+}

src/lib.rs

@@ -20,3 +20,9 @@ pub use store::{monotonic_to_time, Store};
 
 mod sub_store;
 pub use sub_store::SubStore;
+
+mod dispatcher;
+pub use dispatcher::Dispatcher;
+
+mod substate;
+pub use substate::{Substate, SubstateAccess};

src/reducer.rs

@@ -1,4 +1,5 @@
-use crate::ActionWithMeta;
+use crate::{ActionWithMeta, Dispatcher};
 
 /// Function signature for a reducer.
-pub type Reducer<State, Action> = fn(&mut State, &ActionWithMeta<Action>);
+pub type Reducer<State, Action> =
+    fn(&mut State, &ActionWithMeta<Action>, &mut Dispatcher<Action, State>);

src/store.rs

@@ -1,8 +1,8 @@
 use std::sync::OnceLock;
 
 use crate::{
-    ActionId, ActionMeta, ActionWithMeta, Effects, EnablingCondition, Instant, Reducer, SubStore,
-    SystemTime, TimeService,
+    ActionId, ActionMeta, ActionWithMeta, Dispatcher, Effects, EnablingCondition, Instant, Reducer,
+    SubStore, SystemTime, TimeService,
 };
 
 /// Wraps around State and allows only immutable borrow,
@@ -75,6 +75,9 @@ pub struct Store<State, Service, Action> {
     recursion_depth: u32,
 
     last_action_id: ActionId,
+
+    /// Queue for actions to be dispatched after the state update
+    dispatch_queue: Dispatcher<Action, State>,
 }
 
 impl<State, Service, Action> Store<State, Service, Action>
@@ -109,6 +112,8 @@ where
 
             recursion_depth: 0,
             last_action_id: ActionId::new_unchecked(initial_time_nanos as u64),
+
+            dispatch_queue: Dispatcher::new(),
         }
     }
 
@@ -186,6 +191,7 @@ where
         self.last_action_id = curr;
         self.recursion_depth += 1;
 
+        // TODO: instead return queued actinos, pass them to dispatch_effects?
         self.dispatch_reducer(&action_with_meta);
         self.dispatch_effects(action_with_meta);
 
@@ -195,13 +201,26 @@ where
     /// Runs the reducer.
     #[inline(always)]
     fn dispatch_reducer(&mut self, action_with_id: &ActionWithMeta<Action>) {
-        (self.reducer)(self.state.get_mut(), action_with_id);
+        // All new queued elements will be stored here
+        let mut queue = Dispatcher::new();
+        (self.reducer)(self.state.get_mut(), action_with_id, &mut queue);
+
+        // All the enqueued actions gets pushed to the front of the global queue
+        self.dispatch_queue.push_front(queue);
     }
 
     /// Runs the effects.
     #[inline(always)]
     fn dispatch_effects(&mut self, action_with_id: ActionWithMeta<Action>) {
+        // First the effects for this specific action must be handled
         (self.effects)(self, action_with_id);
+
+        // Then dispatch all actions enqueued by the reducer
+        while let Some(action) = self.dispatch_queue.pop() {
+            if action.is_enabled(self.state(), self.last_action_id.into()) {
+                self.dispatch_enabled(action.convert());
+            }
+        }
     }
 }
 
@@ -222,6 +241,8 @@ where
 
             recursion_depth: self.recursion_depth,
             last_action_id: self.last_action_id,
+
+            dispatch_queue: Dispatcher::new(), // TODO: clone
         }
     }
 }

src/substate.rs

@@ -0,0 +1,95 @@
+use crate::Dispatcher;
+
+pub trait SubstateAccess<T> {
+    fn substate(&self) -> &T;
+    fn substate_mut(&mut self) -> &mut T;
+}
+
+pub struct Substate<'a, A, T, S> {
+    state: &'a mut T,
+    dispatcher: &'a mut Dispatcher<A, T>,
+    _marker: std::marker::PhantomData<S>,
+}
+
+impl<'a, A, T, S> Substate<'a, A, T, S>
+where
+    T: SubstateAccess<S>,
+{
+    pub fn new(state: &'a mut T, dispatcher: &'a mut Dispatcher<A, T>) -> Self {
+        Self {
+            state,
+            dispatcher,
+            _marker: Default::default(),
+        }
+    }
+
+    pub fn from_compatible_substate<OS>(other: Substate<'a, A, T, OS>) -> Substate<'a, A, T, S> {
+        let Substate {
+            state, dispatcher, ..
+        } = other;
+
+        Self::new(state, dispatcher)
+    }
+
+    pub fn get_substate(&self) -> &S {
+        self.state.substate()
+    }
+
+    pub fn get_substate_mut(&mut self) -> &mut S {
+        self.state.substate_mut()
+    }
+
+    pub fn into_dispatcher_and_state(self) -> (&'a mut Dispatcher<A, T>, &'a T) {
+        (self.dispatcher, self.state)
+    }
+
+    pub fn into_dispatcher(self) -> &'a mut Dispatcher<A, T> {
+        self.dispatcher
+    }
+}
+
+impl<'a, A, T, S> From<(&'a mut T, &'a mut Dispatcher<A, T>)> for Substate<'a, A, T, S> {
+    fn from(state_and_dispatcher: (&'a mut T, &'a mut Dispatcher<A, T>)) -> Self {
+        let (state, dispatcher) = state_and_dispatcher;
+        Self {
+            state,
+            dispatcher,
+            _marker: Default::default(),
+        }
+    }
+}
+
+impl<'a, A, T, S> std::ops::Deref for Substate<'a, A, T, S>
+where
+    T: SubstateAccess<S>,
+{
+    type Target = S;
+
+    fn deref(&self) -> &Self::Target {
+        self.get_substate()
+    }
+}
+
+impl<'a, A, T, S> std::ops::DerefMut for Substate<'a, A, T, S>
+where
+    T: SubstateAccess<S>,
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.get_substate_mut()
+    }
+}
+
+#[macro_export]
+macro_rules! impl_substate_access {
+    ($state:ty, $substate_type:ty, $($substate_path:tt)*) => {
+        impl redux::SubstateAccess<$substate_type> for $state {
+            fn substate(&self) -> &$substate_type {
+                &self.$($substate_path)*
+            }
+
+            fn substate_mut(&mut self) -> &mut $substate_type {
+                &mut self.$($substate_path)*
+            }
+        }
+    };
+}