add a way to add manual dependency tuple to memos and effects

packages/signals/src/memo.rs

@@ -1,6 +1,6 @@
 use crate::write::Writable;
 use crate::{read::Readable, ReactiveContext, ReadableRef, Signal};
-use crate::{CopyValue, ReadOnlySignal};
+use crate::{CopyValue, Dependency, ReadOnlySignal};
 use std::rc::Rc;
 use std::{
     cell::RefCell,
@@ -153,6 +153,40 @@ impl<T: 'static> Memo<T> {
     pub fn id(&self) -> generational_box::GenerationalBoxId {
         self.inner.id()
     }
+
+    /// Adds an explicit dependency to the memo. If the dependency changes, the memo will rerun.
+    ///
+    /// Signals will automatically be added as dependencies, so you don't need to call this method for them.
+    ///
+    /// NOTE: You must follow the rules of hooks when calling this method.
+    ///
+    /// ```rust
+    /// # use dioxus::prelude::*;
+    /// # async fn sleep(delay: u32) {}
+    ///
+    /// #[component]
+    /// fn Comp(count: u32) -> Element {
+    ///     // Because the resource subscribes to `delay` by adding it as a dependency, the memo will rerun every time `count` changes.
+    ///     let new_count = use_memo(move || async move {
+    ///         count + 1
+    ///     })
+    ///     .use_dependencies((&count,));
+    ///
+    ///     todo!()
+    /// }
+    /// ```
+    pub fn use_dependencies(self, dependency: impl Dependency) -> Self
+    where
+        T: PartialEq,
+    {
+        let mut dependencies_signal = use_hook(|| CopyValue::new(dependency.out()));
+        let changed = { dependency.changed(&*dependencies_signal.read()) };
+        if changed {
+            dependencies_signal.set(dependency.out());
+            self.recompute();
+        }
+        self
+    }
 }
 
 impl<T> Readable for Memo<T>