The CombineRx library contains a series of functions that help with the interoperability between RxSwift and Apple's Combine frameworks.
In order to convert Combine Publishers to RxSwift Observables, you can make use of the asObservable() function. This can be done as follows:
import Combine
import RxSwift
import CombineRx
let myBridgedObservable = Just(0).asObservable()In order to convert RxSwift Observables to Combine Publishers, you can make use of the
asPublisher(withBufferSize:andBridgeBufferingStrategy:) function. This can be done as follows:
import Combine
import RxSwift
import CombineRx
let myBridgedPublisher1 = Observable.just(0).asPublisher(withBufferSize: 1, andBridgeBufferingStrategy: .error)
let myBridgedPublisher2 = Observable.from([0, 1, 2, 3]).asPublisher(withBufferSize: 4, andBridgeBufferingStrategy: .error)One difference between RxSwift and Combine is that Combine adheres to the mechanism of backpressure in order to ensure that Publishers only produce as many elements that Subscribers have requested. This prevents the case where elements might build up in a Publishers buffer faster than they can be processed downstream by a subscriber as this could lead to out-of-memory errors and degradation in performance due to high system resource consumption. Combine applies this backpressure upstream through a contractual obligation by Publishers to only emit an element when it is requested by Subscribers through Subscribers.Demand requests.
RxSwift Observables differ in this regard as they rely on a source with an unbounded rate of production and therefore when bridging to a Combine Publisher, we must maintain a buffer or drop elements accordingly in order to satisfy the requirements of downstream subscribers.
This is the reason for the required withBufferSize and andBridgeBufferingStrategy parameters for asPublisher(withBufferSize:andBridgeBufferingStrategy:). withBufferSize is where the buffer size should manually be set (ideally based directly on the number of expected elements in the sequence). andBridgeBufferingStrategy is the strategy to employ when the maximum buffer capacity is reached. Keeping in line with native Combine strategies, this can either be error, where any buffer overflow is treated as an error, dropNewest where the elements already present in the buffer are maintained and any new elements are ignored, or finally dropOldest where new elements are added to the buffer and replace older elements that were already present.
Additional information on Combine's use of backpressure can be found here.
It is currently possible to install this library using Swift Package Manager. In order to do so, please add the current repository as a package dependency using Xcode or include the following in your Package.swift file:
import PackageDescription
let package = Package(
...
dependencies: [
.package(url: "https://github.com/Jackstone92/CombineRx", .upToNextMajor(from: "0.1.0")),
],
...
targets: [
.target(name: "MyTarget", dependencies: ["CombineRx"]),
]
)Copyright 2020 © Jack Stone
CombineRx is made available under the MIT License