perf: use the Track trait for the Signal wrapper. (leptos-rs#3076)

Author: zakstucke

reactive_graph/src/serde.rs

@@ -75,7 +75,7 @@ impl<T: Serialize + 'static, St: Storage<T>> Serialize for ArcMemo<T, St> {
 
 impl<T, St> Serialize for MaybeSignal<T, St>
 where
-    T: Send + Sync + Serialize,
+    T: Clone + Send + Sync + Serialize,
     St: Storage<SignalTypes<T, St>> + Storage<T>,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

reactive_graph/src/signal/guards.rs

@@ -623,3 +623,46 @@ where
         Display::fmt(&**self, f)
     }
 }
+
+/// A wrapper that implements [`Deref`] and [`Borrow`] for itself.
+pub struct Derefable<T>(pub T);
+
+impl<T> Clone for Derefable<T>
+where
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        Derefable(self.0.clone())
+    }
+}
+
+impl<T> std::ops::Deref for Derefable<T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> Borrow<T> for Derefable<T> {
+    fn borrow(&self) -> &T {
+        self.deref()
+    }
+}
+
+impl<T> PartialEq<T> for Derefable<T>
+where
+    T: PartialEq,
+{
+    fn eq(&self, other: &T) -> bool {
+        self.deref() == other
+    }
+}
+
+impl<T> Display for Derefable<T>
+where
+    T: Display,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&**self, f)
+    }
+}

reactive_graph/src/traits.rs

@@ -168,11 +168,20 @@ pub trait ReadUntracked: Sized + DefinedAt {
         self.try_read_untracked()
             .unwrap_or_else(unwrap_signal!(self))
     }
+
+    /// This is a backdoor to allow overriding the [`Read::try_read`] implementation despite it being auto implemented.
+    ///
+    /// If your type contains a [`Signal`](crate::wrappers::read::Signal),
+    /// call it's [`ReadUntracked::custom_try_read`] here, else return `None`.
+    #[track_caller]
+    fn custom_try_read(&self) -> Option<Option<Self::Value>> {
+        None
+    }
 }
 
 /// Give read-only access to a signal's value by reference through a guard type,
 /// and subscribes the active reactive observer (an effect or computed) to changes in its value.
-pub trait Read {
+pub trait Read: DefinedAt {
     /// The guard type that will be returned, which can be dereferenced to the value.
     type Value: Deref;
 
@@ -185,7 +194,9 @@ pub trait Read {
     /// # Panics
     /// Panics if you try to access a signal that has been disposed.
     #[track_caller]
-    fn read(&self) -> Self::Value;
+    fn read(&self) -> Self::Value {
+        self.try_read().unwrap_or_else(unwrap_signal!(self))
+    }
 }
 
 impl<T> Read for T
@@ -195,13 +206,18 @@ where
     type Value = T::Value;
 
     fn try_read(&self) -> Option<Self::Value> {
-        self.track();
-        self.try_read_untracked()
-    }
-
-    fn read(&self) -> Self::Value {
-        self.track();
-        self.read_untracked()
+        // The [`Read`] trait is auto implemented for types that implement [`ReadUntracked`] + [`Track`]. The [`Read`] trait then auto implements the [`With`] and [`Get`] traits too.
+        //
+        // This is a problem for e.g. the [`Signal`](crate::wrappers::read::Signal) type,
+        // this type must use a custom [`Read::try_read`] implementation to avoid an unnecessary clone.
+        //
+        // This is a backdoor to allow overriding the [`Read::try_read`] implementation despite it being auto implemented.
+        if let Some(custom) = self.custom_try_read() {
+            custom
+        } else {
+            self.track();
+            self.try_read_untracked()
+        }
     }
 }
 
@@ -307,14 +323,13 @@ pub trait With: DefinedAt {
 
 impl<T> With for T
 where
-    T: WithUntracked + Track,
+    T: Read,
 {
-    type Value = <T as WithUntracked>::Value;
+    type Value = <<T as Read>::Value as Deref>::Target;
 
     #[track_caller]
     fn try_with<U>(&self, fun: impl FnOnce(&Self::Value) -> U) -> Option<U> {
-        self.track();
-        self.try_with_untracked(fun)
+        self.try_read().map(|val| fun(&val))
     }
 }