feat(macros): refactor the signal! macro to return a &'static Rc<Signal<T>> type, remove the ref_signal! macro, and update the documentation, sample code, and test cases.

Author: fxdmhtt

cache/src/effect.rs

@@ -166,7 +166,7 @@ impl Effect {
     /// ```
     /// use std::{cell::Cell, rc::Rc};
     /// use reactive_cache::Effect;
-    /// use reactive_macros::{ref_signal, signal};
+    /// use reactive_macros::signal;
     ///
     /// signal!(static mut FLAG: bool = true;);
     /// signal!(static mut COUNTER: i32 = 10;);
@@ -177,29 +177,29 @@ impl Effect {
     /// // Effect closure has a conditional branch
     /// let effect = Effect::new_with_deps(
     ///     move || {
-    ///         match *FLAG_get() {
+    ///         match *FLAG().get() {
     ///             true => {}
     ///             false => {
-    ///                 r_clone.set(*COUNTER_get());
+    ///                 r_clone.set(*COUNTER().get());
     ///             }
     ///         }
     ///     },
     ///     // Explicitly declare both `FLAG` and `COUNTER` as dependencies
     ///     move || {
-    ///         FLAG();
-    ///         COUNTER();
+    ///         FLAG().get();
+    ///         COUNTER().get();
     ///     },
     /// );
     ///
     /// assert_eq!(result.get(), 0); // runs with FLAG = true
     ///
     /// // Changing `FLAG` to false will trigger the effect
-    /// FLAG_set(false);
+    /// 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);
+    /// COUNTER().set(20);
     /// assert_eq!(result.get(), 20);
     /// ```
     pub fn new_with_deps(f: impl Fn() + 'static, deps: impl Fn()) -> Rc<Effect> {

cache/src/macros.rs

@@ -27,7 +27,7 @@
 /// ```rust
 /// use std::{cell::Cell, rc::Rc};
 /// use reactive_cache::effect;
-/// use reactive_macros::{ref_signal, signal};
+/// use reactive_macros::signal;
 ///
 /// signal!(static mut A: i32 = 1;);
 ///
@@ -37,7 +37,7 @@
 ///
 /// // `effect!(f)` form
 /// let e = effect!(move || {
-///     let _ = A();           // reading the signal
+///     let _ = A().get();           // reading the signal
 ///     counter_clone.set(counter_clone.get() + 1); // increment effect counter
 /// });
 ///
@@ -47,11 +47,11 @@
 /// assert_eq!(counter.get(), 1);
 ///
 /// // Changing A triggers the effect again
-/// assert!(A_set(10));
+/// assert!(A().set(10));
 /// assert_eq!(counter.get(), 2);
 ///
 /// // Setting the same value does NOT trigger the effect
-/// assert!(!A_set(10));
+/// assert!(!A().set(10));
 /// assert_eq!(counter.get(), 2);
 ///
 /// // `effect!(f, deps)` form

macros/src/lib.rs

@@ -2,33 +2,34 @@ use proc_macro::TokenStream;
 use quote::{format_ident, quote};
 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.
+/// Wraps a `static mut` variable as a reactive global signal.
 ///
-/// The `ref_signal!` macro transforms a `static mut` variable into a `reactive_cache::Signal`,
-/// and automatically generates:
-/// 1. A `_get()` function that returns a reference to the value, allowing read access.
-///    - This reference behaves like a normal immutable reference for most purposes.
-/// 2. A `_set(value)` function to write the value (returns `true` if changed).
-///
-/// Unlike `signal!`, `ref_signal!` does **not** generate a same-named function that directly returns the value.
+/// The `signal!` macro transforms a `static mut` variable into a `reactive_cache::Signal`,
+/// and generates a **function with the same name as the variable** that returns a
+/// `&'static Rc<Signal<T>>`. You can then call `.get()` to read the value or `.set(value)` to update it.
 ///
 /// # Requirements
 ///
-/// - The macro currently supports only `static mut` variables.
-/// - The variable type must implement `Eq`.
+/// - Supports only `static mut` variables.
+/// - Type `T` must implement `Eq`.
 ///
 /// # Examples
 ///
 /// ```rust
-/// use reactive_macros::ref_signal;
+/// use reactive_macros::signal;
+///
+/// signal!(static mut A: i32 = 10;);
+///
+/// assert_eq!(*A().get(), 10);
+/// assert!(A().set(20));
+/// assert_eq!(*A().get(), 20);
+/// assert!(!A().set(20)); // No change
 ///
-/// ref_signal!(static mut A: String = "hello".to_string(););
+/// signal!(static mut B: String = "hello".to_string(););
 ///
-/// assert_eq!(&*A_get(), "hello");
-/// assert!(A_set("signal".to_string()));
-/// assert_eq!(&*A_get(), "signal");
-/// assert!(!A_set("signal".to_string())); // No change
+/// assert_eq!(*B().get(), "hello");
+/// assert!(B().set("world".to_string()));
+/// assert_eq!(*B().get(), "world");
 /// ```
 ///
 /// # SAFETY
@@ -51,121 +52,22 @@ use syn::{Ident, ItemFn, ItemStatic, ReturnType, parse_macro_input};
 /// halting problem. Therefore, you must ensure manually that effects do not
 /// update signals within their own dependency chain.
 #[proc_macro]
-pub fn ref_signal(input: TokenStream) -> TokenStream {
+pub fn signal(input: TokenStream) -> TokenStream {
     let item = parse_macro_input!(input as ItemStatic);
 
-    let attrs = &item.attrs;
     let vis = &item.vis;
-    let static_token = &item.static_token;
-    let _mutability = &item.mutability;
     let ident = &item.ident;
-    let colon_token = &item.colon_token;
     let ty = &item.ty;
-    let eq_token = &item.eq_token;
     let expr = &item.expr;
-    let semi_token = &item.semi_token;
-
-    let mutability = match &item.mutability {
-        syn::StaticMutability::Mut(_) => quote! { mut },
-        syn::StaticMutability::None => quote! {},
-        _ => {
-            return syn::Error::new_spanned(&item.mutability, "Mutability not supported")
-                .to_compile_error()
-                .into();
-        }
-    };
-
-    let ident_p = format_ident!("_{}", ident.to_string().to_uppercase());
-    let ident_get = format_ident!("{}_get", ident);
-    let ident_set = format_ident!("{}_set", ident);
 
     let lazy_ty = quote! { reactive_cache::Lazy<std::rc::Rc<reactive_cache::Signal<#ty>>> };
     let expr = quote! { reactive_cache::Lazy::new(|| reactive_cache::Signal::new(#expr)) };
 
     let expanded = quote! {
-        #(#attrs)*
-        #vis #static_token #mutability #ident_p #colon_token #lazy_ty #eq_token #expr #semi_token
-
-        #[allow(non_snake_case)]
-        pub fn #ident_get() -> std::cell::Ref<'static, #ty> {
-            unsafe { #ident_p.get() }
-        }
-
-        #[allow(non_snake_case)]
-        pub fn #ident_set(value: #ty) -> bool {
-            unsafe { #ident_p.set(value) }
-        }
-    };
-
-    expanded.into()
-}
-
-/// Wraps a `static mut` variable as a reactive signal (similar to a property)
-/// with getter and setter functions.
-///
-/// The `signal!` macro transforms a `static mut` variable into a `reactive_cache::Signal`,
-/// and automatically generates:
-/// 1. A `_get()` function that returns a reference to the value, allowing read access.
-///    - This reference behaves like a normal immutable reference for most purposes.
-/// 2. A `_set(value)` function to write the value (returns `true` if changed).
-/// 3. A function with the same name as the variable that directly returns the value
-///    by dereferencing the underlying variable. This requires the type to implement `Copy`.
-///
-/// # Requirements
-///
-/// - The macro currently supports only `static mut` variables.
-/// - The variable type must implement `Eq`.
-///
-/// # Examples
-///
-/// ```rust
-/// use reactive_macros::{ref_signal, signal};
-///
-/// signal!(static mut A: i32 = 10;);
-///
-/// assert_eq!(A(), 10);          // returns value directly (requires Copy)
-/// assert_eq!(*A_get(), 10);     // returns a reference to the value
-/// assert!(A_set(20));
-/// assert_eq!(A(), 20);
-/// assert!(!A_set(20)); // No change
-/// ```
-///
-/// # SAFETY
-///
-/// This macro wraps `static mut` variables internally, so it **is not thread-safe**.
-/// It should be used only 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 signal(input: TokenStream) -> TokenStream {
-    let input_clone: proc_macro2::TokenStream = input.clone().into();
-
-    let item = parse_macro_input!(input as ItemStatic);
-    let ident = &item.ident;
-    let ty = &item.ty;
-
-    let ident_p = format_ident!("_{}", ident.to_string().to_uppercase());
-    let ident_fn = format_ident!("{}", ident);
-
-    let expanded = quote! {
-        ref_signal!(#input_clone);
-
         #[allow(non_snake_case)]
-        pub fn #ident_fn() -> #ty {
-            *unsafe { #ident_p.get() }
+        #vis fn #ident() -> &'static std::rc::Rc<reactive_cache::Signal<#ty>> {
+            static mut #ident: #lazy_ty = #expr;
+            unsafe { &*#ident }
         }
     };
 
@@ -252,12 +154,9 @@ pub fn memo(_attr: TokenStream, item: TokenStream) -> TokenStream {
     let expr = quote! { reactive_cache::Lazy::new(|| reactive_cache::Memo::new(|| #block)) };
 
     let expanded = quote! {
-        static mut #ident: #ty = #expr;
-
-        #vis #sig
-        where #output_ty: Clone
-        {
-            unsafe { (*#ident).get() }
+        #vis #sig {
+            static mut #ident: #ty = #expr;
+            unsafe { #ident.get() }
         }
     };
 
@@ -281,7 +180,7 @@ pub fn memo(_attr: TokenStream, item: TokenStream) -> TokenStream {
 /// # Examples
 ///
 /// ```rust
-/// use reactive_macros::{evaluate, ref_signal};
+/// use reactive_macros::evaluate;
 ///
 /// fn print(msg: String) {
 ///     println!("{}", msg);

macros/tests/dep.rs

@@ -2,7 +2,7 @@
 
 use std::cell::Cell;
 
-use reactive_macros::{memo, ref_signal, signal};
+use reactive_macros::{memo, signal};
 
 thread_local! {
     static SOURCE_A_CALLED: Cell<bool> = const { Cell::new(false) };
@@ -16,20 +16,20 @@ signal!(
     static mut A: i32 = 10;
 );
 
-ref_signal!(
+signal!(
     static mut B: String = 5.to_string();
 );
 
 pub fn source_a() -> i32 {
     SOURCE_A_CALLED.set(true);
 
-    A()
+    *A().get()
 }
 
 pub fn source_b() -> i32 {
     SOURCE_B_CALLED.set(true);
 
-    B_get().parse::<i32>().unwrap()
+    B().get().parse::<i32>().unwrap()
 }
 
 #[memo]
@@ -137,7 +137,7 @@ fn signal_set_unchanged_test() {
     DERIVED_D_CALLED.set(false);
     DERIVED_E_CALLED.set(false);
 
-    A_set(10);
+    A().set(10);
 
     assert!(!SOURCE_A_CALLED.get());
     assert!(!SOURCE_B_CALLED.get());
@@ -182,8 +182,8 @@ fn signal_set_value_test() {
     DERIVED_D_CALLED.set(false);
     DERIVED_E_CALLED.set(false);
 
-    A_set(20);
-    A_set(10);
+    A().set(20);
+    A().set(10);
 
     assert!(!SOURCE_A_CALLED.get());
     assert!(!SOURCE_B_CALLED.get());