fix: type inference regression due to From<T> for Signal<T> impl (closes #3200)

This reverts commit 396327b667.

examples/errors_axum/src/error_template.rs

@@ -6,7 +6,9 @@ use leptos_axum::ResponseOptions;
 // A basic function to display errors served by the error boundaries.
 // Feel free to do more complicated things here than just displaying them.
 #[component]
-pub fn ErrorTemplate(#[prop(into)] errors: Signal<Errors>) -> impl IntoView {
+pub fn ErrorTemplate(
+    #[prop(into)] errors: MaybeSignal<Errors>,
+) -> impl IntoView {
     // Get Errors from Signal
     // Downcast lets us take a type that implements `std::error::Error`
     let errors = Memo::new(move |_| {

examples/slots/src/lib.rs

@@ -10,7 +10,7 @@ struct Then {
 // the type with Option<...> and marking the option as #[prop(optional)].
 #[slot]
 struct ElseIf {
-    cond: Signal<bool>,
+    cond: MaybeSignal<bool>,
     children: ChildrenFn,
 }
 
@@ -22,7 +22,7 @@ struct Fallback {
 // Slots are added to components like any other prop.
 #[component]
 fn SlotIf(
-    cond: Signal<bool>,
+    cond: MaybeSignal<bool>,
     then: Then,
     #[prop(default=vec![])] else_if: Vec<ElseIf>,
     #[prop(optional)] fallback: Option<Fallback>,
@@ -43,9 +43,9 @@ fn SlotIf(
 #[component]
 pub fn App() -> impl IntoView {
     let (count, set_count) = signal(0);
-    let is_even = Signal::derive(move || count.get() % 2 == 0);
-    let is_div5 = Signal::derive(move || count.get() % 5 == 0);
-    let is_div7 = Signal::derive(move || count.get() % 7 == 0);
+    let is_even = MaybeSignal::derive(move || count.get() % 2 == 0);
+    let is_div5 = MaybeSignal::derive(move || count.get() % 5 == 0);
+    let is_div7 = MaybeSignal::derive(move || count.get() % 7 == 0);
 
     view! {
         <button on:click=move |_| set_count.update(|value| *value += 1)>"+1"</button>

examples/timer/src/lib.rs

@@ -38,7 +38,7 @@ pub fn TimerDemo() -> impl IntoView {
 pub fn use_interval<T, F>(interval_millis: T, f: F)
 where
     F: Fn() + Clone + 'static,
-    T: Into<Signal<u64>> + 'static,
+    T: Into<MaybeSignal<u64>> + 'static,
 {
     let interval_millis = interval_millis.into();
     Effect::new(move |prev_handle: Option<IntervalHandle>| {

leptos/tests/generic_component.rs

@@ -0,0 +1,22 @@
+#[test]
+fn generic_component_signal_inference() {
+    use leptos::prelude::*;
+
+    #[component]
+    pub fn SimpleCounter(#[prop(into)] step: Signal<i32>) -> impl IntoView {
+        _ = step;
+        view! {
+            <div>
+            </div>
+        }
+    }
+
+    let a = RwSignal::new(1);
+    let (b, _) = signal(1);
+
+    view! {
+        <SimpleCounter step=a/>
+        <SimpleCounter step=b/>
+        <SimpleCounter step=Signal::stored(1)/>
+    };
+}

reactive_graph/src/lib.rs

@@ -84,7 +84,6 @@ pub mod owner;
 #[cfg(feature = "serde")]
 mod serde;
 pub mod signal;
-mod trait_options;
 pub mod traits;
 pub mod transition;
 pub mod wrappers;

reactive_graph/src/nightly.rs

@@ -1,5 +1,3 @@
-#[allow(deprecated)]
-use crate::wrappers::read::{MaybeProp, MaybeSignal};
 use crate::{
     computed::{ArcMemo, Memo},
     owner::Storage,
@@ -9,7 +7,7 @@ use crate::{
     },
     traits::{Get, Set},
     wrappers::{
-        read::{ArcSignal, Signal, SignalTypes},
+        read::{ArcSignal, MaybeProp, MaybeSignal, Signal},
         write::SignalSetter,
     },
 };
@@ -114,8 +112,7 @@ macro_rules! impl_get_fn_traits_get_arena {
     ($($ty:ident),*) => {
         $(
             #[cfg(feature = "nightly")]
-            #[allow(deprecated)]
-            impl<T, S> FnOnce<()> for $ty<T, S> where $ty<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>> {
+            impl<T, S> FnOnce<()> for $ty<T, S> where $ty<T, S>: Get, S: Storage<T> + Storage<Option<T>> {
                 type Output = <Self as Get>::Value;
 
                 #[inline(always)]
@@ -125,8 +122,7 @@ macro_rules! impl_get_fn_traits_get_arena {
             }
 
             #[cfg(feature = "nightly")]
-            #[allow(deprecated)]
-            impl<T, S> FnMut<()> for $ty<T, S> where $ty<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>> {
+            impl<T, S> FnMut<()> for $ty<T, S> where $ty<T, S>: Get, S: Storage<T> + Storage<Option<T>> {
                 #[inline(always)]
                 extern "rust-call" fn call_mut(&mut self, _args: ()) -> Self::Output {
                     self.get()
@@ -134,8 +130,7 @@ macro_rules! impl_get_fn_traits_get_arena {
             }
 
             #[cfg(feature = "nightly")]
-            #[allow(deprecated)]
-            impl<T, S> Fn<()> for $ty<T, S> where $ty<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>> {
+            impl<T, S> Fn<()> for $ty<T, S> where $ty<T, S>: Get, S: Storage<T> + Storage<Option<T>> {
                 #[inline(always)]
                 extern "rust-call" fn call(&self, _args: ()) -> Self::Output {
                     self.get()

reactive_graph/src/serde.rs

@@ -1,11 +1,9 @@
-#[allow(deprecated)]
-use crate::wrappers::read::{MaybeProp, MaybeSignal};
 use crate::{
     computed::{ArcMemo, Memo},
     owner::Storage,
     signal::{ArcReadSignal, ArcRwSignal, ReadSignal, RwSignal},
     traits::With,
-    wrappers::read::{Signal, SignalTypes},
+    wrappers::read::{MaybeProp, MaybeSignal, Signal, SignalTypes},
 };
 use serde::{Deserialize, Serialize};
 
@@ -75,7 +73,6 @@ impl<T: Serialize + 'static, St: Storage<T>> Serialize for ArcMemo<T, St> {
     }
 }
 
-#[allow(deprecated)]
 impl<T, St> Serialize for MaybeSignal<T, St>
 where
     T: Clone + Send + Sync + Serialize,
@@ -99,8 +96,15 @@ where
         S: serde::Serializer,
     {
         match &self.0 {
-            None => None::<T>.serialize(serializer),
-            Some(signal) => signal.with(|value| value.serialize(serializer)),
+            None | Some(MaybeSignal::Static(None)) => {
+                None::<T>.serialize(serializer)
+            }
+            Some(MaybeSignal::Static(Some(value))) => {
+                value.serialize(serializer)
+            }
+            Some(MaybeSignal::Dynamic(signal)) => {
+                signal.with(|value| value.serialize(serializer))
+            }
         }
     }
 }
@@ -142,7 +146,6 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for ArcRwSignal<T> {
     }
 }
 
-#[allow(deprecated)]
 impl<'de, T: Deserialize<'de>, St> Deserialize<'de> for MaybeSignal<T, St>
 where
     St: Storage<T>,

reactive_graph/src/trait_options.rs

@@ -1,238 +0,0 @@
-use crate::{
-    traits::{
-        DefinedAt, Get, GetUntracked, Read, ReadUntracked, Track, With,
-        WithUntracked,
-    },
-    unwrap_signal,
-};
-use std::panic::Location;
-
-impl<T> DefinedAt for Option<T>
-where
-    T: DefinedAt,
-{
-    fn defined_at(&self) -> Option<&'static Location<'static>> {
-        self.as_ref().map(DefinedAt::defined_at).unwrap_or(None)
-    }
-}
-
-impl<T> Track for Option<T>
-where
-    T: Track,
-{
-    fn track(&self) {
-        if let Some(signal) = self {
-            signal.track();
-        }
-    }
-}
-
-/// An alternative [`ReadUntracked`](crate) trait that works with `Option<Readable>` types.
-pub trait ReadUntrackedOptional: Sized + DefinedAt {
-    /// The guard type that will be returned, which can be dereferenced to the value.
-    type Value;
-
-    /// Returns the guard, or `None` if the signal has already been disposed.
-    #[track_caller]
-    fn try_read_untracked(&self) -> Option<Self::Value>;
-
-    /// Returns the guard.
-    ///
-    /// # Panics
-    /// Panics if you try to access a signal that has been disposed.
-    #[track_caller]
-    fn read_untracked(&self) -> Self::Value {
-        self.try_read_untracked()
-            .unwrap_or_else(unwrap_signal!(self))
-    }
-}
-
-impl<T> ReadUntrackedOptional for Option<T>
-where
-    Self: DefinedAt,
-    T: ReadUntracked,
-{
-    type Value = Option<<T as ReadUntracked>::Value>;
-
-    fn try_read_untracked(&self) -> Option<Self::Value> {
-        Some(if let Some(signal) = self {
-            Some(signal.try_read_untracked()?)
-        } else {
-            None
-        })
-    }
-}
-
-/// An alternative [`Read`](crate) trait that works with `Option<Readable>` types.
-pub trait ReadOptional: DefinedAt {
-    /// The guard type that will be returned, which can be dereferenced to the value.
-    type Value;
-
-    /// Subscribes to the signal, and returns the guard, or `None` if the signal has already been disposed.
-    #[track_caller]
-    fn try_read(&self) -> Option<Self::Value>;
-
-    /// Subscribes to the signal, and returns the guard.
-    ///
-    /// # Panics
-    /// Panics if you try to access a signal that has been disposed.
-    #[track_caller]
-    fn read(&self) -> Self::Value {
-        self.try_read().unwrap_or_else(unwrap_signal!(self))
-    }
-}
-
-impl<T> ReadOptional for Option<T>
-where
-    Self: DefinedAt,
-    T: Read,
-{
-    type Value = Option<<T as Read>::Value>;
-
-    fn try_read(&self) -> Option<Self::Value> {
-        Some(if let Some(readable) = self {
-            Some(readable.try_read()?)
-        } else {
-            None
-        })
-    }
-}
-
-/// An alternative [`WithUntracked`](crate) trait that works with `Option<Withable>` types.
-pub trait WithUntrackedOptional: DefinedAt {
-    /// The type of the value contained in the signal.
-    type Value: ?Sized;
-
-    /// Applies the closure to the value, and returns the result,
-    /// or `None` if the signal has already been disposed.
-    #[track_caller]
-    fn try_with_untracked<U>(
-        &self,
-        fun: impl FnOnce(Option<&Self::Value>) -> U,
-    ) -> Option<U>;
-
-    /// Applies the closure to the value, and returns the result.
-    ///
-    /// # Panics
-    /// Panics if you try to access a signal that has been disposed.
-    #[track_caller]
-    fn with_untracked<U>(
-        &self,
-        fun: impl FnOnce(Option<&Self::Value>) -> U,
-    ) -> U {
-        self.try_with_untracked(fun)
-            .unwrap_or_else(unwrap_signal!(self))
-    }
-}
-
-impl<T> WithUntrackedOptional for Option<T>
-where
-    Self: DefinedAt,
-    T: WithUntracked,
-    <T as WithUntracked>::Value: Sized,
-{
-    type Value = <T as WithUntracked>::Value;
-
-    fn try_with_untracked<U>(
-        &self,
-        fun: impl FnOnce(Option<&Self::Value>) -> U,
-    ) -> Option<U> {
-        if let Some(signal) = self {
-            Some(signal.try_with_untracked(|val| fun(Some(val)))?)
-        } else {
-            Some(fun(None))
-        }
-    }
-}
-
-/// An alternative [`With`](crate) trait that works with `Option<Withable>` types.
-pub trait WithOptional: DefinedAt {
-    /// The type of the value contained in the signal.
-    type Value: ?Sized;
-
-    /// Subscribes to the signal, applies the closure to the value, and returns the result,
-    /// or `None` if the signal has already been disposed.
-    #[track_caller]
-    fn try_with<U>(
-        &self,
-        fun: impl FnOnce(Option<&Self::Value>) -> U,
-    ) -> Option<U>;
-
-    /// Subscribes to the signal, applies the closure to the value, and returns the result.
-    ///
-    /// # Panics
-    /// Panics if you try to access a signal that has been disposed.
-    #[track_caller]
-    fn with<U>(&self, fun: impl FnOnce(Option<&Self::Value>) -> U) -> U {
-        self.try_with(fun).unwrap_or_else(unwrap_signal!(self))
-    }
-}
-
-impl<T> WithOptional for Option<T>
-where
-    Self: DefinedAt,
-    T: With,
-    <T as With>::Value: Sized,
-{
-    type Value = <T as With>::Value;
-
-    fn try_with<U>(
-        &self,
-        fun: impl FnOnce(Option<&Self::Value>) -> U,
-    ) -> Option<U> {
-        if let Some(signal) = self {
-            Some(signal.try_with(|val| fun(Some(val)))?)
-        } else {
-            Some(fun(None))
-        }
-    }
-}
-
-impl<T> GetUntracked for Option<T>
-where
-    Self: DefinedAt,
-    T: GetUntracked,
-{
-    type Value = Option<<T as GetUntracked>::Value>;
-
-    fn try_get_untracked(&self) -> Option<Self::Value> {
-        Some(if let Some(signal) = self {
-            Some(signal.try_get_untracked()?)
-        } else {
-            None
-        })
-    }
-}
-
-impl<T> Get for Option<T>
-where
-    Self: DefinedAt,
-    T: Get,
-{
-    type Value = Option<<T as Get>::Value>;
-
-    fn try_get(&self) -> Option<Self::Value> {
-        Some(if let Some(signal) = self {
-            Some(signal.try_get()?)
-        } else {
-            None
-        })
-    }
-}
-
-/// Helper trait to implement flatten() on Option<&Option<T>>.
-pub trait FlattenOptionRefOption {
-    /// The type of the value contained in the double option.
-    type Value;
-
-    /// Converts from `Option<&Option<T>>` to `Option<&T>`.
-    fn flatten(&self) -> Option<&Self::Value>;
-}
-
-impl<'a, T> FlattenOptionRefOption for Option<&'a Option<T>> {
-    type Value = T;
-
-    fn flatten(&self) -> Option<&'a T> {
-        self.map(Option::as_ref).flatten()
-    }
-}

reactive_graph/src/traits.rs

@@ -48,7 +48,6 @@
 //! there isn't an `RwLock` so you can't wrap in a [`ReadGuard`](crate::signal::guards::ReadGuard),
 //! but you can still implement [`WithUntracked`] and [`Track`], the same traits will still be implemented.
 
-pub use crate::trait_options::*;
 use crate::{
     effect::Effect,
     graph::{Observer, Source, Subscriber, ToAnySource},

reactive_graph/src/wrappers.rs

@@ -606,33 +606,6 @@ pub mod read {
         }
     }
 
-    impl<T: Send + Sync + 'static> From<T> for ArcSignal<T, SyncStorage> {
-        #[track_caller]
-        fn from(value: T) -> Self {
-            ArcSignal::stored(value)
-        }
-    }
-
-    impl<T> From<T> for Signal<T>
-    where
-        T: Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: T) -> Self {
-            Self::stored(value)
-        }
-    }
-
-    impl<T> From<T> for Signal<T, LocalStorage>
-    where
-        T: 'static,
-    {
-        #[track_caller]
-        fn from(value: T) -> Self {
-            Self::stored_local(value)
-        }
-    }
-
     impl<T> From<ArcSignal<T, SyncStorage>> for Signal<T>
     where
         T: Send + Sync + 'static,
@@ -708,34 +681,6 @@ pub mod read {
         }
     }
 
-    impl<T> From<ArcReadSignal<T>> for Signal<T>
-    where
-        T: Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: ArcReadSignal<T>) -> Self {
-            Self {
-                inner: ArenaItem::new(SignalTypes::ReadSignal(value)),
-                #[cfg(debug_assertions)]
-                defined_at: std::panic::Location::caller(),
-            }
-        }
-    }
-
-    impl<T> From<ArcReadSignal<T>> for Signal<T, LocalStorage>
-    where
-        T: Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: ArcReadSignal<T>) -> Self {
-            Self {
-                inner: ArenaItem::new_local(SignalTypes::ReadSignal(value)),
-                #[cfg(debug_assertions)]
-                defined_at: std::panic::Location::caller(),
-            }
-        }
-    }
-
     impl<T> From<RwSignal<T>> for Signal<T>
     where
         T: Send + Sync + 'static,
@@ -768,38 +713,6 @@ pub mod read {
         }
     }
 
-    impl<T> From<ArcRwSignal<T>> for Signal<T>
-    where
-        T: Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: ArcRwSignal<T>) -> Self {
-            Self {
-                inner: ArenaItem::new(SignalTypes::ReadSignal(
-                    value.read_only(),
-                )),
-                #[cfg(debug_assertions)]
-                defined_at: std::panic::Location::caller(),
-            }
-        }
-    }
-
-    impl<T> From<ArcRwSignal<T>> for Signal<T, LocalStorage>
-    where
-        T: Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: ArcRwSignal<T>) -> Self {
-            Self {
-                inner: ArenaItem::new_local(SignalTypes::ReadSignal(
-                    value.read_only(),
-                )),
-                #[cfg(debug_assertions)]
-                defined_at: std::panic::Location::caller(),
-            }
-        }
-    }
-
     impl<T> From<Memo<T>> for Signal<T>
     where
         T: Send + Sync + 'static,
@@ -828,74 +741,6 @@ pub mod read {
         }
     }
 
-    impl<T> From<ArcMemo<T>> for Signal<T>
-    where
-        T: Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: ArcMemo<T>) -> Self {
-            Self {
-                inner: ArenaItem::new(SignalTypes::Memo(value)),
-                #[cfg(debug_assertions)]
-                defined_at: std::panic::Location::caller(),
-            }
-        }
-    }
-
-    impl<T> From<ArcMemo<T, LocalStorage>> for Signal<T, LocalStorage>
-    where
-        T: Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: ArcMemo<T, LocalStorage>) -> Self {
-            Self {
-                inner: ArenaItem::new_local(SignalTypes::Memo(value)),
-                #[cfg(debug_assertions)]
-                defined_at: std::panic::Location::caller(),
-            }
-        }
-    }
-
-    impl<T> From<T> for Signal<Option<T>>
-    where
-        T: Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: T) -> Self {
-            Signal::stored(Some(value))
-        }
-    }
-
-    impl<T> From<T> for Signal<Option<T>, LocalStorage>
-    where
-        T: 'static,
-    {
-        #[track_caller]
-        fn from(value: T) -> Self {
-            Signal::stored_local(Some(value))
-        }
-    }
-
-    impl<T> From<Signal<T>> for Signal<Option<T>>
-    where
-        T: Clone + Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: Signal<T>) -> Self {
-            Signal::derive(move || Some(value.get()))
-        }
-    }
-
-    impl<T> From<Signal<T, LocalStorage>> for Signal<Option<T>, LocalStorage>
-    where
-        T: Clone + 'static,
-    {
-        #[track_caller]
-        fn from(value: Signal<T, LocalStorage>) -> Self {
-            Signal::derive_local(move || Some(value.get()))
-        }
-    }
-
     impl From<&str> for Signal<String> {
         #[track_caller]
         fn from(value: &str) -> Self {
@@ -968,7 +813,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<MaybeSignal<T>> for Signal<T>
     where
         T: Send + Sync + 'static,
@@ -982,7 +826,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<MaybeSignal<T, LocalStorage>> for Signal<T, LocalStorage>
     where
         T: Send + Sync + 'static,
@@ -996,7 +839,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<MaybeSignal<T>> for Signal<Option<T>>
     where
         T: Clone + Send + Sync + 'static,
@@ -1012,7 +854,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<MaybeSignal<T, LocalStorage>> for Signal<Option<T>, LocalStorage>
     where
         T: Clone + Send + Sync + 'static,
@@ -1028,27 +869,6 @@ pub mod read {
         }
     }
 
-    impl<T> From<MaybeProp<T>> for Option<Signal<Option<T>>>
-    where
-        T: Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: MaybeProp<T>) -> Self {
-            value.0
-        }
-    }
-
-    impl<T> From<MaybeProp<T, LocalStorage>>
-        for Option<Signal<Option<T>, LocalStorage>>
-    where
-        T: Send + Sync + 'static,
-    {
-        #[track_caller]
-        fn from(value: MaybeProp<T, LocalStorage>) -> Self {
-            value.0
-        }
-    }
-
     /// A wrapper for a value that is *either* `T` or [`Signal<T>`].
     ///
     /// This allows you to create APIs that take either a reactive or a non-reactive value
@@ -1077,12 +897,6 @@ pub mod read {
     /// assert_eq!(above_3(&memoized_double_count.into()), true);
     /// ```
     #[derive(Debug, PartialEq, Eq)]
-    #[deprecated(
-        since = "0.7.0-rc1",
-        note = "`MaybeSignal<T>` is deprecated in favour of `Signal<T>` which \
-                is `Copy`, now has a more efficient From<T> implementation \
-                and other benefits in 0.7."
-    )]
     pub enum MaybeSignal<T, S = SyncStorage>
     where
         T: 'static,
@@ -1094,7 +908,6 @@ pub mod read {
         Dynamic(Signal<T, S>),
     }
 
-    #[allow(deprecated)]
     impl<T: Clone, S> Clone for MaybeSignal<T, S>
     where
         S: Storage<T>,
@@ -1107,10 +920,8 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T: Copy, S> Copy for MaybeSignal<T, S> where S: Storage<T> {}
 
-    #[allow(deprecated)]
     impl<T: Default, S> Default for MaybeSignal<T, S>
     where
         S: Storage<T>,
@@ -1120,7 +931,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T, S> DefinedAt for MaybeSignal<T, S>
     where
         S: Storage<T>,
@@ -1132,7 +942,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T, S> Track for MaybeSignal<T, S>
     where
         S: Storage<T> + Storage<SignalTypes<T, S>>,
@@ -1145,7 +954,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T, S> ReadUntracked for MaybeSignal<T, S>
     where
         T: Clone,
@@ -1170,7 +978,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> MaybeSignal<T>
     where
         T: Send + Sync,
@@ -1184,7 +991,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> MaybeSignal<T, LocalStorage> {
         /// Wraps a derived signal, i.e., any computation that accesses one or more
         /// reactive signals.
@@ -1193,7 +999,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<T> for MaybeSignal<T, SyncStorage>
     where
         SyncStorage: Storage<T>,
@@ -1203,7 +1008,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> FromLocal<T> for MaybeSignal<T, LocalStorage>
     where
         LocalStorage: Storage<T>,
@@ -1213,7 +1017,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<ReadSignal<T>> for MaybeSignal<T>
     where
         T: Send + Sync,
@@ -1223,14 +1026,12 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<ReadSignal<T, LocalStorage>> for MaybeSignal<T, LocalStorage> {
         fn from(value: ReadSignal<T, LocalStorage>) -> Self {
             Self::Dynamic(value.into())
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<RwSignal<T>> for MaybeSignal<T>
     where
         T: Send + Sync,
@@ -1240,14 +1041,12 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<RwSignal<T, LocalStorage>> for MaybeSignal<T, LocalStorage> {
         fn from(value: RwSignal<T, LocalStorage>) -> Self {
             Self::Dynamic(value.into())
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<Memo<T>> for MaybeSignal<T>
     where
         T: Send + Sync,
@@ -1257,14 +1056,12 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<Memo<T, LocalStorage>> for MaybeSignal<T, LocalStorage> {
         fn from(value: Memo<T, LocalStorage>) -> Self {
             Self::Dynamic(value.into())
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<ArcReadSignal<T>> for MaybeSignal<T>
     where
         T: Send + Sync,
@@ -1274,14 +1071,12 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> FromLocal<ArcReadSignal<T>> for MaybeSignal<T, LocalStorage> {
         fn from_local(value: ArcReadSignal<T>) -> Self {
             ReadSignal::from_local(value).into()
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<ArcRwSignal<T>> for MaybeSignal<T>
     where
         T: Send + Sync + 'static,
@@ -1291,7 +1086,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> FromLocal<ArcRwSignal<T>> for MaybeSignal<T, LocalStorage>
     where
         T: 'static,
@@ -1301,7 +1095,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<ArcMemo<T>> for MaybeSignal<T>
     where
         T: Send + Sync,
@@ -1311,14 +1104,12 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<T> FromLocal<ArcMemo<T, LocalStorage>> for MaybeSignal<T, LocalStorage> {
         fn from_local(value: ArcMemo<T, LocalStorage>) -> Self {
             Memo::from_local(value).into()
         }
     }
 
-    #[allow(deprecated)]
     impl<T, S> From<Signal<T, S>> for MaybeSignal<T, S>
     where
         S: Storage<T>,
@@ -1328,7 +1119,6 @@ pub mod read {
         }
     }
 
-    #[allow(deprecated)]
     impl<S> From<&str> for MaybeSignal<String, S>
     where
         S: Storage<String> + Storage<Arc<RwLock<String>>>,
@@ -1372,28 +1162,25 @@ pub mod read {
     /// ```
     #[derive(Debug, PartialEq, Eq)]
     pub struct MaybeProp<T: 'static, S = SyncStorage>(
-        pub(crate) Option<Signal<Option<T>, S>>,
+        pub(crate) Option<MaybeSignal<Option<T>, S>>,
     )
     where
-        S: Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>;
+        S: Storage<Option<T>>;
 
-    impl<T, S> Clone for MaybeProp<T, S>
+    impl<T: Clone, S> Clone for MaybeProp<T, S>
     where
-        S: Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,
+        S: Storage<Option<T>>,
     {
         fn clone(&self) -> Self {
-            *self
+            Self(self.0.clone())
         }
     }
 
-    impl<T, S> Copy for MaybeProp<T, S> where
-        S: Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>
-    {
-    }
+    impl<T: Copy, S> Copy for MaybeProp<T, S> where S: Storage<Option<T>> {}
 
     impl<T, S> Default for MaybeProp<T, S>
     where
-        S: Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,
+        S: Storage<Option<T>>,
     {
         fn default() -> Self {
             Self(None)
@@ -1402,7 +1189,7 @@ pub mod read {
 
     impl<T, S> DefinedAt for MaybeProp<T, S>
     where
-        S: Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,
+        S: Storage<Option<T>>,
     {
         fn defined_at(&self) -> Option<&'static Location<'static>> {
             // TODO this can be improved by adding a defined_at field
@@ -1425,7 +1212,7 @@ pub mod read {
     impl<T, S> ReadUntracked for MaybeProp<T, S>
     where
         T: Clone,
-        S: Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,
+        S: Storage<SignalTypes<Option<T>, S>> + Storage<Option<T>>,
     {
         type Value = ReadGuard<Option<T>, SignalReadGuard<Option<T>, S>>;
 
@@ -1453,49 +1240,43 @@ pub mod read {
         pub fn derive(
             derived_signal: impl Fn() -> Option<T> + Send + Sync + 'static,
         ) -> Self {
-            Self(Some(Signal::derive(derived_signal)))
+            Self(Some(MaybeSignal::derive(derived_signal)))
         }
     }
 
     impl<T> From<T> for MaybeProp<T>
     where
-        T: Send + Sync,
         SyncStorage: Storage<Option<T>>,
     {
         fn from(value: T) -> Self {
-            Self(Some(Signal::stored(Some(value))))
+            Self(Some(MaybeSignal::from(Some(value))))
         }
     }
 
     impl<T> From<Option<T>> for MaybeProp<T>
     where
-        T: Send + Sync,
         SyncStorage: Storage<Option<T>>,
     {
         fn from(value: Option<T>) -> Self {
-            Self(Some(Signal::stored(value)))
+            Self(Some(MaybeSignal::from(value)))
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<MaybeSignal<Option<T>>> for MaybeProp<T>
     where
-        T: Send + Sync,
         SyncStorage: Storage<Option<T>>,
     {
         fn from(value: MaybeSignal<Option<T>>) -> Self {
-            Self(Some(value.into()))
+            Self(Some(value))
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<Option<MaybeSignal<Option<T>>>> for MaybeProp<T>
     where
-        T: Send + Sync,
         SyncStorage: Storage<Option<T>>,
     {
         fn from(value: Option<MaybeSignal<Option<T>>>) -> Self {
-            Self(value.map(Into::into))
+            Self(value)
         }
     }
 
@@ -1528,11 +1309,10 @@ pub mod read {
 
     impl<T> From<Signal<Option<T>>> for MaybeProp<T>
     where
-        T: Send + Sync,
         SyncStorage: Storage<Option<T>>,
     {
         fn from(value: Signal<Option<T>>) -> Self {
-            Self(Some(value))
+            Self(Some(value.into()))
         }
     }
 
@@ -1541,7 +1321,7 @@ pub mod read {
         T: Send + Sync + Clone,
     {
         fn from(value: ReadSignal<T>) -> Self {
-            Self(Some(Signal::derive(move || Some(value.get()))))
+            Self(Some(MaybeSignal::derive(move || Some(value.get()))))
         }
     }
 
@@ -1550,7 +1330,7 @@ pub mod read {
         T: Send + Sync + Clone,
     {
         fn from(value: RwSignal<T>) -> Self {
-            Self(Some(Signal::derive(move || Some(value.get()))))
+            Self(Some(MaybeSignal::derive(move || Some(value.get()))))
         }
     }
 
@@ -1559,7 +1339,7 @@ pub mod read {
         T: Send + Sync + Clone,
     {
         fn from(value: Memo<T>) -> Self {
-            Self(Some(Signal::derive(move || Some(value.get()))))
+            Self(Some(MaybeSignal::derive(move || Some(value.get()))))
         }
     }
 
@@ -1568,13 +1348,13 @@ pub mod read {
         T: Send + Sync + Clone,
     {
         fn from(value: Signal<T>) -> Self {
-            Self(Some(Signal::derive(move || Some(value.get()))))
+            Self(Some(MaybeSignal::derive(move || Some(value.get()))))
         }
     }
 
     impl From<&str> for MaybeProp<String> {
         fn from(value: &str) -> Self {
-            Self(Some(Signal::from(Some(value.to_string()))))
+            Self(Some(MaybeSignal::from(Some(value.to_string()))))
         }
     }
 
@@ -1584,41 +1364,35 @@ pub mod read {
         pub fn derive_local(
             derived_signal: impl Fn() -> Option<T> + 'static,
         ) -> Self {
-            Self(Some(Signal::derive_local(derived_signal)))
+            Self(Some(MaybeSignal::derive_local(derived_signal)))
         }
     }
 
     impl<T> FromLocal<T> for MaybeProp<T, LocalStorage> {
         fn from_local(value: T) -> Self {
-            Self(Some(Signal::stored_local(Some(value))))
+            Self(Some(MaybeSignal::from_local(Some(value))))
         }
     }
 
     impl<T> FromLocal<Option<T>> for MaybeProp<T, LocalStorage> {
         fn from_local(value: Option<T>) -> Self {
-            Self(Some(Signal::stored_local(value)))
+            Self(Some(MaybeSignal::from_local(value)))
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<MaybeSignal<Option<T>, LocalStorage>>
         for MaybeProp<T, LocalStorage>
-    where
-        T: Send + Sync,
     {
         fn from(value: MaybeSignal<Option<T>, LocalStorage>) -> Self {
-            Self(Some(value.into()))
+            Self(Some(value))
         }
     }
 
-    #[allow(deprecated)]
     impl<T> From<Option<MaybeSignal<Option<T>, LocalStorage>>>
         for MaybeProp<T, LocalStorage>
-    where
-        T: Send + Sync,
     {
         fn from(value: Option<MaybeSignal<Option<T>, LocalStorage>>) -> Self {
-            Self(value.map(Into::into))
+            Self(value)
         }
     }
 
@@ -1651,7 +1425,7 @@ pub mod read {
 
     impl<T> From<Signal<Option<T>, LocalStorage>> for MaybeProp<T, LocalStorage> {
         fn from(value: Signal<Option<T>, LocalStorage>) -> Self {
-            Self(Some(value))
+            Self(Some(value.into()))
         }
     }
 
@@ -1660,7 +1434,7 @@ pub mod read {
         T: Send + Sync + Clone,
     {
         fn from(value: ReadSignal<T, LocalStorage>) -> Self {
-            Self(Some(Signal::derive_local(move || Some(value.get()))))
+            Self(Some(MaybeSignal::derive_local(move || Some(value.get()))))
         }
     }
 
@@ -1669,7 +1443,7 @@ pub mod read {
         T: Send + Sync + Clone,
     {
         fn from(value: RwSignal<T, LocalStorage>) -> Self {
-            Self(Some(Signal::derive_local(move || Some(value.get()))))
+            Self(Some(MaybeSignal::derive_local(move || Some(value.get()))))
         }
     }
 
@@ -1678,7 +1452,7 @@ pub mod read {
         T: Send + Sync + Clone,
     {
         fn from(value: Memo<T, LocalStorage>) -> Self {
-            Self(Some(Signal::derive_local(move || Some(value.get()))))
+            Self(Some(MaybeSignal::derive_local(move || Some(value.get()))))
         }
     }
 
@@ -1687,13 +1461,13 @@ pub mod read {
         T: Send + Sync + Clone,
     {
         fn from(value: Signal<T, LocalStorage>) -> Self {
-            Self(Some(Signal::derive_local(move || Some(value.get()))))
+            Self(Some(MaybeSignal::derive_local(move || Some(value.get()))))
         }
     }
 
     impl From<&str> for MaybeProp<String, LocalStorage> {
         fn from(value: &str) -> Self {
-            Self(Some(Signal::stored_local(Some(value.to_string()))))
+            Self(Some(MaybeSignal::from_local(Some(value.to_string()))))
         }
     }
 

tachys/src/reactive_graph/class.rs

@@ -519,7 +519,6 @@ mod stable {
 
     macro_rules! class_signal_arena {
         ($sig:ident) => {
-            #[allow(deprecated)]
             impl<C, S> IntoClass for $sig<C, S>
             where
                 $sig<C, S>: Get<Value = C>,
@@ -589,7 +588,6 @@ mod stable {
                 }
             }
 
-            #[allow(deprecated)]
             impl<S> IntoClass for (&'static str, $sig<bool, S>)
             where
                 $sig<bool, S>: Get<Value = bool>,
@@ -827,14 +825,12 @@ mod stable {
 
     use super::RenderEffect;
     use crate::html::class::IntoClass;
-    #[allow(deprecated)]
-    use reactive_graph::wrappers::read::MaybeSignal;
     use reactive_graph::{
         computed::{ArcMemo, Memo},
         owner::Storage,
         signal::{ArcReadSignal, ArcRwSignal, ReadSignal, RwSignal},
         traits::Get,
-        wrappers::read::{ArcSignal, Signal},
+        wrappers::read::{ArcSignal, MaybeSignal, Signal},
     };
 
     class_signal_arena!(RwSignal);

tachys/src/reactive_graph/inner_html.rs

@@ -89,15 +89,13 @@ where
 #[cfg(not(feature = "nightly"))]
 mod stable {
     use crate::html::element::InnerHtmlValue;
-    #[allow(deprecated)]
-    use reactive_graph::wrappers::read::MaybeSignal;
     use reactive_graph::{
         computed::{ArcMemo, Memo},
         effect::RenderEffect,
         owner::Storage,
         signal::{ArcReadSignal, ArcRwSignal, ReadSignal, RwSignal},
         traits::Get,
-        wrappers::read::{ArcSignal, Signal},
+        wrappers::read::{ArcSignal, MaybeSignal, Signal},
     };
 
     macro_rules! inner_html_signal {
@@ -161,7 +159,6 @@ mod stable {
 
     macro_rules! inner_html_signal_arena {
         ($sig:ident) => {
-            #[allow(deprecated)]
             impl<V, S> InnerHtmlValue for $sig<V, S>
             where
                 $sig<V, S>: Get<Value = V>,

tachys/src/reactive_graph/mod.rs

@@ -507,15 +507,13 @@ mod stable {
             RenderHtml,
         },
     };
-    #[allow(deprecated)]
-    use reactive_graph::wrappers::read::MaybeSignal;
     use reactive_graph::{
         computed::{ArcMemo, Memo},
         effect::RenderEffect,
         owner::Storage,
         signal::{ArcReadSignal, ArcRwSignal, ReadSignal, RwSignal},
         traits::Get,
-        wrappers::read::{ArcSignal, Signal},
+        wrappers::read::{ArcSignal, MaybeSignal, Signal},
     };
 
     macro_rules! signal_impl {
@@ -685,7 +683,6 @@ mod stable {
 
     macro_rules! signal_impl_arena {
         ($sig:ident $dry_resolve:literal) => {
-            #[allow(deprecated)]
             impl<V, S> Render for $sig<V, S>
             where
                 $sig<V, S>: Get<Value = V>,
@@ -710,7 +707,6 @@ mod stable {
                 }
             }
 
-            #[allow(deprecated)]
             impl<V, S> AddAnyAttr for $sig<V, S>
             where
                 $sig<V, S>: Get<Value = V>,
@@ -732,7 +728,6 @@ mod stable {
                 }
             }
 
-            #[allow(deprecated)]
             impl<V, S> RenderHtml for $sig<V, S>
             where
                 $sig<V, S>: Get<Value = V>,
@@ -798,7 +793,6 @@ mod stable {
                 }
             }
 
-            #[allow(deprecated)]
             impl<V, S> AttributeValue for $sig<V, S>
             where
                 $sig<V, S>: Get<Value = V>,

tachys/src/reactive_graph/property.rs

@@ -82,15 +82,13 @@ where
 #[cfg(not(feature = "nightly"))]
 mod stable {
     use crate::html::property::IntoProperty;
-    #[allow(deprecated)]
-    use reactive_graph::wrappers::read::MaybeSignal;
     use reactive_graph::{
         computed::{ArcMemo, Memo},
         effect::RenderEffect,
         owner::Storage,
         signal::{ArcReadSignal, ArcRwSignal, ReadSignal, RwSignal},
         traits::Get,
-        wrappers::read::{ArcSignal, Signal},
+        wrappers::read::{ArcSignal, MaybeSignal, Signal},
     };
 
     macro_rules! property_signal {
@@ -138,7 +136,6 @@ mod stable {
 
     macro_rules! property_signal_arena {
         ($sig:ident) => {
-            #[allow(deprecated)]
             impl<V, S> IntoProperty for $sig<V, S>
             where
                 $sig<V, S>: Get<Value = V>,

tachys/src/reactive_graph/style.rs

@@ -393,7 +393,6 @@ mod stable {
 
     macro_rules! style_signal_arena {
         ($sig:ident) => {
-            #[allow(deprecated)]
             impl<C, S> IntoStyle for $sig<C, S>
             where
                 $sig<C, S>: Get<Value = C>,
@@ -459,7 +458,6 @@ mod stable {
                 }
             }
 
-            #[allow(deprecated)]
             impl<S, St> IntoStyle for (&'static str, $sig<S, St>)
             where
                 $sig<S, St>: Get<Value = S>,
@@ -536,14 +534,12 @@ mod stable {
 
     use super::RenderEffect;
     use crate::html::style::IntoStyle;
-    #[allow(deprecated)]
-    use reactive_graph::wrappers::read::MaybeSignal;
     use reactive_graph::{
         computed::{ArcMemo, Memo},
         owner::Storage,
         signal::{ArcReadSignal, ArcRwSignal, ReadSignal, RwSignal},
         traits::Get,
-        wrappers::read::{ArcSignal, Signal},
+        wrappers::read::{ArcSignal, MaybeSignal, Signal},
     };
     use std::borrow::Cow;