RxSwift

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 disposable resource with state tracking.

Represents an observable sequence wrapper that can be connected and disconnected from its underlying observable sequence.

Represents a disposable resource.

Represents a sequence event.

Sequence grammar: next* (error | completed)

Represents an observable sequence of elements that share a common key. GroupedObservable is typically created by the groupBy operator. Each GroupedObservable instance represents a collection of elements that are grouped by a specific key.

Example usage:

let observable = Observable.of("Apple", "Banana", "Apricot", "Blueberry", "Avocado")

let grouped = observable.groupBy { fruit in
    fruit.first! // Grouping by the first letter of each fruit
}

_ = grouped.subscribe { group in
    print("Group: \(group.key)")
    _ = group.subscribe { event in
        print(event)
    }
}

This will print:

Group: A
next(Apple)
next(Apricot)
next(Avocado)
Group: B
next(Banana)
next(Blueberry)

Represents an object that immediately schedules units of work.

Undocumented

Type that can be converted to observable sequence (Observable<Element>).

Represents a push style sequence.

Supports push-style iteration over an observable sequence.

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.

Represents an object that schedules units of work.