refactor: **breaking** remove the async variant of effects, since the…

… Cmd will do just fine

crates/core/src/dom/effects.rs

@@ -1,7 +1,6 @@
 use crate::dom::Modifier;
 use crate::dom::Cmd;
 use std::future::ready;
-use std::future::Future;
 
 /// Effects is a convenient way to group Msg for component to execute subsequent updates based on certain conditions.
 /// This can be used for doing animation and incremental changes to the view to provide an effect
@@ -41,23 +40,6 @@ where
         }
     }
 
-    /// Create a new Effects with local and external futures that can resolve to MSG and XMSG
-    /// respectively
-    pub fn with_async<F, FX>(
-        local: impl IntoIterator<Item = F>,
-        external: impl IntoIterator<Item = FX>,
-    ) -> Self
-    where
-        F: Future<Output = MSG> + 'static,
-        FX: Future<Output = XMSG> + 'static,
-        XMSG: 'static,
-    {
-        Self {
-            local: local.into_iter().map(Cmd::single).collect(),
-            external: external.into_iter().map(Cmd::single).collect(),
-            modifier: Modifier::default(),
-        }
-    }
 
     /// Create an Effects with  local messages that will be executed on the next update loop on this Component
     pub fn with_local(local: impl IntoIterator<Item = MSG>) -> Self {
@@ -68,18 +50,6 @@ where
         }
     }
 
-    /// Create an Effects with local message that will can resolved into MSG, it will be executed
-    /// on the next update loop on the component it is being returned
-    pub fn with_local_async<F>(local: impl IntoIterator<Item = F>) -> Self
-    where
-        F: Future<Output = MSG> + 'static,
-    {
-        Self {
-            local: local.into_iter().map(Cmd::single).collect(),
-            external: vec![],
-            modifier: Modifier::default(),
-        }
-    }
 
     /// Create an Effects with extern messages that will be executed on the parent Component
     pub fn with_external(external: impl IntoIterator<Item = XMSG>) -> Self
@@ -96,19 +66,6 @@ where
         }
     }
 
-    /// Create an Effects with external messages that will can be resolved into an XMSG, this will
-    /// be dispatch in the next Component update
-    pub fn with_external_async<F>(external: impl IntoIterator<Item = F>) -> Self
-    where
-        F: Future<Output = XMSG> + 'static,
-        XMSG: 'static,
-    {
-        Self {
-            local: vec![],
-            external: external.into_iter().map(Cmd::single).collect(),
-            modifier: Modifier::default(),
-        }
-    }
 
     /// Create and empty Effects
     pub fn none() -> Self {

crates/core/src/dom/program.rs

@@ -183,7 +183,7 @@ where
                 app,
                 current_vdom: Rc::new(RefCell::new(app_view)),
                 pending_msgs: Rc::new(RefCell::new(VecDeque::new())),
-                pending_cmds: Rc::new(RefCell::new(VecDeque::new())),
+                pending_dispatches: Rc::new(RefCell::new(VecDeque::new())),
             },
             root_node: Rc::new(RefCell::new(None)),
             mount_node: Rc::new(RefCell::new(None)),
@@ -708,7 +708,7 @@ where
             );
         }
 
-        // execute this `cmd` batched pending_cmds that may have resulted from updating the app
+        // execute this `cmd` batched pending_dispatches that may have resulted from updating the app
         cmd.emit(self.clone());
     }
 

crates/core/src/dom/program/app_context.rs

@@ -29,7 +29,7 @@ where
     pub(crate) pending_msgs: Rc<RefCell<VecDeque<APP::MSG>>>,
 
     /// pending cmds that hasn't been emited yet
-    pub(crate) pending_cmds: Rc<RefCell<VecDeque<Dispatch<APP>>>>,
+    pub(crate) pending_dispatches: Rc<RefCell<VecDeque<Dispatch<APP>>>>,
 }
 
 pub(crate) struct WeakContext<APP>
@@ -39,7 +39,7 @@ where
     pub(crate) app: Weak<RefCell<APP>>,
     pub(crate) current_vdom: Weak<RefCell<vdom::Node<APP::MSG>>>,
     pub(crate) pending_msgs: Weak<RefCell<VecDeque<APP::MSG>>>,
-    pub(crate) pending_cmds: Weak<RefCell<VecDeque<Dispatch<APP>>>>,
+    pub(crate) pending_dispatches: Weak<RefCell<VecDeque<Dispatch<APP>>>>,
 }
 
 impl<APP> WeakContext<APP>
@@ -50,12 +50,12 @@ where
         let app = self.app.upgrade()?;
         let current_vdom = self.current_vdom.upgrade()?;
         let pending_msgs = self.pending_msgs.upgrade()?;
-        let pending_cmds = self.pending_cmds.upgrade()?;
+        let pending_dispatches = self.pending_dispatches.upgrade()?;
         Some(AppContext {
             app,
             current_vdom,
             pending_msgs,
-            pending_cmds,
+            pending_dispatches,
         })
     }
 }
@@ -69,7 +69,7 @@ where
             app: Weak::clone(&self.app),
             current_vdom: Weak::clone(&self.current_vdom),
             pending_msgs: Weak::clone(&self.pending_msgs),
-            pending_cmds: Weak::clone(&self.pending_cmds),
+            pending_dispatches: Weak::clone(&self.pending_dispatches),
         }
     }
 }
@@ -83,7 +83,7 @@ where
             app: Rc::downgrade(&this.app),
             current_vdom: Rc::downgrade(&this.current_vdom),
             pending_msgs: Rc::downgrade(&this.pending_msgs),
-            pending_cmds: Rc::downgrade(&this.pending_cmds),
+            pending_dispatches: Rc::downgrade(&this.pending_dispatches),
         }
     }
     pub fn strong_count(&self) -> usize {
@@ -103,7 +103,7 @@ where
             app: Rc::clone(&self.app),
             current_vdom: Rc::clone(&self.current_vdom),
             pending_msgs: Rc::clone(&self.pending_msgs),
-            pending_cmds: Rc::clone(&self.pending_cmds),
+            pending_dispatches: Rc::clone(&self.pending_dispatches),
         }
     }
 }
@@ -174,14 +174,14 @@ where
 
         if let Some(cmd) = cmd {
             // we put the cmd in the pending_cmd queue
-            self.pending_cmds.borrow_mut().push_back(cmd);
+            self.pending_dispatches.borrow_mut().push_back(cmd);
             true
         } else {
             false
         }
     }
 
     pub fn batch_pending_cmds(&mut self) -> Dispatch<APP> {
-        Dispatch::batch(self.pending_cmds.borrow_mut().drain(..))
+        Dispatch::batch(self.pending_dispatches.borrow_mut().drain(..))
     }
 }