Signal

pub struct Signal<T, S: 'static = UnsyncStorage> {
    pub(crate) inner: CopyValue<SignalData<T>, S>,
}

/// The data stored for tracking in a signal.
pub struct SignalData<T> {
    pub(crate) subscribers: Arc<Mutex<HashSet<ReactiveContext>>>,
    pub(crate) value: T,
}

    fn try_read_unchecked(&self) -> BorrowResult<ReadableRef<'static, Self>>
    where
        T: 'static,
    {
        let inner = self.inner.try_read_unchecked()?;

        if let Some(reactive_context) = ReactiveContext::current() {
            tracing::trace!("Subscribing to the reactive context {}", reactive_context);
            reactive_context.subscribe(inner.subscribers.clone());
        }

        Ok(S::map(inner, |v| &v.value))
    }

    fn try_peek_unchecked(&self) -> BorrowResult<ReadableRef<'static, Self>>
    where
        T: 'static,
    {
        self.inner
            .try_read_unchecked()
            .map(|inner| S::map(inner, |v| &v.value))
    }

pub struct ReactiveContext {
    scope: ScopeId,
    inner: GenerationalBox<Inner, SyncStorage>,
}

fn app() -> Element {
  let count = use_signal(|| 0);
  let flag = use_signal(|| true);
  HANDLES.set(Some((count, flag)));
  let shown = if flag() { count() } else { -1 };
  println!("  [app 运行] flag={} count={} shown={shown}", flag.peek(), count.peek());
  rsx! { "{shown}" }
}

fn subs<T: 'static>(label: &str, s: &Signal<T>) {
  let mut v = vec![];
  s.subscribers().visit(|rc| v.push(rc.to_string()));
  println!("  {label} 的订阅者: {v:?}");
}

  [app 运行] flag=true count=0 shown=0
--- count += 1
  [app 运行] flag=true count=1 shown=1
  count 的订阅者: ["ReactiveContext(for scope: ScopeId(3, \"root\"))"]
  flag 的订阅者: ["ReactiveContext(for scope: ScopeId(3, \"root\"))"]
--- flag = false
  [app 运行] flag=false count=1 shown=-1
  count 的订阅者: []
  flag 的订阅者: ["ReactiveContext(for scope: ScopeId(3, \"root\"))"]
--- count += 1（flag 为 false）
  （没有脏 scope，组件没重跑）
  count 的订阅者: []
  flag 的订阅者: ["ReactiveContext(for scope: ScopeId(3, \"root\"))"]
--- flag = true
  [app 运行] flag=true count=2 shown=2
  count 的订阅者: ["ReactiveContext(for scope: ScopeId(3, \"root\"))"]
  flag 的订阅者: ["ReactiveContext(for scope: ScopeId(3, \"root\"))"]

fn read_while_write() -> Element {
  let mut count = use_signal(|| 0);
  let _w = count.write();
  let _r = count.read();
  rsx! {}
}

fn write_while_read() -> Element {
  let mut count = use_signal(|| 0);
  let _r = count.read();
  let _w = count.write();
  rsx! {}
}

fn read_in_with_mut() -> Element {
  let mut count = use_signal(|| 0);
  count.with_mut(|v| *v = count() + 1);
  rsx! {}
}

error[E0502]: cannot borrow `count` as immutable because it is also borrowed as mutable
  --> src/bin/sig_borrow.rs:9:12
   |
 8 |   let _w = count.write();
   |            ----- mutable borrow occurs here
 9 |   let _r = count.read();
   |            ^^^^^ immutable borrow occurs here
10 |   rsx! {}
11 | }
   | - mutable borrow might be used here, when `_w` is dropped and runs the destructor for type `WriteLock<'_, i32, UnsyncStorage, dioxus::prelude::SignalSubscriberDrop<i32, UnsyncStorage>>`

error[E0502]: cannot borrow `count` as mutable because it is also borrowed as immutable
  --> src/bin/sig_borrow.rs:16:12
   |
15 |   let _r = count.read();
   |            ----- immutable borrow occurs here
16 |   let _w = count.write();
   |            ^^^^^^^^^^^^^ mutable borrow occurs here
17 |   rsx! {}
18 | }
   | - immutable borrow might be used here, when `_r` is dropped and runs the destructor for type `dioxus::dioxus_core::internal::generational_box::GenerationalRef<std::cell::Ref<'_, i32>>`

error[E0502]: cannot borrow `count` as mutable because it is also borrowed as immutable
  --> src/bin/sig_borrow.rs:22:3
   |
22 |   count.with_mut(|v| *v = count() + 1);
   |   ^^^^^^--------^---^^^^^^-----^^^^^^^
   |   |     |        |        |
   |   |     |        |        first borrow occurs due to use of `count` in closure
   |   |     |        immutable borrow occurs here
   |   |     immutable borrow later used by call
   |   mutable borrow occurs here
...

fn read_while_write() -> Element {
  let mut count = use_signal(|| 0);
  let other = count; // Copy 出第二个句柄
  let _w = count.write();
  let _r = other.read();
  rsx! {}
}

fn write_while_read() -> Element {
  let count = use_signal(|| 0);
  let mut other = count;
  let _r = count.read();
  let _w = other.write();
  rsx! {}
}

fn read_in_with_mut() -> Element {
  let mut count = use_signal(|| 0);
  let other = count;
  count.with_mut(|v| *v = other() + 1);
  rsx! {}
}

fn across_await() -> Element {
  let mut count = use_signal(|| 0);
  use_hook(|| {
    spawn(async move {
      let r = count.read();
      println!("task: holding read, value = {}", *r);
      tokio::time::sleep(Duration::from_millis(100)).await;
      println!("task: done, value = {}", *r);
    })
  });
  rsx! { button { onclick: move |_| count += 1, "+" } }
}

=== rw
thread 'main' (1187842) panicked at src/bin/sig_borrow.rs:10:18:
called `Result::unwrap()` on an `Err` value: AlreadyBorrowedMut(AlreadyBorrowedMutError { borrowed_mut_at: Location { file: "src/bin/sig_borrow.rs", line: 9, column: 18 } })
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
rendered: 
=== wr
thread 'main' (1187869) panicked at src/bin/sig_borrow.rs:18:18:
called `Result::unwrap()` on an `Err` value: AlreadyBorrowed(AlreadyBorrowedError { borrowed_at: [Location { file: "src/bin/sig_borrow.rs", line: 17, column: 18 }] })
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
rendered: 
=== with_mut
thread 'main' (1187921) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dioxus-signals-0.7.10/src/read.rs:259:38:
called `Result::unwrap()` on an `Err` value: AlreadyBorrowedMut(AlreadyBorrowedMutError { borrowed_mut_at: Location { file: "src/bin/sig_borrow.rs", line: 25, column: 9 } })
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
rendered: 
=== await
task: holding read, value = 0
click while task holds the read guard

thread 'main' (1188014) panicked at src/bin/sig_borrow.rs:39:37:
called `Result::unwrap()` on an `Err` value: AlreadyBorrowed(AlreadyBorrowedError { borrowed_at: [Location { file: "src/bin/sig_borrow.rs", line: 33, column: 21 }] })
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

=== rw --release
called `Result::unwrap()` on an `Err` value: AlreadyBorrowedMut(AlreadyBorrowedMutError)
=== wr --release
called `Result::unwrap()` on an `Err` value: AlreadyBorrowed(AlreadyBorrowedError)
=== with_mut --release
called `Result::unwrap()` on an `Err` value: AlreadyBorrowedMut(AlreadyBorrowedMutError)
=== await --release
called `Result::unwrap()` on an `Err` value: AlreadyBorrowed(AlreadyBorrowedError)

        // First we create a closure that captures something with the Same in memory layout as Self (MaybeUninit<Self>).
        let uninit_callable = MaybeUninit::<Self>::uninit();
        // Then move that value into the closure. We assume that the closure now has a in memory layout of Self.
        let uninit_closure = move || Self::read(unsafe { &*uninit_callable.as_ptr() }).clone();

        // Check that the size of the closure is the same as the size of Self in case the compiler changed the layout of the closure.
        let size_of_closure = std::mem::size_of_val(&uninit_closure);
        assert_eq!(size_of_closure, std::mem::size_of::<Self>());
        // ...
            unsafe {
                std::mem::transmute(self)
            },

fn read_then_write() -> Element {
  let mut count = use_signal(|| 0);
  let v = count(); // 先读：订阅
  println!("  [read_then_write 运行] count = {v}");
  count += 1; // 再写：通知刚订阅的自己
  rsx! { "{v}" }
}

fn write_then_read() -> Element {
  let mut count = use_signal(|| 0);
  count += 1; // 先写：这一轮还没有订阅者
  let v = count(); // 再读：订阅
  println!("  [write_then_read 运行] count = {v}");
  rsx! { "{v}" }
}

=== read_then_write
  [read_then_write 运行] count = 0
  第 1 轮：wait_for_work 返回（有脏 scope）
  [read_then_write 运行] count = 1
  第 2 轮：wait_for_work 返回（有脏 scope）
  [read_then_write 运行] count = 2
  第 3 轮：wait_for_work 返回（有脏 scope）
  [read_then_write 运行] count = 3
  第 4 轮：wait_for_work 返回（有脏 scope）
  [read_then_write 运行] count = 4

=== write_then_read
  [write_then_read 运行] count = 1
  第 1 轮：50ms 内没返回，停了