feat(macros): Implement the ref_signal! macro and update the signal! macro.

- Added the `ref_signal!` macro to create a signal that returns a reference.
- Updated the `signal!` macro to return a value directly (requires the type to implement `Copy`).
- Modified relevant test files to adapt to the new signal macro.

Author: fxdmhtt

macros/src/lib.rs

@@ -5,11 +5,13 @@ 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.
 ///
-/// The `signal!` macro transforms a `static mut` variable into a `reactive_cache::Signal`,
+/// The `ref_signal!` macro transforms a `static mut` variable into a `reactive_cache::Signal`,
 /// and automatically generates:
-/// 1. A `_get()` function to read the value.
+/// 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 to simplify access (calls `_get()`).
+/// 
+/// Unlike `signal!`, `ref_signal!` does **not** generate a same-named function that directly returns the value.
 ///
 /// # Requirements
 ///
@@ -19,16 +21,14 @@ use syn::{Ident, ItemFn, ItemStatic, ReturnType, parse_macro_input};
 /// # Examples
 ///
 /// ```rust
-/// use std::cell::Cell;
-/// use reactive_macros::signal;
+/// use reactive_macros::ref_signal;
 ///
-/// signal!(static mut A: i32 = 10;);
+/// ref_signal!(static mut A: String = "hello".to_string(););
 ///
-/// assert_eq!(*A(), 10);
-/// assert_eq!(*A_get(), 10);
-/// assert!(A_set(20));
-/// assert_eq!(*A(), 20);
-/// assert!(!A_set(20)); // No change
+/// assert_eq!(&*A_get(), "hello");
+/// assert!(A_set("signal".to_string()));
+/// assert_eq!(&*A_get(), "signal");
+/// assert!(!A_set("signal".to_string())); // No change
 /// ```
 ///
 /// # SAFETY
@@ -51,7 +51,7 @@ 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 signal(input: TokenStream) -> TokenStream {
+pub fn ref_signal(input: TokenStream) -> TokenStream {
     let item = parse_macro_input!(input as ItemStatic);
 
     let attrs = &item.attrs;
@@ -78,7 +78,6 @@ pub fn signal(input: TokenStream) -> TokenStream {
     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 ident_fn = format_ident!("{}", ident);
 
     let lazy_ty = quote! { reactive_cache::Lazy<reactive_cache::Signal<#ty>> };
     let expr = quote! { reactive_cache::Lazy::new(|| reactive_cache::Signal::new(Some(#expr))) };
@@ -96,10 +95,77 @@ pub fn signal(input: TokenStream) -> TokenStream {
         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 + Default`.
+///
+/// # Examples
+///
+/// ```rust
+/// use reactive_macros::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! {
+        reactive_macros::ref_signal!(#input_clone);
 
         #[allow(non_snake_case)]
-        pub fn #ident_fn() -> std::cell::Ref<'static, #ty> {
-            #ident_get()
+        pub fn #ident_fn() -> #ty {
+            *unsafe { #ident_p.get() }
         }
     };
 

macros/tests/dep.rs

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

macros/tests/effect.rs

@@ -3,7 +3,7 @@
 use std::{cell::Cell, rc::Rc};
 
 use reactive_cache::effect;
-use reactive_macros::{memo, signal};
+use reactive_macros::{memo, ref_signal, signal};
 
 static mut SOURCE_A_CALLED: i32 = 0;
 static mut SOURCE_B_CALLED: i32 = 0;
@@ -16,20 +16,20 @@ signal!(
     static mut A: i32 = 10;
 );
 
-signal!(
+ref_signal!(
     static mut B: String = 5.to_string();
 );
 
 pub fn source_a() -> i32 {
     unsafe { SOURCE_A_CALLED += 1 };
 
-    *A_get()
+    A()
 }
 
 pub fn source_b() -> i32 {
     unsafe { SOURCE_B_CALLED += 1 };
 
-    B().parse::<i32>().unwrap()
+    B_get().parse::<i32>().unwrap()
 }
 
 #[memo]
@@ -140,10 +140,10 @@ fn switch_effect_test() {
     let b_rst_clone = b_rst.clone();
     let _ = Rc::into_raw(effect!(
         move || {
-            match *SWITCH_A() {
+            match SWITCH_A() {
                 true => {}
                 false => {
-                    b_rst_clone.set(*SWITCH_B());
+                    b_rst_clone.set(*SWITCH_B_get());
                 }
             }
         },