Fix cancellation of ViewStore.suspend (#725)

* Fix cancellation of ViewStore.suspend

* wip

* Remove capture list

Author: mluisbrown

Sources/ComposableArchitecture/Beta/Concurrency.swift

@@ -109,9 +109,10 @@ import SwiftUI
   extension ViewStore {
     /// Sends an action into the store and then suspends while a piece of state is `true`.
     ///
-    /// This method can be used to interact with async/await code, allowing you to suspend while work
-    /// is being performed in an effect. One common example of this is using SwiftUI's `.refreshable`
-    /// method, which shows a loading indicator on the screen while work is being performed.
+    /// This method can be used to interact with async/await code, allowing you to suspend while
+    /// work is being performed in an effect. One common example of this is using SwiftUI's
+    /// `.refreshable` method, which shows a loading indicator on the screen while work is being
+    /// performed.
     ///
     /// For example, suppose we wanted to load some data from the network when a pull-to-refresh
     /// gesture is performed on a list. The domain and logic for this feature can be modeled like so:
@@ -173,17 +174,19 @@ import SwiftUI
     ///
     /// Here we've used the ``send(_:while:)`` method to suspend while the `isLoading` state is
     /// `true`. Once that piece of state flips back to `false` the method will resume, signaling to
-    /// `.refreshable` that the work has finished which will cause the loading indicator to disappear.
+    /// `.refreshable` that the work has finished which will cause the loading indicator to
+    /// disappear.
     ///
     /// **Note:** ``ViewStore`` is not thread safe and you should only send actions to it from the
-    /// main thread. If you are wanting to send actions on background threads due to the fact that the
-    /// reducer is performing computationally expensive work, then a better way to handle this is to
-    /// wrap that work in an ``Effect`` that is performed on a background thread so that the result
-    /// can be fed back into the store.
+    /// main thread. If you are wanting to send actions on background threads due to the fact that
+    /// the reducer is performing computationally expensive work, then a better way to handle this
+    /// is to wrap that work in an ``Effect`` that is performed on a background thread so that the
+    /// result can be fed back into the store.
     ///
     /// - Parameters:
     ///   - action: An action.
-    ///   - predicate: A predicate on `State` that determines for how long this method should suspend.
+    ///   - predicate: A predicate on `State` that determines for how long this method should
+    ///     suspend.
     public func send(
       _ action: Action,
       while predicate: @escaping (State) -> Bool
@@ -199,7 +202,8 @@ import SwiftUI
     /// - Parameters:
     ///   - action: An action.
     ///   - animation: The animation to perform when the action is sent.
-    ///   - predicate: A predicate on `State` that determines for how long this method should suspend.
+    ///   - predicate: A predicate on `State` that determines for how long this method should
+    ///     suspend.
     public func send(
       _ action: Action,
       animation: Animation?,
@@ -211,20 +215,20 @@ import SwiftUI
 
     /// Suspends while a predicate on state is `true`.
     ///
-    /// - Parameter predicate: A predicate on `State` that determines for how long this method should
-    /// suspend.
+    /// - Parameter predicate: A predicate on `State` that determines for how long this method
+    ///   should suspend.
     public func suspend(while predicate: @escaping (State) -> Bool) async {
-    var cancellable: Disposable?
+      let cancellable = Box<Disposable?>(wrappedValue: nil)
       try? await withTaskCancellationHandler(
-      handler: { [cancellable] in cancellable?.dispose() },
+        handler: { cancellable.wrappedValue?.dispose() },
         operation: {
           try Task.checkCancellation()
         try await withUnsafeThrowingContinuation { (continuation: UnsafeContinuation<Void, Error>) in
             guard !Task.isCancelled else {
               continuation.resume(throwing: CancellationError())
               return
             }
-          cancellable = self.produced.producer
+            cancellable.wrappedValue = self.produced.producer
               .filter { !predicate($0) }
             .take(first: 1)
             .startWithValues { _ in
@@ -236,4 +240,12 @@ import SwiftUI
       )
     }
   }
+
+  private class Box<Value> {
+    var wrappedValue: Value
+
+    init(wrappedValue: Value) {
+      self.wrappedValue = wrappedValue
+    }
+  }
 #endif