This property wrapper guarantees that a closure does nothing if its enclosing object is deinitialized.

EscapingClosurePropertyWrapper.swift

@propertyWrapper
struct Escaping {
    typealias Closure = () -> Void
    var store: Closure

    var wrappedValue: Closure {
        get { self.store }
        set { self.store = newValue }
    }

    init(wrappedValue: @escaping Closure) {
        self.store = wrappedValue
    }

    static subscript<EnclosingSelf: AnyObject, FinalValue>(
           _enclosingInstance observed: EnclosingSelf,
           wrapped wrappedKeyPath: ReferenceWritableKeyPath<EnclosingSelf, FinalValue>,
           storage storageKeyPath: ReferenceWritableKeyPath<EnclosingSelf, Self>
       ) -> Closure
    {
        get {
            { [weak observed] in
                guard let this = observed else {
                    return
                }

                this[keyPath: storageKeyPath].store()
            }
        }
        set {
            observed[keyPath: storageKeyPath].store = newValue
        }
    }
}

main.swift

class Thing {
    @Escaping
    var method = {
        print(42)
    }
}


var f: () -> Void = {}

do {
    let t = Thing()
    f = t.method
    f() // prints 42
}

f() // does not print 42