ToComputed impls for primitive types

Author: sfisol

CHANGES.md

@@ -9,6 +9,7 @@
 * `Driver::timezone_offset` (Gets browsers time zone offset in seconds)
 * `chrono::NaiveDate` support in `AutoJsJson`
 * `LazyCache::<T>::new_resource()` helper
+* `ToComputed` impls for primitive types
 
 ### Changed
 

crates/vertigo/src/computed/computed_box.rs

@@ -191,19 +191,3 @@ impl From<&str> for Computed<String> {
         Value::new(value.to_string()).to_computed()
     }
 }
-
-pub trait ToComputed<T: Clone> {
-    fn to_computed(&self) -> Computed<T>;
-}
-
-impl<T: Clone + 'static> ToComputed<T> for Computed<T> {
-    fn to_computed(&self) -> Computed<T> {
-        self.clone()
-    }
-}
-
-impl<T: Clone + 'static> ToComputed<T> for &Computed<T> {
-    fn to_computed(&self) -> Computed<T> {
-        (*self).clone()
-    }
-}

crates/vertigo/src/computed/mod.rs

@@ -7,18 +7,20 @@ mod graph_id;
 mod graph_value;
 mod reactive;
 pub mod struct_mut;
+mod to_computed;
 mod value;
 
 #[cfg(test)]
 mod tests;
 
 pub use auto_map::AutoMap;
-pub use computed_box::{Computed, ToComputed};
+pub use computed_box::Computed;
 pub use dependencies::Dependencies;
 pub use drop_resource::DropResource;
 pub use graph_id::GraphId;
 pub use graph_value::GraphValue;
 pub use reactive::Reactive;
+pub use to_computed::ToComputed;
 pub use value::Value;
 
 /// Allows to create `Computed<T1, T2, ...>` out of `Value<T1>`, `Value<T2>`, ...

crates/vertigo/src/computed/to_computed.rs

@@ -0,0 +1,67 @@
+use super::Computed;
+
+/// A trait allowing converting the type into computed.
+///
+/// ```rust
+/// use vertigo::{ToComputed, transaction};
+///
+/// let comp_1 = 5.to_computed();
+/// let comp_2 = 'x'.to_computed();
+/// let comp_3 = false.to_computed();
+///
+/// transaction(|context| {
+///     assert_eq!(comp_1.get(context), 5);
+///     assert_eq!(comp_2.get(context), 'x');
+///     assert_eq!(comp_3.get(context), false);
+/// });
+///
+/// ```
+pub trait ToComputed<T: Clone> {
+    fn to_computed(&self) -> Computed<T>;
+}
+
+impl<T: Clone + 'static> ToComputed<T> for Computed<T> {
+    fn to_computed(&self) -> Computed<T> {
+        self.clone()
+    }
+}
+
+impl<T: Clone + 'static> ToComputed<T> for &Computed<T> {
+    fn to_computed(&self) -> Computed<T> {
+        (*self).clone()
+    }
+}
+
+macro_rules! impl_to_computed {
+    ($typename: ty) => {
+        impl ToComputed<$typename> for $typename {
+            fn to_computed(&self) -> Computed<$typename> {
+                let value = *self;
+                Computed::from(move |_| value)
+            }
+        }
+    };
+}
+
+impl_to_computed!(i8);
+impl_to_computed!(i16);
+impl_to_computed!(i32);
+impl_to_computed!(i64);
+impl_to_computed!(i128);
+impl_to_computed!(isize);
+
+impl_to_computed!(u8);
+impl_to_computed!(u16);
+impl_to_computed!(u32);
+impl_to_computed!(u64);
+impl_to_computed!(u128);
+impl_to_computed!(usize);
+
+impl_to_computed!(f32);
+impl_to_computed!(f64);
+
+impl_to_computed!(char);
+
+impl_to_computed!(bool);
+
+impl_to_computed!(());