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

Transforming Observables

Filtering Observables

Combining Observables

Error Handling Operators

Observable Utility Operators

Conditional and Boolean Operators

Mathematical and Aggregate Operators

Connectable Observable Operators

Creating new operators is also pretty straightforward.

RxCocoa extensions

iOS / OSX


extension NSObject {
    public var rx_deallocated: Observable<Void> {}
#if !DISABLE_SWIZZLING
    public var rx_deallocating: Observable<Void> {}
#endif
}

extension NSObject {
    public func rx_observe<Element>(
        type: E.Type,
        _ keyPath: String,
        options: NSKeyValueObservingOptions = .New | .Initial,
        retainSelf: Bool = true
    )  -> Observable<Element?> {}
#if !DISABLE_SWIZZLING
    public func rx_observeWeakly<Element>(
        type: E.Type,
        _ keyPath: String,
        options: NSKeyValueObservingOptions = .New | .Initial
    ) -> Observable<Element?> {}
#endif
}

extension NSURLSession {
    public func rx_response(request: NSURLRequest) -> Observable<(NSData, NSURLResponse)> {}
    public func rx_data(request: NSURLRequest) -> Observable<NSData> {}
    public func rx_JSON(request: NSURLRequest) -> Observable<AnyObject> {}
    public func rx_JSON(URL: NSURL) -> Observable<AnyObject> {}
}

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

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

extension CLLocationManager {
    public var rx_delegate: DelegateProxy {}
    public var rx_didUpdateLocations: Observable<[CLLocation]> {}
    public var rx_didFailWithError: Observable<NSError> {}
    public var rx_didFinishDeferredUpdatesWithError: Observable<NSError> {}
    public var rx_didPauseLocationUpdates: Observable<Void> {}
    public var rx_didResumeLocationUpdates: Observable<Void> {}
    public var rx_didUpdateHeading: Observable<CLHeading> {}
    public var rx_didEnterRegion: Observable<CLRegion> {}
    public var rx_didExitRegion: Observable<CLRegion> {}
    public var rx_didDetermineStateForRegion: Observable<(state: CLRegionState, region: CLRegion)> {}
    public var rx_monitoringDidFailForRegionWithError: Observable<(region: CLRegion?, error: NSError)> {}
    public var rx_didStartMonitoringForRegion: Observable<CLRegion> {}
    public var rx_didRangeBeaconsInRegion: Observable<(beacons: [CLBeacon], region: CLBeaconRegion)> {}
    public var rx_rangingBeaconsDidFailForRegionWithError: Observable<(region: CLBeaconRegion, error: NSError)> {}
    public var rx_didVisit: Observable<CLVisit> {}
    public var rx_didChangeAuthorizationStatus: Observable<CLAuthorizationStatus> {}
}

iOS


extension UIControl {
    public func rx_controlEvent(controlEvents: UIControlEvents) -> ControlEvent<Void> {}
    public var rx_enabled: ObserverOf<Bool> {}
}

extension UIButton {
    public var rx_tap: ControlEvent<Void> {}
}

extension UITextField {
    public var rx_text: ControlProperty<String> {}
}

extension UITextView {
    override func rx_createDelegateProxy() -> RxScrollViewDelegateProxy {}
    public var rx_text: ControlProperty<String> {}
}

extension UISearchBar {
    public var rx_delegate: DelegateProxy {}
    public var rx_searchText: ControlProperty<String> {}
}

extension UILabel {
    public var rx_text: ObserverOf<String> {}
}

extension UIDatePicker {
    public var rx_date: ControlProperty<NSDate> {}
}

extension UIImageView {
    public var rx_image: ObserverOf<UIImage!> {}
    public func rx_imageAnimated(transitionType: String?) -> AnyObserver<UIImage?>
}

extension UIScrollView {
    public var rx_delegate: DelegateProxy {}
    public func rx_setDelegate(delegate: UIScrollViewDelegate) {}
    public var rx_contentOffset: ControlProperty<CGPoint> {}
}

extension UIBarButtonItem {
    public var rx_tap: ControlEvent<Void> {}
}

extension UISlider {
    public var rx_value: ControlProperty<Float> {}
}

extension UITableView {
    public var rx_dataSource: DelegateProxy {}
    public func rx_setDataSource(dataSource: UITableViewDataSource) -> Disposable {}
    public func rx_itemsWithCellFactory(source: O)(cellFactory: (UITableView, Int, S.Generator.Element) -> UITableViewCell) -> Disposable {}
    public func rx_itemsWithCellIdentifier(cellIdentifier: String, cellType: Cell.Type = Cell.self)(source: O)(configureCell: (Int, S.Generator.Element, Cell) -> Void) -> Disposable {}
    public func rx_itemsWithDataSource(dataSource: DataSource)(source: O) -> Disposable {}
    public var rx_itemSelected: ControlEvent<NSIndexPath> {}
    public var rx_itemDeselected: ControlEvent<NSIndexPath> {}
    public var rx_itemInserted: ControlEvent<NSIndexPath> {}
    public var rx_itemDeleted: ControlEvent<NSIndexPath> {}
    public var rx_itemMoved: ControlEvent<ItemMovedEvent> {}
    // This method only works in case one of the `rx_itemsWith*` methods was used, or data source implements `SectionedViewDataSourceType`
    public func rx_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 rx_modelDeselected<T>(modelType: T.Type) -> ControlEvent<T> {}
}

extension UICollectionView {
    public var rx_dataSource: DelegateProxy {}
    public func rx_setDataSource(dataSource: UICollectionViewDataSource) -> Disposable {}
    public func rx_itemsWithCellFactory(source: O)(cellFactory: (UICollectionView, Int, S.Generator.Element) -> UICollectionViewCell) -> Disposable {}
    public func rx_itemsWithCellIdentifier(cellIdentifier: String, cellType: Cell.Type = Cell.self)(source: O)(configureCell: (Int, S.Generator.Element, Cell) -> Void) -> Disposable {}
    public func rx_itemsWithDataSource(dataSource: DataSource)(source: O) -> Disposable {}
    public var rx_itemSelected: ControlEvent<NSIndexPath> {}
    public var rx_itemDeselected: ControlEvent<NSIndexPath> {}
    // This method only works in case one of the `rx_itemsWith*` methods was used, or data source implements `SectionedViewDataSourceType`
    public func rx_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 rx_modelSelected<T>(modelType: T.Type) -> ControlEvent<T> {}
}

extension UIGestureRecognizer {
    public var rx_event: ControlEvent<UIGestureRecognizer> {}
}

extension UIImagePickerController {
    public var rx_didFinishPickingMediaWithInfo: Observable<[String : AnyObject]> {}
    public var rx_didCancel: Observable<()> {}
}

extension UISegmentedControl {
    public var rx_value: ControlProperty<Int> {}
}

extension UISwitch {
    public var rx_value: ControlProperty<Bool> {}
}

extension UIActivityIndicatorView {
    public var rx_animating: AnyObserver<Bool> {}
}

extension UINavigationItem {
    public var rx_title: AnyObserver<String?> {}
}

OSX

extension NSControl {
    public var rx_controlEvent: ControlEvent<()> {}
    public var rx_enabled: AnyObserver<Bool> {}
}


extension NSSlider {
    public var rx_value: ControlProperty<Double> {}
}

extension NSButton {
    public var rx_tap: ControlEvent<Void> {}
    public var rx_state: ControlProperty<Int> {}
}

extension NSImageView {
    public var rx_image: ObserverOf<NSImage?> {}
    public func rx_imageAnimated(transitionType: String?) -> AnyObserver<NSImage?>
}

extension NSTextField {
    public var rx_delegate: DelegateProxy {}
    public var rx_text: ControlProperty<String> {}
}

extension UITabBarItem {
    public var rx_badgeValue: AnyObserver<String?> {}
}