protocol Disposable {
    func dispose()
}

final class AnonymouseDisposable: Disposable {
    
    private let _disposeHandler: () -> Void
    
    init(_ disposeHandler: @escaping () -> Void) {
        _disposeHandler = disposeHandler
    }
    
    func dispose() {
        _disposeHandler()
    }
}

class CompositeDisposable: Disposable {
    
    private(set) var isDisposed: Bool = false
    
    private var disposables: [Disposable] = []
    
    init() {}
    
    func add(disposable: Disposable) {
        if isDisposed {
            disposable.dispose()
            return
        }
        disposables.append(disposable)
    }
    
    func dispose() {
        guard !isDisposed else { return }
        disposables.forEach { disposable in
            disposable.dispose()
        }
        isDisposed = true
    }
}

let subscriber = Subscriber<Int> { publisher -> Disposable 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)
    }
    return AnonymouseDisposable {
        print("AnonymouseDisposable")
    }
}

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")
    }
}

let dispoable = subscriber.subscribe(publisher: publisher)
DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
    dispoable.dispose()
}