From 3bf6d2d7cfb0f918c1e1f4eabe906c047098b7e5 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Sat, 14 Oct 2023 12:08:54 -0500
Subject: [PATCH 1/6] add must use to several hooks

---
 packages/fermi/src/callback.rs                | 1 +
 packages/fermi/src/hooks/atom_ref.rs          | 1 +
 packages/fermi/src/hooks/read.rs              | 2 ++
 packages/fermi/src/hooks/set.rs               | 1 +
 packages/fermi/src/hooks/state.rs             | 1 +
 packages/fullstack/src/hooks/server_future.rs | 1 +
 packages/hooks/src/computed.rs                | 2 ++
 packages/hooks/src/use_callback.rs            | 2 ++
 packages/hooks/src/use_context.rs             | 1 +
 packages/hooks/src/use_coroutine.rs           | 1 +
 packages/hooks/src/use_future.rs              | 1 +
 packages/hooks/src/use_memo.rs                | 1 +
 packages/hooks/src/use_ref.rs                 | 1 +
 packages/hooks/src/use_shared_state.rs        | 1 +
 packages/hooks/src/use_state.rs               | 1 +
 packages/html/src/eval.rs                     | 1 +
 packages/router/src/hooks/use_navigator.rs    | 1 +
 packages/router/src/hooks/use_route.rs        | 1 +
 packages/router/src/hooks/use_router.rs       | 1 +
 packages/signals/src/selector.rs              | 2 ++
 packages/signals/src/signal.rs                | 1 +
 21 files changed, 25 insertions(+)

diff --git a/packages/fermi/src/callback.rs b/packages/fermi/src/callback.rs
index a7ca9155f..bb9f61bf2 100644
--- a/packages/fermi/src/callback.rs
+++ b/packages/fermi/src/callback.rs
@@ -28,6 +28,7 @@ impl CallbackApi {
     }
 }
 
+#[must_use]
 pub fn use_atom_context(cx: &ScopeState) -> &CallbackApi {
     todo!()
 }
diff --git a/packages/fermi/src/hooks/atom_ref.rs b/packages/fermi/src/hooks/atom_ref.rs
index 74dd9268b..8dbeb2c4d 100644
--- a/packages/fermi/src/hooks/atom_ref.rs
+++ b/packages/fermi/src/hooks/atom_ref.rs
@@ -13,6 +13,7 @@ use std::{
 ///
 ///
 ///
+#[must_use]
 pub fn use_atom_ref<'a, T: 'static>(
     cx: &'a ScopeState,
     atom: &'static AtomRef<T>,
diff --git a/packages/fermi/src/hooks/read.rs b/packages/fermi/src/hooks/read.rs
index 57a544e93..c2538c74d 100644
--- a/packages/fermi/src/hooks/read.rs
+++ b/packages/fermi/src/hooks/read.rs
@@ -2,10 +2,12 @@ use crate::{use_atom_root, AtomId, AtomRoot, Readable};
 use dioxus_core::{ScopeId, ScopeState};
 use std::rc::Rc;
 
+#[must_use]
 pub fn use_read<V: 'static>(cx: &ScopeState, f: impl Readable<V>) -> &V {
     use_read_rc(cx, f).as_ref()
 }
 
+#[must_use]
 pub fn use_read_rc<V: 'static>(cx: &ScopeState, f: impl Readable<V>) -> &Rc<V> {
     let root = use_atom_root(cx);
 
diff --git a/packages/fermi/src/hooks/set.rs b/packages/fermi/src/hooks/set.rs
index 5e5141227..89fe48b0f 100644
--- a/packages/fermi/src/hooks/set.rs
+++ b/packages/fermi/src/hooks/set.rs
@@ -2,6 +2,7 @@ use crate::{use_atom_root, Writable};
 use dioxus_core::ScopeState;
 use std::rc::Rc;
 
+#[must_use]
 pub fn use_set<T: 'static>(cx: &ScopeState, f: impl Writable<T>) -> &Rc<dyn Fn(T)> {
     let root = use_atom_root(cx);
     cx.use_hook(|| {
diff --git a/packages/fermi/src/hooks/state.rs b/packages/fermi/src/hooks/state.rs
index 071b18059..d4ebc529c 100644
--- a/packages/fermi/src/hooks/state.rs
+++ b/packages/fermi/src/hooks/state.rs
@@ -30,6 +30,7 @@ use std::{
 ///     ))
 /// }
 /// ```
+#[must_use]
 pub fn use_atom_state<T: 'static>(cx: &ScopeState, f: impl Writable<T>) -> &AtomState<T> {
     let root = crate::use_atom_root(cx);
 
diff --git a/packages/fullstack/src/hooks/server_future.rs b/packages/fullstack/src/hooks/server_future.rs
index e4d89480e..f8eaef963 100644
--- a/packages/fullstack/src/hooks/server_future.rs
+++ b/packages/fullstack/src/hooks/server_future.rs
@@ -22,6 +22,7 @@ use std::sync::Arc;
 /// will be allowed to continue
 ///
 /// - dependencies: a tuple of references to values that are PartialEq + Clone
+#[must_use = "Consider using `cx.spawn` to run a future without reading its value"]
 pub fn use_server_future<T, F, D>(
     cx: &ScopeState,
     dependencies: D,
diff --git a/packages/hooks/src/computed.rs b/packages/hooks/src/computed.rs
index 3369d6832..dbea75d73 100644
--- a/packages/hooks/src/computed.rs
+++ b/packages/hooks/src/computed.rs
@@ -37,6 +37,7 @@ use std::{
 ///    }
 /// }
 /// ```
+#[must_use]
 pub fn use_tracked_state<T: 'static>(cx: &ScopeState, init: impl FnOnce() -> T) -> &Tracked<T> {
     cx.use_hook(|| {
         let init = init();
@@ -160,6 +161,7 @@ impl<I> Drop for Tracker<I> {
     }
 }
 
+#[must_use = "Consider using the `use_effect` hook to rerun an effect whenever the tracked state changes if you don't need the result of the computation"]
 pub fn use_selector<I: 'static, O: Clone + PartialEq + 'static>(
     cx: &ScopeState,
     tracked: &Tracked<I>,
diff --git a/packages/hooks/src/use_callback.rs b/packages/hooks/src/use_callback.rs
index 3f223b581..da45be807 100644
--- a/packages/hooks/src/use_callback.rs
+++ b/packages/hooks/src/use_callback.rs
@@ -24,6 +24,8 @@ macro_rules! use_callback {
         )
     };
 }
+
+#[must_use]
 pub fn use_callback<T, R, F>(cx: &ScopeState, make: impl FnOnce() -> R) -> impl FnMut(T) + '_
 where
     R: FnMut(T) -> F + 'static,
diff --git a/packages/hooks/src/use_context.rs b/packages/hooks/src/use_context.rs
index fdf363252..0d94492f6 100644
--- a/packages/hooks/src/use_context.rs
+++ b/packages/hooks/src/use_context.rs
@@ -3,6 +3,7 @@ use dioxus_core::ScopeState;
 /// Consume some context in the tree, providing a sharable handle to the value
 ///
 /// Does not regenerate the value if the value is changed at the parent.
+#[must_use]
 pub fn use_context<T: 'static + Clone>(cx: &ScopeState) -> Option<&T> {
     cx.use_hook(|| cx.consume_context::<T>()).as_ref()
 }
diff --git a/packages/hooks/src/use_coroutine.rs b/packages/hooks/src/use_coroutine.rs
index e5563d793..f2577b90c 100644
--- a/packages/hooks/src/use_coroutine.rs
+++ b/packages/hooks/src/use_coroutine.rs
@@ -79,6 +79,7 @@ where
 /// Get a handle to a coroutine higher in the tree
 ///
 /// See the docs for [`use_coroutine`] for more details.
+#[must_use]
 pub fn use_coroutine_handle<M: 'static>(cx: &ScopeState) -> Option<&Coroutine<M>> {
     cx.use_hook(|| cx.consume_context::<Coroutine<M>>())
         .as_ref()
diff --git a/packages/hooks/src/use_future.rs b/packages/hooks/src/use_future.rs
index 67bcdc74e..e6853ddef 100644
--- a/packages/hooks/src/use_future.rs
+++ b/packages/hooks/src/use_future.rs
@@ -17,6 +17,7 @@ use crate::{use_state, UseState};
 /// will be canceled before the new one is started.
 ///
 /// - dependencies: a tuple of references to values that are PartialEq + Clone
+#[must_use = "Consider using `cx.spawn` to run a future without reading its value"]
 pub fn use_future<T, F, D>(
     cx: &ScopeState,
     dependencies: D,
diff --git a/packages/hooks/src/use_memo.rs b/packages/hooks/src/use_memo.rs
index 3181d57b8..be61b8d53 100644
--- a/packages/hooks/src/use_memo.rs
+++ b/packages/hooks/src/use_memo.rs
@@ -28,6 +28,7 @@ use crate::UseFutureDep;
 ///     render!(Calculator { number: 0 })
 /// }
 /// ```
+#[must_use = "Consider using `use_effect` to run rerun a callback when dependencies change"]
 pub fn use_memo<T, D>(cx: &ScopeState, dependencies: D, callback: impl FnOnce(D::Out) -> T) -> &T
 where
     T: 'static,
diff --git a/packages/hooks/src/use_ref.rs b/packages/hooks/src/use_ref.rs
index cf1b0306f..d0b95074e 100644
--- a/packages/hooks/src/use_ref.rs
+++ b/packages/hooks/src/use_ref.rs
@@ -110,6 +110,7 @@ use std::{
 ///     }
 /// })
 /// ```
+#[must_use]
 pub fn use_ref<T: 'static>(cx: &ScopeState, initialize_refcell: impl FnOnce() -> T) -> &UseRef<T> {
     let hook = cx.use_hook(|| UseRef {
         update: cx.schedule_update(),
diff --git a/packages/hooks/src/use_shared_state.rs b/packages/hooks/src/use_shared_state.rs
index 18ce1e5f1..37226c759 100644
--- a/packages/hooks/src/use_shared_state.rs
+++ b/packages/hooks/src/use_shared_state.rs
@@ -158,6 +158,7 @@ impl<T> ProvidedStateInner<T> {
 /// Any time a component calls `write`, every consumer of the state will be notified - excluding the provider.
 ///
 /// Right now, there is not a distinction between read-only and write-only, so every consumer will be notified.
+#[must_use]
 pub fn use_shared_state<T: 'static>(cx: &ScopeState) -> Option<&UseSharedState<T>> {
     let state_owner: &mut Option<UseSharedStateOwner<T>> = &mut *cx.use_hook(move || {
         let scope_id = cx.scope_id();
diff --git a/packages/hooks/src/use_state.rs b/packages/hooks/src/use_state.rs
index a2da3c885..254493510 100644
--- a/packages/hooks/src/use_state.rs
+++ b/packages/hooks/src/use_state.rs
@@ -30,6 +30,7 @@ use std::{
 ///     ))
 /// }
 /// ```
+#[must_use]
 pub fn use_state<T: 'static>(
     cx: &ScopeState,
     initial_state_fn: impl FnOnce() -> T,
diff --git a/packages/html/src/eval.rs b/packages/html/src/eval.rs
index c90f5125b..292de70fc 100644
--- a/packages/html/src/eval.rs
+++ b/packages/html/src/eval.rs
@@ -33,6 +33,7 @@ type EvalCreator = Rc<dyn Fn(&str) -> Result<UseEval, EvalError>>;
 /// parts is practically asking for a hacker to find an XSS vulnerability in
 /// it. **This applies especially to web targets, where the JavaScript context
 /// has access to most, if not all of your application data.**
+#[must_use]
 pub fn use_eval(cx: &ScopeState) -> &EvalCreator {
     &*cx.use_hook(|| {
         let eval_provider = cx
diff --git a/packages/router/src/hooks/use_navigator.rs b/packages/router/src/hooks/use_navigator.rs
index c1c21ee63..a05cd036f 100644
--- a/packages/router/src/hooks/use_navigator.rs
+++ b/packages/router/src/hooks/use_navigator.rs
@@ -48,6 +48,7 @@ use crate::prelude::{Navigator, RouterContext};
 /// # let mut vdom = VirtualDom::new(App);
 /// # let _ = vdom.rebuild();
 /// ```
+#[must_use]
 pub fn use_navigator(cx: &ScopeState) -> &Navigator {
     &*cx.use_hook(|| {
         let router = cx
diff --git a/packages/router/src/hooks/use_route.rs b/packages/router/src/hooks/use_route.rs
index 42cca27fb..51d78cfca 100644
--- a/packages/router/src/hooks/use_route.rs
+++ b/packages/router/src/hooks/use_route.rs
@@ -46,6 +46,7 @@ use crate::utils::use_router_internal::use_router_internal;
 /// # let _ = vdom.rebuild();
 /// # assert_eq!(dioxus_ssr::render(&vdom), "<h1>App</h1><h2>Current Path</h2><p>/</p>")
 /// ```
+#[must_use]
 pub fn use_route<R: Routable + Clone>(cx: &ScopeState) -> Option<R> {
     match use_router_internal(cx) {
         Some(r) => Some(r.current()),
diff --git a/packages/router/src/hooks/use_router.rs b/packages/router/src/hooks/use_router.rs
index 0891ebf97..5f1f13e45 100644
--- a/packages/router/src/hooks/use_router.rs
+++ b/packages/router/src/hooks/use_router.rs
@@ -3,6 +3,7 @@ use dioxus::prelude::ScopeState;
 use crate::{prelude::RouterContext, utils::use_router_internal::use_router_internal};
 
 #[deprecated = "prefer the use_navigator or use_route functions"]
+#[must_use]
 /// A hook that provides access to information about the router.
 pub fn use_router(cx: &ScopeState) -> &RouterContext {
     use_router_internal(cx)
diff --git a/packages/signals/src/selector.rs b/packages/signals/src/selector.rs
index 346506ff7..91ab920c8 100644
--- a/packages/signals/src/selector.rs
+++ b/packages/signals/src/selector.rs
@@ -21,6 +21,7 @@ use crate::{get_effect_stack, signal::SignalData, CopyValue, Effect, ReadOnlySig
 ///     render! { "{double}" }
 /// }
 /// ```
+#[must_use = "Consider using `use_effect` to rerun a callback when dependencies change"]
 pub fn use_selector<R: PartialEq>(
     cx: &ScopeState,
     f: impl FnMut() -> R + 'static,
@@ -44,6 +45,7 @@ pub fn use_selector<R: PartialEq>(
 ///     render! { "{double}" }
 /// }
 /// ```
+#[must_use = "Consider using `use_effect` to rerun a callback when dependencies change"]
 pub fn use_selector_with_dependencies<R: PartialEq, D: Dependency>(
     cx: &ScopeState,
     dependencies: D,
diff --git a/packages/signals/src/signal.rs b/packages/signals/src/signal.rs
index c1ae076d9..51a53ac39 100644
--- a/packages/signals/src/signal.rs
+++ b/packages/signals/src/signal.rs
@@ -43,6 +43,7 @@ use crate::{CopyValue, Effect};
 ///     }
 /// }
 /// ```
+#[must_use]
 pub fn use_signal<T: 'static>(cx: &ScopeState, f: impl FnOnce() -> T) -> Signal<T> {
     *cx.use_hook(|| Signal::new(f()))
 }

From 9f729dd6ded42ab1a4333bfc0c5b6d9c409ceecb Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Sat, 14 Oct 2023 14:32:08 -0500
Subject: [PATCH 2/6] fix clippy

---
 packages/cli/src/builder.rs        | 2 +-
 packages/hooks/src/use_callback.rs | 1 -
 packages/hooks/src/use_future.rs   | 1 -
 packages/server-macro/src/lib.rs   | 2 +-
 4 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/packages/cli/src/builder.rs b/packages/cli/src/builder.rs
index 5fc96d1a4..68c494c42 100644
--- a/packages/cli/src/builder.rs
+++ b/packages/cli/src/builder.rs
@@ -312,7 +312,7 @@ pub fn build_desktop(config: &CrateConfig, _is_serve: bool) -> Result<BuildResul
     if !config.out_dir.is_dir() {
         create_dir_all(&config.out_dir)?;
     }
-    copy(res_path, &config.out_dir.join(target_file))?;
+    copy(res_path, config.out_dir.join(target_file))?;
 
     // this code will copy all public file to the output dir
     if config.asset_dir.is_dir() {
diff --git a/packages/hooks/src/use_callback.rs b/packages/hooks/src/use_callback.rs
index da45be807..52e592f6b 100644
--- a/packages/hooks/src/use_callback.rs
+++ b/packages/hooks/src/use_callback.rs
@@ -25,7 +25,6 @@ macro_rules! use_callback {
     };
 }
 
-#[must_use]
 pub fn use_callback<T, R, F>(cx: &ScopeState, make: impl FnOnce() -> R) -> impl FnMut(T) + '_
 where
     R: FnMut(T) -> F + 'static,
diff --git a/packages/hooks/src/use_future.rs b/packages/hooks/src/use_future.rs
index e6853ddef..67bcdc74e 100644
--- a/packages/hooks/src/use_future.rs
+++ b/packages/hooks/src/use_future.rs
@@ -17,7 +17,6 @@ use crate::{use_state, UseState};
 /// will be canceled before the new one is started.
 ///
 /// - dependencies: a tuple of references to values that are PartialEq + Clone
-#[must_use = "Consider using `cx.spawn` to run a future without reading its value"]
 pub fn use_future<T, F, D>(
     cx: &ScopeState,
     dependencies: D,
diff --git a/packages/server-macro/src/lib.rs b/packages/server-macro/src/lib.rs
index f739490d3..5ad9a682b 100644
--- a/packages/server-macro/src/lib.rs
+++ b/packages/server-macro/src/lib.rs
@@ -109,7 +109,7 @@ pub fn server(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
         let upper_cammel_case_name = Converter::new()
             .from_case(Case::Snake)
             .to_case(Case::UpperCamel)
-            .convert(&sig.ident.to_string());
+            .convert(sig.ident.to_string());
         args.struct_name = Some(Ident::new(&upper_cammel_case_name, sig.ident.span()));
     }
     let struct_name = args.struct_name.as_ref().unwrap();

From b1d606936353ac79bc89336d1bdc4ad15dc5bfcb Mon Sep 17 00:00:00 2001
From: Evan Simkowitz <esimkowitz@users.noreply.github.com>
Date: Mon, 16 Oct 2023 08:49:21 -0700
Subject: [PATCH 3/6] Fix deref for Write struct in dioxus-signals (#1549)

---
 packages/signals/src/signal.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/signals/src/signal.rs b/packages/signals/src/signal.rs
index c1ae076d9..91619e0fb 100644
--- a/packages/signals/src/signal.rs
+++ b/packages/signals/src/signal.rs
@@ -305,7 +305,7 @@ impl<'a, T: 'static, I: 'static> Write<'a, T, I> {
     }
 }
 
-impl<'a, T: 'static> Deref for Write<'a, T> {
+impl<'a, T: 'static, I: 'static> Deref for Write<'a, T, I> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -313,7 +313,7 @@ impl<'a, T: 'static> Deref for Write<'a, T> {
     }
 }
 
-impl<T> DerefMut for Write<'_, T> {
+impl<T, I> DerefMut for Write<'_, T, I> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.write
     }

From c65116c173b2e8c536a4e594bd482a8f2d54e252 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Mon, 16 Oct 2023 13:03:37 -0500
Subject: [PATCH 4/6] restore deref<Fn() -> Ref>

---
 packages/generational-box/src/lib.rs |  8 ++--
 packages/signals/src/rt.rs           | 42 +++++++++++++++--
 packages/signals/src/signal.rs       | 69 ++++++++++++++++++++++++++++
 3 files changed, 112 insertions(+), 7 deletions(-)

diff --git a/packages/generational-box/src/lib.rs b/packages/generational-box/src/lib.rs
index 60bd41419..4be383b4f 100644
--- a/packages/generational-box/src/lib.rs
+++ b/packages/generational-box/src/lib.rs
@@ -184,7 +184,7 @@ impl<T: 'static> GenerationalBox<T> {
     }
 
     /// Try to read the value. Returns None if the value is no longer valid.
-    pub fn try_read(&self) -> Option<Ref<'_, T>> {
+    pub fn try_read(&self) -> Option<Ref<'static, T>> {
         self.validate()
             .then(|| {
                 Ref::filter_map(self.raw.data.borrow(), |any| {
@@ -196,12 +196,12 @@ impl<T: 'static> GenerationalBox<T> {
     }
 
     /// Read the value. Panics if the value is no longer valid.
-    pub fn read(&self) -> Ref<'_, T> {
+    pub fn read(&self) -> Ref<'static, T> {
         self.try_read().unwrap()
     }
 
     /// Try to write the value. Returns None if the value is no longer valid.
-    pub fn try_write(&self) -> Option<RefMut<'_, T>> {
+    pub fn try_write(&self) -> Option<RefMut<'static, T>> {
         self.validate()
             .then(|| {
                 RefMut::filter_map(self.raw.data.borrow_mut(), |any| {
@@ -213,7 +213,7 @@ impl<T: 'static> GenerationalBox<T> {
     }
 
     /// Write the value. Panics if the value is no longer valid.
-    pub fn write(&self) -> RefMut<'_, T> {
+    pub fn write(&self) -> RefMut<'static, T> {
         self.try_write().unwrap()
     }
 
diff --git a/packages/signals/src/rt.rs b/packages/signals/src/rt.rs
index 113fe9b30..ac7915531 100644
--- a/packages/signals/src/rt.rs
+++ b/packages/signals/src/rt.rs
@@ -1,5 +1,7 @@
 use std::cell::{Ref, RefMut};
 
+use std::mem::MaybeUninit;
+use std::ops::Deref;
 use std::rc::Rc;
 
 use dioxus_core::prelude::*;
@@ -120,17 +122,17 @@ impl<T: 'static> CopyValue<T> {
     }
 
     /// Read the value. If the value has been dropped, this will panic.
-    pub fn read(&self) -> Ref<'_, T> {
+    pub fn read(&self) -> Ref<'static, T> {
         self.value.read()
     }
 
     /// Try to write the value. If the value has been dropped, this will return None.
-    pub fn try_write(&self) -> Option<RefMut<'_, T>> {
+    pub fn try_write(&self) -> Option<RefMut<'static, T>> {
         self.value.try_write()
     }
 
     /// Write the value. If the value has been dropped, this will panic.
-    pub fn write(&self) -> RefMut<'_, T> {
+    pub fn write(&self) -> RefMut<'static, T> {
         self.value.write()
     }
 
@@ -164,3 +166,37 @@ impl<T: 'static> PartialEq for CopyValue<T> {
         self.value.ptr_eq(&other.value)
     }
 }
+
+impl<T> Deref for CopyValue<T> {
+    type Target = dyn Fn() -> Ref<'static, T>;
+
+    fn deref(&self) -> &Self::Target {
+        // https://github.com/dtolnay/case-studies/tree/master/callable-types
+
+        // First we create a closure that captures something with the Same in memory layout as Self (MaybeUninit<Self>).
+        let uninit_callable = MaybeUninit::<Self>::uninit();
+        // Then move that value into the closure. We assume that the closure now has a in memory layout of Self.
+        let uninit_closure = move || Self::read(unsafe { &*uninit_callable.as_ptr() });
+
+        // Check that the size of the closure is the same as the size of Self in case the compiler changed the layout of the closure.
+        let size_of_closure = std::mem::size_of_val(&uninit_closure);
+        assert_eq!(size_of_closure, std::mem::size_of::<Self>());
+
+        // Then cast the lifetime of the closure to the lifetime of &self.
+        fn cast_lifetime<'a, T>(_a: &T, b: &'a T) -> &'a T {
+            b
+        }
+        let reference_to_closure = cast_lifetime(
+            {
+                // The real closure that we will never use.
+                &uninit_closure
+            },
+            // We transmute self into a reference to the closure. This is safe because we know that the closure has the same memory layout as Self so &Closure == &Self.
+            unsafe { std::mem::transmute(self) },
+        );
+
+        // Cast the closure to a trait object.
+        let reference_to_trait_object = reference_to_closure as &Self::Target;
+        reference_to_trait_object
+    }
+}
diff --git a/packages/signals/src/signal.rs b/packages/signals/src/signal.rs
index 91619e0fb..e5b521085 100644
--- a/packages/signals/src/signal.rs
+++ b/packages/signals/src/signal.rs
@@ -1,5 +1,6 @@
 use std::{
     cell::{Ref, RefCell, RefMut},
+    mem::MaybeUninit,
     ops::{Deref, DerefMut},
     rc::Rc,
     sync::Arc,
@@ -268,6 +269,40 @@ impl<T: 'static> PartialEq for Signal<T> {
     }
 }
 
+impl<T> Deref for Signal<T> {
+    type Target = dyn Fn() -> Ref<'static, T>;
+
+    fn deref(&self) -> &Self::Target {
+        // https://github.com/dtolnay/case-studies/tree/master/callable-types
+
+        // First we create a closure that captures something with the Same in memory layout as Self (MaybeUninit<Self>).
+        let uninit_callable = MaybeUninit::<Self>::uninit();
+        // Then move that value into the closure. We assume that the closure now has a in memory layout of Self.
+        let uninit_closure = move || Self::read(unsafe { &*uninit_callable.as_ptr() });
+
+        // Check that the size of the closure is the same as the size of Self in case the compiler changed the layout of the closure.
+        let size_of_closure = std::mem::size_of_val(&uninit_closure);
+        assert_eq!(size_of_closure, std::mem::size_of::<Self>());
+
+        // Then cast the lifetime of the closure to the lifetime of &self.
+        fn cast_lifetime<'a, T>(_a: &T, b: &'a T) -> &'a T {
+            b
+        }
+        let reference_to_closure = cast_lifetime(
+            {
+                // The real closure that we will never use.
+                &uninit_closure
+            },
+            // We transmute self into a reference to the closure. This is safe because we know that the closure has the same memory layout as Self so &Closure == &Self.
+            unsafe { std::mem::transmute(self) },
+        );
+
+        // Cast the closure to a trait object.
+        let reference_to_trait_object = reference_to_closure as &Self::Target;
+        reference_to_trait_object
+    }
+}
+
 struct SignalSubscriberDrop<T: 'static> {
     signal: Signal<T>,
 }
@@ -358,3 +393,37 @@ impl<T: 'static> PartialEq for ReadOnlySignal<T> {
         self.inner == other.inner
     }
 }
+
+impl<T> Deref for ReadOnlySignal<T> {
+    type Target = dyn Fn() -> Ref<'static, T>;
+
+    fn deref(&self) -> &Self::Target {
+        // https://github.com/dtolnay/case-studies/tree/master/callable-types
+
+        // First we create a closure that captures something with the Same in memory layout as Self (MaybeUninit<Self>).
+        let uninit_callable = MaybeUninit::<Self>::uninit();
+        // Then move that value into the closure. We assume that the closure now has a in memory layout of Self.
+        let uninit_closure = move || Self::read(unsafe { &*uninit_callable.as_ptr() });
+
+        // Check that the size of the closure is the same as the size of Self in case the compiler changed the layout of the closure.
+        let size_of_closure = std::mem::size_of_val(&uninit_closure);
+        assert_eq!(size_of_closure, std::mem::size_of::<Self>());
+
+        // Then cast the lifetime of the closure to the lifetime of &self.
+        fn cast_lifetime<'a, T>(_a: &T, b: &'a T) -> &'a T {
+            b
+        }
+        let reference_to_closure = cast_lifetime(
+            {
+                // The real closure that we will never use.
+                &uninit_closure
+            },
+            // We transmute self into a reference to the closure. This is safe because we know that the closure has the same memory layout as Self so &Closure == &Self.
+            unsafe { std::mem::transmute(self) },
+        );
+
+        // Cast the closure to a trait object.
+        let reference_to_trait_object = reference_to_closure as &Self::Target;
+        reference_to_trait_object
+    }
+}

From 87dae6a41f614d065b708b3a3bbe9a3b4ac5adf2 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Mon, 16 Oct 2023 13:08:18 -0500
Subject: [PATCH 5/6] add a test for derefing signals to a closure

---
 packages/signals/tests/create.rs | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/packages/signals/tests/create.rs b/packages/signals/tests/create.rs
index 57d8325af..ecda2f376 100644
--- a/packages/signals/tests/create.rs
+++ b/packages/signals/tests/create.rs
@@ -29,6 +29,30 @@ fn create_signals_global() {
     }
 }
 
+#[test]
+fn deref_signal() {
+    let mut dom = VirtualDom::new(|cx| {
+        render! {
+            for _ in 0..10 {
+                Child {}
+            }
+        }
+    });
+
+    fn Child(cx: Scope) -> Element {
+        let signal = Signal::new("hello world".to_string());
+
+        // You can call signals like functions to get a Ref of their value.
+        assert_eq!(&*signal(), "hello world");
+
+        render! {
+            "hello world"
+        }
+    }
+
+    let _edits = dom.rebuild().santize();
+}
+
 #[test]
 fn drop_signals() {
     let mut dom = VirtualDom::new(|cx| {

From 6e9aa4dba1c5e3c7b29724021be225aad117b729 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Mon, 16 Oct 2023 13:29:32 -0500
Subject: [PATCH 6/6] fix clippy

---
 packages/signals/src/rt.rs     | 3 +--
 packages/signals/src/signal.rs | 6 ++----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/packages/signals/src/rt.rs b/packages/signals/src/rt.rs
index ac7915531..0f89a3fe6 100644
--- a/packages/signals/src/rt.rs
+++ b/packages/signals/src/rt.rs
@@ -196,7 +196,6 @@ impl<T> Deref for CopyValue<T> {
         );
 
         // Cast the closure to a trait object.
-        let reference_to_trait_object = reference_to_closure as &Self::Target;
-        reference_to_trait_object
+        reference_to_closure as &Self::Target
     }
 }
diff --git a/packages/signals/src/signal.rs b/packages/signals/src/signal.rs
index e5b521085..944bde225 100644
--- a/packages/signals/src/signal.rs
+++ b/packages/signals/src/signal.rs
@@ -298,8 +298,7 @@ impl<T> Deref for Signal<T> {
         );
 
         // Cast the closure to a trait object.
-        let reference_to_trait_object = reference_to_closure as &Self::Target;
-        reference_to_trait_object
+        reference_to_closure as &Self::Target
     }
 }
 
@@ -423,7 +422,6 @@ impl<T> Deref for ReadOnlySignal<T> {
         );
 
         // Cast the closure to a trait object.
-        let reference_to_trait_object = reference_to_closure as &Self::Target;
-        reference_to_trait_object
+        reference_to_closure as &Self::Target
     }
 }