CombineToRxSwift.swift

typealias ObservableType = Publisher

typealias ObserverType = Subscriber

typealias Observable<Element> = AnyPublisher<Element, Error>

typealias Observer<Element, Failure: Error> = AnySubscriber<Element, Failure>

extension ObservableType {
    
    func subscribe<Observer: ObserverType>(_ observer: Observer) where
        Observer.Input == Output, Observer.Failure == Failure {
            receive(subscriber: observer)
    }
    
    func subscribe(
        onNext: @escaping (Output) -> Void,
        onError: ((Failure) -> Void)? = nil,
        onCompleted: (() -> Void)? = nil) {
        let observer = Observer<Output, Failure>(receiveSubscription: { subscription in
            debugPrint("sssss")
        }, receiveValue: { output -> Subscribers.Demand in
            onNext(output)
            return .none
        }) { completion in
            switch completion {
            case .finished:
                onCompleted?()
            case .failure(let error):
                onError?(error)
            }
        }
        
        subscribe(observer)
    }
}

enum Event<Element, Failure: Error> {
    case next(Element)
    case error(Failure)
    case completed
}

extension ObserverType {
    
    func on(_ event: Event<Input, Failure>) {
        switch event {
        case .next(let element):
            _ = receive(element)
        case .error(let error):
            receive(completion: .failure(error))
        case .completed:
            receive(completion: .finished)
        }
    }
}