RxSwift

                AnyObserver
                `

A type-erased ObserverType.

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

Declaration

Swift

public struct AnyObserver<Element> : ObserverType

                Binder
                `

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.

Declaration

Swift

public struct Binder<Value> : ObserverType

                Cancelable
                `

Represents disposable resource with state tracking.

Declaration

Swift

public protocol Cancelable : Disposable

                ConnectableObservableType
                `

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

Declaration

Swift

public protocol ConnectableObservableType : ObservableType

                Disposable
                `

Represents a disposable resource.

Declaration

Swift

public protocol Disposable

                Event
                `

Represents a sequence event.

Sequence grammar: next* (error | completed)

Declaration

Swift

@frozen
public enum Event<Element>

extension Event: CustomDebugStringConvertible

extension Event: EventConvertible

                GroupedObservable
                `

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)

Declaration

Swift

public struct GroupedObservable<Key, Element> : ObservableType

                ImmediateSchedulerType
                `

Represents an object that immediately schedules units of work.

Declaration

Swift

public protocol ImmediateSchedulerType

                Observable
                `

Undocumented

Declaration

Swift

public class Observable<Element> : ObservableType

                ObservableConvertibleType
                `

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

Declaration

Swift

public protocol ObservableConvertibleType

                ObservableType
                `

Represents a push style sequence.

Declaration

Swift

public protocol ObservableType : ObservableConvertibleType

                ObserverType
                `

Supports push-style iteration over an observable sequence.

Declaration

Swift

public protocol ObserverType

                Reactive
                `

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.

Declaration

Swift

@dynamicMemberLookup
public struct Reactive<Base>

                SchedulerType
                `

Represents an object that schedules units of work.

Declaration

Swift

public protocol SchedulerType : ImmediateSchedulerType