Observable.swift

protocol Disposable {
    func dispose()
    func addToDisposablesBag(bag: DisposablesBag)
}

extension Disposable {
    func addToDisposablesBag(bag: DisposablesBag) {
        bag.add(self)
    }
}


class DisposablesBag {
    private var disposables = [Disposable]()
    
    func add(disposable: Disposable) {
        disposables.append(disposable)
    }
    
    func disposeAll() {
        disposables.forEach{$0.dispose()}
    }
}


class Observation<T> {
    typealias Observer = T->Void
    let observer: Observer
    weak var observed: Observable<T>?
    
    init(observer: Observer, observed: Observable<T>) {
        self.observer = observer
        self.observed = observed
    }
}

extension Observation: Disposable {
    func dispose() {
        observed?.unobserve(self)
    }
}


extension Observation:Equatable { }
func ==<T>(lhs: Observation<T>, rhs: Observation<T>) -> Bool {
    return lhs === rhs
}

class Observable<T> {
    var value: T {
        didSet {
            observations.forEach{$0.observer(self.value)}
        }
    }
    private var observations = [Observation<T>]()
    
    init(value: T) {
        self.value = value
    }
    
    func observe(observer: T->Void) -> Observation<T> {
        let observation = Observation(observer: observer, observed: self)
        observations.append(observation)
        return observation
    }
    
    func unobserve(observation: Observation<T>) {
        observations = observations.filter{$0 != observation}
    }
}


let bag = DisposablesBag()
let s = Observable(value: "a string")
s.observe {(s: String) in
    print(s)
}.addToDisposablesBag(bag)

s.value = "another string"
print(s.value)
s.value = "again"
bag.disposeAll()
s.value = "and again"