refactor(cache): Refactor the Effect and Memo types

- Removed generic closures to save code space
- Removed the IEffect trait

Author: fxdmhtt

cache/src/effect.rs

@@ -4,64 +4,27 @@ use crate::effect_stack::{effect_peak, effect_pop, effect_push};
 
 /// A reactive effect that runs a closure whenever its dependencies change.
 ///
-/// `Effect<F>` behaves similarly to an "event listener" or a callback,
+/// `Effect` behaves similarly to an "event listener" or a callback,
 /// but it is automatically tied to any signals or memos it reads during execution.
 /// When those dependencies change, the effect will re-run.
 ///
-/// Note: The closure runs **immediately upon creation** via `Effect::wrap`,
+/// Note: The closure runs **immediately upon creation** via [`Effect::new`],
 /// so the effect is always initialized with an up-to-date value.
 ///
 /// In short:
-/// - Like a callback: wraps a closure of type `F` and runs it.
+/// - Like a callback: wraps a closure and runs it.
 /// - Adds tracking: automatically re-runs when dependent signals change.
 /// - Runs once immediately at creation.
-///
-/// # Type Parameters
-///
-/// - `F`: The closure type wrapped by this effect. Must implement `Fn()`.
-///   The closure is executed immediately upon creation and tracked for reactive updates.
-pub struct Effect<F>
-where
-    F: Fn() + 'static,
-{
-    f: F,
+pub struct Effect {
+    f: Box<dyn Fn()>,
 }
 
-impl<F> Effect<F>
-where
-    F: Fn(),
-{
-    fn new_inner<D>(f: F, deps: Option<D>) -> Rc<dyn IEffect>
-    where
-        D: Fn() + 'static,
-    {
-        let e: Rc<dyn IEffect> = Rc::new(Effect { f });
-        let w = Rc::downgrade(&e);
-
-        // Dependency collection only at creation time
-        effect_push(w.clone(), true);
-        if let Some(deps) = &deps {
-            deps();
-        } else {
-            e.run();
-        }
-        effect_pop(w.clone(), true);
-
-        // If there is an additional dependency initializer,
-        // the `Effect` needs to be run immediately
-        // after dependency collection is completed.
-        if deps.is_some() {
-            run_untracked(&e);
-        }
-
-        e
-    }
-
+impl Effect {
     /// Creates a new `Effect`, wrapping the provided closure
     /// and running it immediately for dependency tracking.
     ///
-    /// Returns an `Rc<dyn IEffect>` so the effect can be stored and shared
-    /// as a non-generic trait object.
+    /// Returns an `Rc<Effect>` so the effect can be stored and shared
+    /// as a non-generic type.
     ///
     /// # Examples
     ///
@@ -80,8 +43,16 @@ where
     /// assert_eq!(counter.get(), 1);
     /// ```
     #[allow(clippy::new_ret_no_self)]
-    pub fn new(f: F) -> Rc<dyn IEffect> {
-        Self::new_inner::<fn()>(f, None)
+    pub fn new(f: impl Fn() + 'static) -> Rc<Effect> {
+        let e: Rc<Effect> = Rc::new(Effect { f: Box::new(f) });
+        let w = Rc::downgrade(&e);
+
+        // Dependency collection only at creation time
+        effect_push(w.clone(), true);
+        e.run();
+        effect_pop(w.clone(), true);
+
+        e
     }
 
     /// Creates a new `Effect` with an additional dependency initializer.
@@ -97,8 +68,8 @@ where
     /// (e.g. `if`/`match`), and you want to ensure that *all possible branches*
     /// have their dependencies tracked on the first run.
     ///
-    /// Returns an `Rc<dyn IEffect>` so the effect can be stored and shared
-    /// as a non-generic trait object.
+    /// Returns an `Rc<Effect>` so the effect can be stored and shared
+    /// as a non-generic type.
     ///
     /// # Examples
     ///
@@ -141,46 +112,42 @@ where
     /// COUNTER_set(20);
     /// assert_eq!(result.get(), 20);
     /// ```
-    pub fn new_with_deps<D>(f: F, deps: D) -> Rc<dyn IEffect>
-    where
-        D: Fn() + 'static,
-    {
-        Self::new_inner(f, Some(deps))
+    pub fn new_with_deps(f: impl Fn() + 'static, deps: impl Fn()) -> Rc<Effect> {
+        let e: Rc<Effect> = Rc::new(Effect { f: Box::new(f) });
+        let w = Rc::downgrade(&e);
+
+        // Dependency collection only at creation time
+        effect_push(w.clone(), true);
+        deps();
+        effect_pop(w.clone(), true);
+
+        // If there is an additional dependency initializer,
+        // the `Effect` needs to be run immediately
+        // after dependency collection is completed.
+        run_untracked(&e);
+
+        e
     }
-}
 
-/// A non-generic trait for reactive effects.
-///
-/// `IEffect` serves as a type-erased trait for `Effect<F>` instances.
-/// By implementing `IEffect`, an `Effect<F>` can be stored as `Rc<dyn IEffect>`
-/// regardless of the specific closure type `F`. This allows the reactive system
-/// to manage multiple effects uniformly without exposing the generic type.
-pub trait IEffect {
     /// Runs the effect closure.
     ///
     /// Typically called by the reactive system when dependencies change.
     ///
     /// # Notes
     ///
-    /// Any calls to `Effect` must be handled with care.
+    /// After initialization, any call to an `Effect` must go through `run()`.
+    /// Since the preconditions for executing `run()` differ depending on context
+    /// (e.g. dependency collection vs. signal-triggered updates), such calls
+    /// must be handled with care.
     ///
-    /// After initialization, any calls to an `Effect` are completely dependent on
-    /// run() , including Signal-triggered runs or dependency collection. However,
-    /// these calls have different assumptions.
+    /// Dependency collection for an `Effect` should be limited to its directly
+    /// connected signals. The intended call chain is:
     ///
-    /// Specifically, dependency collection for an `Effect` should be limited to
-    /// its directly connected Signals. In this case, the `Effect`'s call chain
-    /// conforms to the `Effect → Memo(s) → Signal(s)` model, which assumes that
-    /// the `Effect` must be the start of the call chain. Any Signals linked to
-    /// calls to other `Effect`s should not be collected, and runs triggered by
-    /// `Signal`s should not be subject to dependency collection.
-    fn run(&self);
-}
-
-impl<F> IEffect for Effect<F>
-where
-    F: Fn(),
-{
+    /// `Effect → Memo(s) → Signal(s)`
+    ///
+    /// In this model, the `Effect` must always be the root of the chain.
+    /// Other `Effect`s should not be tracked as dependencies, and runs triggered
+    /// by signals should not themselves cause further dependency collection.
     fn run(&self) {
         assert!(
             std::ptr::eq(&*effect_peak().unwrap().effect.upgrade().unwrap(), self),
@@ -191,7 +158,7 @@ where
     }
 }
 
-pub(crate) fn run_untracked(e: &Rc<dyn IEffect>) {
+pub(crate) fn run_untracked(e: &Rc<Effect>) {
     let w = Rc::downgrade(e);
 
     effect_push(w.clone(), false);

cache/src/effect_stack.rs

@@ -4,24 +4,24 @@ use std::rc::Weak;
 
 use once_cell::unsync::Lazy;
 
-use crate::IEffect;
+use crate::Effect;
 
 pub(crate) struct EffectStackEntry {
-    pub(crate) effect: Weak<dyn IEffect>,
+    pub(crate) effect: Weak<Effect>,
     pub(crate) collecting: bool,
 }
 
 static mut EFFECT_STACK: Lazy<Vec<EffectStackEntry>> = Lazy::new(Vec::new);
 
-pub(crate) fn effect_push(effect: Weak<dyn IEffect>, collecting: bool) {
+pub(crate) fn effect_push(effect: Weak<Effect>, collecting: bool) {
     unsafe { EFFECT_STACK.push(EffectStackEntry { effect, collecting }) }
 }
 
 pub(crate) fn effect_peak() -> Option<&'static EffectStackEntry> {
     unsafe { EFFECT_STACK.last() }
 }
 
-pub(crate) fn effect_pop(effect: Weak<dyn IEffect>, collecting: bool) {
+pub(crate) fn effect_pop(effect: Weak<Effect>, collecting: bool) {
     let e = unsafe { EFFECT_STACK.pop() }
         .expect("`effect_push` and `effect_pop` are called in pairs and should not be empty.");
 

cache/src/lib.rs

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

cache/src/memo.rs

@@ -4,7 +4,7 @@ use crate::{Observable, call_stack, remove_from_cache, store_in_cache, touch};
 
 /// A memoized reactive computation that caches its result and tracks dependencies.
 ///
-/// `Memo<T, F>` behaves similarly to a computed property: it stores the result of a closure
+/// `Memo<T>` behaves similarly to a computed property: it stores the result of a closure
 /// and only recomputes when its dependencies change. Other signals or effects that access
 /// the memo will automatically be tracked.
 ///
@@ -15,29 +15,19 @@ use crate::{Observable, call_stack, remove_from_cache, store_in_cache, touch};
 /// # Type Parameters
 ///
 /// - `T`: The result type of the computation. Must implement `Clone`.
-/// - `F`: The closure type that computes the value. Must implement `Fn() -> T`.
-pub struct Memo<T, F>
-where
-    F: Fn() -> T,
-{
-    f: F,
+pub struct Memo<T> {
+    f: Box<dyn Fn() -> T>,
     dependents: RefCell<Vec<&'static dyn Observable>>,
 }
 
-impl<T, F> Observable for Memo<T, F>
-where
-    F: Fn() -> T,
-{
+impl<T> Observable for Memo<T> {
     fn invalidate(&'static self) {
         remove_from_cache(self);
         self.dependents.borrow().iter().for_each(|d| d.invalidate());
     }
 }
 
-impl<T, F> Memo<T, F>
-where
-    F: Fn() -> T,
-{
+impl<T> Memo<T> {
     /// Creates a new `Memo` wrapping the provided closure.
     ///
     /// # Examples
@@ -47,9 +37,9 @@ where
     ///
     /// let memo = Memo::new(|| 10);
     /// ```
-    pub fn new(f: F) -> Self {
+    pub fn new(f: impl Fn() -> T + 'static) -> Self {
         Memo {
-            f,
+            f: Box::new(f),
             dependents: vec![].into(),
         }
     }
@@ -64,7 +54,7 @@ where
     /// use once_cell::unsync::Lazy;
     /// use reactive_cache::Memo;
     ///
-    /// static mut MEMO: Lazy<Memo<i32, fn() -> i32>> = Lazy::new(|| Memo::new(|| 5));
+    /// static mut MEMO: Lazy<Memo<i32>> = Lazy::new(|| Memo::new(|| 5));
     /// assert_eq!(unsafe { (*MEMO).get() }, 5);
     /// ```
     pub fn get(&'static self) -> T

cache/src/signal.rs

@@ -3,7 +3,7 @@ use std::{
     rc::Weak,
 };
 
-use crate::{IEffect, Observable, call_stack, effect_stack::EffectStackEntry};
+use crate::{Effect, Observable, call_stack, effect_stack::EffectStackEntry};
 
 /// A reactive signal that holds a value, tracks dependencies, and triggers effects.
 ///
@@ -23,7 +23,7 @@ use crate::{IEffect, Observable, call_stack, effect_stack::EffectStackEntry};
 pub struct Signal<T> {
     value: RefCell<T>,
     dependents: RefCell<Vec<&'static dyn Observable>>,
-    effects: RefCell<Vec<Weak<dyn IEffect>>>,
+    effects: RefCell<Vec<Weak<Effect>>>,
 }
 
 impl<T> Signal<T> {

macros/src/lib.rs

@@ -241,7 +241,7 @@ pub fn memo(_attr: TokenStream, item: TokenStream) -> TokenStream {
     }
 
     let ident = format_ident!("{}", ident.to_string().to_uppercase());
-    let ty = quote! { reactive_cache::Lazy<reactive_cache::Memo<#output_ty, fn() -> #output_ty>> };
+    let ty = quote! { reactive_cache::Lazy<reactive_cache::Memo<#output_ty>> };
     let expr = quote! { reactive_cache::Lazy::new(|| reactive_cache::Memo::new(|| #block)) };
 
     let expanded = quote! {