feat(cache): Refactored the cache mechanism and optimized dependency management, aiming to eliminate tight coupling with global variables.

- Optimized dependency management using Rc and Weak
- Rewrote the Memo structure and related logic

Author: fxdmhtt

cache/src/cache.rs

@@ -4,16 +4,14 @@ use lru::LruCache;
 use once_cell::unsync::Lazy;
 use std::{any::Any, num::NonZeroUsize, rc::Rc};
 
-use crate::Observable;
-
-type CacheKey = *const dyn Observable;
+use crate::IMemo;
 
 const CACHE_CAP: usize = 128;
 
-static mut CACHE: Lazy<LruCache<CacheKey, Rc<dyn Any>>> =
+static mut CACHE: Lazy<LruCache<*const dyn IMemo, Rc<dyn Any>>> =
     Lazy::new(|| LruCache::new(NonZeroUsize::new(CACHE_CAP).unwrap()));
 
-pub(crate) fn touch<T>(key: &'static dyn Observable) -> Option<Rc<T>>
+pub(crate) fn touch<T>(key: &Rc<dyn IMemo>) -> Option<Rc<T>>
 where
     T: 'static,
 {
@@ -25,21 +23,21 @@ where
         return None;
     }
 
-    unsafe { CACHE.get(&(key as _)) }
+    unsafe { CACHE.get(&Rc::as_ptr(key)) }
         .map(Rc::clone)
         .filter(|rc| rc.is::<T>())
         .map(|rc| unsafe { Rc::from_raw(Rc::into_raw(rc) as *const T) })
 }
 
-pub(crate) fn store_in_cache<T>(key: &'static dyn Observable, val: T) -> Rc<T>
+pub(crate) fn store_in_cache<T>(key: &Rc<dyn IMemo>, val: T) -> Rc<T>
 where
     T: 'static,
 {
     let rc = Rc::new(val);
-    unsafe { CACHE.put(key, Rc::clone(&rc) as _) };
+    unsafe { CACHE.put(Rc::as_ptr(key), Rc::clone(&rc) as _) };
     rc
 }
 
-pub(crate) fn remove_from_cache(key: &'static dyn Observable) {
-    unsafe { CACHE.pop(&(key as _)) };
+pub(crate) fn remove_from_cache(key: &Rc<dyn IMemo>) -> bool {
+    unsafe { CACHE.pop(&Rc::as_ptr(key)) }.is_some()
 }

cache/src/call_stack.rs

@@ -1,6 +1,7 @@
 pub(crate) mod cache;
-pub(crate) mod call_stack;
 pub(crate) mod effect_stack;
+pub(crate) mod memo_stack;
+pub(crate) mod observable;
 
 pub mod effect;
 pub mod macros;
@@ -9,13 +10,11 @@ pub mod signal;
 
 pub(crate) use cache::{remove_from_cache, store_in_cache, touch};
 pub use effect::Effect;
+pub(crate) use memo::IMemo;
 pub use memo::Memo;
+pub(crate) use observable::IObservable;
 pub use signal::Signal;
 
-pub(crate) trait Observable {
-    fn invalidate(&'static self);
-}
-
 pub use once_cell::unsync::Lazy;
 
 #[cfg(feature = "macros")]

cache/src/lib.rs

@@ -1,6 +1,9 @@
-use std::cell::RefCell;
+use std::{
+    cell::RefCell,
+    rc::{Rc, Weak},
+};
 
-use crate::{Observable, call_stack, remove_from_cache, store_in_cache, touch};
+use crate::{IObservable, memo_stack, store_in_cache, touch};
 
 /// A memoized reactive computation that caches its result and tracks dependencies.
 ///
@@ -17,31 +20,36 @@ use crate::{Observable, call_stack, remove_from_cache, store_in_cache, touch};
 /// - `T`: The result type of the computation. Must implement `Clone`.
 pub struct Memo<T> {
     f: Box<dyn Fn() -> T>,
-    dependents: RefCell<Vec<&'static dyn Observable>>,
-}
-
-impl<T> Observable for Memo<T> {
-    fn invalidate(&'static self) {
-        remove_from_cache(self);
-        self.dependents.borrow().iter().for_each(|d| d.invalidate());
-    }
+    dependents: RefCell<Vec<Weak<dyn IMemo>>>,
+    /// A self-referential weak pointer, set during construction with `Rc::new_cyclic`.
+    /// Used to upgrade to `Rc<Memo<T>>` and then coerce into `Rc<dyn IMemo>` when needed.
+    weak: Weak<Memo<T>>,
 }
 
 impl<T> Memo<T> {
     /// Creates a new `Memo` wrapping the provided closure.
     ///
+    /// # Requirements
+    /// - `T` must be `'static`, because the value is stored in global cache.
+    /// - The closure must be `'static` as well.
+    ///
     /// # Examples
     ///
     /// ```
     /// use reactive_cache::Memo;
     ///
     /// let memo = Memo::new(|| 10);
+    /// assert_eq!(memo.get(), 10);
     /// ```
-    pub fn new(f: impl Fn() -> T + 'static) -> Self {
-        Memo {
+    pub fn new(f: impl Fn() -> T + 'static) -> Rc<Self>
+    where
+        T: 'static,
+    {
+        Rc::new_cyclic(|weak| Memo {
             f: Box::new(f),
             dependents: vec![].into(),
-        }
+            weak: weak.clone(),
+        })
     }
 
     /// Returns the memoized value, recomputing it only if necessary.
@@ -51,37 +59,45 @@ impl<T> Memo<T> {
     /// # Examples
     ///
     /// ```
-    /// use once_cell::unsync::Lazy;
     /// use reactive_cache::Memo;
     ///
-    /// static mut MEMO: Lazy<Memo<i32>> = Lazy::new(|| Memo::new(|| 5));
-    /// assert_eq!(unsafe { (*MEMO).get() }, 5);
+    /// let memo = Memo::new(|| 5);
+    /// assert_eq!(memo.get(), 5);
     /// ```
-    pub fn get(&'static self) -> T
+    pub fn get(&self) -> T
     where
-        T: Clone,
+        T: Clone + 'static,
     {
-        if let Some(last) = call_stack::last()
-            && !self
-                .dependents
-                .borrow()
-                .iter()
-                .any(|d| std::ptr::eq(*d, *last))
-        {
-            self.dependents.borrow_mut().push(*last);
-        }
+        self.dependency_collection();
 
-        call_stack::push(self);
+        memo_stack::push(self.weak.clone());
 
-        let rc = if let Some(rc) = touch(self) {
-            rc
+        let rc = if let Some(this) = self.weak.upgrade() {
+            let key: Rc<dyn IMemo> = this.clone();
+            if let Some(rc) = touch(&key) {
+                rc
+            } else {
+                let result: T = (self.f)();
+                store_in_cache(&key, result)
+            }
         } else {
-            let result: T = (self.f)();
-            store_in_cache(self, result)
+            unreachable!()
         };
 
-        call_stack::pop();
+        memo_stack::pop();
 
         (*rc).clone()
     }
 }
+
+impl<T> IObservable for Memo<T> {
+    fn dependents(&self) -> &RefCell<Vec<Weak<dyn IMemo>>> {
+        &self.dependents
+    }
+}
+
+/// Internal marker trait for all memoized computations.
+/// Used for type erasure when storing heterogeneous `Memo<T>` in caches.
+pub(crate) trait IMemo: IObservable {}
+
+impl<T> IMemo for Memo<T> {}

cache/src/memo.rs

@@ -0,0 +1,21 @@
+#![allow(static_mut_refs)]
+
+use std::rc::Weak;
+
+use once_cell::sync::Lazy;
+
+use crate::IMemo;
+
+static mut MEMO_STACK: Lazy<Vec<Weak<dyn IMemo>>> = Lazy::new(Vec::new);
+
+pub(crate) fn push(op: Weak<dyn IMemo>) {
+    unsafe { MEMO_STACK.push(op) }
+}
+
+pub(crate) fn last() -> Option<&'static Weak<dyn IMemo>> {
+    unsafe { MEMO_STACK.last() }
+}
+
+pub(crate) fn pop() -> Option<Weak<dyn IMemo>> {
+    unsafe { MEMO_STACK.pop() }
+}

cache/src/memo_stack.rs

@@ -0,0 +1,33 @@
+use std::{cell::RefCell, rc::Weak};
+
+use crate::{IMemo, memo_stack, remove_from_cache};
+
+pub(crate) trait IObservable {
+    fn dependents(&self) -> &RefCell<Vec<Weak<dyn IMemo>>>;
+
+    /// Invalidates all dependent observables.
+    fn invalidate(&self) {
+        self.dependents().borrow_mut().retain(|d| {
+            if let Some(d) = d.upgrade() {
+                remove_from_cache(&d);
+                d.invalidate();
+                true
+            } else {
+                false
+            }
+        });
+    }
+
+    /// Track observables in the call stack
+    fn dependency_collection(&self) {
+        if let Some(last) = memo_stack::last()
+            && !self
+                .dependents()
+                .borrow()
+                .iter()
+                .any(|d| Weak::ptr_eq(d, last))
+        {
+            self.dependents().borrow_mut().push(last.clone());
+        }
+    }
+}

cache/src/observable.rs

@@ -3,7 +3,7 @@ use std::{
     rc::Weak,
 };
 
-use crate::{Effect, Observable, call_stack, effect_stack::EffectStackEntry};
+use crate::{Effect, IMemo, IObservable, effect_stack::EffectStackEntry};
 
 /// A reactive signal that holds a value, tracks dependencies, and triggers effects.
 ///
@@ -22,17 +22,15 @@ use crate::{Effect, Observable, call_stack, effect_stack::EffectStackEntry};
 /// - `T`: The type of the value stored in the signal. Must implement `Eq + Default`.
 pub struct Signal<T> {
     value: RefCell<T>,
-    dependents: RefCell<Vec<&'static dyn Observable>>,
+    dependents: RefCell<Vec<Weak<dyn IMemo>>>,
     effects: RefCell<Vec<Weak<Effect>>>,
 }
 
 impl<T> Signal<T> {
-    /// Invalidates all dependent observables.
-    fn invalidate(&self) {
-        self.dependents.borrow().iter().for_each(|d| d.invalidate());
-    }
-
-    /// Runs all dependent effects.
+    /// Re-runs all dependent effects that are still alive.
+    ///
+    /// This is triggered after the signal's value has changed.  
+    /// Dead effects (already dropped) are cleaned up automatically.
     fn flush_effects(&self) {
         // When triggering an Effect, dependencies are not collected for that Effect.
         self.effects.borrow_mut().retain(|w| {
@@ -45,11 +43,15 @@ impl<T> Signal<T> {
         });
     }
 
+    /// Called after the value is updated.  
+    /// Triggers all dependent effects.
     #[allow(non_snake_case)]
     fn OnPropertyChanged(&self) {
         self.flush_effects()
     }
 
+    /// Called before the value is updated.  
+    /// Invalidates all memoized computations depending on this signal.
     #[allow(non_snake_case)]
     fn OnPropertyChanging(&self) {
         self.invalidate()
@@ -81,7 +83,8 @@ impl<T> Signal<T> {
         }
     }
 
-    /// Gets a reference to the current value, tracking dependencies and effects if inside a reactive context.
+    /// Gets a reference to the current value, tracking dependencies
+    /// and effects if inside a reactive context.
     ///
     /// # Examples
     ///
@@ -92,16 +95,7 @@ impl<T> Signal<T> {
     /// assert_eq!(*signal.get(), 42);
     /// ```
     pub fn get(&self) -> Ref<'_, T> {
-        // Track observables in the call stack
-        if let Some(last) = call_stack::last()
-            && !self
-                .dependents
-                .borrow()
-                .iter()
-                .any(|d| std::ptr::eq(*d, *last))
-        {
-            self.dependents.borrow_mut().push(*last);
-        }
+        self.dependency_collection();
 
         // Track effects in the call stack
         if let Some(EffectStackEntry {
@@ -119,7 +113,8 @@ impl<T> Signal<T> {
 
     /// Sets the value of the signal.
     ///
-    /// Returns `true` if the value changed and dependent effects were triggered.
+    /// Returns `true` if the value changed, all dependent memos are
+    /// invalidated and dependent effects were triggered.
     ///
     /// # Examples
     ///
@@ -150,3 +145,9 @@ impl<T> Signal<T> {
         true
     }
 }
+
+impl<T> IObservable for Signal<T> {
+    fn dependents(&self) -> &RefCell<Vec<Weak<dyn IMemo>>> {
+        &self.dependents
+    }
+}

cache/src/signal.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>> };
+    let ty = quote! { reactive_cache::Lazy<std::rc::Rc<reactive_cache::Memo<#output_ty>>> };
     let expr = quote! { reactive_cache::Lazy::new(|| reactive_cache::Memo::new(|| #block)) };
 
     let expanded = quote! {