ReactiveUI.Primitives.Advanced namespace¶

Part of the ReactiveUI.Primitives.Core package.

Type	Kind	Summary
AggregateWitness	class	Single-source sink that folds every observed value through an immutable value-type `TAggregator` and emits the aggregate result once the source completes. The accumulator is advanced functionally through a constrained (devirtualized, allocation-free) call, so each concrete aggregate operator shares this one implementation without a base class or per-value indirection.
AllPredicateWitness	class	Observer for detecting whether all values match a predicate.
AnyPredicateWitness	class	Observer for detecting whether any value matches a predicate.
AnyWitness	class	Observer for detecting whether any value is present.
AppendDelegateWitness	class	Delegate-backed observer for fused prepend/append inline subscriptions.
AppendWitness	class	Observer for append.
AsyncEnumerableSignal	class	Async-enumerable observable adapter.
BufferWitness	class	Sink that batches source values into fixed-size windows.
CallbackWitness	class	Observer that forwards notifications to delegates.
CollectArrayWitness	class	Sink that buffers values and emits them as an array on completion.
CollectListWitness	class	Sink that buffers values and emits them as a list on completion.
ContainsWitness	class	Observer for detecting whether a value is contained in a sequence.
CopyOnWriteList	class	Immutable array-backed list optimized for copy-on-write observer storage.
CountAggregator	struct	Immutable accumulator that counts every observed value as an Int32.
CountPredicateAggregator	struct	Immutable accumulator that counts the values matching a predicate as an Int32.
DefaultIfEmptyWitness	class	Observer for default-if-empty.
DisposedMarker	class	Disposable marker for disposed sinks.
DisposedWitness	class	Observer that rejects every notification because the subscription has already been disposed.
DistinctByCountAggregator	struct	Immutable accumulator that counts distinct selected keys as an Int32.
DistinctByLongCountAggregator	struct	Immutable accumulator that counts distinct selected keys as a Int64.
DistinctByWitness	class	Observer for distinct-by.
DistinctWitness	class	Sink that forwards the first occurrence of each value.
EmptyWitness	class	Delegate-backed observer that defaults missing handlers to no-op behavior.
FoldWitness	class	Sink that emits a running accumulation for every source value.
ForwardingWitness	class	Observer that forwards notifications to a standard observer.
FromEnumerableSignal	class	Represents a finite signal backed by an enumerable sequence.
IAggregator	interface	An immutable value-type accumulator for a single-source aggregate sink: each [Add](# folds a value into the running state and returns the next accumulator, while [Result](# yields the terminal value. Implemented as a `readonly record struct` so [AggregateWitness](# can advance it through a constrained, devirtualized, allocation-free call rather than an interface or delegate dispatch.
IAsyncEnumerableBackedSignal	interface	Observable adapter backed by an async enumerable.
IInlineSignal	interface	Represents the IInlineSignal interface.
IRequireCurrentThread	interface	Marks a sequencer that must run on the current thread.
IgnoreValuesWitness	class	Sink that drops values and forwards only terminal notifications.
ImmediateReturnSignal	class	Represents the ImmediateReturnSignal class.
ImmediateThrowSignal	class	Represents the immediate Throw signal fast path.
ImmutableEmptySignal	class	Represents the ImmutableEmptySignal class.
ImmutableNeverSignal	class	Represents the ImmutableNeverSignal class.
ImmutableReturnFalseSignal	class	Represents the ImmutableReturnFalseSignal class.
ImmutableReturnInt32Signal	class	Represents the ImmutableReturnInt32Signal class.
ImmutableReturnTrueSignal	class	Represents the ImmutableReturnTrueSignal class.
KeepNotNullWitness	class	Sink that forwards only non-null values.
KeepTypeWitness	class	Sink that forwards only values assignable to `TResult`.
ListWitness	class	Observer that forwards notifications to an immutable observer list.
LongCountAggregator	struct	Immutable accumulator that counts every observed value as a Int64.
LongCountPredicateAggregator	struct	Immutable accumulator that counts the values matching a predicate as a Int64.
RangeConcatSignal	class	Concatenates synchronous integer ranges without outer observable/coordinator overhead.
RangeSignal	class	Represents the RangeSignal class.
RangeZipSignal	class	Zips two synchronous integer ranges without coordinator queues.
ReduceWitness	class	Sink that emits the final accumulation once the source completes.
RepeatSignal	class	Represents the RepeatSignal class.
SinkSubscription	class	Shared single-upstream-subscription management for sink observers. Operating on a caller-owned IDisposable field through a `ref` parameter lets each sink implement IObserver directly — with no shared base class, and therefore no virtual-dispatch overhead on the hot notification path — while still sharing the assign-once / dispose-once teardown.
SinkTerminal	class	Shared terminal-forwarding helpers for single-source sink observers. Each sink computes a single result and forwards it downstream exactly once, disposing itself afterwards. Centralizing the forward-then-dispose `using` scope — and the `done` latch that guards it — keeps the individual sinks to their distinguishing accumulation logic and removes the otherwise-identical terminal boilerplate.
SkipWhileWitness	class	Sink that drops leading values while the predicate holds, then mirrors the source.
SkipWitness	class	Sink that drops the first `count` values, then forwards the rest.
StatefulWitness	class	Observer that forwards notifications to stateful delegates.
SubscriptionSlots	class	Helpers for the interlocked single-assignment subscription slots shared by the catch-style sinks (`RecoverSignal`, `ResumeSignal`): a slot holds at most one live subscription and, once the sink is disposed, swaps to a sentinel so a late assignment is disposed instead of stored.
SynchronizeWitness	class	Observer that serializes notifications behind a gate so downstream operators always observe the single-threaded `OnNext*` then `OnError`\	`OnCompleted` grammar they depend on, even when the upstream source delivers concurrently. Stateful sinks (counting, distinct, buffering) rely on that grammar; placing one of these ahead of them is the supported way to consume a non-conformant source.
TakeWhileWitness	class	Sink that forwards values while the predicate holds, then completes and unsubscribes.
TakeWitness	class	Observer used by Take to dispose the upstream subscription as soon as the requested count is reached.
TapWitness	class	Sink that runs side-effects before forwarding each notification.
ThrowWitness	class	Observer that ignores values and completion and rethrows errors.
UnfoldSignal	class	Finite state expansion signal.
UniqueByWitness	class	Sink that suppresses adjacent values whose projected key matches the previous one.
UniqueWitness	class	Sink that suppresses adjacent duplicate values.
UseSignal	class	Resource-scoped signal.
Witness	class	Factory methods for allocation-conscious observers in the ReactiveUI.Primitives vocabulary.
WitnessTeardown	class	Shared run-once teardown for witness sinks.