Feat: rename recoil to atoms

packages/atoms/src/lib.rs

@@ -0,0 +1,573 @@
+use std::{
+    cell::{Ref, RefCell},
+    collections::HashMap,
+    hash::Hash,
+    marker::PhantomData,
+    rc::Rc,
+};
+
+pub use atomfamily::*;
+pub use atoms::*;
+pub use ecs::*;
+use error::*;
+pub use hooks::*;
+pub use hooks::*;
+pub use root::*;
+pub use selector::*;
+pub use selectorfamily::*;
+pub use traits::*;
+pub use utils::*;
+mod tracingimmap;
+
+mod traits {
+    use dioxus_core::prelude::Context;
+
+    use super::*;
+    pub trait MapKey: PartialEq + Hash + 'static {}
+    impl<T: PartialEq + Hash + 'static> MapKey for T {}
+
+    pub trait AtomValue: PartialEq + 'static {}
+    impl<T: PartialEq + 'static> AtomValue for T {}
+
+    // Atoms, selectors, and their family variants are readable
+    pub trait Readable<T: AtomValue>: Sized + Copy {
+        fn use_read<'a, P: 'static>(self, ctx: Context<'a, P>) -> &'a T {
+            hooks::use_read(&ctx, self)
+        }
+
+        // This returns a future of the value
+        // If the atom is currently pending, that future will resolve to pending
+        // If the atom is currently ready, the future will immediately resolve
+        // if the atom switches from ready to pending, the component will re-run, returning a pending future
+        fn use_read_async<'a, P>(self, ctx: Context<'a, P>) -> &'a T {
+            todo!()
+        }
+
+        fn initialize(self, api: &RecoilRoot) -> T;
+
+        // We use the Raw Ptr to the atom
+        // TODO: Make sure atoms with the same definitions don't get merged together. I don't think they do, but double check
+        fn static_id(self) -> u32;
+    }
+
+    // Only atoms and atom families are writable
+    // Selectors and selector families are not
+    pub trait Writable<T: AtomValue>: Readable<T> + Sized {
+        fn use_read_write<'a, P>(self, ctx: Context<'a, P>) -> (&'a T, &'a Rc<dyn Fn(T)>) {
+            todo!()
+        }
+
+        fn use_write<'a, P>(self, ctx: Context<'a, P>) -> &'a Rc<dyn Fn(T)> {
+            todo!()
+        }
+    }
+}
+
+mod atoms {
+    use super::*;
+
+    // Currently doesn't do anything, but will eventually add effects, id, serialize/deserialize keys, etc
+    // Doesn't currently allow async values, but the goal is to eventually enable them
+    pub struct AtomBuilder {}
+
+    pub type Atom<T> = fn(&mut AtomBuilder) -> T;
+
+    // impl<T: AtomValue> Readable<T> for Atom<T> {}
+    impl<T: AtomValue> Readable<T> for &'static Atom<T> {
+        fn static_id(self) -> u32 {
+            self as *const _ as u32
+        }
+
+        fn initialize(self, api: &RecoilRoot) -> T {
+            let mut builder = AtomBuilder {};
+            let p = self(&mut builder);
+            p
+        }
+    }
+
+    impl<T: AtomValue> Writable<T> for &'static Atom<T> {}
+
+    mod compilests {
+        use super::*;
+        use dioxus_core::prelude::Context;
+
+        fn _test(ctx: Context<()>) {
+            const EXAMPLE_ATOM: Atom<i32> = |_| 10;
+
+            // ensure that atoms are both read and write
+            let _ = use_read(&ctx, &EXAMPLE_ATOM);
+            let _ = use_read_write(&ctx, &EXAMPLE_ATOM);
+            let _ = use_write(&ctx, &EXAMPLE_ATOM);
+        }
+    }
+}
+
+mod atomfamily {
+    use super::*;
+    pub trait FamilyCollection<K, V> {}
+    impl<K, V> FamilyCollection<K, V> for HashMap<K, V> {}
+
+    use im_rc::HashMap as ImHashMap;
+
+    /// AtomHashMaps provide an efficient way of maintaing collections of atoms.
+    ///
+    /// Under the hood, AtomHashMaps uses [IM](https://www.rust-lang.org)'s immutable HashMap implementation to lazily
+    /// clone data as it is modified.
+    ///
+    ///
+    ///
+    ///
+    ///
+    ///
+    pub type AtomHashMap<K, V> = fn(&mut ImHashMap<K, V>);
+
+    pub trait AtomFamilySelector<K: MapKey, V: AtomValue + Clone> {
+        fn select(&'static self, k: &K) -> AtomMapSelection<K, V> {
+            todo!()
+        }
+    }
+
+    impl<K: MapKey, V: AtomValue + Clone> AtomFamilySelector<K, V> for AtomHashMap<K, V> {
+        fn select(&'static self, k: &K) -> AtomMapSelection<K, V> {
+            todo!()
+        }
+    }
+
+    pub struct AtomMapSelection<'a, K: MapKey, V: AtomValue> {
+        root: &'static AtomHashMap<K, V>,
+        key: &'a K,
+    }
+
+    impl<'a, K: MapKey, V: AtomValue> Readable<V> for &AtomMapSelection<'a, K, V> {
+        fn static_id(self) -> u32 {
+            todo!()
+        }
+
+        fn initialize(self, api: &RecoilRoot) -> V {
+            todo!()
+            // let mut builder = AtomBuilder {};
+            // let p = self(&mut builder);
+            // p
+        }
+    }
+
+    impl<'a, K: MapKey, T: AtomValue> Writable<T> for &AtomMapSelection<'a, K, T> {}
+
+    mod compiletests {
+        use dioxus_core::prelude::Context;
+
+        use super::*;
+        const Titles: AtomHashMap<u32, &str> = |map| {};
+
+        fn test(ctx: Context<()>) {
+            let title = Titles.select(&10).use_read(ctx);
+            let t2 = use_read(&ctx, &Titles.select(&10));
+        }
+    }
+}
+
+mod selector {
+    use super::*;
+    pub struct SelectorBuilder {}
+    impl SelectorBuilder {
+        pub fn get<T: AtomValue>(&self, t: impl Readable<T>) -> &T {
+            todo!()
+        }
+    }
+    pub type Selector<T> = fn(&mut SelectorBuilder) -> T;
+    impl<T: AtomValue> Readable<T> for &'static Selector<T> {
+        fn static_id(self) -> u32 {
+            todo!()
+        }
+
+        fn initialize(self, api: &RecoilRoot) -> T {
+            todo!()
+        }
+    }
+
+    pub struct SelectorFamilyBuilder {}
+
+    impl SelectorFamilyBuilder {
+        pub fn get<T: AtomValue>(&self, t: impl Readable<T>) -> &T {
+            todo!()
+        }
+    }
+}
+mod selectorfamily {
+    use super::*;
+    // pub trait SelectionSelector<K, V> {
+    //     fn select(&self, k: &K) -> CollectionSelection<K, V> {
+    //         todo!()
+    //     }
+    // }
+    // impl<K, V, F> SelectionSelector<K, V> for AtomFamily<K, V, F> {}
+
+    /// Create a new value as a result of a combination of previous values
+    /// If you need to return borrowed data, check out [`SelectorFamilyBorrowed`]
+    pub type SelectorFamily<Key, Value> = fn(&mut SelectorFamilyBuilder, Key) -> Value;
+
+    impl<K, V: AtomValue> Readable<V> for &'static SelectorFamily<K, V> {
+        fn static_id(self) -> u32 {
+            todo!()
+        }
+
+        fn initialize(self, api: &RecoilRoot) -> V {
+            todo!()
+        }
+    }
+
+    /// Borrowed selector families are – surprisingly - discouraged.
+    /// This is because it's not possible safely memoize these values without keeping old versions around.
+    ///
+    /// However, it does come in handy to borrow the contents of an item without re-rendering child components.
+    pub type SelectorFamilyBorrowed<Key, Value> =
+        for<'a> fn(&'a mut SelectorFamilyBuilder, Key) -> &'a Value;
+
+    // impl<'a, K, V: 'a> SelectionSelector<K, V> for fn(&'a mut SelectorFamilyBuilder, K) -> V {}
+}
+
+mod root {
+    use std::{
+        any::{Any, TypeId},
+        collections::{HashSet, VecDeque},
+        iter::FromIterator,
+        sync::atomic::{AtomicU32, AtomicUsize},
+    };
+
+    use super::*;
+    // use generational_arena::Index as ConsumerId;
+    type AtomId = u32;
+    type ConsumerId = u32;
+
+    pub type RecoilContext = RefCell<RecoilRoot>;
+
+    // Sometimes memoization means we don't need to re-render components that holds "correct values"
+    // IE we consider re-render more expensive than keeping the old value around.
+    // We *could* unsafely overwrite this slot, but that's just **asking** for UB (holding a &mut while & is held in components)
+    //
+    // Instead, we choose to let the hook itself hold onto the Rc<T> by not forcing a render when T is the same.
+    // Whenever the component needs to be re-rendered for other reasons, the "get" method will automatically update the Rc<T> to the most recent one.
+    pub struct RecoilRoot {
+        nodes: RefCell<HashMap<AtomId, Slot>>,
+        consumer_map: HashMap<ConsumerId, AtomId>,
+    }
+
+    struct Slot {
+        type_id: TypeId,
+        source: AtomId,
+        value: Rc<dyn Any>,
+        consumers: HashMap<ConsumerId, Rc<dyn Fn()>>,
+        dependents: HashSet<AtomId>,
+    }
+
+    static NEXT_ID: AtomicU32 = AtomicU32::new(0);
+    fn next_consumer_id() -> u32 {
+        NEXT_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    }
+
+    impl RecoilRoot {
+        pub(crate) fn new() -> Self {
+            Self {
+                nodes: Default::default(),
+                consumer_map: Default::default(),
+            }
+        }
+
+        pub fn subscribe<T: AtomValue>(
+            &mut self,
+            readable: impl Readable<T>,
+            receiver_fn: Rc<dyn Fn()>,
+        ) -> ConsumerId {
+            let consumer_id = next_consumer_id();
+            let atom_id = readable.static_id();
+            log::debug!("Subscribing consumer to atom {} {}", consumer_id, atom_id);
+
+            let mut nodes = self.nodes.borrow_mut();
+            let slot = nodes.get_mut(&atom_id).unwrap();
+            slot.consumers.insert(consumer_id, receiver_fn);
+            self.consumer_map.insert(consumer_id, atom_id);
+            consumer_id
+        }
+
+        pub fn unsubscribe(&mut self, consumer_id: ConsumerId) {
+            let atom_id = self.consumer_map.get(&consumer_id).unwrap();
+            let mut nodes = self.nodes.borrow_mut();
+            let slot = nodes.get_mut(&atom_id).unwrap();
+            slot.consumers.remove(&consumer_id);
+        }
+
+        /// Directly get the *slot*
+        /// All Atoms are held in slots (an Rc)
+        ///
+        ///
+        pub fn try_get_raw<T: AtomValue>(&self, readable: impl Readable<T>) -> Result<Rc<T>> {
+            let atom_id = readable.static_id();
+            let mut nodes = self.nodes.borrow_mut();
+            if !nodes.contains_key(&atom_id) {
+                let value = Slot {
+                    type_id: TypeId::of::<T>(),
+                    source: atom_id,
+                    value: Rc::new(readable.initialize(self)),
+                    consumers: Default::default(),
+                    dependents: Default::default(),
+                };
+                nodes.insert(atom_id, value);
+            }
+            let out = nodes
+                .get(&atom_id)
+                .unwrap()
+                .value
+                .clone()
+                .downcast::<T>()
+                .unwrap();
+
+            Ok(out)
+        }
+
+        pub fn try_set<T: AtomValue>(
+            &mut self,
+            writable: impl Writable<T>,
+            new_val: T,
+        ) -> crate::error::Result<()> {
+            let atom_id = writable.static_id();
+
+            self.set_by_id(atom_id, new_val);
+
+            Ok(())
+        }
+
+        // A slightly dangerous method to manually overwrite any slot given an AtomId
+        pub(crate) fn set_by_id<T: AtomValue>(&mut self, atom_id: AtomId, new_val: T) {
+            let mut nodes = self.nodes.borrow_mut();
+            let consumers = match nodes.get_mut(&atom_id) {
+                Some(slot) => {
+                    slot.value = Rc::new(new_val);
+                    &slot.consumers
+                }
+                None => {
+                    let value = Slot {
+                        type_id: TypeId::of::<T>(),
+                        source: atom_id,
+                        value: Rc::new(new_val),
+                        // value: Rc::new(writable.initialize(self)),
+                        consumers: Default::default(),
+                        dependents: Default::default(),
+                    };
+                    nodes.insert(atom_id, value);
+                    &nodes.get(&atom_id).unwrap().consumers
+                }
+            };
+
+            for (id, consumer_fn) in consumers {
+                log::debug!("triggering selector {}", id);
+                consumer_fn();
+            }
+        }
+    }
+}
+
+mod hooks {
+    use super::*;
+    use dioxus_core::{hooks::use_ref, prelude::Context, virtual_dom::Scoped};
+
+    pub fn use_init_recoil_root<P>(ctx: Context<P>, cfg: impl Fn(())) {
+        ctx.use_create_context(move || RefCell::new(RecoilRoot::new()))
+    }
+
+    /// Gain access to the recoil API directly - set, get, modify, everything
+    /// This is the foundational hook in which read/write/modify are built on
+    ///
+    /// This does not subscribe the component to *any* updates
+    ///
+    /// You can use this method to create controllers that perform much more complex actions than set/get
+    /// However, be aware that "getting" values through this hook will not subscribe the component to any updates.
+    pub fn use_recoil_api<'a>(ctx: &impl Scoped<'a>) -> &'a Rc<RecoilContext> {
+        ctx.use_context::<RecoilContext>()
+    }
+
+    pub fn use_write<'a, T: AtomValue>(
+        ctx: &impl Scoped<'a>,
+        // todo: this shouldn't need to be static
+        writable: impl Writable<T>,
+    ) -> &'a Rc<dyn Fn(T)> {
+        let api = use_recoil_api(ctx);
+        ctx.use_hook(
+            move || {
+                let api = api.clone();
+                let raw_id = writable.static_id();
+                Rc::new(move |new_val| {
+                    //
+                    log::debug!("setting new value ");
+                    let mut api = api.as_ref().borrow_mut();
+
+                    // api.try_set(writable, new_val).expect("failed to set");
+                    api.set_by_id(raw_id, new_val);
+                }) as Rc<dyn Fn(T)>
+            },
+            move |hook| &*hook,
+            |hook| {},
+        )
+    }
+
+    /// Read the atom and get the Rc directly to the Atom's slot
+    /// This is useful if you need the memoized Atom value. However, Rc<T> is not as easy to
+    /// work with as
+    pub fn use_read_raw<'a, T: AtomValue>(
+        ctx: &impl Scoped<'a>,
+        readable: impl Readable<T>,
+    ) -> &'a Rc<T> {
+        struct ReadHook<T> {
+            value: Rc<T>,
+            consumer_id: u32,
+        }
+
+        let api = use_recoil_api(ctx);
+        ctx.use_hook(
+            move || {
+                let mut api = api.as_ref().borrow_mut();
+
+                let update = ctx.schedule_update();
+                let val = api.try_get_raw(readable).unwrap();
+                let id = api.subscribe(readable, update);
+                ReadHook {
+                    value: val,
+                    consumer_id: id,
+                }
+            },
+            move |hook| {
+                let api = api.as_ref().borrow();
+
+                let val = api.try_get_raw(readable).unwrap();
+                hook.value = val;
+                &hook.value
+            },
+            move |hook| {
+                let mut api = api.as_ref().borrow_mut();
+                api.unsubscribe(hook.consumer_id);
+            },
+        )
+    }
+
+    ///
+    pub fn use_read<'a, T: AtomValue>(ctx: &impl Scoped<'a>, readable: impl Readable<T>) -> &'a T {
+        use_read_raw(ctx, readable).as_ref()
+    }
+
+    /// # Use an atom in both read and write
+    ///
+    /// This method is only available for atoms and family selections (not selectors).
+    ///
+    /// This is equivalent to calling both `use_read` and `use_write`, but saves you the hassle and repitition
+    ///
+    /// ## Example
+    ///
+    /// ```
+    /// const Title: Atom<&str> = |_| "hello";
+    /// let (title, set_title) = use_read_write(ctx, &Title);
+    ///
+    /// // equivalent to:
+    /// let (title, set_title) = (use_read(ctx, &Title), use_write(ctx, &Title));
+    /// ```
+    pub fn use_read_write<'a, T: AtomValue + 'static>(
+        ctx: &impl Scoped<'a>,
+        writable: impl Writable<T>,
+    ) -> (&'a T, &'a Rc<dyn Fn(T)>) {
+        (use_read(ctx, writable), use_write(ctx, writable))
+    }
+
+    /// # Modify an atom without using `use_read`.
+    ///
+    /// Occasionally, a component might want to write to an atom without subscribing to its changes. `use_write` does not
+    /// provide this functionality, so `use_modify` exists to gain access to the current atom value while setting it.
+    ///
+    /// ## Notes
+    ///
+    /// Do note that this hook can only be used with Atoms where T: Clone since we actually clone the current atom to make
+    /// it mutable.
+    ///
+    /// Also note that you need to stack-borrow the closure since the modify closure expects an &dyn Fn. If we made it
+    /// a static type, it wouldn't be possible to use the `modify` closure more than once (two closures always are different)
+    ///
+    /// ## Example
+    ///
+    /// ```ignore
+    /// let modify_atom = use_modify(ctx, Atom);
+    ///
+    /// modify_atom(&|a| *a += 1)
+    /// ```
+    pub fn use_modify<'a, T: AtomValue + 'static + Clone, P>(
+        ctx: Context<'a, P>,
+        writable: impl Writable<T>,
+    ) -> impl Fn(&dyn Fn()) {
+        |_| {}
+    }
+
+    /// Use a family collection directly
+    /// !! Any changes to the family will cause this subscriber to update
+    /// Try not to put this at the very top-level of your app.
+    pub fn use_read_family<'a, K, V, P>(
+        ctx: Context<'a, P>,
+        t: &AtomHashMap<K, V>,
+    ) -> &'a im_rc::HashMap<K, V> {
+        todo!()
+    }
+}
+
+mod ecs {
+    use super::*;
+    pub struct Blah<K, V> {
+        _p: PhantomData<(K, V)>,
+    }
+    pub type EcsModel<K, Ty> = fn(Blah<K, Ty>);
+}
+
+mod utils {
+    use super::*;
+    use dioxus_core::prelude::*;
+
+    pub struct RecoilApi {}
+
+    /// This tiny util wraps your main component with the initializer for the recoil root.
+    /// This is useful for small programs and the examples in this crate
+    pub fn RecoilApp<T: 'static>(
+        root: impl for<'a> Fn(Context<'a, T>) -> VNode,
+    ) -> impl for<'a> Fn(Context<'a, T>) -> VNode {
+        move |ctx| {
+            use_init_recoil_root(ctx, |_| {});
+            root(ctx)
+        }
+    }
+}
+
+mod compiletests {}
+
+pub mod error {
+    use thiserror::Error as ThisError;
+    pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+    #[derive(ThisError, Debug)]
+    pub enum Error {
+        #[error("Fatal Internal Error: {0}")]
+        FatalInternal(&'static str),
+        // #[error("Context is missing")]
+        // MissingSharedContext,
+
+        // #[error("No event to progress")]
+        // NoEvent,
+
+        // #[error("Wrong Properties Type")]
+        // WrongProps,
+
+        // #[error("Base scope has not been mounted yet")]
+        // NotMounted,
+        // #[error("I/O Error: {0}")]
+        // BorrowMut(#[from] std::),
+        // #[error("eee Error: {0}")]
+        // IO(#[from] core::result::),
+        #[error("I/O Error: {0}")]
+        IO(#[from] std::io::Error),
+
+        #[error(transparent)]
+        Other(#[from] anyhow::Error), // source and Display delegate to anyhow::Error
+    }
+}

packages/atoms/src/tracingimmap.rs

@@ -0,0 +1,29 @@
+//! Tracing immap
+//! Traces modifications since last generation
+//! To reconstruct the history, you will need *all* the generations between the start and end points
+
+use im_rc::HashMap as ImMap;
+
+pub struct TracedHashMap<K, V> {
+    inner: ImMap<K, V>,
+    generation: u32,
+    mods_since_last_gen: Vec<K>,
+}
+
+impl<K: Clone, V: Clone> TracedHashMap<K, V> {
+    fn next_generation(&self) -> Self {
+        Self {
+            generation: self.generation + 1,
+            inner: self.inner.clone(),
+            mods_since_last_gen: vec![],
+        }
+    }
+}
+
+#[test]
+fn compare_dos() {
+    let map1 = im_rc::hashmap! {3 => 2, 2 => 3};
+    let map2 = im_rc::hashmap! {2 => 3, 3 => 2};
+
+    assert_eq!(map1, map2);
+}