Convert closure Result to Rx generically?

Question

I have a bunch of functions with Result completion handlers that I’d like to convert to RxSwift.

They follow this convention:

func fetch(id: Int, completion: @escaping (Result<AuthorType, DataError>) -> Void) {...}

I could use the typical:

return Observable<AuthorType>.create { on(.next... }

Is there a more considerate generic way like PromiseKit does:

func fetch() -> Promise<AuthorType> {
return Promise { fetch(completion: $0.resolve) }

}

Anything like this possible in RxSwift?

Answer 1

There isn't a constructor like you are asking for out of the box, but it's easy enough to create:

extension ObservableType {
    static func createFromResultCallback<E: Error>(_ fn: @escaping (@escaping (Result<Element, E>) -> Void) -> ()) -> Observable<Element> {
        return Observable.create { observer in
            fn { result in
                switch result {
                case .success(let value):
                    observer.onNext(value)
                    observer.onCompleted()
                case .failure(let error):
                    observer.onError(error)
                }
            }
            return Disposables.create()
        }
    }
}

For your example, it could be used like:

func fetch(id: Int) -> Observable<AuthorType> {
    return .createFromResultCallback { fetch(id: id, $0) }
}

And if you have a function that only takes a callback like:

func shortFetch(_ completion: @escaping (Result<AuthorType, DataError>) -> Void)

Then you could create an Observable with the above by just doing:

Observable.createFromResultCallback(shortFetch)

Remember there is a major difference in behavior once you wrap the function in an Observable like this. Now it is cold which means it won't execute until after something subscribes to the observable and will execute every time something subscribes. This is unlike a Promise which will execute immediately and only once.