refactor(cache): Refactored the effect module and added the IEffect trait.

- Genericized the Effect struct to support any Fn() type.
- Adjusted the memo and signal modules to adapt to the new IEffect interface.
- Optimized some code structure to improve readability and maintainability.

Author: fxdmhtt

cache/src/call_stack.rs

@@ -4,11 +4,11 @@ use std::rc::Weak;
 
 use once_cell::sync::Lazy;
 
-use crate::{Effect, Observable};
+use crate::{IEffect, Observable};
 
 static mut CALL_STACK: Lazy<Vec<&'static dyn Observable>> = Lazy::new(Vec::new);
 
-static mut CREATING_EFFECT: Option<Weak<Effect>> = None;
+static mut CREATING_EFFECT: Option<Weak<dyn IEffect>> = None;
 
 pub(crate) fn push(op: &'static dyn Observable) {
     unsafe { CALL_STACK.push(op) }
@@ -22,16 +22,16 @@ pub(crate) fn pop() -> Option<&'static dyn Observable> {
     unsafe { CALL_STACK.pop() }
 }
 
-pub(crate) fn creating_effect_push(effect: Weak<Effect>) {
+pub(crate) fn creating_effect_push(effect: Weak<dyn IEffect>) {
     assert!(unsafe { CREATING_EFFECT.is_none() });
     unsafe { CREATING_EFFECT = Some(effect) }
 }
 
-pub(crate) fn creating_effect_peak() -> Option<Weak<Effect>> {
+pub(crate) fn creating_effect_peak() -> Option<Weak<dyn IEffect>> {
     unsafe { CREATING_EFFECT.clone() }
 }
 
-pub(crate) fn creating_effect_pop() -> Weak<Effect> {
+pub(crate) fn creating_effect_pop() -> Weak<dyn IEffect> {
     assert!(unsafe { CREATING_EFFECT.is_some() });
     unsafe { CREATING_EFFECT.take().unwrap() }
 }

cache/src/effect.rs

@@ -1,21 +1,40 @@
 use std::rc::Rc;
 
-pub struct Effect {
-    f: Box<dyn Fn()>,
+pub struct Effect<F>
+where
+    F: Fn(),
+{
+    f: F,
 }
 
-impl Effect {
-    pub fn new(f: impl Fn() + 'static) -> Rc<Self> {
-        let e = Rc::new(Effect { f: Box::new(f) });
+impl<F> Effect<F>
+where
+    F: Fn(),
+{
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new(f: F) -> Rc<dyn IEffect>
+    where
+        F: 'static,
+    {
+        let e: Rc<dyn IEffect> = Rc::new(Effect { f });
 
         crate::creating_effect_push(Rc::downgrade(&e));
         e.run();
         crate::creating_effect_pop();
 
         e
     }
+}
+
+pub trait IEffect {
+    fn run(&self);
+}
 
-    pub(crate) fn run(&self) {
+impl<F> IEffect for Effect<F>
+where
+    F: Fn(),
+{
+    fn run(&self) {
         (self.f)()
     }
 }

cache/src/lib.rs

@@ -7,7 +7,7 @@ pub mod signal;
 
 pub(crate) use cache::{remove_from_cache, store_in_cache, touch};
 pub(crate) use call_stack::{creating_effect_peak, creating_effect_pop, creating_effect_push};
-pub use effect::Effect;
+pub use effect::{Effect, IEffect};
 pub use memo::Memo;
 pub use signal::Signal;
 

cache/src/memo.rs

@@ -2,7 +2,6 @@ use crate::{Observable, call_stack, remove_from_cache, store_in_cache, touch};
 
 pub struct Memo<T, F>
 where
-    T: Clone,
     F: Fn() -> T,
 {
     f: F,
@@ -11,7 +10,6 @@ where
 
 impl<T, F> Observable for Memo<T, F>
 where
-    T: Clone,
     F: Fn() -> T,
 {
     fn invalidate(&'static self) {
@@ -22,7 +20,6 @@ where
 
 impl<T, F> Memo<T, F>
 where
-    T: Clone,
     F: Fn() -> T,
 {
     pub fn new(f: F) -> Self {
@@ -32,7 +29,10 @@ where
         }
     }
 
-    pub fn get(&'static mut self) -> T {
+    pub fn get(&'static mut self) -> T
+    where
+        T: Clone,
+    {
         if let Some(last) = call_stack::last()
             && !self.dependents.iter().any(|d| std::ptr::eq(*d, *last))
         {

cache/src/signal.rs

@@ -3,21 +3,15 @@ use std::{
     rc::Weak,
 };
 
-use crate::{Effect, Observable, call_stack};
+use crate::{IEffect, Observable, call_stack};
 
-pub struct Signal<T>
-where
-    T: Eq + Default + 'static,
-{
+pub struct Signal<T> {
     value: RefCell<T>,
     dependents: RefCell<Vec<&'static dyn Observable>>,
-    effects: RefCell<Vec<Weak<Effect>>>,
+    effects: RefCell<Vec<Weak<dyn IEffect>>>,
 }
 
-impl<T> Signal<T>
-where
-    T: Eq + Default + 'static,
-{
+impl<T> Signal<T> {
     fn invalidate(&self) {
         self.dependents.borrow().iter().for_each(|d| d.invalidate());
     }
@@ -43,7 +37,10 @@ where
         self.invalidate()
     }
 
-    pub fn new(value: Option<T>) -> Self {
+    pub fn new(value: Option<T>) -> Self
+    where
+        T: Default,
+    {
         Signal {
             value: value.unwrap_or_default().into(),
             dependents: vec![].into(),
@@ -71,7 +68,10 @@ where
         self.value.borrow()
     }
 
-    pub fn set(&self, value: T) -> bool {
+    pub fn set(&self, value: T) -> bool
+    where
+        T: Eq,
+    {
         if *self.value.borrow() == value {
             return false;
         }