Memo 与 effect

struct UpdateInformation<T> {
    dirty: Arc<AtomicBool>,
    callback: RefCell<Box<dyn FnMut() -> T>>,
}

pub struct Memo<T> {
    inner: Signal<T>,
    update: CopyValue<UpdateInformation<T>>,
}

        let dirty = Arc::new(AtomicBool::new(false));
        let (tx, mut rx) = futures_channel::mpsc::unbounded();

        let callback = {
            let dirty = dirty.clone();
            move || {
                dirty.store(true, std::sync::atomic::Ordering::Relaxed);
                let _ = tx.unbounded_send(());
            }
        };
        let rc = ReactiveContext::new_with_callback(callback, current_scope_id(), location);

        // Create a new signal in that context, wiring up its dependencies and subscribers
        let mut recompute = move || rc.reset_and_run_in(&mut f);
        let value = recompute();
        // ...
        let state: Signal<T> = Signal::new_with_caller(value, location);
        // ...
        spawn_isomorphic(async move {
            while rx.next().await.is_some() {
                // Remove any pending updates
                while rx.try_recv().is_ok() {}
                memo.recompute();
            }
        });

    fn recompute(&self)
    where
        T: PartialEq + 'static,
    {
        let mut update_copy = self.update;
        let update_write = update_copy.write();
        let peak = self.inner.peek();
        let new_value = (update_write.callback.borrow_mut())();
        if new_value != *peak {
            drop(peak);
            let mut copy = self.inner;
            copy.set(new_value);
        }
        // Always mark the memo as no longer dirty even if the value didn't change
        update_write
            .dirty
            .store(false, std::sync::atomic::Ordering::Relaxed);
    }

        // Read the inner generational box instead of the signal so we have more fine grained control over exactly when the subscription happens
        let read = self.inner.inner.try_read_unchecked()?;

        let needs_update = self
            .update
            .read()
            .dirty
            .swap(false, std::sync::atomic::Ordering::Relaxed);
        let result = if needs_update {
            drop(read);
            // We shouldn't be subscribed to the value here so we don't trigger the scope we are currently in to rerun even though that scope got the latest value because we synchronously update the value: https://github.com/DioxusLabs/dioxus/issues/2416
            self.recompute();
            self.inner.inner.try_read_unchecked()
        } else {
            Ok(read)
        };
        // Subscribe to the current scope before returning the value
        if let Ok(read) = &result {
            if let Some(reactive_context) = ReactiveContext::current() {
                tracing::trace!("Subscribing to the reactive context {}", reactive_context);
                reactive_context.subscribe(read.subscribers.clone());
            }
        }

fn app() -> Element {
  let count = use_signal(|| 0);
  let half = use_memo(move || {
    let h = count() / 2;
    println!("    [memo 闭包] count={} -> {h}", count.peek());
    h
  });
  HANDLES.set(Some((count, half)));
  println!("    [app 运行] half={half}");
  rsx! { "{half}" }
}

--- rebuild
    [memo 闭包] count=0 -> 0
    [app 运行] half=0
  （没有脏 scope 了）
--- count = 1
    [memo 闭包] count=1 -> 0
  （没有脏 scope 了）
--- count = 2
    [memo 闭包] count=2 -> 1
  wait_for_work 返回，render_immediate
    [app 运行] half=1
  （没有脏 scope 了）
--- count = 3，紧接着同步读 half
    [memo 闭包] count=3 -> 1
  同步读到 half = 1
    [memo 闭包] count=3 -> 1
  （没有脏 scope 了）
--- count = 4，紧接着同步读 half
    [memo 闭包] count=4 -> 2
  同步读到 half = 2
  wait_for_work 返回，render_immediate
    [memo 闭包] count=4 -> 2
    [app 运行] half=2
  （没有脏 scope 了）

pub fn use_memo<R: PartialEq + 'static>(mut f: impl FnMut() -> R + 'static) -> Memo<R> {
    let callback = use_callback(move |_| f());
    let caller = std::panic::Location::caller();
    #[allow(clippy::redundant_closure)]
    use_hook(|| Memo::new_with_location(move || callback(()), caller))
}

pub fn use_effect(mut callback: impl FnMut() + 'static) -> Effect {
    let callback = use_callback(move |_| callback());

    let location = std::panic::Location::caller();

    use_hook(|| {
        // Inside the effect, we track any reads so that we can rerun the effect if a value the effect reads changes
        let (rc, mut changed) = ReactiveContext::new_with_origin(location);

        // Deduplicate queued effects
        let effect_queued = Rc::new(Cell::new(false));

        // ...
        let queue_effect_for_next_render = move || {
            if effect_queued.get() {
                return;
            }
            effect_queued.set(true);
            let effect_queued = effect_queued.clone();
            queue_effect(move || {
                rc.reset_and_run_in(|| callback(()));
                effect_queued.set(false);
            });
        };

        queue_effect_for_next_render();
        spawn(async move {
            loop {
                // Wait for context to change
                let _ = changed.next().await;

                // Run the effect
                queue_effect_for_next_render();
            }
        });
        Effect { rc }
    })
}

pub(crate) struct Effect {
    // The scope that the effect is attached to
    pub(crate) order: ScopeOrder,
    // The callbacks that will be run when effects are rerun
    effect: RefCell<VecDeque<Box<dyn FnOnce() + 'static>>>,
}

pub fn use_reactive<O, D: Dependency>(
    non_reactive_data: D,
    mut closure: impl FnMut(D::Out) -> O + 'static,
) -> impl FnMut() -> O + 'static {
    let mut first_run = false;
    let mut last_state = use_signal(|| {
        first_run = true;
        non_reactive_data.out()
    });
    if !first_run && non_reactive_data.changed(&*last_state.peek()) {
        last_state.set(non_reactive_data.out())
    }
    move || closure(last_state())
}

#[component]
fn Child(x: i32) -> Element {
  let plain = use_memo(move || x * 10);
  let reactive = use_memo(use_reactive!(|x| x * 10));
  use_effect(move || println!("  [plain effect] x = {x}"));
  use_effect(use_reactive!(|x| println!("  [reactive effect] x = {x}")));
  println!("  [Child 运行] x = {x}, plain = {plain}, reactive = {reactive}");
  rsx! { "{plain} {reactive}" }
}

fn app() -> Element {
  let x = use_signal(|| 1);
  X.set(Some(x));
  rsx! { Child { x: x() } }
}

--- rebuild
  [Child 运行] x = 1, plain = 10, reactive = 10
  [plain effect] x = 1
  [reactive effect] x = 1
--- x = 2
  [Child 运行] x = 2, plain = 10, reactive = 20
  [reactive effect] x = 2
--- x = 3
  [Child 运行] x = 3, plain = 10, reactive = 30
  [reactive effect] x = 3

--- rebuild
  [App 运行]
  [Child 运行]
--- rebuild 返回
  [App effect] n = 0
  [Child effect] n = 0
--- n = 1
  [App effect] n = 1
  [Child effect] n = 1