Refactored the Effect creation logic

Author: fxdmhtt

cache/src/cache.rs

@@ -17,7 +17,7 @@ pub(crate) fn touch<T: 'static>(key: &'static dyn Observable) -> Option<Rc<T>> {
     // When the Effect performs dependency calculations for the first time,
     // it must ignore the relevant cache,
     // otherwise the underlying Signal will not remember the Effect.
-    if crate::current_effect_peak().is_some() {
+    if crate::creating_effect_peak().is_some() {
         remove_from_cache(key);
         return None;
     }

cache/src/call_stack.rs

@@ -1,14 +1,14 @@
 #![allow(static_mut_refs)]
 
-use std::rc::Rc;
+use std::rc::Weak;
 
 use once_cell::sync::Lazy;
 
 use crate::{Effect, Observable};
 
 static mut CALL_STACK: Lazy<Vec<&'static dyn Observable>> = Lazy::new(Vec::new);
 
-static mut CURRENT_EFFECT: Option<Rc<Effect>> = None;
+static mut CREATING_EFFECT: Option<Weak<Effect>> = 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 current_effect_push(effect: Rc<Effect>) {
-    assert!(unsafe { CURRENT_EFFECT.is_none() });
-    unsafe { CURRENT_EFFECT = Some(effect) }
+pub(crate) fn creating_effect_push(effect: Weak<Effect>) {
+    assert!(unsafe { CREATING_EFFECT.is_none() });
+    unsafe { CREATING_EFFECT = Some(effect) }
 }
 
-pub(crate) fn current_effect_peak() -> Option<Rc<Effect>> {
-    unsafe { CURRENT_EFFECT.clone() }
+pub(crate) fn creating_effect_peak() -> Option<Weak<Effect>> {
+    unsafe { CREATING_EFFECT.clone() }
 }
 
-pub(crate) fn current_effect_pop() -> Rc<Effect> {
-    assert!(unsafe { CURRENT_EFFECT.is_some() });
-    unsafe { CURRENT_EFFECT.take().unwrap() }
+pub(crate) fn creating_effect_pop() -> Weak<Effect> {
+    assert!(unsafe { CREATING_EFFECT.is_some() });
+    unsafe { CREATING_EFFECT.take().unwrap() }
 }

cache/src/effect.rs

@@ -8,9 +8,9 @@ impl Effect {
     pub fn new(f: impl Fn() + 'static) -> Rc<Self> {
         let e = Rc::new(Effect { f: Box::new(f) });
 
-        crate::current_effect_push(e.clone());
+        crate::creating_effect_push(Rc::downgrade(&e));
         e.run();
-        crate::current_effect_pop();
+        crate::creating_effect_pop();
 
         e
     }

cache/src/lib.rs

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

cache/src/signal.rs

@@ -1,6 +1,6 @@
 use std::{
     cell::{Ref, RefCell},
-    rc::{Rc, Weak},
+    rc::Weak,
 };
 
 use crate::{Effect, Observable, call_stack};
@@ -62,11 +62,10 @@ where
             self.dependents.borrow_mut().push(*last);
         }
 
-        if let Some(e) = call_stack::current_effect_peak() {
-            let e = Rc::downgrade(&e);
-            if !self.effects.borrow().iter().any(|w| Weak::ptr_eq(w, &e)) {
-                self.effects.borrow_mut().push(e);
-            }
+        if let Some(e) = call_stack::creating_effect_peak()
+            && !self.effects.borrow().iter().any(|w| Weak::ptr_eq(w, &e))
+        {
+            self.effects.borrow_mut().push(e);
         }
 
         self.value.borrow()