enum Event<Element> {
    case next(Element)
    case error(Error)
    case finish
}


protocol PublisherType {
    associatedtype Element
    
    func pub(event: Event<Element>)
}

class Publisher<Element>: PublisherType {
    private let _handler: (Event<Element>) -> Void
    
    init(_ handler: @escaping (Event<Element>) -> Void) {
        _handler = handler
    }
    
    func pub(event: Event<Element>) {
        _handler(event)
    }
}

protocol SubscriberType {
    associatedtype Element
    
    func subscribe<P: PublisherType>(publisher: P) where P.Element == Element
}

class Subscriber<Element>: SubscriberType {
    
    private let _eventGenerator: (Publisher<Element>) -> Void
    
    init(_ eventGenerator: @escaping (Publisher<Element>) -> Void) {
        _eventGenerator = eventGenerator
    }
    
    func subscribe<P: PublisherType>(publisher: P) where P.Element == Element {
        _eventGenerator(publisher as! Publisher<Element>)
    }
}

let subscriber = Subscriber<Int> { publisher in
    publisher.pub(event: .next(1))
    publisher.pub(event: .next(2))
    publisher.pub(event: .next(3))
    
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        publisher.pub(event: .finish)
    }
}

let publisher = Publisher<Int> { (event) in
    switch event {
    case .next(let value):
        print("receive next \(value)")
    case .error(let error):
        print("receive error \(error)")
    case .finish:
        print("receive finish")
    }
}

subscriber.subscribe(publisher: publisher)