Simple stupid internally type-erasing reactive NotificationCenter addition to handle observables through misconnected parts of application

EventDispatcher.swift

import RxSwift

protocol Dispatchable {}

protocol DispatchableElement {}

extension PublishSubject: Dispatchable where E: DispatchableElement {}

final class EventDispatcher {
    
    static let shared = EventDispatcher()
    
    private let disposeBag = DisposeBag()
    
    private var subjects = [String: Dispatchable]()
    
    private func typeDescriptor<T>(_ type: T.Type) -> String {
        return String(describing: type)
    }
    
    func update<O: ObservableType>(_ sequence: O) where O.E: DispatchableElement {
        let descriptor = typeDescriptor(O.E.self)
        if let subject = subjects[descriptor] as? PublishSubject<O.E> {
            sequence.subscribe(subject).disposed(by: disposeBag)
        } else {
            let subject = PublishSubject<O.E>()
            sequence.subscribe(subject).disposed(by: disposeBag)
            subjects[descriptor] = subject
        }
    }
    
    func onNext<E: DispatchableElement>(_ value: E) {
        if let subject = subjects[typeDescriptor(E.self)] as? PublishSubject<E> {
            subject.onNext(value)
        }
    }
    
    func events<E: DispatchableElement>(_ type: E.Type) -> Observable<E> {
        let descriptor = typeDescriptor(type)
        let subject = subjects[descriptor] as? PublishSubject<E> ?? PublishSubject<E>()
        subjects[descriptor] = subject
        return subject
    }
}

struct Dog: DispatchableElement {
    let name: String
}
_ = EventDispatcher.shared.events(Dog.self).subscribe { print($0.name) }
EventDispatcher.shared.update(Observable.from([Dog(name: "Ball"), Dog(name: "Cat")])
EventDispatcher.shared.onNext(Dog(name: "Dog"))
// "Ball"
// "Cat"
// "Dog"