APIKit 3 + RxSwift 3 + ReactiveCocoa 5

APIKit+Rx+RAC.swift

import Foundation
import APIKit
import RxSwift
import ReactiveSwift
import Result

extension Session : RxSwift.ReactiveCompatible {}

extension RxSwift.Reactive where Base: Session {
    
    public func send<T: Request>(request: T) -> Observable<T.Response> {
        return Observable.create { [base = self.base] observer in
            let task = base.send(request) { result in
                switch result {
                case .success(let response):
                    observer.on(.next(response))
                    observer.on(.completed)
                case .failure(let error):
                    observer.onError(error)
                }
            }
            
            return Disposables.create {
                task?.cancel()
            }
        }
    }
}


extension Session : ReactiveSwift.ReactiveExtensionsProvider {}

extension ReactiveSwift.Reactive where Base: Session {
    
    public func send<T: Request>(request: T) -> SignalProducer<T.Response, AnyError> {
        return SignalProducer { [base = self.base] observer, disposable in
            let task = base.send(request) { result in
                switch result {
                case .success(let response):
                    observer.send(value: response)
                    observer.sendCompleted()
                case .failure(let error):
                    observer.send(error: AnyError(error))
                }
            }
            
            disposable += {
                task?.cancel()
            }
        }
    }
    
}

let request = GetRateLimitRequest()
        
Session.shared.rx.send(request: request).subscribe({ event in
    print(event)
}).disposed(by: disposeBag)

Session.shared.reactive.send(request: request).start({ (event) in
    print(event)
})