异步：resource、future 与 spawn

fn app() -> Element {
  let x = use_signal(|| 0);
  let y = use_signal(|| 0);
  let z = use_signal(|| 0);
  // ...
  log("App runs");
  use_future(move || {
    let x_now = x(); // sync part of the closure
    log(format!("  use_future closure called, x={x_now}"));
    async move {
      let y_now = y(); // inside the async block, before any .await
      log(format!("  use_future body polled, y={y_now}"));
      tokio::time::sleep(Duration::from_millis(5)).await;
      log(format!("  use_future after .await, z={}", z()));
    }
  });
  use_hook(|| {
    spawn(async move {
      log(format!("  spawn body polled, y={}", y()));
      tokio::time::sleep(Duration::from_millis(5)).await;
      log(format!("  spawn after .await, z={}", z()));
    })
  });
  rsx! { "hi" }
}

App runs
  use_future closure called, x=0
  use_future body polled, y=0
  spawn body polled, y=0
  use_future after .await, z=0
  spawn after .await, z=0
-- x = 1
App runs
-- y = 1
-- z = 1
-- end

fn app() -> Element {
  let a = use_signal(|| 1);
  let b = use_signal(|| 10);
  // ...
  let res = use_resource(move || {
    let a_now = a(); // read before the async block
    async move {
      let _g = Guard(a_now); // logs "future(a=..) dropped" in Drop
      log(format!("  future(a={a_now}) starts"));
      tokio::time::sleep(Duration::from_millis(20)).await;
      let b_now = b(); // read after an .await
      log(format!("  future(a={a_now}) ends, b={b_now}"));
      a_now + b_now
    }
  });
  log(format!("App runs: state={:?} value={:?}", res.state().cloned(), res.read().clone()));
  rsx! { "{res.read().clone():?}" }
}

App runs: state=Pending value=None
-- settle
  future(a=1) starts
  future(a=1) ends, b=10
  future(a=1) dropped
App runs: state=Ready value=Some(11)
  edit: SetText { value: "Some(11)", id: ElementId(1) }
-- b = 20 (read only after .await)
  future(a=1) starts
App runs: state=Pending value=Some(11)
  future(a=1) ends, b=20
  future(a=1) dropped
App runs: state=Ready value=Some(21)
  edit: SetText { value: "Some(21)", id: ElementId(1) }
-- a = 2, 5ms later a = 3
  future(a=2) starts
App runs: state=Pending value=Some(21)
  future(a=2) dropped
  future(a=3) starts
App runs: state=Pending value=Some(21)
  future(a=3) ends, b=20
  future(a=3) dropped
App runs: state=Ready value=Some(23)
  edit: SetText { value: "Some(23)", id: ElementId(1) }
-- end

    let mut value = use_signal(|| None);
    let mut state = use_signal(|| UseResourceState::Pending);
    let (rc, changed) = use_hook(|| {
        let (rc, changed) = ReactiveContext::new_with_origin(location);
        (rc, Rc::new(Cell::new(Some(changed))))
    });

    let mut waker = use_waker::<()>();

    let cb = use_callback(move |_| {
        // Set the state to Pending when the task is restarted
        state.set(UseResourceState::Pending);

        // Create the user's task
        let fut = rc.reset_and_run_in(&mut future);

        // Spawn a wrapper task that polls the inner future and watches its dependencies
        spawn(async move {
            // Move the future here and pin it so we can poll it
            let fut = fut;
            pin_mut!(fut);

            // Run each poll in the context of the reactive scope
            // This ensures the scope is properly subscribed to the future's dependencies
            let res = future::poll_fn(|cx| {
                rc.run_in(|| {
                    tracing::trace_span!("polling resource", location = %location)
                        .in_scope(|| fut.poll_unpin(cx))
                })
            })
            .await;

            // Set the value and state
            state.set(UseResourceState::Ready);
            value.set(Some(res));

            // Notify that the value has changed
            waker.wake(());
        })
    });

    let mut task = use_hook(|| Signal::new(cb(())));

    use_hook(|| {
        let mut changed = changed.take().unwrap();
        spawn(async move {
            loop {
                // Wait for the dependencies to change
                let _ = changed.next().await;

                // Stop the old task
                task.write().cancel();

                // Start a new task
                task.set(cb(()));
            }
        })
    });

fn app() -> Element {
  let res = use_resource(|| async {
    RUNS.set(RUNS.get() + 1);
    let run = RUNS.get();
    log(format!("  future #{run} starts"));
    tokio::time::sleep(Duration::from_millis(10)).await;
    run
  });
  RES.set(Some(res));
  let s = match res.suspend() {
    Ok(v) => format!("Ok({})", v()),
    Err(e) => format!("Err({e:?})"),
  };
  log(format!("App runs: state={:?} value={:?} suspend()={s}", res.state().cloned(), res.peek().clone()));
  rsx! { "x" }
}

App runs: state=Pending value=None suspend()=Err(Suspended(SuspendedFuture { origin: ScopeId(3, "root"), task: DefaultKey(1v1) }))
  future #1 starts
App runs: state=Ready value=Some(1) suspend()=Ok(1)
-- restart()
  future #2 starts
App runs: state=Pending value=Some(1) suspend()=Err(Suspended(SuspendedFuture { origin: ScopeId(3, "root"), task: DefaultKey(1v3) }))
App runs: state=Ready value=Some(2) suspend()=Ok(2)
-- restart(); pause()
App runs: state=Paused value=Some(2) suspend()=Ok(2)
-- resume()
  future #3 starts
App runs: state=Pending value=Some(2) suspend()=Err(Suspended(SuspendedFuture { origin: ScopeId(3, "root"), task: DefaultKey(1v5) }))
App runs: state=Ready value=Some(3) suspend()=Ok(3)
-- restart(); cancel()
App runs: state=Stopped value=Some(3) suspend()=Err(Suspended(SuspendedFuture { origin: ScopeId(3, "root"), task: DefaultKey(1v7) }))
-- end

fn app() -> Element {
  let res = use_resource(|| async {
    tokio::time::sleep(Duration::from_millis(10)).await;
    7
  });
  RES.set(Some(res));
  let v = res.suspend()?;
  log(format!("App runs: v={}", v()));
  rsx! { "v={v}" }
}

App runs: v=7
html: v=7
-- cancel() after Ready

thread 'main' (1785960) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dioxus-core-0.7.10/src/scope_arena.rs:123:22:
Suspended on a task that no longer exists
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

fn app() -> Element {
  let mut other = use_signal(|| 0);
  let mut n = use_signal(|| 0);
  let res = use_resource(move || async move {
    POLLS.set(POLLS.get() + 1);
    let p = POLLS.get();
    if p <= 3 || p % 1000 == 0 { log(format!("  resource future starts (#{p})")); }
    match CASE.get() {
      0 => other += 1,  // write a signal the resource never reads
      1 => n += 1,      // AddAssign on the resource's own signal, no read
      _ => {
        let v = n();    // read ...
        n.set(v + 1);   // ... then write the same signal
      }
    }
    tokio::time::sleep(Duration::from_millis(1)).await;
  });
  let _ = res.state().cloned();
  log(format!("App runs other={} n={}", other.peek(), n.peek()));
  rsx! { "x" }
}

== case 0
App runs other=0 n=0
  resource future starts (#1)
App runs other=1 n=0
resource future started 1 times
== case 1
App runs other=0 n=0
  resource future starts (#1)
App runs other=0 n=1
resource future started 1 times

    let mut state = use_signal(|| UseFutureState::Pending);

    let callback = use_callback(move |_| {
        let fut = future();
        dioxus_core::spawn(async move {
            state.set(UseFutureState::Pending);
            fut.await;
            state.set(UseFutureState::Ready);
        })
    });

    // Create the task inside a CopyValue so we can reset it in-place later
    let task = use_hook(|| CopyValue::new(callback(())));

    use_hook_did_run(move |did_run| match did_run {
        true => task.peek().resume(),
        false => task.peek().pause(),
    });

    let mut tx_copy_value = use_hook(|| CopyValue::new(None));

    let future = use_future(move || {
        let (tx, rx) = futures_channel::mpsc::unbounded();
        tx_copy_value.set(Some(tx));
        init(rx)
    });

    use_context_provider(|| Coroutine {
        tx: tx_copy_value,
        future,
    })

fn app() -> Element {
  let mut total = use_signal(|| 0usize);
  let co = use_coroutine(move |mut rx: UnboundedReceiver<String>| async move {
    log("  coroutine starts");
    while let Some(msg) = rx.next().await {
      log(format!("  coroutine got {msg:?}"));
      total += msg.len();
    }
  });
  log(format!("App runs: total={total} task={:?}", co.task()));
  rsx! { Child {} }
}

#[component]
fn Child() -> Element {
  let co = use_coroutine_handle::<String>();
  CHILD_TX.set(Some(co));
  log("Child runs");
  rsx! { "child" }
}

App runs: total=0 task=Task { id: DefaultKey(1v1), unsend: PhantomData<*const ()> }
Child runs
-- send two messages before the first poll
  coroutine starts
  coroutine got "hello"
  coroutine got "dioxus"
App runs: total=11 task=Task { id: DefaultKey(1v1), unsend: PhantomData<*const ()> }
-- restart()
  coroutine starts
-- send after restart
  coroutine got "again"
App runs: total=16 task=Task { id: DefaultKey(1v3), unsend: PhantomData<*const ()> }

== case 2
App runs other=0 n=0
  resource future starts (#1)
  resource future starts (#2)
  resource future starts (#3)
...
  resource future starts (#305000)
  resource future starts (#306000)