Sendable miscellany: effects, publishers, etc.

Sources/ComposableArchitecture/Effect.swift

@@ -346,7 +346,7 @@ extension Effect {
   /// - Returns: A publisher that uses the provided closure to map elements from the upstream effect
   ///   to new elements that it then publishes.
   @inlinable
-  public func map<T>(_ transform: @escaping (Action) -> T) -> Effect<T> {
+  public func map<T>(_ transform: @escaping @Sendable (Action) -> T) -> Effect<T> {
     switch self.operation {
     case .none:
       return .none

Sources/ComposableArchitecture/Internal/Create.swift

@@ -20,7 +20,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-import Combine
+@preconcurrency import Combine
 import Darwin
 
 final class DemandBuffer<S: Subscriber>: @unchecked Sendable {
@@ -105,25 +105,25 @@ final class DemandBuffer<S: Subscriber>: @unchecked Sendable {
 
 extension AnyPublisher where Failure == Never {
   private init(
-    _ callback: @escaping (Effect<Output>.Subscriber) -> Cancellable
+    _ callback: @escaping @Sendable (Effect<Output>.Subscriber) -> Cancellable
   ) {
     self = Publishers.Create(callback: callback).eraseToAnyPublisher()
   }
 
   static func create(
-    _ factory: @escaping (Effect<Output>.Subscriber) -> Cancellable
+    _ factory: @escaping @Sendable (Effect<Output>.Subscriber) -> Cancellable
   ) -> AnyPublisher<Output, Failure> {
     AnyPublisher(factory)
   }
 }
 
 extension Publishers {
-  fileprivate class Create<Output>: Publisher {
+  fileprivate final class Create<Output>: Publisher, Sendable {
     typealias Failure = Never
 
-    private let callback: (Effect<Output>.Subscriber) -> Cancellable
+    private let callback: @Sendable (Effect<Output>.Subscriber) -> Cancellable
 
-    init(callback: @escaping (Effect<Output>.Subscriber) -> Cancellable) {
+    init(callback: @escaping @Sendable (Effect<Output>.Subscriber) -> Cancellable) {
       self.callback = callback
     }
 
@@ -134,33 +134,33 @@ extension Publishers {
 }
 
 extension Publishers.Create {
-  fileprivate final class Subscription<Downstream: Subscriber>: Combine.Subscription
+  fileprivate final class Subscription<Downstream: Subscriber>: Combine.Subscription, Sendable
   where Downstream.Input == Output, Downstream.Failure == Never {
     private let buffer: DemandBuffer<Downstream>
-    private var cancellable: Cancellable?
+    private let cancellable = LockIsolated<Cancellable?>(nil)
 
     init(
-      callback: @escaping (Effect<Output>.Subscriber) -> Cancellable,
+      callback: @escaping @Sendable (Effect<Output>.Subscriber) -> Cancellable,
       downstream: Downstream
     ) {
       self.buffer = DemandBuffer(subscriber: downstream)
 
-      let cancellable = callback(
-        .init(
-          send: { [weak self] in _ = self?.buffer.buffer(value: $0) },
-          complete: { [weak self] in self?.buffer.complete(completion: $0) }
+      self.cancellable.setValue(
+        callback(
+          .init(
+            send: { [weak self] in _ = self?.buffer.buffer(value: $0) },
+            complete: { [weak self] in self?.buffer.complete(completion: $0) }
+          )
         )
       )
-
-      self.cancellable = cancellable
     }
 
     func request(_ demand: Subscribers.Demand) {
       _ = self.buffer.demand(demand)
     }
 
     func cancel() {
-      self.cancellable?.cancel()
+      self.cancellable.value?.cancel()
     }
   }
 }
@@ -172,13 +172,13 @@ extension Publishers.Create.Subscription: CustomStringConvertible {
 }
 
 extension Effect {
-  struct Subscriber {
-    private let _send: (Action) -> Void
-    private let _complete: (Subscribers.Completion<Never>) -> Void
+  struct Subscriber: Sendable {
+    private let _send: @Sendable (Action) -> Void
+    private let _complete: @Sendable (Subscribers.Completion<Never>) -> Void
 
     init(
-      send: @escaping (Action) -> Void,
-      complete: @escaping (Subscribers.Completion<Never>) -> Void
+      send: @escaping @Sendable (Action) -> Void,
+      complete: @escaping @Sendable (Subscribers.Completion<Never>) -> Void
     ) {
       self._send = send
       self._complete = complete

Sources/ComposableArchitecture/Effects/EffectActions.swift → Sources/ComposableArchitecture/Internal/EffectActions.swift

@@ -1,6 +1,7 @@
-extension Effect {
-  @_spi(Internals)
-  public var actions: AsyncStream<Action> {
+@preconcurrency import Combine
+
+extension Effect where Action: Sendable {
+  @_spi(Internals) public var actions: AsyncStream<Action> {
     switch self.operation {
     case .none:
       return .finished

Sources/ComposableArchitecture/Internal/NavigationID.swift

@@ -88,7 +88,7 @@ struct NavigationID: Hashable, @unchecked Sendable {
     self.identifier = AnyHashableSendable(id)
   }
 
-  init<Value, Root, ID: Hashable>(
+  init<Value, Root, ID: Hashable & Sendable>(
     id: ID,
     keyPath: KeyPath<Root, IdentifiedArray<ID, Value>>
   ) {

Sources/ComposableArchitecture/Macros.swift

@@ -48,7 +48,7 @@ public macro Reducer(state: _SynthesizedConformance..., action: _SynthesizedConf
 ///
 /// See <doc:Reducers#Synthesizing-protocol-conformances-on-State-and-Action> for more information.
 @_documentation(visibility: public)
-public struct _SynthesizedConformance {}
+public struct _SynthesizedConformance: Sendable {}
 
 extension _SynthesizedConformance {
   /// Extends the `State` or `Action` types that ``Reducer()`` creates with the `Codable`

Sources/ComposableArchitecture/Reducer/Reducers/ForEachReducer.swift

@@ -308,7 +308,7 @@ public struct _ForEachReducer<
     return self.element
       .dependency(\.navigationIDPath, elementNavigationID)
       .reduce(into: &state[keyPath: self.toElementsState][id: id]!, action: elementAction)
-      .map { self.toElementAction.embed((id, $0)) }
+      .map { [toElementAction] in toElementAction.embed((id, $0)) }
       ._cancellable(id: navigationID, navigationIDPath: self.navigationIDPath)
   }
 }

Sources/ComposableArchitecture/Reducer/Reducers/IfCaseLetReducer.swift

@@ -246,7 +246,7 @@ public struct _IfCaseLetReducer<Parent: Reducer, Child: Reducer>: Reducer {
     return self.child
       .dependency(\.navigationIDPath, newNavigationID)
       .reduce(into: &childState, action: childAction)
-      .map { self.toChildAction.embed($0) }
+      .map { [toChildAction] in toChildAction.embed($0) }
       .cancellable(id: childID)
   }
 }

Sources/ComposableArchitecture/Reducer/Reducers/IfLetReducer.swift

@@ -314,7 +314,7 @@ public struct _IfLetReducer<Parent: Reducer, Child: Reducer>: Reducer {
     return self.child
       .dependency(\.navigationIDPath, self.navigationIDPath.appending(navigationID))
       .reduce(into: &state[keyPath: self.toChildState]!, action: childAction)
-      .map { self.toChildAction.embed($0) }
+      .map { [toChildAction] in toChildAction.embed($0) }
       ._cancellable(id: navigationID, navigationIDPath: self.navigationIDPath)
   }
 }

Sources/ComposableArchitecture/Reducer/Reducers/PresentationReducer.swift

@@ -607,7 +607,7 @@ public struct _PresentationReducer<Base: Reducer, Destination: Reducer>: Reducer
         .reduce(
           into: &state[keyPath: self.toPresentationState].wrappedValue!, action: destinationAction
         )
-        .map { self.toPresentationAction.embed(.presented($0)) }
+        .map { [toPresentationAction] in toPresentationAction.embed(.presented($0)) }
         ._cancellable(navigationIDPath: destinationNavigationIDPath)
       baseEffects = self.base.reduce(into: &state, action: action)
       if let ephemeralType = ephemeralType(of: destinationState),

Sources/ComposableArchitecture/Reducer/Reducers/Scope.swift

@@ -379,12 +379,12 @@ public struct Scope<ParentState, ParentAction, Child: Reducer>: Reducer {
 
       return self.child
         .reduce(into: &childState, action: childAction)
-        .map { self.toChildAction.embed($0) }
+        .map { [toChildAction] in toChildAction.embed($0) }
 
     case let .keyPath(toChildState):
       return self.child
         .reduce(into: &state[keyPath: toChildState], action: childAction)
-        .map { self.toChildAction.embed($0) }
+        .map { [toChildAction] in toChildAction.embed($0) }
     }
   }
 }

Sources/ComposableArchitecture/Reducer/Reducers/StackReducer.swift

@@ -517,7 +517,7 @@ public struct _StackReducer<Base: Reducer, Destination: Reducer>: Reducer {
             into: &state[keyPath: self.toStackState][id: elementID]!,
             action: destinationAction
           )
-          .map { toStackAction.embed(.element(id: elementID, action: $0)) }
+          .map { [toStackAction] in toStackAction.embed(.element(id: elementID, action: $0)) }
           ._cancellable(navigationIDPath: elementNavigationIDPath)
       } else {
         reportIssue(

Sources/ComposableArchitecture/TestStore.swift

@@ -1917,7 +1917,7 @@ extension TestStore where State: Equatable {
   ///     expected.
   @_disfavoredOverload
   @available(iOS 16, macOS 13, tvOS 16, watchOS 9, *)
-  public func receive<Value: Equatable>(
+  public func receive<Value: Equatable & Sendable>(
     _ actionCase: _CaseKeyPath<Action, Value>,
     _ value: Value,
     timeout duration: Duration,

Sources/ComposableArchitecture/ViewStore.swift

@@ -399,31 +399,26 @@ public final class ViewStore<ViewState, ViewAction>: ObservableObject {
   /// - Parameter predicate: A predicate on `ViewState` that determines for how long this method
   ///   should suspend.
   public func yield(while predicate: @escaping (_ state: ViewState) -> Bool) async {
-    if #available(iOS 15, macOS 12, tvOS 15, watchOS 8, *) {
-      _ = await self.publisher
-        .values
-        .first(where: { !predicate($0) })
-    } else {
-      let cancellable = Box<AnyCancellable?>(wrappedValue: nil)
-      try? await withTaskCancellationHandler {
-        try Task.checkCancellation()
-        try await withUnsafeThrowingContinuation {
-          (continuation: UnsafeContinuation<Void, Error>) in
-          guard !Task.isCancelled else {
-            continuation.resume(throwing: CancellationError())
-            return
-          }
-          cancellable.wrappedValue = self.publisher
-            .filter { !predicate($0) }
-            .prefix(1)
-            .sink { _ in
-              continuation.resume()
-              _ = cancellable
-            }
+    let isolatedCancellable = LockIsolated<AnyCancellable?>(nil)
+    try? await withTaskCancellationHandler {
+      try Task.checkCancellation()
+      try await withUnsafeThrowingContinuation {
+        (continuation: UnsafeContinuation<Void, Error>) in
+        guard !Task.isCancelled else {
+          continuation.resume(throwing: CancellationError())
+          return
         }
-      } onCancel: {
-        cancellable.wrappedValue?.cancel()
+        let cancellable = self.publisher
+          .filter { !predicate($0) }
+          .prefix(1)
+          .sink { _ in
+            continuation.resume()
+            _ = isolatedCancellable
+          }
+        isolatedCancellable.setValue(cancellable)
       }
+    } onCancel: {
+      isolatedCancellable.value?.cancel()
     }
   }