feat(cache): Added Effect::new_with_deps method, allowing users to pass in additional dependency initializers to avoid dependency exceptions caused by branch statements in Effect.

Author: fxdmhtt

cache/Cargo.toml

@@ -14,6 +14,9 @@ once_cell = "1.21.3"
 
 reactive-macros = { version = "0.2.0", path = "../macros", optional = true }
 
+[dev-dependencies]
+reactive-macros = { path = "../macros" }
+
 [features]
 default = []
 

cache/src/cache.rs

@@ -20,7 +20,7 @@ where
     // 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::creating_effect_peak().is_some() {
+    if unsafe { crate::call_stack::CREATING_EFFECT } {
         remove_from_cache(key);
         return None;
     }

cache/src/call_stack.rs

@@ -8,7 +8,8 @@ use crate::{IEffect, Observable};
 
 static mut CALL_STACK: Lazy<Vec<&'static dyn Observable>> = Lazy::new(Vec::new);
 
-static mut CREATING_EFFECT: Option<Weak<dyn IEffect>> = None;
+pub(crate) static mut CREATING_EFFECT: bool = false;
+static mut CURRENT_EFFECT: Option<Weak<dyn IEffect>> = None;
 
 pub(crate) fn push(op: &'static dyn Observable) {
     unsafe { CALL_STACK.push(op) }
@@ -22,16 +23,16 @@ pub(crate) fn pop() -> Option<&'static dyn Observable> {
     unsafe { CALL_STACK.pop() }
 }
 
-pub(crate) fn creating_effect_push(effect: Weak<dyn IEffect>) {
-    assert!(unsafe { CREATING_EFFECT.is_none() });
-    unsafe { CREATING_EFFECT = Some(effect) }
+pub(crate) fn current_effect_push(effect: Weak<dyn IEffect>) {
+    assert!(unsafe { CURRENT_EFFECT.is_none() });
+    unsafe { CURRENT_EFFECT = Some(effect) }
 }
 
-pub(crate) fn creating_effect_peak() -> Option<Weak<dyn IEffect>> {
-    unsafe { CREATING_EFFECT.clone() }
+pub(crate) fn current_effect_peak() -> Option<Weak<dyn IEffect>> {
+    unsafe { CURRENT_EFFECT.clone() }
 }
 
-pub(crate) fn creating_effect_pop() -> Weak<dyn IEffect> {
-    assert!(unsafe { CREATING_EFFECT.is_some() });
-    unsafe { CREATING_EFFECT.take().unwrap() }
+pub(crate) fn current_effect_pop() -> Weak<dyn IEffect> {
+    assert!(unsafe { CURRENT_EFFECT.is_some() });
+    unsafe { CURRENT_EFFECT.take().unwrap() }
 }

cache/src/effect.rs

@@ -29,6 +29,27 @@ impl<F> Effect<F>
 where
     F: Fn(),
 {
+    fn new_inner<D>(f: F, deps: Option<D>) -> Rc<dyn IEffect>
+    where
+        F: 'static,
+        D: Fn() + 'static,
+    {
+        let e: Rc<dyn IEffect> = Rc::new(Effect { f });
+
+        unsafe { crate::call_stack::CREATING_EFFECT = true };
+        crate::current_effect_push(Rc::downgrade(&e));
+
+        if let Some(deps) = deps {
+            deps();
+        }
+        e.run();
+
+        crate::current_effect_pop();
+        unsafe { crate::call_stack::CREATING_EFFECT = false };
+
+        e
+    }
+
     /// Creates a new `Effect`, wrapping the provided closure
     /// and running it immediately for dependency tracking.
     ///
@@ -56,13 +77,68 @@ where
     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();
+        Self::new_inner::<fn()>(f, None)
+    }
 
-        e
+    /// Creates a new `Effect` with an additional dependency initializer.
+    ///
+    /// This works like [`Effect::new`], but also runs the provided `deps` closure
+    /// during the initial dependency collection phase.
+    ///
+    /// This is useful when your effect closure contains conditional logic
+    /// (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.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::{cell::Cell, rc::Rc};
+    /// use reactive_cache::Effect;
+    /// use reactive_macros::signal;
+    ///
+    /// signal!(static mut FLAG: bool = true;);
+    /// signal!(static mut COUNTER: i32 = 10;);
+    ///
+    /// let result = Rc::new(Cell::new(0));
+    /// let r_clone = result.clone();
+    ///
+    /// // Effect closure has a conditional branch
+    /// let effect = Effect::new_with_deps(
+    ///     move || {
+    ///         match *FLAG_get() {
+    ///             true => {}
+    ///             false => {
+    ///                 r_clone.set(*COUNTER_get());
+    ///             }
+    ///         }
+    ///     },
+    ///     // Explicitly declare both `FLAG` and `COUNTER` as dependencies
+    ///     move || {
+    ///         FLAG();
+    ///         COUNTER();
+    ///     },
+    /// );
+    ///
+    /// assert_eq!(result.get(), 0); // runs with FLAG = true
+    /// 
+    /// // Changing `FLAG` to false will trigger the effect
+    /// FLAG_set(false);
+    /// assert_eq!(result.get(), 10);
+    ///
+    /// // Changing `COUNTER` still triggers the effect, even though
+    /// // `FLAG` was true on the first run.
+    /// COUNTER_set(20);
+    /// assert_eq!(result.get(), 20);
+    /// ```
+    pub fn new_with_deps<D>(f: F, deps: D) -> Rc<dyn IEffect>
+    where
+        F: 'static,
+        D: Fn() + 'static,
+    {
+        Self::new_inner(f, Some(deps))
     }
 }
 

cache/src/lib.rs

@@ -2,11 +2,12 @@ mod cache;
 mod call_stack;
 
 pub mod effect;
+pub mod macros;
 pub mod memo;
 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(crate) use call_stack::{current_effect_pop, current_effect_push};
 pub use effect::{Effect, IEffect};
 pub use memo::Memo;
 pub use signal::Signal;

cache/src/macros.rs

@@ -0,0 +1,87 @@
+/// Creates a reactive effect from a closure (and optionally a dependency collector).
+///
+/// The `effect!` macro is a convenient wrapper around
+/// [`reactive_cache::Effect::new`] and [`reactive_cache::Effect::new_with_deps`].
+/// It allows you to quickly register a reactive effect that automatically tracks
+/// dependencies and re-runs when they change.
+///
+/// # Forms
+///
+/// - `effect!(f)`  
+///   Equivalent to calling [`Effect::new(f)`].
+///
+/// - `effect!(f, deps)`  
+///   Equivalent to calling [`Effect::new_with_deps(f, deps)`].
+///
+/// # Requirements
+///
+/// - `f` must be a closure or function pointer that takes no arguments and returns `()`.
+/// - `deps` (if provided) must also be a closure or function pointer taking no arguments and returning `()`.
+///
+/// # Examples
+///
+/// ```rust
+/// use std::{cell::Cell, rc::Rc};
+/// use reactive_cache::effect;
+/// use reactive_macros::signal;
+///
+/// signal!(static mut A: i32 = 1;);
+///
+/// // Track effect runs
+/// let counter = Rc::new(Cell::new(0));
+/// let counter_clone = counter.clone();
+///
+/// // `effect!(f)` form
+/// let e = effect!(move || {
+///     let _ = A();           // reading the signal
+///     counter_clone.set(counter_clone.get() + 1); // increment effect counter
+/// });
+///
+/// let ptr = Rc::into_raw(e); // actively leak to avoid implicitly dropping the effect
+///
+/// // Effect runs immediately upon creation
+/// assert_eq!(counter.get(), 1);
+///
+/// // Changing A triggers the effect again
+/// assert!(A_set(10));
+/// assert_eq!(counter.get(), 2);
+///
+/// // Setting the same value does NOT trigger the effect
+/// assert!(!A_set(10));
+/// assert_eq!(counter.get(), 2);
+///
+/// // `effect!(f, deps)` form
+/// let _ = effect!(
+///     || println!("effect body"),
+///     || println!("dependency collector")
+/// );
+/// ```
+///
+/// # SAFETY
+///
+/// The macro internally uses [`reactive_cache::Effect`], which relies on
+/// `static` tracking and is **not thread-safe**. Only use in single-threaded contexts.
+///
+/// # Warning
+///
+/// **Do not set any signal that is part of the same effect chain.**
+///
+/// Effects automatically run whenever one of their dependent signals changes.
+/// If an effect modifies a signal that it (directly or indirectly) observes,
+/// it creates a circular dependency. This can lead to:
+/// - an infinite loop of updates, or
+/// - conflicting updates that the system cannot resolve.
+///
+/// In the general case, it is impossible to automatically determine whether
+/// such an effect will ever terminate—this is essentially a version of the
+/// halting problem. Therefore, you must ensure manually that effects do not
+/// update signals within their own dependency chain.
+#[macro_export]
+macro_rules! effect {
+    ($f:expr) => {
+        reactive_cache::Effect::new($f)
+    };
+    ($f:expr, $f2:expr) => {
+        reactive_cache::Effect::new_with_deps($f, $f2)
+    };
+}

cache/src/signal.rs

@@ -103,7 +103,7 @@ impl<T> Signal<T> {
         }
 
         // Track effects in the call stack
-        if let Some(e) = call_stack::creating_effect_peak()
+        if let Some(e) = call_stack::current_effect_peak()
             && !self.effects.borrow().iter().any(|w| Weak::ptr_eq(w, &e))
         {
             self.effects.borrow_mut().push(e);

macros/src/lib.rs

@@ -1,6 +1,6 @@
 use proc_macro::TokenStream;
 use quote::{format_ident, quote};
-use syn::{Expr, Ident, ItemFn, ItemStatic, ReturnType, parse_macro_input};
+use syn::{Ident, ItemFn, ItemStatic, ReturnType, parse_macro_input};
 
 /// Wraps a `static mut` variable as a reactive signal (similar to a property)
 /// with getter and setter functions.
@@ -175,8 +175,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, fn() -> #output_ty>> };
     let expr = quote! { reactive_cache::Lazy::new(|| reactive_cache::Memo::new(|| #block)) };
 
     let expanded = quote! {
@@ -192,95 +191,6 @@ pub fn memo(_attr: TokenStream, item: TokenStream) -> TokenStream {
     expanded.into()
 }
 
-/// Creates a reactive effect from a closure or function pointer.
-///
-/// The `effect!` procedural macro is a convenient wrapper around `reactive_cache::Effect::new`.
-/// It allows you to quickly register a reactive effect that automatically tracks
-/// dependencies and re-runs when they change.
-///
-/// # Requirements
-///
-/// - The argument must be either:
-///   1. A closure (e.g., `|| { ... }`), or  
-///   2. A function pointer / function name with zero arguments.
-/// - The closure or function must return `()` (no return value required).
-///
-/// # Examples
-///
-/// ```rust
-/// use std::{cell::Cell, rc::Rc};
-/// use reactive_macros::{effect, signal};
-///
-/// signal!(static mut A: i32 = 1;);
-///
-/// // Track effect runs
-/// let counter = Rc::new(Cell::new(0));
-/// let counter_clone = counter.clone();
-///
-/// let e = effect!(move || {
-///     let _ = A();           // reading the signal
-///     counter_clone.set(counter_clone.get() + 1); // increment effect counter
-/// });
-///
-/// let ptr = Rc::into_raw(e); // actively leak to avoid implicitly dropping the effect
-///
-/// // Effect runs immediately upon creation
-/// assert_eq!(counter.get(), 1);
-///
-/// // Changing A triggers the effect again
-/// assert!(A_set(10));
-/// assert_eq!(counter.get(), 2);
-///
-/// // Setting the same value does NOT trigger the effect
-/// assert!(!A_set(10));
-/// assert_eq!(counter.get(), 2);
-/// ```
-///
-/// # SAFETY
-///
-/// The macro internally uses `reactive_cache::Effect`, which relies on
-/// `static` tracking and is **not thread-safe**. Only use in single-threaded contexts.
-///
-/// # Warning
-///
-/// **Do not set any signal that is part of the same effect chain.**
-///
-/// Effects automatically run whenever one of their dependent signals changes.
-/// If an effect modifies a signal that it (directly or indirectly) observes,
-/// it creates a circular dependency. This can lead to:
-/// - an infinite loop of updates, or
-/// - conflicting updates that the system cannot resolve.
-///
-/// In the general case, it is impossible to automatically determine whether
-/// such an effect will ever terminate—this is essentially a version of the
-/// halting problem. Therefore, you must ensure manually that effects do not
-/// update signals within their own dependency chain.
-#[proc_macro]
-pub fn effect(input: TokenStream) -> TokenStream {
-    let expr = parse_macro_input!(input as Expr);
-
-    let expanded = match expr {
-        Expr::Path(path) if path.path.get_ident().is_some() => {
-            let ident = path.path.get_ident().unwrap();
-            quote! {
-                reactive_cache::Effect::new(#ident)
-            }
-        }
-        Expr::Closure(closure) => {
-            quote! {
-                reactive_cache::Effect::new(#closure)
-            }
-        }
-        _ => {
-            return syn::Error::new_spanned(&expr, "Expected a variable name or a closure")
-                .to_compile_error()
-                .into();
-        }
-    };
-
-    expanded.into()
-}
-
 /// Evaluates a zero-argument function and optionally reports when the value changes.
 ///
 /// The `#[evaluate(print_fn)]` attribute macro transforms a function into a reactive