Support MaybeDyn<Option<Cow<'static, str>>> and make some impls more flexible (#713)

* Add some more impls for MaybeDyn for converting from signals

* Add implementations for Option<Cow<'static, str>>

* More flexible From<Signal> impl for MaybeDyn

* Add a test

* Fix errors

Author: lukechu10

packages/sycamore-reactive/src/maybe_dyn.rs

@@ -94,15 +94,25 @@ impl<T: Into<Self> + 'static> MaybeDyn<T> {
     }
 }
 
-impl<T: Into<Self>> From<ReadSignal<T>> for MaybeDyn<T> {
-    fn from(val: ReadSignal<T>) -> Self {
-        MaybeDyn::Signal(val)
+impl<T: Into<Self>, U: Into<MaybeDyn<T>> + Clone> From<ReadSignal<U>> for MaybeDyn<T> {
+    fn from(val: ReadSignal<U>) -> Self {
+        // Check if U == T, i.e. ReadSignal<U> is actually a ReadSignal<T>.
+        //
+        // If so, we use a trick to convert the generic type to the concrete type. This should be
+        // optimized out by the compiler to be zero-cost.
+        if let Some(val) =
+            (&mut Some(val) as &mut dyn std::any::Any).downcast_mut::<Option<ReadSignal<T>>>()
+        {
+            MaybeDyn::Signal(val.unwrap())
+        } else {
+            MaybeDyn::Derived(Rc::new(move || val.get_clone().into()))
+        }
     }
 }
 
-impl<T: Into<Self>> From<Signal<T>> for MaybeDyn<T> {
-    fn from(val: Signal<T>) -> Self {
-        MaybeDyn::Signal(*val)
+impl<T: Into<Self>, U: Into<MaybeDyn<T>> + Clone> From<Signal<U>> for MaybeDyn<T> {
+    fn from(val: Signal<U>) -> Self {
+        Self::from(*val)
     }
 }
 
@@ -149,20 +159,39 @@ macro_rules! impl_into_maybe_dyn {
             }
         }
 
+        $crate::impl_into_maybe_dyn_with_convert!($ty; Into::into $(; $($from),*)?);
+    };
+}
+
+/// Create `From<U>` implementations for `MaybeDyn<T>` for a list of types.
+///
+/// Usually, you would use the [`impl_into_maybe_dyn!`] macro instead of this macro.
+#[macro_export]
+macro_rules! impl_into_maybe_dyn_with_convert {
+    ($ty:ty; $convert:expr $(; $($from:ty),*)?) => {
         $(
             $(
                 impl From<$from> for $crate::MaybeDyn<$ty> {
                     fn from(val: $from) -> Self {
-                        MaybeDyn::Static(val.into())
+                        MaybeDyn::Static($convert(val))
                     }
                 }
             )*
         )?
     };
 }
 
-impl_into_maybe_dyn!(bool);
 impl_into_maybe_dyn!(Cow<'static, str>; &'static str, String);
+impl_into_maybe_dyn_with_convert!(
+    Option<Cow<'static, str>>; |x| Some(Into::into(x));
+    Cow<'static, str>, &'static str, String
+);
+impl_into_maybe_dyn_with_convert!(
+    Option<Cow<'static, str>>; |x| Option::map(x, Into::into);
+    Option<&'static str>, Option<String>
+);
+
+impl_into_maybe_dyn!(bool);
 
 impl_into_maybe_dyn!(f32);
 impl_into_maybe_dyn!(f64);
@@ -180,6 +209,12 @@ impl_into_maybe_dyn!(u64);
 impl_into_maybe_dyn!(u128);
 impl_into_maybe_dyn!(usize);
 
+impl<T> From<Option<T>> for MaybeDyn<Option<T>> {
+    fn from(val: Option<T>) -> Self {
+        MaybeDyn::Static(val)
+    }
+}
+
 impl<T> From<Vec<T>> for MaybeDyn<Vec<T>> {
     fn from(val: Vec<T>) -> Self {
         MaybeDyn::Static(val)
@@ -209,14 +244,27 @@ mod tests {
     fn maybe_dyn_signal() {
         let _ = create_root(move || {
             let signal = create_signal(123);
-            let value = MaybeDyn::from(signal);
-            assert!(value.as_static().is_none());
+            let value = MaybeDyn::<i32>::from(signal);
+            assert!(matches!(value, MaybeDyn::Signal(_)));
+
             assert_eq!(value.get(), 123);
             assert_eq!(value.get_clone(), 123);
             assert_eq!(value.evaluate(), 123);
         });
     }
 
+    #[test]
+    fn maybe_dyn_signal_from() {
+        let _ = create_root(move || {
+            let signal = create_signal("abc");
+            let value = MaybeDyn::<Cow<'static, str>>::from(signal);
+            assert!(matches!(value, MaybeDyn::Derived(_)));
+
+            assert_eq!(value.get_clone(), "abc");
+            assert_eq!(value.evaluate(), "abc");
+        });
+    }
+
     #[test]
     fn maybe_dyn_derived() {
         let value = MaybeDyn::<i32>::from(|| 123);

packages/sycamore/tests/web/cleanup.rs

@@ -2,7 +2,7 @@ use std::cell::Cell;
 
 use super::*;
 
-thread_local!(static CLEANUP_CALLED: Cell<bool> = Cell::new(false));
+thread_local!(static CLEANUP_CALLED: Cell<bool> = const { Cell::new(false) });
 fn assert_cleanup_called(f: impl FnOnce()) {
     CLEANUP_CALLED.with(|cleanup_called| {
         cleanup_called.set(false);

packages/sycamore/tests/web/indexed.rs

@@ -231,7 +231,12 @@ fn insert_front() {
 #[wasm_bindgen_test]
 fn nested_reactivity() {
     let _ = create_root(|| {
-        let count = create_signal(vec![1, 2, 3].into_iter().map(create_signal).collect());
+        let count = create_signal(
+            vec![1, 2, 3]
+                .into_iter()
+                .map(create_signal)
+                .collect::<Vec<_>>(),
+        );
 
         let view = move || {
             view! {

packages/sycamore/tests/web/keyed.rs

@@ -271,7 +271,12 @@ fn insert_front() {
 #[wasm_bindgen_test]
 fn nested_reactivity() {
     let _ = create_root(|| {
-        let count = create_signal(vec![1, 2, 3].into_iter().map(create_signal).collect());
+        let count = create_signal(
+            vec![1, 2, 3]
+                .into_iter()
+                .map(create_signal)
+                .collect::<Vec<_>>(),
+        );
 
         let view = move || {
             view! {

packages/tools/bench/benches/reactivity.rs

@@ -43,7 +43,7 @@ pub fn bench(c: &mut Criterion) {
     c.bench_function("reactivity_map_indexed", |b| {
         let root = create_root(|| {
             b.iter(|| {
-                let v = create_signal((0..100).collect());
+                let v = create_signal((0..100).collect::<Vec<_>>());
                 let mapped = map_indexed(v, |x| x * 2);
                 mapped.track();
 
@@ -57,7 +57,7 @@ pub fn bench(c: &mut Criterion) {
     c.bench_function("reactivity_map_keyed", |b| {
         let root = create_root(|| {
             b.iter(|| {
-                let v = create_signal((0..100).collect());
+                let v = create_signal((0..100).collect::<Vec<_>>());
                 let mapped = map_keyed(v, |x| x * 2, |x| *x);
                 mapped.track();