Mastering Escaping Closure Captures and Mutating Self Parameter in Struct to Prevent Duplicate

Mastering Escaping Closure Captures and Mutating Self Parameter in Struct to Prevent Duplicate

Structs in Swift, especially when dealing with mutable properties and closures, can pose challenges like escaping closure captures with mutating self parameter leading to struct duplication. Understanding the intricacies of these concepts is essential for effective Swift programming. Let’s explore the behavior and solutions to address the issue of capturing mutating self in escaping closures within structs.

Understanding Escaping Closure in Swift Structs

The error message “Escaping closure captures mutating ‘self’ parameter” often occurs when working with Swift structs. Let’s delve into why this happens and explore potential solutions.

  1. Understanding the Issue:

    • Swift structs are value types, which means they are immutable by default.
    • When you mark a function as mutating, it indicates to the compiler that the function modifies the struct.
    • However, capturing a mutating self in an escaping closure within a struct can lead to problems.
  2. Example:
    Consider the following struct:

    public struct Trigger {
        public var value = false
        public mutating func toggle() {
            value = true
            let responseDate = Date().advanced(by: 3)
            OperationQueue.main.schedule(after: .init(responseDate)) {
        private mutating func moveBack() {
            value = false

    The error occurs because the escaping closure captures the mutating self parameter.

  3. Why Does This Happen?:

    • When you call a mutating function, a new instance of the struct is created with the updated value.
    • For example, someCounter.increment() creates a new Counter instance with an incremented count.
    • If an escaping closure captures self, it retains a strong reference to the original instance.
    • However, execution may have already moved on, making it too late to update the original instance.
  4. Solutions:

    • The quick solution is to use a reference type (i.e., a class) instead of a struct.
    • Classes allow you to mutate properties asynchronously and work well with SwiftUI’s ObservableObject.
    • If you want to stick with a struct, consider using a capture list to explicitly capture a weak or unowned reference to self in the closure.
    • However, be cautious about retain cycles and memory leaks when capturing self in closures.

Understanding Escaping and Non-Escaping Closures

In Swift, closures are powerful constructs that allow you to encapsulate functionality and pass it around as first-class citizens. Let’s dive into the concept of escaping and non-escaping closures.

  1. Escaping Closures:

    • An escaping closure is one that outlives the function it is passed to. In other words, it continues to exist even after the function has returned.
    • Common use cases for escaping closures include asynchronous operations (like network requests) or when you need to store the closure for later execution.
    • Imagine the closure as a bandit breaking out of a prison (the function). It escapes the function’s boundaries and lives on.
    • Example:
      func loadData(completion: @escaping (Data?) -> Void) {
              let data = try? Data(contentsOf: url)
              DispatchQueue.main.async {

      In this example, the loadData function takes an escaping closure as an argument. It loads data asynchronously from a URL and executes the closure after the data has been fetched. The closure is marked as escaping because it outlives the loadData

  2. Non-Escaping Closures:

    • A non-escaping closure is one that is called within the function it is passed to, before the function returns.
    • These closures stay within the function’s boundaries and do not outlive it.
    • Prior to Swift 3, all closures were considered escaping by default. However, since Swift 3, methods are considered non-escaping by default.
    • Example:
      func processItems(using closure: () -> Void) {
          // Do something with the closure

      In this case, the closure is invoked immediately within the processItems function.

Remember that using @escaping informs callers that the closure might be stored or outlive the function. It’s essential to handle retain cycles and memory leaks when dealing with escaping closures. 🧐

For more details, you can explore the official Swift documentation on closures

Understanding Mutating Functions

In Swift, mutating functions play a crucial role when working with structs. Let’s dive into what they mean and why they’re necessary:

  1. Structs and Immutability:

    • A struct in Swift is an immutable value type. This means that once you create an instance of a struct, its properties cannot be modified directly.
    • Unlike classes, which are reference types, structs are copied when passed around or assigned to new variables.
  2. The mutating Keyword:

    • When you want to change a property inside a method of a struct, you need to mark that method with the mutating keyword.
    • This keyword indicates that the method can modify the internal state of the struct.
    • Without mutating, Swift would prevent you from modifying properties within the method.
  3. Example:

    struct Person {
        var name: String
        // A mutating function to make the person anonymous
        mutating func makeAnonymous() {
            name = "Anonymous"
    • In the example above, the makeAnonymous() function modifies the name property.
    • You can only call this function on variables of type Person, not on constants.
  4. Conceptualizing Mutating Functions:

    • Think of your struct like a number:
      • When you perform the operation 4 + 1, the value 4 doesn’t become 5. Instead, you get a new value after the operation.
      • Mutating functions operate similarly—they return a new struct with modified properties.
    • You cannot call mutating functions on constants (e.g., let someStruct = SomeStruct()), as that would be equivalent to trying to assign a new value to a constant.
    • Mutating functions can only be performed on variables (e.g., var someStruct = SomeStruct()).

Remember, the mutating keyword ensures that you can modify properties within a struct, allowing you to work with value types effectively!

Handling Closure Captures in Swift

When working with closures in Swift, especially when capturing self, there are some nuances to consider. Let’s delve into the issue of escaping closure captures with mutating self parameters and explore potential solutions.

  1. The Problem:
    When you have a mutating method within a struct, and you attempt to capture self inside an escaping closure, Swift raises an error. This occurs because the closure captures self strongly, leading to a retain cycle.

  2. The Error:
    The error message typically looks like this:

    Escaping closure captures mutating 'self' parameter
  3. Why Does This Happen?:
    The issue arises because structs are value types, and when you capture self in a closure, it creates a copy of the struct. Since the method is mutating, it tries to modify the original struct, leading to a conflict.

  4. Solutions:

    • Change to a Class:
      The straightforward solution is to change your view model (MyViewModel) from a struct to a class. Classes are reference types, so capturing self in closures won’t cause this issue.

      class MyViewModel {
          var dueDate: String?
          func getLoanData() {
              getLoanDetails { loanDetails, error in
                  self.dueDate = loanDetails?.dueDate
    • Capture Weak or Unowned References:
      If you want to stick with structs, you can use a capture list to explicitly capture a weak or unowned reference to self. This prevents the closure from strongly capturing self and avoids the retain cycle.

      struct MyViewModel {
          var dueDate: String?
          mutating func getLoanData() {
              getLoanDetails { [weak self] loanDetails, error in
                  self?.dueDate = loanDetails?.dueDate
  5. Choose Wisely:
    Consider the trade-offs:

    • Structs: Value semantics, lightweight, but require careful handling of closures.
    • Classes: Reference semantics, more flexible with closures, but heavier.

For more information, you can refer to the following Stack Overflow discussions:

Working with Mutable Structs in Swift Closures

When working with mutable structs in Swift closures, there are some nuances to be aware of. Let’s dive into the behavior and explore ways to prevent struct duplication.

  1. Behavior of Structs in Closures:

    • Suppose you have a class (A) containing a struct variable (S).
    • In one of the class’s functions, you call a mutating function on the struct variable. This function takes a closure.
    • Inside the closure, you check the struct variable’s properties.
    • The struct’s mutating function, in turn, calls a function from another class (B) or struct ©, which also takes a closure.
    • When using class B, the struct’s properties are not updated within the closure of class A. However, if you use struct C instead of class B, the properties are updated as expected.
  2. Example:

    struct NetworkingStruct {
        func fetchDataOverNetwork(completion: () -> ()) {
            // Fetch data from the network and call the closure
    struct ViewModelStruct {
        var data: String = "A"
        // Mutate itself in a closure called from a struct
        mutating func changeFromStruct(completion: () -> ()) {
            let networkingStruct = NetworkingStruct()
            networkingStruct.fetchDataOverNetwork {
       = "B"
    class ViewController {
        var viewModel: ViewModelStruct = ViewModelStruct()
        func changeViewModelStruct() {
            print( // This never changes inside the closure
            viewModel.changeFromStruct {
                print( // This changes inside/outside the closure
    let c = ViewController()
    • In the above example, the data property of ViewModelStruct is updated when using NetworkingStruct but not when using NetworkingClass.
  3. Explanation:

    • The difference lies in whether the networking component (NetworkingClass or NetworkingStruct) is a class or a struct.
    • Swift treats classes and structs differently when capturing values in closures.
    • This behavior is independent of the ViewController or ViewModel.
  4. Considerations:

    • When dealing with mutable structs in closures:
      • Be aware of how closures capture variables.
      • Consider using classes or other approaches to avoid unexpected behavior.
      • Swift’s memory management handles capturing for you.

In conclusion, navigating the complexities of escaping closure captures with mutating self parameter in structs is crucial for maintaining code integrity. By grasping the nuances of retaining strong references and struct duplication, developers can enhance their Swift coding practices. Solutions like leveraging classes or employing capture lists with weak references provide ways to mitigate the risks of retain cycles and memory leaks.

With a firm grasp on these concepts, Swift developers can optimize their code structure and foster more efficient and bug-free applications.


    Leave a Reply

    Your email address will not be published. Required fields are marked *