use std::cell::{Cell, RefCell};
use std::rc::{Rc, Weak};
use std::sync::atomic::{AtomicU64, Ordering};
thread_local! {
static CURRENT_SUBSCRIBER: RefCell<Option<Subscriber>> = const { RefCell::new(None) };
static ROOT_EFFECTS: RefCell<Vec<Rc<EffectState>>> = const { RefCell::new(Vec::new()) };
static BATCH_DEPTH: Cell<u32> = const { Cell::new(0) };
static BATCHED_EFFECTS: RefCell<Vec<Rc<EffectState>>> = const { RefCell::new(Vec::new()) };
#[cfg(feature = "web")]
static PENDING_EFFECTS: RefCell<Vec<Rc<EffectState>>> = const { RefCell::new(Vec::new()) };
#[cfg(feature = "web")]
static MICROTASK_QUEUED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
#[derive(Clone)]
enum Subscriber {
Effect(Weak<EffectState>),
Memo(Weak<MemoState>),
}
impl Subscriber {
fn same_node(&self, other: &Subscriber) -> bool {
match (self, other) {
(Self::Effect(a), Self::Effect(b)) => Weak::ptr_eq(a, b),
(Self::Memo(a), Self::Memo(b)) => Weak::ptr_eq(a, b),
_ => false,
}
}
}
fn push_subscriber(list: &mut Vec<Subscriber>, subscriber: &Subscriber) {
if let Some(last) = list.last() {
if last.same_node(subscriber) {
return;
}
}
list.push(subscriber.clone());
}
struct SubscriberGuard {
previous: Option<Subscriber>,
}
impl SubscriberGuard {
fn swap_in(next: Option<Subscriber>) -> Self {
Self {
previous: CURRENT_SUBSCRIBER.with(|current| current.replace(next)),
}
}
}
impl Drop for SubscriberGuard {
fn drop(&mut self) {
CURRENT_SUBSCRIBER.with(|current| {
current.replace(self.previous.take());
});
}
}
struct MemoState {
dirty: Cell<bool>,
recompute: RefCell<Option<Box<dyn Fn()>>>,
subscribers: RefCell<Vec<Subscriber>>,
disposed: Cell<bool>,
}
impl MemoState {
fn recompute_now(self: &Rc<Self>) {
self.dirty.set(false);
let _subscriber = SubscriberGuard::swap_in(Some(Subscriber::Memo(Rc::downgrade(self))));
struct RecomputeGuard<'a> {
state: &'a MemoState,
compute: Option<Box<dyn Fn()>>,
completed: bool,
}
impl Drop for RecomputeGuard<'_> {
fn drop(&mut self) {
*self.state.recompute.borrow_mut() = self.compute.take();
if !self.completed {
self.state.dirty.set(true);
}
}
}
let mut guard = RecomputeGuard {
state: self,
compute: self.recompute.borrow_mut().take(),
completed: false,
};
if let Some(compute) = guard.compute.as_ref() {
compute();
}
guard.completed = true;
}
}
struct EffectState {
execute: Box<dyn Fn()>,
disposed: Cell<bool>,
children: RefCell<Vec<Rc<EffectState>>>,
owned_memos: RefCell<Vec<Rc<MemoState>>>,
cleanups: RefCell<Vec<Box<dyn FnOnce()>>>,
}
impl EffectState {
fn run(&self) {
(self.execute)();
}
fn dispose_children(&self) {
let cleanups = std::mem::take(&mut *self.cleanups.borrow_mut());
for cleanup in cleanups {
cleanup();
}
let memos = std::mem::take(&mut *self.owned_memos.borrow_mut());
for memo in memos {
memo.disposed.set(true);
}
let children = std::mem::take(&mut *self.children.borrow_mut());
for child in children {
child.dispose();
}
}
fn dispose(&self) {
self.disposed.set(true);
self.dispose_children();
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
struct SignalId(u64);
impl SignalId {
fn new() -> Self {
static NEXT_ID: AtomicU64 = AtomicU64::new(0);
SignalId(NEXT_ID.fetch_add(1, Ordering::Relaxed))
}
}
struct SignalState<T> {
value: T,
subscribers: Vec<Subscriber>,
}
struct SignalInner<T> {
id: SignalId,
state: Rc<RefCell<SignalState<T>>>,
}
impl<T> Clone for SignalInner<T> {
fn clone(&self) -> Self {
Self {
id: self.id,
state: self.state.clone(),
}
}
}
pub fn create_signal<T>(value: T) -> (ReadSignal<T>, WriteSignal<T>) {
let inner = SignalInner {
id: SignalId::new(),
state: Rc::new(RefCell::new(SignalState {
value,
subscribers: Vec::new(),
})),
};
(
ReadSignal {
inner: inner.clone(),
},
WriteSignal { inner },
)
}
pub struct ReadSignal<T> {
inner: SignalInner<T>,
}
impl<T> Clone for ReadSignal<T> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
}
impl<T: Clone> ReadSignal<T> {
pub fn get(&self) -> T {
CURRENT_SUBSCRIBER.with(|current| {
if let Some(subscriber) = current.borrow().as_ref() {
let mut state = self.inner.state.borrow_mut();
push_subscriber(&mut state.subscribers, subscriber);
}
});
self.inner.state.borrow().value.clone()
}
}
impl<T> ReadSignal<T> {
pub fn with<U, F>(&self, f: F) -> U
where
F: FnOnce(&T) -> U,
{
CURRENT_SUBSCRIBER.with(|current| {
if let Some(subscriber) = current.borrow().as_ref() {
let mut state = self.inner.state.borrow_mut();
push_subscriber(&mut state.subscribers, subscriber);
}
});
let state = self.inner.state.borrow();
f(&state.value)
}
}
pub struct WriteSignal<T> {
inner: SignalInner<T>,
}
impl<T> Clone for WriteSignal<T> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
}
impl<T> WriteSignal<T> {
pub fn set(&self, new_value: T) {
{
let mut state = self.inner.state.borrow_mut();
state.value = new_value;
}
self.notify();
}
pub fn update<F>(&self, f: F)
where
F: FnOnce(&mut T),
{
{
let mut state = self.inner.state.borrow_mut();
f(&mut state.value);
}
self.notify();
}
fn notify(&self) {
let subscribers: Vec<Subscriber> = {
let mut state = self.inner.state.borrow_mut();
state.subscribers.drain(..).collect()
};
let mut to_run: Vec<Rc<EffectState>> = Vec::new();
for subscriber in subscribers {
collect_dependents(&subscriber, &mut to_run);
}
schedule_effects(to_run);
}
}
fn push_unique(queue: &mut Vec<Rc<EffectState>>, effect: Rc<EffectState>) {
if !queue.iter().any(|seen| Rc::ptr_eq(seen, &effect)) {
queue.push(effect);
}
}
fn unschedule_pending(#[allow(unused_variables)] effects: &[Rc<EffectState>]) {
#[cfg(all(feature = "web", target_arch = "wasm32"))]
PENDING_EFFECTS.with(|pending| {
pending
.borrow_mut()
.retain(|queued| !effects.iter().any(|e| Rc::ptr_eq(e, queued)));
});
}
fn schedule_effects(effects: Vec<Rc<EffectState>>) {
if BATCH_DEPTH.with(|depth| depth.get()) > 0 {
queue_batched(effects);
return;
}
let mut pending = take_batched();
for effect in effects {
push_unique(&mut pending, effect);
}
if pending.is_empty() {
return;
}
schedule_async(pending);
}
fn queue_batched(effects: Vec<Rc<EffectState>>) {
BATCHED_EFFECTS.with(|batched| {
let mut batched = batched.borrow_mut();
for effect in effects {
push_unique(&mut batched, effect);
}
});
}
fn take_batched() -> Vec<Rc<EffectState>> {
BATCHED_EFFECTS.with(|batched| std::mem::take(&mut *batched.borrow_mut()))
}
fn run_now(effects: Vec<Rc<EffectState>>) {
for effect in effects {
run_effect(effect);
}
}
struct BatchGuard;
impl BatchGuard {
fn enter() -> Self {
BATCH_DEPTH.with(|depth| depth.set(depth.get() + 1));
Self
}
}
impl Drop for BatchGuard {
fn drop(&mut self) {
BATCH_DEPTH.with(|depth| depth.set(depth.get().saturating_sub(1)));
}
}
fn schedule_async(#[allow(unused_variables)] effects: Vec<Rc<EffectState>>) {
#[cfg(all(feature = "web", target_arch = "wasm32"))]
{
PENDING_EFFECTS.with(|pending| {
let mut p = pending.borrow_mut();
for effect in effects {
push_unique(&mut p, effect);
}
});
if !MICROTASK_QUEUED.with(|q| q.get()) {
MICROTASK_QUEUED.with(|q| q.set(true));
let closure = wasm_bindgen::closure::Closure::once(|_val: wasm_bindgen::JsValue| {
MICROTASK_QUEUED.with(|q| q.set(false));
let effects = PENDING_EFFECTS.with(|pending| {
let mut p = pending.borrow_mut();
std::mem::take(&mut *p)
});
for effect in effects {
run_effect(effect);
}
});
let promise = js_sys::Promise::resolve(&wasm_bindgen::JsValue::UNDEFINED);
let _ = promise.then(&closure);
closure.forget();
}
}
#[cfg(any(not(feature = "web"), not(target_arch = "wasm32")))]
{
for effect in effects {
run_effect(effect);
}
}
}
pub fn batch<T, F>(f: F) -> T
where
F: FnOnce() -> T,
{
let result = {
let _guard = BatchGuard::enter();
f()
};
if BATCH_DEPTH.with(|depth| depth.get()) == 0 {
let effects = take_batched();
unschedule_pending(&effects);
run_now(effects);
}
result
}
fn collect_dependents(subscriber: &Subscriber, effects: &mut Vec<Rc<EffectState>>) {
match subscriber {
Subscriber::Effect(weak) => {
let Some(effect) = weak.upgrade() else {
return;
};
if effect.disposed.get() {
return;
}
push_unique(effects, effect);
}
Subscriber::Memo(weak) => {
let Some(memo) = weak.upgrade() else {
return;
};
if memo.disposed.get() {
return;
}
memo.dirty.set(true);
let downstream: Vec<Subscriber> = memo.subscribers.borrow_mut().drain(..).collect();
for next in &downstream {
collect_dependents(next, effects);
}
}
}
}
pub fn untrack<T, F>(f: F) -> T
where
F: FnOnce() -> T,
{
let _guard = SubscriberGuard::swap_in(None);
f()
}
pub struct Memo<T> {
state: Rc<MemoState>,
value: Rc<RefCell<Option<T>>>,
}
impl<T> Clone for Memo<T> {
fn clone(&self) -> Self {
Self {
state: self.state.clone(),
value: self.value.clone(),
}
}
}
impl<T> Memo<T> {
fn track_and_refresh(&self) {
CURRENT_SUBSCRIBER.with(|current| {
if let Some(subscriber) = current.borrow().as_ref() {
push_subscriber(&mut self.state.subscribers.borrow_mut(), subscriber);
}
});
if self.state.dirty.get() && !self.state.disposed.get() {
self.state.recompute_now();
}
}
pub fn with<U, F>(&self, f: F) -> U
where
F: FnOnce(&T) -> U,
{
self.track_and_refresh();
let value = self.value.borrow();
let value = value
.as_ref()
.expect("memo value is absent after computation");
f(value)
}
}
impl<T: Clone> Memo<T> {
pub fn get(&self) -> T {
self.with(|value| value.clone())
}
}
pub fn create_memo<T, F>(f: F) -> Memo<T>
where
T: 'static,
F: Fn() -> T + 'static,
{
let value: Rc<RefCell<Option<T>>> = Rc::new(RefCell::new(None));
let state = Rc::new(MemoState {
dirty: Cell::new(true),
recompute: RefCell::new(None),
subscribers: RefCell::new(Vec::new()),
disposed: Cell::new(false),
});
{
let value_slot = value.clone();
*state.recompute.borrow_mut() = Some(Box::new(move || {
let next = f();
*value_slot.borrow_mut() = Some(next);
}));
}
CURRENT_SUBSCRIBER.with(|current| {
if let Some(Subscriber::Effect(owner)) = current.borrow().as_ref() {
if let Some(owner) = owner.upgrade() {
owner.owned_memos.borrow_mut().push(state.clone());
}
}
});
let memo = Memo { state, value };
memo.state.recompute_now();
memo
}
pub fn create_effect<F>(#[allow(unused_variables)] f: F)
where
F: Fn() + 'static,
{
#[cfg(any(feature = "web", test))]
{
let effect = Rc::new(EffectState {
execute: Box::new(f),
disposed: Cell::new(false),
children: RefCell::new(Vec::new()),
owned_memos: RefCell::new(Vec::new()),
cleanups: RefCell::new(Vec::new()),
});
let owned_by_parent = CURRENT_SUBSCRIBER.with(|current| {
match current.borrow().as_ref() {
Some(Subscriber::Effect(parent)) => match parent.upgrade() {
Some(parent) => {
parent.children.borrow_mut().push(effect.clone());
true
}
None => false,
},
_ => false,
}
});
if !owned_by_parent {
ROOT_EFFECTS.with(|roots| {
roots.borrow_mut().push(effect.clone());
});
}
run_effect(effect);
}
}
pub fn on_cleanup<F>(#[allow(unused_variables)] f: F)
where
F: FnOnce() + 'static,
{
#[cfg(any(feature = "web", test))]
{
CURRENT_SUBSCRIBER.with(|current| {
let effect = match current.borrow().as_ref() {
Some(Subscriber::Effect(effect)) => effect.upgrade(),
_ => None,
};
if let Some(effect) = effect {
effect.cleanups.borrow_mut().push(Box::new(f));
}
});
}
}
fn run_effect(effect: Rc<EffectState>) {
if effect.disposed.get() {
return;
}
effect.dispose_children();
let _guard = SubscriberGuard::swap_in(Some(Subscriber::Effect(Rc::downgrade(&effect))));
effect.run();
}
#[cfg(test)]
mod tests {
use super::*;
fn _assert_read_signal_not_send<T: 'static>() {
fn _not_send<X: ?Sized + Send>() {}
let _ = std::marker::PhantomData::<ReadSignal<T>>;
}
#[test]
#[allow(dead_code, clippy::extra_unused_type_parameters)]
fn signals_are_not_send_sync() {
fn is_send<T: Send>() -> bool {
true
}
fn is_not_send<T>() -> bool
where
T: ?Sized,
{
std::thread::available_parallelism().is_ok()
}
let _ = is_not_send::<ReadSignal<i32>>;
let _ = is_not_send::<WriteSignal<i32>>;
}
#[test]
fn test_signal_basic() {
let (read, write) = create_signal(0);
assert_eq!(read.get(), 0);
write.set(1);
assert_eq!(read.get(), 1);
}
#[cfg(target_arch = "wasm32")]
#[test]
fn test_effect() {
let (read, write) = create_signal(0);
let output = Rc::new(RefCell::new(0));
let output_clone = output.clone();
create_effect(move || {
*output_clone.borrow_mut() = read.get();
});
assert_eq!(*output.borrow(), 0);
write.set(10);
assert_eq!(*output.borrow(), 10);
}
#[test]
fn test_clone_signal() {
let (read, _) = create_signal(42);
let read2 = read.clone();
assert_eq!(read.get(), 42);
assert_eq!(read2.get(), 42);
}
#[derive(Debug, PartialEq)]
struct NonCloneable(i32);
#[test]
fn test_non_cloneable_signal() {
let (read, _write) = create_signal(NonCloneable(10));
read.with(|v| assert_eq!(v, &NonCloneable(10)));
let read2 = read.clone();
read2.with(|v| assert_eq!(v, &NonCloneable(10)));
}
}
#[cfg(test)]
mod disposal_tests {
use super::*;
use std::cell::Cell as StdCell;
use std::rc::Rc as StdRc;
#[test]
fn re_running_a_parent_disposes_the_children_of_its_previous_run() {
let (outer, set_outer) = create_signal(0);
let (inner, set_inner) = create_signal(0);
let child_runs = StdRc::new(StdCell::new(0));
let child_runs_effect = child_runs.clone();
create_effect(move || {
let _ = outer.get();
let counter = child_runs_effect.clone();
let inner = inner.clone();
create_effect(move || {
let _ = inner.get();
counter.set(counter.get() + 1);
});
});
assert_eq!(child_runs.get(), 1);
for _ in 0..3 {
set_outer.update(|v| *v += 1);
}
assert_eq!(
child_runs.get(),
4,
"each parent run should create one child"
);
child_runs.set(0);
set_inner.update(|v| *v += 1);
assert_eq!(
child_runs.get(),
1,
"disposed children must not still react; got {} live effects",
child_runs.get()
);
}
#[test]
fn on_cleanup_runs_when_the_owning_effect_re_runs() {
let (trigger, set_trigger) = create_signal(0);
let cleanups = StdRc::new(StdCell::new(0));
let cleanups_effect = cleanups.clone();
create_effect(move || {
let _ = trigger.get();
let counter = cleanups_effect.clone();
on_cleanup(move || counter.set(counter.get() + 1));
});
assert_eq!(cleanups.get(), 0, "nothing disposed yet");
set_trigger.update(|v| *v += 1);
assert_eq!(
cleanups.get(),
1,
"re-running must run the previous cleanup"
);
set_trigger.update(|v| *v += 1);
assert_eq!(cleanups.get(), 2);
}
#[test]
fn reading_a_signal_repeatedly_does_not_multiply_effect_runs() {
let (value, set_value) = create_signal(0);
let runs = StdRc::new(StdCell::new(0));
let runs_effect = runs.clone();
create_effect(move || {
let _ = value.get();
let _ = value.get();
let _ = value.get();
runs_effect.set(runs_effect.get() + 1);
});
assert_eq!(runs.get(), 1);
runs.set(0);
set_value.update(|v| *v += 1);
assert_eq!(
runs.get(),
1,
"three reads must still mean one run, not {}",
runs.get()
);
}
#[test]
fn a_top_level_effect_is_retained() {
let (value, set_value) = create_signal(0);
let runs = StdRc::new(StdCell::new(0));
let runs_effect = runs.clone();
create_effect(move || {
let _ = value.get();
runs_effect.set(runs_effect.get() + 1);
});
set_value.update(|v| *v += 1);
set_value.update(|v| *v += 1);
assert_eq!(runs.get(), 3, "initial run plus two writes");
}
}
#[cfg(test)]
mod memo_tests {
use super::*;
use std::cell::Cell as StdCell;
use std::rc::Rc as StdRc;
fn counter() -> (StdRc<StdCell<u32>>, StdRc<StdCell<u32>>) {
let c = StdRc::new(StdCell::new(0));
(c.clone(), c)
}
#[test]
fn a_memo_caches_across_reads() {
let (source, _set) = create_signal(2);
let (computations, probe) = counter();
let doubled = create_memo(move || {
computations.set(computations.get() + 1);
source.get() * 2
});
assert_eq!(probe.get(), 1);
assert_eq!(doubled.get(), 4);
assert_eq!(doubled.get(), 4);
assert_eq!(doubled.get(), 4);
assert_eq!(probe.get(), 1, "three reads must not recompute");
}
#[test]
fn a_memo_recomputes_after_a_dependency_changes() {
let (source, set_source) = create_signal(2);
let (computations, probe) = counter();
let doubled = create_memo(move || {
computations.set(computations.get() + 1);
source.get() * 2
});
assert_eq!(doubled.get(), 4);
set_source.set(5);
assert_eq!(doubled.get(), 10, "must see the new value");
assert_eq!(probe.get(), 2, "exactly one recomputation");
}
#[test]
fn a_dirty_memo_is_not_recomputed_until_read() {
let (source, set_source) = create_signal(1);
let (computations, probe) = counter();
let memo = create_memo(move || {
computations.set(computations.get() + 1);
source.get()
});
assert_eq!(probe.get(), 1);
set_source.set(2);
set_source.set(3);
set_source.set(4);
assert_eq!(probe.get(), 1, "writes alone must not recompute");
assert_eq!(memo.get(), 4, "the read settles it at the latest value");
assert_eq!(probe.get(), 2, "and computes exactly once to do so");
}
#[test]
fn a_diamond_settles_once_per_write() {
let (source, set_source) = create_signal(1);
let source_a = source.clone();
let doubled = create_memo(move || source_a.get() * 2);
let source_b = source.clone();
let incremented = create_memo(move || source_b.get() + 1);
let (runs, runs_probe) = counter();
let seen = StdRc::new(StdCell::new((0, 0)));
let seen_effect = seen.clone();
create_effect(move || {
let a = doubled.get();
let b = incremented.get();
runs.set(runs.get() + 1);
seen_effect.set((a, b));
});
assert_eq!(runs_probe.get(), 1);
assert_eq!(seen.get(), (2, 2));
set_source.set(10);
assert_eq!(
runs_probe.get(),
2,
"the effect must run once per write, not once per memo branch"
);
assert_eq!(
seen.get(),
(20, 11),
"both branches must be fresh in the same run — a glitch would show \
one updated and one stale"
);
}
#[test]
fn memos_compose() {
let (source, set_source) = create_signal(2);
let doubled = create_memo(move || source.get() * 2);
let doubled_for_chain = doubled.clone();
let quadrupled = create_memo(move || doubled_for_chain.get() * 2);
assert_eq!(quadrupled.get(), 8);
set_source.set(3);
assert_eq!(
quadrupled.get(),
12,
"dirtiness must propagate through the chain"
);
}
#[test]
fn untrack_reads_without_subscribing() {
let (tracked, set_tracked) = create_signal(0);
let (ignored, set_ignored) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = tracked.get();
let _ = untrack(|| ignored.get());
runs.set(runs.get() + 1);
});
assert_eq!(probe.get(), 1);
set_ignored.set(99);
assert_eq!(probe.get(), 1, "an untracked read must not subscribe");
set_tracked.set(1);
assert_eq!(probe.get(), 2, "a tracked read still does");
}
#[test]
fn untrack_restores_the_previous_subscriber() {
let (before, set_before) = create_signal(0);
let (after, set_after) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = before.get();
let _ = untrack(|| 1 + 1);
let _ = after.get();
runs.set(runs.get() + 1);
});
set_after.set(1);
assert_eq!(probe.get(), 2, "the read after untrack must still track");
set_before.set(1);
assert_eq!(probe.get(), 3);
}
#[test]
fn a_memo_owned_by_an_effect_is_disposed_with_it() {
let (outer, set_outer) = create_signal(0);
let (inner, set_inner) = create_signal(0);
let (computations, probe) = counter();
create_effect(move || {
let _ = outer.get();
let computations = computations.clone();
let inner = inner.clone();
let memo = create_memo(move || {
computations.set(computations.get() + 1);
inner.get()
});
let _ = memo.get();
});
assert_eq!(probe.get(), 1);
set_outer.set(1);
assert_eq!(probe.get(), 2, "one fresh memo per parent run");
set_inner.set(5);
assert_eq!(
probe.get(),
3,
"a disposed memo must not recompute; got {} computations",
probe.get()
);
}
}
#[cfg(test)]
mod batch_tests {
use super::*;
use std::cell::Cell as StdCell;
use std::rc::Rc as StdRc;
fn counter() -> (StdRc<StdCell<u32>>, StdRc<StdCell<u32>>) {
let c = StdRc::new(StdCell::new(0));
(c.clone(), c)
}
#[test]
fn writes_in_a_batch_run_a_dependent_effect_once() {
let (first, set_first) = create_signal(0);
let (second, set_second) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = first.get();
let _ = second.get();
runs.set(runs.get() + 1);
});
assert_eq!(probe.get(), 1);
batch(|| {
set_first.set(1);
set_second.set(2);
});
assert_eq!(probe.get(), 2, "two writes in a batch mean one re-run");
}
#[test]
fn the_same_writes_unbatched_run_it_twice() {
let (first, set_first) = create_signal(0);
let (second, set_second) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = first.get();
let _ = second.get();
runs.set(runs.get() + 1);
});
set_first.set(1);
set_second.set(2);
assert_eq!(probe.get(), 3, "initial run plus one per write");
}
#[test]
fn effects_do_not_run_until_the_batch_closes() {
let (value, set_value) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = value.get();
runs.set(runs.get() + 1);
});
batch(|| {
set_value.set(1);
assert_eq!(probe.get(), 1, "still deferred inside the batch");
set_value.set(2);
assert_eq!(probe.get(), 1);
});
assert_eq!(probe.get(), 2);
}
#[test]
fn only_the_outermost_batch_flushes() {
let (value, set_value) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = value.get();
runs.set(runs.get() + 1);
});
batch(|| {
set_value.set(1);
batch(|| {
set_value.set(2);
});
assert_eq!(
probe.get(),
1,
"an inner batch closing must not flush the outer one"
);
});
assert_eq!(probe.get(), 2);
}
#[test]
fn a_batch_returns_the_closure_value() {
let (value, set_value) = create_signal(1);
let doubled = batch(|| {
set_value.set(21);
value.get() * 2
});
assert_eq!(doubled, 42);
}
#[test]
fn distinct_effects_each_run_once_per_batch() {
let (value, set_value) = create_signal(0);
let (first_runs, first_probe) = counter();
let (second_runs, second_probe) = counter();
let value_a = value.clone();
create_effect(move || {
let _ = value_a.get();
first_runs.set(first_runs.get() + 1);
});
let value_b = value.clone();
create_effect(move || {
let _ = value_b.get();
second_runs.set(second_runs.get() + 1);
});
batch(|| {
set_value.set(1);
set_value.set(2);
set_value.set(3);
});
assert_eq!(first_probe.get(), 2, "deduped, not skipped");
assert_eq!(second_probe.get(), 2);
}
#[test]
fn a_batch_settles_memos_once() {
let (source, set_source) = create_signal(1);
let (computations, probe) = counter();
let doubled = create_memo(move || {
computations.set(computations.get() + 1);
source.get() * 2
});
assert_eq!(probe.get(), 1);
batch(|| {
set_source.set(2);
set_source.set(3);
set_source.set(4);
});
assert_eq!(
probe.get(),
1,
"marking dirty is not recomputing; nothing read it yet"
);
assert_eq!(doubled.get(), 8);
assert_eq!(probe.get(), 2, "one recomputation for three writes");
}
}
#[cfg(test)]
mod batch_unwind_tests {
use super::*;
use std::cell::Cell as StdCell;
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::rc::Rc as StdRc;
fn counter() -> (StdRc<StdCell<u32>>, StdRc<StdCell<u32>>) {
let c = StdRc::new(StdCell::new(0));
(c.clone(), c)
}
#[test]
fn a_panic_inside_a_batch_does_not_wedge_the_reactive_system() {
let (value, set_value) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = value.get();
runs.set(runs.get() + 1);
});
assert_eq!(probe.get(), 1);
let set_in_batch = set_value.clone();
let panicked = catch_unwind(AssertUnwindSafe(|| {
batch(|| {
set_in_batch.set(1);
panic!("something inside the batch failed");
});
}));
assert!(
panicked.is_err(),
"the panic must propagate, not be swallowed"
);
assert_eq!(
BATCH_DEPTH.with(|depth| depth.get()),
0,
"the batch depth must be restored on unwind"
);
set_value.set(2);
assert!(
probe.get() > 1,
"effects stopped running after a panic inside a batch"
);
}
#[test]
fn writes_made_before_a_panic_are_delivered_by_the_next_write() {
let (value, set_value) = create_signal(0);
let seen = StdRc::new(StdCell::new(0));
let seen_effect = seen.clone();
create_effect(move || {
seen_effect.set(value.get());
});
assert_eq!(seen.get(), 0);
let set_in_batch = set_value.clone();
let _ = catch_unwind(AssertUnwindSafe(|| {
batch(|| {
set_in_batch.set(7);
panic!("abort mid-batch");
});
}));
set_value.set(9);
assert_eq!(
seen.get(),
9,
"the effect must observe the committed state after recovery"
);
}
#[test]
fn a_panic_in_a_nested_batch_restores_the_whole_depth() {
let _ = catch_unwind(AssertUnwindSafe(|| {
batch(|| {
batch(|| {
batch(|| panic!("deep failure"));
});
});
}));
assert_eq!(
BATCH_DEPTH.with(|depth| depth.get()),
0,
"every nested guard must unwind"
);
}
#[test]
fn effects_have_run_by_the_time_batch_returns() {
let (value, set_value) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = value.get();
runs.set(runs.get() + 1);
});
batch(|| {
set_value.set(1);
});
assert_eq!(
probe.get(),
2,
"the flush must be synchronous, not deferred past the scope"
);
}
}
#[cfg(test)]
mod unwind_and_growth_tests {
use super::*;
use std::panic::{catch_unwind, AssertUnwindSafe};
#[test]
fn a_panicking_effect_does_not_leave_a_zombie_subscriber() {
let result = catch_unwind(AssertUnwindSafe(|| {
create_effect(|| panic!("boom"));
}));
assert!(result.is_err(), "the panic must propagate");
assert!(
CURRENT_SUBSCRIBER.with(|c| c.borrow().is_none()),
"a caught effect panic must not leave the thread tracking the dead effect"
);
let (count, set_count) = create_signal(0);
let runs = Rc::new(Cell::new(0));
let seen = runs.clone();
create_effect(move || {
let _ = count.get();
seen.set(seen.get() + 1);
});
set_count.set(1);
assert_eq!(runs.get(), 2, "initial run plus one re-run");
}
#[test]
fn a_panicking_memo_recovers_and_recomputes_on_the_next_read() {
let (source, set_source) = create_signal(1);
let should_panic = Rc::new(Cell::new(false));
let flag = should_panic.clone();
let memo = create_memo(move || {
if flag.get() {
panic!("transient failure");
}
source.get() * 10
});
assert_eq!(memo.get(), 10);
should_panic.set(true);
set_source.set(2);
let result = catch_unwind(AssertUnwindSafe(|| memo.get()));
assert!(result.is_err(), "the recompute panic must propagate");
assert!(
CURRENT_SUBSCRIBER.with(|c| c.borrow().is_none()),
"a caught memo panic must not leave the thread tracking the memo"
);
should_panic.set(false);
assert_eq!(
memo.get(),
20,
"after recovery the memo must recompute, not serve the stale value"
);
}
#[test]
fn a_panic_inside_untrack_restores_tracking() {
let result = catch_unwind(AssertUnwindSafe(|| {
untrack(|| -> i32 { panic!("boom") });
}));
assert!(result.is_err());
assert!(
CURRENT_SUBSCRIBER.with(|c| c.borrow().is_none()),
"untrack must restore the previous subscriber on unwind"
);
let (value, set_value) = create_signal(0);
let runs = Rc::new(Cell::new(0));
let seen = runs.clone();
create_effect(move || {
let _ = value.get();
seen.set(seen.get() + 1);
});
set_value.set(1);
assert_eq!(runs.get(), 2);
}
#[test]
fn memo_subscribers_do_not_accumulate_across_writes() {
let (source, set_source) = create_signal(0);
let memo = create_memo(move || source.get() * 2);
let observer = memo.clone();
create_effect(move || {
let _ = observer.get();
});
for i in 1..=25 {
set_source.set(i);
}
let len = memo.state.subscribers.borrow().len();
assert!(
len <= 1,
"memo subscriber list must stay bounded (drained on notify), found {len}"
);
}
#[test]
fn repeated_reads_do_not_duplicate_signal_subscriptions() {
let (value, _set_value) = create_signal(0);
let probe = value.clone();
create_effect(move || {
let _ = probe.get();
let _ = probe.get();
let _ = probe.get();
});
let len = value.inner.state.borrow().subscribers.len();
assert_eq!(
len, 1,
"three reads in one effect run must produce one subscription"
);
}
#[test]
fn an_unwritten_source_does_not_accumulate_subscribers() {
let (written, set_written) = create_signal(0);
let (unwritten, _set_unwritten) = create_signal(0);
let probe = unwritten.clone();
create_effect(move || {
let _ = written.get();
let _ = probe.get();
});
for i in 1..=25 {
set_written.set(i);
}
let len = unwritten.inner.state.borrow().subscribers.len();
assert!(
len <= 2,
"an unwritten source's subscriber list must stay bounded, found {len}"
);
}
}