How would I create a custom reactive collection store type?

[ISibboI]

I would like to create a custom map type that automatically assigns keys to values on insert instead of expecting the user to pass a key. This map should be a reactive store, in the same way as the std HashMap is. The struct would look like this:

use rustc_hash::FxHashMap;

pub struct UidStore<Index, Value> {
    next_id: Index,
    store: FxHashMap<Index, Value>,
}

However, if I would simply derive Store on this struct, this would make next_id and store public, which I don't want. I only want the hash map to me modified through special methods on UidStore, that automatically choose a key based on the next_id field.

Hence, I thought about manually implementing the reactivity for my struct, but I am stuck. This is what I have so far, copied from the hash map implementation in the dioxus repo:

use std::hash::Hash;

use dioxus::{signals::Writable, stores::Store};
use rustc_hash::FxHashMap;

pub struct UidStore<Index, Value> {
    next_id: Index,
    store: FxHashMap<Index, Value>,
}

pub trait UidStoreExt<Index, Value, Lens> {
    fn insert(&mut self, value: Value) -> Index
    where
        Index: Eq + Hash,
        Lens: Writable;
}

impl<Index, Value, Lens> UidStoreExt<Index, Value, Lens> for Store<UidStore<Index, Value>, Lens> {
    fn insert(&mut self, value: Value) -> Index
    where
        Index: Eq + Hash,
        Lens: Writable,
    {
        let key = todo!("how do I access next_id here without making it known to the reactive system?");
        todo!("how do I insert into the hash map here?")
    }
}

I have no idea how I should implement the insert method. I want the insert operation translate into an insert into the hash map. This should of course enable the hash map to be reactive, but avoid making the next_id reactive.

I hope this is kind of clear, feel free to ask clarifying questions.

[ealmloff]

Currently you would need to manually derive store with something like this:

mod uid_store {
    use std::hash::Hash;

    use dioxus::prelude::*;
    use dioxus::stores::Store;
    use dioxus_stores::macro_helpers::dioxus_signals::MappedMutSignal;
    use rustc_hash::FxHashMap;

    pub struct UidStore<Index, Value> {
        next_id: Index,
        store: FxHashMap<Index, Value>,
    }

    impl<Index: Default, Value> UidStore<Index, Value> {
        pub fn new() -> Self {
            Self {
                next_id: Index::default(),
                store: FxHashMap::default(),
            }
        }
    }

    type NextIdLens<Index, Value, Lens> = MappedMutSignal<
        Index,
        Lens,
        fn(&UidStore<Index, Value>) -> &Index,
        fn(&mut UidStore<Index, Value>) -> &mut Index,
    >;

    type StoreLens<Index, Value, Lens> = MappedMutSignal<
        FxHashMap<Index, Value>,
        Lens,
        fn(&UidStore<Index, Value>) -> &FxHashMap<Index, Value>,
        fn(&mut UidStore<Index, Value>) -> &mut FxHashMap<Index, Value>,
    >;

    #[store(name = UidStoreFieldExt)]
    impl<Index, Value, Lens> Store<UidStore<Index, Value>, Lens> {
        fn next_id(self) -> Store<Index, NextIdLens<Index, Value, Lens>> {
            let map: fn(&UidStore<Index, Value>) -> &Index = |v| &v.next_id;
            let map_mut: fn(&mut UidStore<Index, Value>) -> &mut Index = |v| &mut v.next_id;
            self.into_selector().child(0, map, map_mut).into()
        }

        fn store(self) -> Store<FxHashMap<Index, Value>, StoreLens<Index, Value, Lens>> {
            let map: fn(&UidStore<Index, Value>) -> &FxHashMap<Index, Value> = |v| &v.store;
            let map_mut: fn(&mut UidStore<Index, Value>) -> &mut FxHashMap<Index, Value> =
                |v| &mut v.store;
            self.into_selector().child(1, map, map_mut).into()
        }
    }

    #[store(pub)]
    impl<
            Index: Eq + Hash + Copy + std::ops::AddAssign<Index> + From<u8> + 'static,
            Value: 'static,
            Lens,
        > Store<UidStore<Index, Value>, Lens>
    {
        fn insert(&mut self, value: Value) -> Index {
            // Use peek() to read next_id without subscribing to the reactive system
            let key = *self.next_id().peek();
            // Increment next_id
            *self.next_id.write() += Index::from(1u8);
            // Insert into the hash map through the store lens
            self.store().write().insert(key, value);
            key
        }
    }
}

We should probably change the derive store macro to only expose private fields with a private trait instead of the current public one

[ISibboI]

Thanks for the quick reply, your example is perfect for me.

I agree that keeping private fields private would be a big improvement to the store macro from the perspective of software architecture.

I have one more question: is it possible to make next_id completely non-reactive in this example? Like make it accessible via a private method that returns &mut, but without creating a child selector for it? The performance overhead of having next_id known to the reactive system is probably negligible, but I'm wondering anyways.

[ealmloff]

Since you never subscribe to it and instead read it non-reactively with peek, the subscriber tree for next_id should never get created. You can't directly return &mut T from stores since they are behind a refcell/rwlock. You could return Ref<'_, T> by mapping the read from the store which is effectively what the selectors + peek does (or write with the mutable version)