API.md

API

RxSwift supported operators

In some cases there are multiple aliases for the same operator, because on different platforms / implementations, the same operation is sometimes named differently. Sometimes this is because of historical reasons, while sometimes because of reserved language keywords.

When lacking a strong community consensus, RxSwift will usually include multiple aliases.

Operators are stateless by default.

Creating Observables

• asObservable
• create
• deferred
• empty
• error
• toObservable (array)
• interval
• never
• just
• of
• range
• repeatElement
• timer

Transforming Observables

• buffer
• flatMap
• flatMapFirst
• flatMapLatest
• map
• scan
• window

Filtering Observables

• debounce / throttle
• distinctUntilChanged
• elementAt
• filter
• sample
• skip
• take
• takeLast
• single

Combining Observables

• merge
• startWith
• switchLatest
• combineLatest
• zip

Error Handling Operators

• catch
• retry
• retryWhen

Observable Utility Operators

• delaySubscription / delay
• do / doOnNext
• observeOn / observeSingleOn
• subscribe
• subscribeOn
• timeout
• using
• debug

Conditional and Boolean Operators

• amb
• skipWhile
• skipUntil
• takeUntil
• takeWhile

Mathematical and Aggregate Operators

• concat
• reduce / aggregate
• toArray

Connectable Observable Operators

• multicast
• publish
• refCount
• replay
• shareReplay

Creating new operators is also pretty straightforward.

RxCocoa extensions

iOS / macOS

extension Reactive where Base: NSObject {

    public var deallocated: Observable<Void> {}

#if !DISABLE_SWIZZLING

    public var deallocating: Observable<Void> {}

#endif

}

extension Reactive where Base: NSObject {

    public func observe<Element>(
        type: E.Type,
        _ keyPath: String,
        options: NSKeyValueObservingOptions = .New | .Initial,
        retainSelf: Bool = true
    )  -> Observable<Element?> {}

#if !DISABLE_SWIZZLING

    public func observeWeakly<Element>(
        type: E.Type,
        _ keyPath: String,
        options: NSKeyValueObservingOptions = .New | .Initial
    ) -> Observable<Element?> {}

#endif
}

extension Reactive where Base: NSURLSession {

    public func response(request: NSURLRequest) -> Observable<(NSData, NSURLResponse)> {}

    public func data(request: NSURLRequest) -> Observable<NSData> {}

    public func JSON(request: NSURLRequest) -> Observable<AnyObject> {}

    public func JSON(URL: NSURL) -> Observable<AnyObject> {}

}

extension Reactive where Base: NSNotificationCenter {

    public func notification(name: String, object: AnyObject?) -> Observable<NSNotification> {}

}

class DelegateProxy {

    public func observe(selector: Selector) -> Observable<[AnyObject]> {}

}

extension Reactive where Base: CLLocationManager {

    public var delegate: DelegateProxy {}

    public var didUpdateLocations: Observable<[CLLocation]> {}

    public var didFailWithError: Observable<NSError> {}

    public var didFinishDeferredUpdatesWithError: Observable<NSError> {}

    public var didPauseLocationUpdates: Observable<Void> {}

    public var didResumeLocationUpdates: Observable<Void> {}

    public var didUpdateHeading: Observable<CLHeading> {}

    public var didEnterRegion: Observable<CLRegion> {}

    public var didExitRegion: Observable<CLRegion> {}

    public var didDetermineStateForRegion: Observable<(state: CLRegionState, region: CLRegion)> {}

    public var monitoringDidFailForRegionWithError: Observable<(region: CLRegion?, error: NSError)> {}

    public var didStartMonitoringForRegion: Observable<CLRegion> {}

    public var didRangeBeaconsInRegion: Observable<(beacons: [CLBeacon], region: CLBeaconRegion)> {}

    public var rangingBeaconsDidFailForRegionWithError: Observable<(region: CLBeaconRegion, error: NSError)> {}

    public var didVisit: Observable<CLVisit> {}

    public var didChangeAuthorizationStatus: Observable<CLAuthorizationStatus> {}

}

iOS

extension Reactive where Base: UIControl {

    public func controlEvent(controlEvents: UIControlEvents) -> ControlEvent<Void> {}

    public var enabled: ObserverOf<Bool> {}
}

extension Reactive where Base: UIButton {

    public var tap: ControlEvent<Void> {}

}

extension Reactive where Base: UITextField {

    public var text: ControlProperty<String> {}

}

extension Reactive where Base: UITextView {

    override func createDelegateProxy() -> RxScrollViewDelegateProxy {}

    public var text: ControlProperty<String> {}

}

extension Reactive where Base: UISearchBar {

    public var delegate: DelegateProxy {}

    public var searchText: ControlProperty<String> {}

}

extension Reactive where Base: UILabel {

    public var text: ObserverOf<String> {}

}

extension Reactive where Base: UIDatePicker {

    public var date: ControlProperty<Date> {}

}

extension Reactive where Base: UIImageView {

    public var image: ObserverOf<UIImage!> {}

    public func imageAnimated(transitionType: String?) -> AnyObserver<UIImage?>

}

extension Reactive where Base: UIScrollView {

    public var delegate: DelegateProxy {}

    public func setDelegate(delegate: UIScrollViewDelegate) {}

    public var contentOffset: ControlProperty<CGPoint> {}

}

extension Reactive where Base: UIBarButtonItem {

    public var tap: ControlEvent<Void> {}

}

extension Reactive where Base: UISlider {

    public var value: ControlProperty<Float> {}

}

extension Reactive where Base: UITableView {

    public var dataSource: DelegateProxy {}

    public func setDataSource(dataSource: UITableViewDataSource) -> Disposable {}

    public func itemsWithCellFactory(source: O)(cellFactory: (UITableView, Int, S.Iterator.Element) -> UITableViewCell) -> Disposable {}

    public func itemsWithCellIdentifier(cellIdentifier: String, cellType: Cell.Type = Cell.self)(source: O)(configureCell: (Int, S.Iterator.Element, Cell) -> Void) -> Disposable {}

    public func itemsWithDataSource(dataSource: DataSource)(source: O) -> Disposable {}

    public var itemSelected: ControlEvent<IndexPath> {}

    public var itemDeselected: ControlEvent<IndexPath> {}

    public var itemInserted: ControlEvent<IndexPath> {}

    public var itemDeleted: ControlEvent<IndexPath> {}

    public var itemMoved: ControlEvent<ItemMovedEvent> {}

    // This method only works in case one of the `rx.itemsWith*` methods was used, or data source implements `SectionedViewDataSourceType`
    public func modelSelected<T>(modelType: T.Type) -> ControlEvent<T> {}

    // This method only works in case one of the `rx.itemsWith*` methods was used, or data source implements `SectionedViewDataSourceType`
    public func modelDeselected<T>(modelType: T.Type) -> ControlEvent<T> {}

}

extension Reactive where Base: UICollectionView {

    public var dataSource: DelegateProxy {}

    public func setDataSource(dataSource: UICollectionViewDataSource) -> Disposable {}

    public func itemsWithCellFactory(source: O)(cellFactory: (UICollectionView, Int, S.Iterator.Element) -> UICollectionViewCell) -> Disposable {}

    public func itemsWithCellIdentifier(cellIdentifier: String, cellType: Cell.Type = Cell.self)(source: O)(configureCell: (Int, S.Iterator.Element, Cell) -> Void) -> Disposable {}

    public func itemsWithDataSource(dataSource: DataSource)(source: O) -> Disposable {}

    public var itemSelected: ControlEvent<IndexPath> {}

    public var itemDeselected: ControlEvent<IndexPath> {}

    // This method only works in case one of the `rx.itemsWith*` methods was used, or data source implements `SectionedViewDataSourceType`
    public func modelSelected<T>(modelType: T.Type) -> ControlEvent<T> {}

    // This method only works in case one of the `rx.itemsWith*` methods was used, or data source implements `SectionedViewDataSourceType`
    public func modelSelected<T>(modelType: T.Type) -> ControlEvent<T> {}
}

extension Reactive where Base: UIGestureRecognizer {

    public var event: ControlEvent<UIGestureRecognizer> {}

}

extension Reactive where Base: UIImagePickerController {

    public var didFinishPickingMediaWithInfo: Observable<[String : AnyObject]> {}

    public var didCancel: Observable<()> {}

}

extension Reactive where Base: UISegmentedControl {

    public var value: ControlProperty<Int> {}

}

extension Reactive where Base: UISwitch {

    public var value: ControlProperty<Bool> {}

}

extension Reactive where Base: UIActivityIndicatorView {

    public var animating: AnyObserver<Bool> {}

}

extension Reactive where Base: UINavigationItem {

    public var title: AnyObserver<String?> {}
}

OSX

extension Reactive where Base: NSControl {

    public var controlEvent: ControlEvent<()> {}

    public var enabled: AnyObserver<Bool> {}

}

extension Reactive where Base: NSSlider {

    public var value: ControlProperty<Double> {}

}

extension Reactive where Base: NSButton {

    public var tap: ControlEvent<Void> {}

    public var state: ControlProperty<Int> {}

}

extension Reactive where Base: NSImageView {

    public var image: ObserverOf<NSImage?> {}

    public func imageAnimated(transitionType: String?) -> AnyObserver<NSImage?>
}

extension Reactive where Base: NSTextField {

    public var delegate: DelegateProxy {}

    public var text: ControlProperty<String> {}

}

extension Reactive where Base: UITabBarItem {

    public var badgeValue: AnyObserver<String?> {}

}

extension Reactive where Base: UITabBar {

    public var didSelectItem: ControlEvent<UITabBarItem> {}

    public var willBeginCustomizing: ControlEvent<[UITabBarItem]> {}

    public var didBeginCustomizing: ControlEvent<[UITabBarItem]> {}

    public var willEndCustomizing: ControlEvent<(items: [UITabBarItem], changed: Bool)> {}

    public var didEndCustomizing: ControlEvent<(items: [UITabBarItem], changed: Bool)> {}

}