Repository navigation
v1.0.0
The first tagged release. Before it, consumers built the untagged 0.1 sources; the breaking changes
below are relative to those sources, each with a Migration: note.
Delivery
- Fixed: a subscriber panic no longer stalls its delivery queue. The panic still propagates to
the thread draining the queue, but the items queued behind the panicking one, and later ones,
are delivered to every live subscriber (including new ones) by the next publication. This
applies to every signal, event bus and collection source. - Changed: subscribers of one queue are invoked in subscription order (previously unspecified),
and a subscriber disposed on the delivering thread, including by another subscriber while the
same item is in flight, is never invoked again. - Changed:
Signal::set/replace/updateandEventBus::emitdeliver in commit order when
several threads write concurrently. - Added:
DeliveryQueue::push,DeliveryQueue::drainandDeliveryQueue::pending_len.
enqueuekeeps its contract (pushfollowed bydrain).
Errors and interop
- Breaking:
ReactiveErrorhas a new variantExternal(Arc<dyn Error + Send + Sync>)carrying
an error from another layer. Migration: add a wildcard or anExternal(_)arm to exhaustive
matches onReactiveError. - Added:
impl From<CollectionError> for ReactiveError(PoisonedstaysPoisoned, every
other variant becomesExternalholding the original), so?on collection subscriptions works
insidewhen_activatedcallbacks.CollectionError::from(ReactiveError::External(..))recovers a
wrapped collection error; other external errors map toPoisoned. - Added:
ValueStream::map_errandValueStream::err_into, andReactiveError::external. - Breaking (generic error parameters):
ReactiveValueStreamExt<T, E = ReactiveError>and
OptionValueStreamExt<T, StreamError = CollectionError>are implemented for streams of any error
type, andEffect::watchaccepts&ValueStream<T, E>and returnsResult<Effect, E>.
Migration: code that built a stream withValueStream::new(..)and relied on a scalar
operator to infer the error type now needs an annotation (ValueStream::<T, ReactiveError>::new)
orValueStream::from_reactive. - Breaking (generic error parameters): every collection operator that takes a stream (sort
comparers and resort triggers, page/virtual requests includingsort_and_*,batch_if/buffer_if
pause streams, regroupers, group selectors, forced-transform triggers, tree predicates,switch,
populate_from*, theto_*_change_set*andedit_diff*bridges, buffered change-set streams)
and every per-item selector returning one (filter_on_observable,auto_refresh*,
transform_on_observable,group_on_observable,merge_many*,when_*value_changed*,
true_for_*,query_when_changed_on*) acceptsValueStream<_, E>with
CollectionError: From<E>. Passsignal.values()directly; thecollection_streamadapter shown
in earlier docs is no longer needed. Two-stream operators
(sort_*_dynamic_with_resort,sort_and_*_dynamic*,group_dynamic_with_regrouper) take an
independent error type for each stream. Migration: existing call sites keep compiling, except
a stream built inline withprimitives::ValueStream::new(..)(the crate-root one) whose error
type was inferred from the operator: annotate it (ValueStream::<_, CollectionError>::new) or
build it with thecollections::ValueStreamalias, which fixesCollectionError. - Added:
Computed::from_stream(&stream, initial)holds a stream's latest value as scalar state
(for example a collectioncount()drivingCommand::with_can_execute). - Added:
ValueStreamcombinators onReactiveValueStreamExt:merge,combine_latest,
with_latest_from,switch_map,scan,take,first,take_until,pairwise,
distinct_until_changed_by,shareandshare_replay.
Collection sources
- Breaking:
CollectionErrorhas a new variantContended. Migration: add a wildcard or a
Contendedarm to exhaustivematches onCollectionError. - Fixed (behavior): cross-thread contention no longer fails with
NestedUpdate. On native
targets edits, reads,connect,lookup,watch*,suspend_notificationsandcount_changed
wait for the lock, so concurrent writers and readers all succeed; onwasm32they return
Contendedwithout blocking and without leaving partial subscriptions.NestedUpdatenow means
same-thread re-entry only, and is also returned (instead of deadlocking) for reads such as
items()/len()/count()/keys()/version()andsuspend_notificationsmade from inside the
source's own edit closure, key selector or aT::clonerunning under its lock. The same applies
to live groups (RayListGroup,RayCacheGroup). Migration: retry loops onNestedUpdatefor
contention are no longer needed. - Fixed:
changes(),preview(),connect()andcount_changed()deliver batches in commit
(version) order with several writer threads; an edit made inside apreview()callback is
delivered after the batch that triggered it. - Fixed:
count_changed()registers before reading its baseline: counts changed during the
initial callback or concurrently are reported, and the last reported count equalslen()/count(). - Fixed:
connect(),watch(key),watch_value(key)andwatch_optional(key)subscribed while
notifications are suspended no longer receive changes their snapshot already covers when the
suspension ends. The resumed publication is still one publicChangeSet. - Fixed: dropping the last notification-suspension guard always resumes publication, also when
it is dropped inside the source's own edit or while another thread holds the source under the
non-blocking policy (the resume is applied when the lock is released). - Fixed: a live group connection made between a grouping operator staging a change and
publishing it no longer receives that change twice, and disposing a keyed watch whose subscriber
owns another watch on the same cache no longer deadlocks. - Documented: native targets now wait on contention, so accessing source B from inside source
A's edit closure while another thread does the reverse can deadlock; keep one global order. - Added: updater reads (
ListUpdater::items/len/is_empty/get,
CacheUpdater::lookup/contains_key/count/keys) reflecting the edit's own changes, making
read-modify-write inside oneeditatomic. - Added:
SourceList::get/contains/read,SourceCache::contains_key/read(with the new
CacheView), the same onObservableList/ObservableCache, andSourceCache::from_items. - Changed (behavior):
watch_valueandwatch_optionalemit at most one value per batch, the
key's final state in it (aloadthat keeps the key emits only the new value, with noNone
flicker), andChangeStream::watch(key)forwards aClearwith only the watched key's entry.
Materialization and composition
- Fixed:
populate_into,populate_from*, theto_*_change_set*adapters,
ObservableList/ObservableCache::from_stream(andas_observable_*) and the source size limits
no longer discard a batch whose destination edit fails: the batch is kept and retried, in order,
when the destination's lock is next released (and in any case before the next batch). A failure
that cannot clear (Poisoned) is reported and its batch dropped. A retry runs on the thread that
releases the lock, so the destination's subscribers can be called from that thread. - Added:
populate_into_with_errors,populate_from_with_errors,
populate_from_batches_with_errors, theto_list_change_set*_with_errors/
to_cache_change_set*_with_errorsadapters,limit_size_to_with_errorsonSourceListand
SourceCache, andObservableList::errors()/ObservableCache::errors(), which report each
failed attempt. - Fixed: the source size limits (
SourceList/SourceCache::limit_size_to) recompute an eviction
whose edit failed instead of queueing it, so an item is never evicted twice or in place of another,
and emit only the items actually removed. - Fixed:
ref_countrolls back a subscriber whose upstream connection failed; a subscriber that
joined from another thread meanwhile waits for the outcome and connects again itself (on wasm32 it
getsContendedinstead of waiting). A late subscriber's snapshot always comes before live
batches, and batches from a released upstream are ignored. - Fixed:
switchdelivers its output in order and never concurrently, never forwards a
superseded inner's batches after itsClear, and leaves no inner subscription after disposal.
Added:switch_with_errorsreports an inner subscription that failed; the switch retries when
the outer stream emits again.
Operator emission
- Fixed: operators with several inputs (dynamic filters, sorts, page/virtualize and group
operators,*_with_resort,*_with_regrouper,sort_and_*_dynamic*, all joins, static and
dynamic combiners, forced transforms,transform_to_tree_with_predicateand
merge_many_*_change_sets) no longer deliver batches out of order or concurrently when their
inputs are driven from different threads; each subscription has one ordered output, possibly
delivered by the thread that is already draining it. The live groups created by the group
operators and the right groups of*_join_manyare notified the same way: their own streams
receive batches in computation order, after the operator released its lock, so a group's
subscriber may edit the operator's inputs (it used to deadlock*_join_many). - Fixed:
reverse,virtualize,group_by,ensure_unique_keys, cachetransform_manyand
collect_update_statsno longer call their subscriber while holding their own state lock, so a
panicking subscriber no longer poisons them and stops their output.
Change indexes
- Documented: the
CacheChange(andListChange) index contract on the types: indexes are
positions in the emitting operator's own output orNone; anUpdatewith differing indexes is
a remove plus an insert; aMovecarries the item as it is, and a later change to the same key
in the batch uses the post-move position. - Fixed: keyed sort keeps its position maps in sync after indexed upserts of existing keys (it
could misorder or panic) and inserts with a binary search (O(log n) comparisons). - Fixed (behavior change): cache
filter,transform_safe*, forced transforms and the dynamic
filter index their own output instead of forwarding source positions, andfilterno longer
emitsRemove/Clearfor keys it never included. Code that relied on source-space indexes from
these operators sees output positions now; the test
transforms_filters::cache_filter_and_transform_emit_keyed_changes, which pinned a source-space
index, now expects the filter's output position. - Fixed: an index-less
Update(from an upstream that does not know positions) updates the key
in place in sorts, safe and forced transforms and trees instead of moving it to the end. - Performance: initial loads through
filter,transform_safeand joins append new keys
without scanning, so they stay linear. - Fixed:
transform_inline*emits a positional update as aMoveplusRefresh; keyed
windows (page_keyed*,virtualize_keyed*,top_keyed), joins, combiners, stream
limit_size_to, immutable groups and trees emit correctMove/Updateindex pairs; join output
follows the left (or combined) source order after mixed batches. - Fixed:
a.or([b])(and the other combiners) keep an update followed by a refresh of the same
key in one batch. - Fixed: the cache-to-list bridge behind
as_observable_list,remove_keyandbind_to_vec
positions rows by its own key mirror, so a non-conforming upstream cannot duplicate or misplace
them; materialized views store the item aRefreshcarries.
Keyed operators and windows
- Fixed: live list and cache groups (including
group_on_observable) keep valid indexes when a
group is created and emptied in one batch, and remove empty groups in a deterministic order; cachegroup_byorders members by source order and handles a fullClear. - Fixed (behavior change):
add_keyemits the list positions on every change (it emitted
Nonefor additions);ensure_unique_keysemits indexes from its own order, forwards moves
(moving only keys whose order changed) and emits one change per key (a key that is moved and
refreshed gets both);ValueStreamedit_diff*emits indexes valid in order (a
swap is oneMove, removals run from the end). The tests
side_effects_options_bridges::list_add_key_converts_list_changes_to_keyed_cache_changesand
aggregation_diagnostics_diff::value_stream_snapshot_edit_diff_emits_list_changeswere updated. - Fixed (behavior change):
change_keytracks source to destination keys: a change of
destination key emitsRemoveplusAdd, collisions keep a remaining source's item, a refresh
never changes which source provides a key, and no indexes are emitted (destination positions
are unknown: sort afterchange_key). The test
side_effects_options_bridges::cache_change_key_preserves_reasons_and_remaps_keyswas updated. - Fixed: synchronous cache
transform_manygives a shared child key to the first live parent
(falling back on removal) and emits in a deterministic order; cache-parent
merge_many_*_change_setskeep only a parent's latest child stream within a batch. - Fixed (behavior change): page and virtual responses (list, keyed and
sort_and_*) are
emitted whenever a response field changes, with an empty change set if the visible items did
not, and once the source has loaded even for an empty window. Listpage_dynamic*and
virtualize_dynamic*no longer show a default0..25window before the first request. - Fixed:
sort_and_page_*/sort_and_virtualize_*run on the keyed sort's state, so they
matchsort_keyed_*plus the keyed window and load with O(n log n) comparisons.
Time
- Added:
primitives::Scheduler(now,schedule(delay, task) -> ScheduledTask, cancelled on
drop),ThreadScheduler(one lazily started timer thread per instance),default_scheduler()
(one shared instance) andManualScheduler(a virtual clock for deterministic tests:
advance_by,run_due,pending). Custom schedulers build their handles with
ScheduledTask::new(cancel)orScheduledTask::done(); a handle can also becancelled or
detached. - Added:
*_with_schedulervariants ofbatch,buffer_initial,
batch_if_with_timeout/buffer_if_with_timeoutand list and cacheauto_refresh_buffered.
The existing methods run ondefault_scheduler()instead of spawning a thread per window or
timeout. Implementers ofListLifecycleExt/CacheLifecycleExtoutside the crate (none are
expected) must addauto_refresh_buffered_with_scheduler. - Fixed: timer flushes of these operators and of
auto_refreshare emitted in order with the
source batches and never concurrently with them, so buffered refresh indexes always resolve to
the refreshed item;batcharms its next window only after a flush was delivered. - Fixed: dropping a timed operator's subscription cancels its pending timer without waiting
(also from inside its own delivery), releases the buffered changes and the subscriber at once,
and nothing more is delivered on the dropping thread once the drop returns. A subscriber panic
caught by the caller no longer stopsbatchorexpire_after*. - Added:
expire_after_with_schedulerandexpire_after_with_polling_with_scheduleron
CacheExpireAfterExt,ListExpireAfterExt,SourceCacheExpireAfterExtand
SourceListExpireAfterExt;ChangeSetAdapterOptions::expire_after_with_scheduler,
expire_after_with_polling_with_schedulerandwith_scheduler. Everyexpire_after*runs on a
scheduler instead of a thread per subscription, and disposal no longer joins a timer thread. - Breaking:
ChangeSetAdapterOptionshas a new public field,scheduler. Migration: code
that builds it with a struct literal addsscheduler: None(or..Default::default()); the
constructors and builders are unchanged. Implementers of the expiration traits outside the crate
(none are expected) add the two new methods. - Fixed: the polling variants (stream, source and adapter options) expire due items within one
polling interval; source changes no longer postpone the poll forever. - Fixed (behavior change): stream
expire_aftertranslates later source changes to its own
output: list indexes skip expired items, cache indexes are positions among unexpired keys, an
update (cache) or replacement (list) of an expired item adds it back, and its refreshes, moves
and removals are dropped. - Fixed: source
expire_aftertakes due items inside its source edit, only from state that has
seen every committed batch (it waits otherwise, for example duringsuspend_notifications),
retries an edit that failed because the source was busy, and reports exactly the items the edit
removed; under a concurrent editor no item misses its expiry. - Fixed: repeated updates of the same items no longer grow the expiration queue: it holds one
entry per live item. - Fixed (behavior change): stream
limit_size_toforwardsRefreshand same-valueUpdate
changes of the keys it holds (it dropped them), and maintains its state per change instead of
cloning and diffing the whole retained cache on every batch. - Fixed: source
limit_size_to(lists and caches) picks the items to evict inside its source
edit, only from state that has seen every committed batch, so an item renewed while an earlier
batch is still being delivered is no longer evicted as the oldest. Eviction follows delivery:
while writers commit faster than batches are delivered, the source can exceed the limit until
the limiter has received them. - Added:
debounce,throttleandsampleonValueStream<T, E>(ReactiveValueStreamExt),
each with a*_with_schedulervariant; disposal cancels their pending timers.
Aggregates
- Fixed (behavior change):
is_empty/is_not_emptyemit one initial value that reflects the
snapshot (a non-empty source yields[false], not[true, false]) and afterwards only distinct
changes. The testslist_aggregations_track_snapshots_counts_sum_and_averageand
cache_aggregations_track_query_counts_sum_and_average(in
aggregation_diagnostics_diff::list_aggregations_track_snapshots_counts_sum_and_average) pinned
the old sequences and were updated. - Fixed:
sum_byoverf64/f32,avg_byandstd_dev_byuse a compensated running sum
(an overflowing sum is infinite, and recovers when a value leaves;
recomputed from the values when one of magnitude 2^53 or more leaves) and count infinities and
NaN apart, so they recover once a non-finite value leaves and stay accurate across
large-magnitude additions and removals. - Fixed:
max_byandmin_byorder NaN as the greatest value (equal to itself), so their
results and change detection do not depend on arrival order.
Performance
- Sources and keyed operators mirror their key order with an indexed order (O(1) key lookups per
insert, removal or move) instead of scanning:SourceCacheedits no longer rebuild a position map
per edit, and transforms, the cache-to-list bridge (remove_key),ensure_unique_keys,
filter_with_state, keyed sorting, lifecycle operators, expiration, live grouping, joins and
transform_to_treeload in near-linear time. - Sources publish one shared batch per edit to all subscribers (each item is cloned once into
state and once into the batch), skip keyed-watch partitioning while no key is watched, and
create the rxRust subject and its bridge on the firstchanges_rx()call. - Fixed (behavior change): a new state or predicate in
filter_with_state/filter_dynamic
(list and cache) emits only the inclusion flips; the list version emitted aReplacefor every
visible position whose item changed. - Fixed (behavior change): list-shaped sorts (list
sort_*and the cachesort_*returning
list changes) reorder withMovechanges on a comparer change or resort instead of replacing
items (a reorder that would shift more than about four million positions in all falls back to
the positional diff). - Fixed (behavior change):
transform_to_treeinserts a child at its position among its
siblings (oneAddin the parent'schildren()) instead of appending it and moving every
sibling into place. - Fixed:
left_join_many/full_join_manydrop the group of a removed left key when no right
item uses it (they were kept forever), andtransform_to_treefrees the nodes of a parent cycle
when its subscription is disposed (they leaked). - Fixed: in
*_join_many, a right-sideUpdatethat also moves the item (a new
current_index) moves it inside its group too; the group kept it at its old position. - Added Criterion benchmarks
joins,treeandsort_and_page. - The test
source_lock_policy::a_reentrant_clone_during_a_deferred_resume_gets_nested_update
pinned a clone of the suspended batch during a deferred resume; resumes now share the batch,
and the test becamea_deferred_resume_clones_no_items_under_the_lock. - The
connectionunit testssource_cache_history_free_startup_disposal_releases_bufferand
startup_diagnostic_gauge_releases_buffer_on_dispose_drop_and_livecounted a copy of each buffered
batch; a connecting subscriber now buffers the shared batch, so its item is dropped once.
Lifecycle
- Breaking: list
dispose_manyanddispose_many_withrequireT: PartialEq(like the cache
versions) and no longer dispose an item replaced by an equal one. Added: list
dispose_many_by(same_item, dispose). Migration: types withoutPartialEquse
dispose_many_by(|_, _| false, dispose)to keep disposing every replaced item. - Fixed:
collect_update_statsemits its summaries in batch order and outside its lock. - Fixed (behavior change):
true_for_all*/true_for_any*evaluate after a batch's item
streams have been subscribed: over one passing item they emit[true](not[true, false, true]), and adding another passing item emits nothing. - Fixed (behavior change):
filter_on_observableandmerge_many_*_change_setsfold the values
child streams emit while being subscribed into the source batch: subscribing emits one startup
batch, a replaced or updated item whose result does not change is oneReplace/Update(no
remove and add), and a parent updated with identical children emits nothing.
Async operators
- Added: list
transform_async_with_options(transform, TransformAsyncOptions): a batch's
futures run concurrently up tomaximum_concurrencyand their results are applied in index
order. List async transforms no longer requireU: PartialEq. - Added:
transform_many_async_with_optionsand the_with_optionsforms of the other seven
transform_many_*async*operators, honoringTransformAsyncOptions::maximum_concurrency;
TransformPanic, the error a safe async transform reports for a panicking future. - Fixed: cache
transform_many_async*/*_async_stream*run on one worker thread per
subscription instead of one thread per parent, and emit through the ordered emitter (no
concurrent deliveries, no stale children behind a slow subscriber). - Fixed (behavior change): async transforms (cache and list) drop an in-flight future when a
later batch removes or replaces its item or updates its key, and every future on disposal; the
worker exits promptly and nothing is emitted afterwards. A future superseded before it ran is
not run. The teststransforms_filters::cache_transform_safe_forced_retries_failed_source_items::cache_transform_safe_async_reports_errors_and_recovers(now waits for the first error before updating the key) andtransforms_filters::cache_transform_many_async_ignores_stale_materialization_after_parent_re::cache_transform_many_async_ignores_stale_materialization_after_parent_removed(the removed parent's receiver may already be dropped) were updated. A source that releases its callback (a finite stream) still gets every pending transform-many transform finished. - Fixed (behavior change): a panicking future no longer kills the worker: the item is skipped
(safe variants report it throughon_errorwhenEcan carry aTransformPanic, aString
or a boxed error), and later batches are processed. Cache async transforms emit indexes as
positions in their own output, so skipped and failed items do not shift them; list async
transforms leave skipped items out with translated indexes. - Fixed: in
async_dispose_many*, a finalizer that panics (its factory or its future) no
longer stops the later finalizers, and the completion stream always fires after every queued
finalizer, including the teardown ones. - Fixed (behavior change):
maximum_concurrency: Some(0)runs one future at a time (it meant
unbounded for cache transforms). Listtransform_async*run a batch's futures concurrently
(unbounded) and apply the results in index order; they awaited each change in turn.
Signals
- Fixed: a
values()subscriber never receives an older value after a newer one, and ends on
the signal's current value, even when another thread writes during the subscription. - Fixed: a panic inside an
updateclosure, or insideT::eq/T::cloneduring a write,
leaves the signal unchanged and usable; later calls no longer returnReactiveError::Poisoned. - Changed: writes clone less: without subscribers
set/replaceclone the value once and
updatetwice (previously four times each). - Fixed:
ValueStream::start_withsubscribes upstream before emitting the initial value, so a
write made while handling the initial value is delivered instead of lost (on the same thread it
arrives nested inside the initial callback). Upstream values from other threads wait until the
initial callback has returned. - Added:
Signal::try_get,Signal::try_read,ReadSignal::try_getand
ReadSignal::try_read, which returnOk(None)instead of waiting when another thread holds the
signal's lock.
Computed values
- Fixed:
Computedis glitch-free: a diamond publishes one consistent value per write, and
combine2(a, a, …)never mixes two versions ofa. - Fixed:
Computed::get()(and reads throughread_signal()) recompute when an input changed,
so they are fresh even while another thread is still delivering the input's change. - Changed: construction evaluates the closure once unless an input changed meanwhile; the new
value starts at version0. - Fixed: a panic inside a derive/combine closure propagates to the writer but no longer stops
theComputedfrom updating. - Added:
Computed::combine3andComputed::derive_distinct.
Commands
- Breaking (behavior): calling
executewhile disabled returnsCommandError::Disabledand
publishes nothing. It used to set the state toCommandState::Cancelled. Migration: observe
the returned error instead of theCancelledstate; the test
command_tracks_state_and_can_executewas updated accordingly. - Changed:
CommandState::Cancellednow means anAsyncCommand::execute()future was dropped
after it started (for example byselect!or a timeout); the state no longer staysRunning. - Fixed: with overlapping executions only the most recently started one publishes its terminal
state. - Fixed: a panicking action publishes
Failed("panicked: …")and the panic continues to the
caller or out of the future. For anAsyncCommandthis includes an action that panics before
returning its future. - Added:
Command::is_executing/AsyncCommand::is_executing,ExecutionPolicy
(Concurrent, the default, andIgnoreWhileRunning),with_execution_policyand
execution_policyon both command types.
Activation
- Added:
ViewModelActivator::is_activeandActivationToken::is_active. A token that joins a
generation whose callbacks then fail reports inactive. - Added:
ViewModelActivator::when_activated_scoped, which runs work once for the current
generation; registering it from inside an activation callback no longer accumulates. - Fixed: when a callback registered while active fails, the subscriptions it added before
failing are disposed. - Fixed: a panicking activation callback abandons its generation (disposing the partial work)
instead of leaving the activator stuck in a half-activated generation.
API hygiene
- Breaking:
ReactiveError,CollectionErrorandCommandErrorare#[non_exhaustive].
Migration: add a wildcard arm to exhaustivematches on them outside this crate. The change
and reason enums (ListChange,CacheChange,ChangeReason, …) stay exhaustive. - Breaking (lint):
Subscription,CompositeSubscription,Effect,ActivationToken,
Disposable, both notification-suspension guards,Computed,ValueStream,ChangeStreamand
EventStreamare#[must_use]. Dropping one of the guards disposes it at once, so an unused
value was usually a bug. Migration: bind the value (let _subscription = …) for as long as it
should stay active, ordrop(…)it explicitly. - Breaking (implementers only): the public extension traits are not sealed, and this release
adds methods to, or makes generic over the stream error,ReactiveValueStreamExt,
ListStreamExt,CacheStreamExt,ListLifecycleExt,CacheLifecycleExt, the populate and
ValueStream*ChangeSetExtadapters, the limit, expiration and switch traits. Migration: only
an implementation outside the crate (none are expected) must add the new methods and signatures;
callers are unaffected. - Added:
DebugforSignal,ReadSignal,Computed,Command,AsyncCommand,EventBus,
EventStream,ValueStream,Subscription,CompositeSubscription,Disposable,Effect,
DisposeBag,ViewModelActivator,ActivationToken,SourceList,SourceCache,
ObservableList,ObservableCacheandChangeStream. The output reads a snapshot without
blocking on a lock: the value of a signal,Computedor command state, the length and version
of a source (<locked>while another thread, or an edit on this one, holds it), counts of
handles; streams print as opaque. - Added:
CompositeSubscription::add,dispose,len,is_emptyandDefault;
DisposeWithforDisposable,EffectandCompositeSubscription;DisposeBag::clear,len
andis_empty;CloneforEventStream;DefaultforSignal<T: Default>. - Changed:
EventBus::emit(andEventBus: Clone,DeliveryQueue: Clone) no longer require
T: Clone. - Added: rustdoc for every public item (the crate denies
missing_docsin CI) and a
crate-root overview linking the guide; docs.rs builds with all features. - CI: jobs for rustdoc, the MSRV (Rust 1.95), the
#[wasm_bindgen_test]tests on
wasm32-unknown-unknownand macOS.