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 called differently. Sometimes this is because historical reasons, 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
• defer
• empty
• failWith
• from (array)
• interval
• never
• returnElement / just
• returnElements
• 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
• 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 / 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>(
        keyPath: String,
        options: NSKeyValueObservingOptions = .New | .Initial,
        retainSelf: Bool = true
    )  -> Observable<Element?> {}

#if !DISABLE_SWIZZLING

    public func rx_observeWeakly<Element>(
        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_controlEvents(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(animated: Bool) -> ObserverOf<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)(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_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.
    public func rx_modelSelected<T>() -> 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)(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> {}

    // This method only works in case one of the `rx_itemsWith*` methods was used.
    public func rx_modelSelected<T>() -> ControlEvent<T> {}
}

extension UIGestureRecognizer {

    public var rx_event: ControlEvent<UIGestureRecognizer> {}

}

extension UIActionSheet {

    public var rx_delegate: DelegateProxy {}

    public var rx_clickedButtonAtIndex: ControlEvent<Int> {}

    public var rx_willDismissWithButtonIndex: ControlEvent<Int> {}

    public var rx_didDismissWithButtonIndex: ControlEvent<Int> {}

}

extension UIAlertView {

    public var rx_delegate: DelegateProxy {}

    public var rx_clickedButtonAtIndex: ControlEvent<Int> {}

    public var rx_willDismissWithButtonIndex: ControlEvent<Int> {}

    public var rx_didDismissWithButtonIndex: ControlEvent<Int> {}

}

extension UISegmentedControl {

    public var rx_value: ControlProperty<Int> {}

}

extension UISwitch {

    public var rx_value: ControlProperty<Bool> {}

}

extension UIActivityIndicatorView {

    public var rx_animating: AnyObserver<Bool> {}

}

OSX

extension NSControl {

    public var rx_controlEvents: ControlEvent<()> {}

}

extension NSSlider {

    public var rx_value: ControlProperty<Double> {}

}

extension NSButton {

    public var rx_tap: ControlEvent<Void> {}

}

extension NSImageView {

    public var rx_image: ObserverOf<NSImage!> {}

    public func rx_imageAnimated(animated: Bool) -> ObserverOf<NSImage!> {}
}

extension NSTextField {

    public var rx_delegate: DelegateProxy {}

    public var rx_text: ControlProperty<String> {}

}