TypeErasedEventDispatcher.swift

protocol Event {}

protocol ErasedListener {
    func dispatchIfMatches(event: Event)
}

struct Listener<T: Event>: ErasedListener {
    let dispatch: T -> Void
    func dispatchIfMatches(event: Event) {
        (event as? T).flatMap(dispatch)
    }
}

protocol Dispatcher {
    var events: [Event] {get set}
    var listeners: [ErasedListener] {get set}

    mutating func listen<E: Event>(listener: E -> Void)
    func fire(event: Event)
    mutating func push<E: Event>(event: E)
    func flush()
}

extension Dispatcher {
    mutating func listen<E: Event>(listener: E -> Void) {
        let concreteListener = Listener(dispatch: listener)

        self.listeners.append(concreteListener as ErasedListener)
    }

    func fire(event: Event) {
        for listener in self.listeners {
            listener.dispatchIfMatches(event)
        }
    }

    mutating func push<E: Event>(event: E) {
        self.events.append(event)
    }

    func flush() {
        for event in events {
            self.fire(event)
        }
    }
}

struct MyDispatcher: Dispatcher {
    var listeners = [ErasedListener]()
    var events = [Event]()
}

struct Event1: Event {
    let someInfo1: String
}

struct Event2: Event {
    let someInfo2: String
}

var dispatcher = MyDispatcher()

dispatcher.listen { (event: Event1) in
    print("event 1: \(event.someInfo1)")
}
dispatcher.listen { (event: Event2) in
    print("event 2: \(event.someInfo2)")
}

dispatcher.fire(Event1(someInfo1: "eventing 1"))
dispatcher.fire(Event2(someInfo2: "eventing 2"))


let events1 = ["one","two","three"].map(Event1.init)
let events2 = ["a", "b", "c"].map(Event2.init)

events1.forEach { dispatcher.push($0) }
events2.forEach { dispatcher.push($0) }

print("STUFF SHOULD GO AFTER THIS")

dispatcher.flush()

// Output:
//
//event 1: eventing 1
//event 2: eventing 2
//STUFF SHOULD GO AFTER THIS
//event 1: one
//event 1: two
//event 1: three
//event 2: a
//event 2: b
//event 2: c