rx.swift

enum Event<T> {
    case next(T)
    case error(Error)
    case completed
}

final class AnyObservable<T> {
    let handler: (@escaping (Event<T>) -> Void) -> Void

    init(handler: @escaping (@escaping (Event<T>) -> Void) -> Void) {
        self.handler = handler
    }

    func subscribe(observer: @escaping (Event<T>) -> Void) {
        handler(observer)
    }

    func map<U>(_ transform: @escaping (T) -> U) -> AnyObservable<U> {
        return AnyObservable<U> { observer in
            self.subscribe { event in
                switch event {
                case .next(let value):
                    observer(.next(transform(value)))
                case .error(let error):
                    observer(.error(error))
                case .completed:
                    observer(.completed)
                }
            }
        }
    }
}

let obs = AnyObservable<String> { observer in
    observer(.next("Hello"))
    observer(.next("World"))
    observer(.completed)
}

obs.subscribe { event in
    switch event {
    case .next(let value):
        print(".next: \(value)")
    case .error(let error):
        print(".error: \(error)")
    case .completed:
        print(".completed")
    }
}

obs.map({ str in
    return str.characters.count
}).subscribe { event in
    switch event {
    case .next(let value):
        print(".next: \(value)")
    case .error(let error):
        print(".error: \(error)")
    case .completed:
        print(".completed")
    }
}

// .next: Hello
// .next: World
// .completed
// .next: 5
// .next: 5
// .completed