Observer Pattern in Swift - Or at least my custom implementation

main.swift

class Person {
    var name = Observable("John")
}

var person: Person? = Person()
var subscription: Subscription<String>? = person?.name.subscribe() { (oldValue, newValue) in
    print("name changed: \(oldValue) to \(newValue)")
}

person?.name.value = "Jane"

person?.name.unsubscribe(subscription!)
subscription = nil
person = nil

Observable.swift

struct Observable<T> {
    typealias ChangeHandler = (_ oldValue: T, _ newValue: T) -> Void
    
    var value: T {
        didSet {
            notifySubscribers(oldValue: oldValue, newValue: value)
        }
    }
    
    internal init(_ value: T) {
        self.value = value
    }
    
    private var subscriptions = [Subscription<T>]()
    
    internal mutating func subscribe(changeHandler: @escaping ChangeHandler) -> Subscription<T> {
        let subscription = Subscription(changeHandler: changeHandler)
        self.subscriptions.append(subscription)
        return subscription
    }
    
    internal mutating func unsubscribe(_ subscription: Subscription<T>) {
        self.subscriptions = self.subscriptions.filter { $0 !== subscription }
    }
    
    private func notifySubscribers(oldValue: T, newValue: T) {
        for subscription in subscriptions {
            subscription.changeHandler(oldValue, newValue)
        }
    }
}

Subscription.swift

class Subscription<T> {
    typealias ChangeHandler = (_ oldValue: T, _ newValue: T) -> Void
    
    let changeHandler: ChangeHandler
    
    init(changeHandler: @escaping ChangeHandler) {
        self.changeHandler = changeHandler
    }
}