Structures

A collection of utility methods for common disposable operations.

A type-erased ObserverType.

Forwards operations to an arbitrary underlying observer with the same Element type, hiding the specifics of the underlying observer type.

Observer that enforces interface binding rules:

• can’t bind errors (in debug builds binding of errors causes fatalError in release builds errors are being logged)
• ensures binding is performed on a specific scheduler

Binder doesn’t retain target and in case target is released, element isn’t bound.

By default it binds elements on main scheduler.

Represents an observable sequence of elements that have a common key.

Converts historical virtual time into real time.

Since historical virtual time is also measured in Date, this converter is identity function.

Infallible is an Observable-like push-style interface which is guaranteed to not emit error events.

Unlike SharedSequence, it does not share its resources or replay its events, but acts as a standard Observable.

Resource utilization information

Observable sequences containing 0 or 1 element.

Use Reactive proxy as customization point for constrained protocol extensions.

General pattern would be:

// 1. Extend Reactive protocol with constrain on Base // Read as: Reactive Extension where Base is a SomeType extension Reactive where Base: SomeType { // 2. Put any specific reactive extension for SomeType here }

With this approach we can have more specialized methods and properties using Base and not just specialized on common base type.

Binders are also automatically synthesized using @dynamicMemberLookup for writable reference properties of the reactive base.