Can we add labelled hooks to dioxus

[NikhilNathanael]

To preface, I'm not an expert in either React or Dioxus so please correct me if i get something.

Dioxus seems to have lifted the rules of hooks directly from React.

Rules of Hooks from React

Don’t call Hooks inside loops, conditions, nested functions, or try/catch/finally blocks. Instead, always use Hooks at the top level of your React function, before any early returns. You can only call Hooks while React is rendering a function component:

Rules of Hooks from dioxus docs

Hooks should only be called from the root of a component or another hook

The reason we can't simply allow users to provide a label along with the initializer closure is because such a label would have to be type-erased and Hash, Ord, and Eq (for HashMap or BTreeMap) are not dyn compatible.

Making a dyn-compatible version of Eq is not too hard. This is all the code you need.

pub trait DynEq: Any {
	fn dyn_eq(&self, other: &dyn DynEq) -> bool;
}
impl<T: Any + Eq + 'static> DynEq for T {
	fn dyn_eq(&self, other: &dyn DynEq) -> bool {
		(other as &dyn Any).downcast_ref::<T>().filter(|other| PartialEq::eq(self, other)).is_some()
	}
}

Implementing a dyn compatible version of Hash is not so trivial but the crate dyn_hash already does this.

You can have type erased labels with the above two traits, and a common subtrait to specifically denote labels for hooks (as opposed to other kinds of labels). This allows a dyn HookLabel to be the key of a HashMap. (i.e. HashMap<dyn HookLabel, dyn Any>)

pub trait HookLabel: DynEq + DynHash + Send + Sync{}
impl<T: DynEq + DynHash + Send + Sync> HookLabel for T {}

// Equivalent to 
// impl Hash for dyn HookLabel {...}
dyn_hash::hash_trait_object!(HookLabel);

impl PartialEq for dyn HookLabel {
	fn eq(&self, other: &dyn HookLabel) -> bool {
		(self as &dyn DynEq).dyn_eq(other as &dyn DynEq)
	}
}
impl Eq for dyn HookLabel {}

This implementation of labels seems alright to me, but i was wondering if there were any obvious issues with this that i might have missed.

Note: This idea was inspired by bevy's use of type erased labels (see ScheduleLabel, AppLabel, RenderLabel, etc). My suggestion differs in that it uses trait-upcasting to make the label trait simply a marker trait, but this has an MSRV of 1.86, which may not be desirable.

[ealmloff]

You can implement a dyn compatible version of almost any trait. You could implement labeled hooks in user land by lazily injecting a hashmap into each scope with the hash and value of each hook.

This isn't the default strategy dioxus uses to keep track of hooks because labels add a lot of boilerplate to each hook call. If you want to experiment with the approach, you could try creating a library for labeled hooks in dioxus

[NikhilNathanael]

I'm not sure why there'd be any boilerplate to hooks. You can just use any value as a label.
The main reason i was asking was to allow hooks in conditionals and loops. You can't do that with a userspace library if dioxus doesn't support it.

[NikhilNathanael]

I've made an MVP PR about this, and it didn't seem to difficult. But i wanted to see if there'd be any unforeseen issues with it first

[ealmloff]

Here is what this could look like in userland:

use std::{any::Any, cell::RefCell, collections::HashMap, hash::{Hash, Hasher}, rc::Rc};

use dioxus::{logger::tracing, prelude::*};

fn main() {
    launch(App);
}

fn App() -> Element {
    let mut len = use_signal(|| 0_usize);
    (0..len()).for_each(|i| {
        labeled_hook(i, || tracing::info!(i));
    });
    rsx! {
        button {
            onclick: move |_| {
                *len.write() += 1;
            },
            "+"
        }
        button {
            onclick: move |_| {
                *len.write() -= 1;
            },
            "-"
        }
    }  
}

#[derive(Clone)]
struct LabeledHooks {
    hooks: Rc<RefCell<HashMap<u64, Box<dyn Any>>>>,
}

fn labeled_hooks() -> LabeledHooks {
    has_context().unwrap_or_else(|| {
        provide_context(LabeledHooks {
            hooks: Rc::new(RefCell::new(HashMap::new())),
        })
    })
}

fn labeled_hook<T: Clone + 'static>(label: impl Hash, value: impl FnOnce() -> T) -> T {
    let mut hasher = std::collections::hash_map::DefaultHasher::new();
    label.hash(&mut hasher);
    let hash = hasher.finish();
    labeled_hooks().hooks.borrow_mut().entry(hash).or_insert_with(|| {
        let value = value();
        Box::new(value)
    }).downcast_ref::<T>().unwrap().clone()
}

[NikhilNathanael]

huh... and i guess you could make this more usable by making LabelledHooks generic over the label type and just inserting a new one for each type.

i understand why its not the default, but why doesn't dioxus provide this capability as an option, though? Like... Not having to worry about one of Rules of Hooks™ seems quite useful?