Swift 是否将关闭结果转换为Rx？

我有一系列带有结果完成处理程序的函数，我想将它们转换为RxSwift

它们遵循这一公约：

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

func fetch（id:Int，completion:@escaping）（结果：

func fetch（）->Promise{
返回承诺{fetch（完成：$0.resolve）}

}

RxSwift中可能存在类似的任何内容？
没有您要求的现成构造函数，但创建以下内容非常简单：

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()
        }
    }
}

记住一旦你将函数包装成这样一个可观察对象，行为会有很大的不同。现在它是冷的，这意味着它在某个对象订阅该可观察对象之后才会执行，并且每次订阅某个对象时都会执行。这不同于承诺会立即执行并且只执行一次

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

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()
        }
    }
}

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

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

Observable.createFromResultCallback(shortFetch)