如何在没有在 Swift 中使用引用类型的情况下将 @escaping 用于在 didSet 中使用的函数？

Question

This down code works just fine! As soon as I update testFunc, with '@escaping', it start make error about

Escaping closure captures mutating 'self' parameter

struct TestType {

    var string: String {
        didSet(oldValue) {
            if (oldValue != string) {
  
                testFunc(string: string, result: { resultValue in
                    value = resultValue
                })
            }
        }
    }
    
   private(set) var value: String
 
}


func testFunc(string: String, result: (String) -> Void) {
    result(string + " updated!")
}

my goal is to be able use:

func testFunc(string: String, result: @escaping (String) -> Void) {
    result(string + " updated!")
}

How can I solve the issue without using a reference type?

Answer 1

The problem with capturing mutating self in an @escaping closure in a struct is there are really only two choices in how Swift might theoretically attempt to do it.

The first is to capture a reference to the struct , but in many cases it lives on the stack. Since the @escaping closure could be called later, that means writing to the position on the stack where self was , but likely isn't there anymore. If that happens when the stack has shrunk, then you're writing to an address that is effectively unreachable by any other code. If it happens when the stack has grown back (or larger), then you're likely stomping on unrelated data, possibly some function's return address. If you're lucky the result will be that the program crashes. If you're unlucky, it will silently do the wrong thing.

Another possible implementation is that Swift could capture a copy, which of course, could be safely written to, but would be inaccessible to any other code. That's pretty pointless.

There is a third option Swift could do, which is it could box the struct (that is actually place it on the heap). The problem is that nothing else would know about the heap location. Again that's pretty pointless... and much much slower than allocating things on the stack.

If you really need to capture a mutating self , then you need TestType to be a class , but that means the rest of your code has to be written with reference semantics in mind.

Very likely, you need to think about whatever problem you're trying to solve in a different way. Without knowing what that is, concrete solutions are impossible to suggest.