Added "Maybe<T>" value. This replaces Value<Option<T>> with Value<Maybe<T>>

Author: togglebyte

Cargo.toml

@@ -22,13 +22,12 @@ anathema-store = { path = "./anathema-store" }
 anathema-templates = { path = "./anathema-templates" }
 anathema-widgets = { path = "./anathema-widgets" }
 anathema-geometry = { path = "./anathema-geometry" }
-anathema-strings = { path = "./anathema-strings" }
 anathema-value-resolver = { path = "./anathema-value-resolver" }
 
 [features]
 default = []
 profile = ["anathema-runtime/profile", "anathema-widgets/profile", "anathema-backend/profile"]
-debuggy = ["anathema-widgets/debuggy"]
+filelog = ["anathema-debug/filelog"]
 
 [lints]
 workspace = true
@@ -54,7 +53,6 @@ members = [
     "anathema-state",
     "anathema-state-derive",
     "anathema-store",
-    "anathema-strings",
     "anathema-templates", 
     "anathema-widgets", 
     "anathema-value-resolver", 

anathema-debug/Cargo.toml

@@ -5,5 +5,9 @@ edition.workspace = true
 
 [dependencies]
 
+[features]
+default = []
+filelog = []
+
 [lints]
 workspace = true

anathema-debug/src/lib.rs

@@ -36,3 +36,40 @@ impl<O: Write> Debug<O> {
         self.0
     }
 }
+
+#[cfg(feature = "filelog")]
+pub mod macros {
+    #[macro_export]
+    macro_rules! debug_to_file {
+        ($($arg:tt)*) => {
+            use ::std::io::Write as _;
+            let mut file = std::fs::OpenOptions::new().create(true).append(true).open("/tmp/log.lol").unwrap();
+            let payload = format!($($arg)*);
+            file.write_all(payload.as_bytes()).unwrap();
+            file.write(b"\n").unwrap();
+            file.flush();
+        }
+    }
+
+    #[macro_export]
+    macro_rules! debug_tree {
+        ($tree:expr) => {
+            let mut d = $crate::tree::debug::DebugTree::new();
+            $tree.apply_visitor(&mut d);
+            $crate::debug_to_file!("{}", d.output);
+        };
+    }
+}
+
+#[cfg(not(feature = "filelog"))]
+pub mod macros {
+    #[macro_export]
+    macro_rules! debug_to_file {
+        ($($arg:tt)*) => {};
+    }
+
+    #[macro_export]
+    macro_rules! debug_tree {
+        ($tree:expr) => {};
+    }
+}

anathema-runtime/src/runtime/mod.rs

@@ -439,17 +439,20 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
                 return;
             };
 
-            let Some(remote_state) = self.layout_ctx.states.get(event.state) else { return };
-            let Some(remote_state) = remote_state.shared_state() else { return };
-            self.with_component(widget_id, state_id, |comp, children, ctx| {
-                // TODO:
-                // Create a new event type
-                // if the event is stopped then return from drain_assoc_events
-
-                let event_ident = self.document.strings.get_ref_unchecked(event.external);
-                comp.dyn_component
-                    .any_receive(children, ctx, event_ident, &*remote_state);
-            });
+            panic!(
+                "this is going to be reworked. this was working while SharedState didn't have a lifetime, it does now so... figure it out"
+            );
+            // let Some(remote_state) = self.layout_ctx.states.get(event.state) else { return };
+            // let Some(remote_state) = remote_state.shared_state() else { return };
+            // self.with_component(widget_id, state_id, |comp, children, ctx| {
+            //     // TODO:
+            //     // Create a new event type
+            //     // if the event is stopped then return from drain_assoc_events
+
+            //     let event_ident = self.document.strings.get_ref_unchecked(event.external);
+            //     comp.dyn_component
+            //         .any_receive(children, ctx, event_ident, &*remote_state);
+            // });
         }
     }
 

anathema-state/src/lib.rs

@@ -5,12 +5,12 @@ use anathema_store::slab::Key;
 
 pub use crate::colors::{Color, FromColor};
 pub use crate::numbers::Number;
-pub use crate::states::{AnyMap, AnyState, State, StateId, States, TypeId};
+pub use crate::states::{AnyMap, State, StateId, States, TypeId};
 pub use crate::store::watchers::Watcher;
 pub use crate::store::{
     Change, Changes, SubTo, Subscriber, Watched, clear_all_changes, clear_all_subs, drain_changes, drain_watchers,
 };
-pub use crate::value::{List, Map, PendingValue, SharedState, Type, Value, ValueRef};
+pub use crate::value::{List, Map, Maybe, Nullable, PendingValue, SharedState, Type, Value, ValueRef};
 
 mod colors;
 mod numbers;

anathema-state/src/states.rs

@@ -63,7 +63,7 @@ impl SlabIndex for StateId {
     }
 }
 
-pub trait State: 'static {
+pub trait State: Any + 'static {
     fn type_info(&self) -> Type;
 
     fn as_int(&self) -> Option<i64> {
@@ -101,134 +101,23 @@ pub trait State: 'static {
     fn as_any_list(&self) -> Option<&dyn AnyList> {
         None
     }
-}
-
-impl<T: State> AnyState for T {
-    fn to_any_ref(&self) -> &dyn Any {
-        self
-    }
-
-    fn to_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    fn type_info(&self) -> Type {
-        <Self as State>::type_info(self)
-    }
-
-    fn as_int(&self) -> Option<i64> {
-        <Self as State>::as_int(self)
-    }
-
-    fn as_float(&self) -> Option<f64> {
-        <Self as State>::as_float(self)
-    }
-
-    fn as_hex(&self) -> Option<Hex> {
-        <Self as State>::as_hex(self)
-    }
-
-    fn as_color(&self) -> Option<Color> {
-        <Self as State>::as_color(self)
-    }
-
-    fn as_char(&self) -> Option<char> {
-        <Self as State>::as_char(self)
-    }
-
-    fn as_str(&self) -> Option<&str> {
-        <Self as State>::as_str(self)
-    }
-
-    fn as_bool(&self) -> Option<bool> {
-        <Self as State>::as_bool(self)
-    }
-
-    fn as_any_map(&self) -> Option<&dyn AnyMap> {
-        <Self as State>::as_any_map(self)
-    }
-
-    fn as_any_list(&self) -> Option<&dyn AnyList> {
-        <Self as State>::as_any_list(self)
-    }
-}
-
-pub trait AnyState: 'static {
-    fn type_info(&self) -> Type;
-
-    fn to_any_ref(&self) -> &dyn Any;
-
-    fn to_any_mut(&mut self) -> &mut dyn Any;
-
-    fn as_int(&self) -> Option<i64> {
-        None
-    }
-
-    fn as_float(&self) -> Option<f64> {
-        None
-    }
-
-    fn as_hex(&self) -> Option<Hex> {
-        None
-    }
-
-    fn as_color(&self) -> Option<Color> {
-        None
-    }
-
-    fn as_char(&self) -> Option<char> {
-        None
-    }
-
-    fn as_str(&self) -> Option<&str> {
-        None
-    }
 
-    fn as_bool(&self) -> Option<bool> {
+    fn as_maybe(&self) -> Option<&dyn AnyMaybe> {
         None
     }
-
-    fn as_any_map(&self) -> Option<&dyn AnyMap> {
-        None
-    }
-
-    fn as_any_list(&self) -> Option<&dyn AnyList> {
-        None
-    }
-}
-
-impl dyn AnyState {
-    pub fn try_to<T: 'static>(&self) -> Option<&T> {
-        self.to_any_ref().downcast_ref()
-    }
-
-    pub fn to<T: 'static>(&self) -> &T {
-        match self.try_to() {
-            Some(val) => val,
-            None => panic!("invalid type"),
-        }
-    }
 }
 
-impl Debug for dyn AnyState {
+impl Debug for dyn State {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "<AnyState ({:?})>", self.type_info())
+        write!(f, "<State ({:?})>", self.type_info())
     }
 }
 
-impl AnyState for Box<dyn AnyState> {
+impl State for Box<dyn State> {
     fn type_info(&self) -> Type {
         self.as_ref().type_info()
     }
 
-    fn to_any_ref(&self) -> &dyn Any {
-        self.as_ref().to_any_ref()
-    }
-
-    fn to_any_mut(&mut self) -> &mut dyn Any {
-        self.as_mut().to_any_mut()
-    }
-
     fn as_int(&self) -> Option<i64> {
         self.as_ref().as_int()
     }
@@ -264,6 +153,10 @@ impl AnyState for Box<dyn AnyState> {
     fn as_any_list(&self) -> Option<&dyn AnyList> {
         self.as_ref().as_any_list()
     }
+
+    fn as_maybe(&self) -> Option<&dyn AnyMaybe> {
+        self.as_ref().as_maybe()
+    }
 }
 
 pub trait AnyMap {
@@ -282,50 +175,8 @@ pub trait AnyList {
     }
 }
 
-// -----------------------------------------------------------------------------
-//   - State implementation... -
-//   State implementation for primitives and non-state types
-// -----------------------------------------------------------------------------
-impl<T: State + TypeId> State for Option<T> {
-    fn type_info(&self) -> Type {
-        T::TYPE
-    }
-
-    fn as_int(&self) -> Option<i64> {
-        self.as_ref()?.as_int()
-    }
-
-    fn as_float(&self) -> Option<f64> {
-        self.as_ref()?.as_float()
-    }
-
-    fn as_hex(&self) -> Option<Hex> {
-        self.as_ref()?.as_hex()
-    }
-
-    fn as_color(&self) -> Option<Color> {
-        self.as_ref()?.as_color()
-    }
-
-    fn as_char(&self) -> Option<char> {
-        self.as_ref()?.as_char()
-    }
-
-    fn as_str(&self) -> Option<&str> {
-        self.as_ref()?.as_str()
-    }
-
-    fn as_bool(&self) -> Option<bool> {
-        self.as_ref()?.as_bool()
-    }
-
-    fn as_any_map(&self) -> Option<&dyn AnyMap> {
-        self.as_ref()?.as_any_map()
-    }
-
-    fn as_any_list(&self) -> Option<&dyn AnyList> {
-        self.as_ref()?.as_any_list()
-    }
+pub trait AnyMaybe {
+    fn get(&self) -> Option<PendingValue>;
 }
 
 macro_rules! impl_num_state {
@@ -445,29 +296,30 @@ impl_float_state!(f64);
 
 #[derive(Debug)]
 pub struct States {
-    inner: Slab<StateId, Value<Box<dyn AnyState>>>,
+    inner: Slab<StateId, Value<Box<dyn State>>>,
 }
 
 impl States {
     pub fn new() -> Self {
         Self { inner: Slab::empty() }
     }
 
-    pub fn insert(&mut self, state: Value<Box<dyn AnyState>>) -> StateId {
+    pub fn insert(&mut self, state: Box<dyn State>) -> StateId {
+        let state = Value::from_box(state);
         self.inner.insert(state)
     }
 
-    pub fn get(&self, state_id: impl Into<StateId>) -> Option<&Value<Box<dyn AnyState>>> {
+    pub fn get(&self, state_id: impl Into<StateId>) -> Option<&Value<Box<dyn State>>> {
         self.inner.get(state_id.into()).map(|b| b)
     }
 
-    pub fn get_mut(&mut self, state_id: impl Into<StateId>) -> Option<&mut Value<Box<dyn AnyState>>> {
+    pub fn get_mut(&mut self, state_id: impl Into<StateId>) -> Option<&mut Value<Box<dyn State>>> {
         self.inner.get_mut(state_id.into())
     }
 
     pub fn with_mut<F, U>(&mut self, index: impl Into<StateId>, f: F) -> U
     where
-        F: FnOnce(&mut dyn AnyState, &mut Self) -> U,
+        F: FnOnce(&mut dyn State, &mut Self) -> U,
     {
         let mut ticket = self.inner.checkout(index.into());
         let ret = f(&mut *ticket.to_mut(), self);
@@ -480,7 +332,7 @@ impl States {
     /// # Panics
     ///
     /// Will panic if the state does not exist.
-    pub fn remove(&mut self, state_id: StateId) -> Value<Box<dyn AnyState>> {
+    pub fn remove(&mut self, state_id: StateId) -> Value<Box<dyn State>> {
         self.inner.remove(state_id)
     }
 }

anathema-state/src/store/change.rs

@@ -34,6 +34,7 @@ pub(crate) fn changed(key: ValueKey, change: Change) {
         return;
     }
 
+    anathema_debug::debug_to_file!("changed {:?}", key);
     CHANGES.with_borrow_mut(|changes| {
         changes.push((subscribers, change));
     });

anathema-state/src/store/mod.rs

@@ -53,6 +53,7 @@ impl ValueKey {
             9 => Type::Composite,
             10 => Type::Unit,
             11 => Type::Color,
+            12 => Type::Maybe,
             _ => unreachable!("corrupt type information"),
         }
     }