Conformance of 'Notification' to 'Sendable' is unavailable

[shannoga]

Hi
I am trying to build a generic notification center dependency.
I found an example in your case studies (02-Effects-LongLiving) and wanted to implement it in a similar way using AsyncStream.

I have two questions:

1. There is a warning stating that Notification dose not conform to Sendable, is there a way to avoid this warning?
2. I found that I can build the client, returning NotificationCenter.Notifications which conforms to AsyncSequence and use it in the reducer, I wonder why Sequence is a better choice (Was that to avoid dependency on Notification?)

struct Notifications: DependencyKey {
   var notification: (String, AnyObject?) -> NotificationCenter.Notifications
   var applicationDidFinishLaunching: () -> NotificationCenter.Notifications
   var applicationDidBecomeActive: () -> NotificationCenter.Notifications
   var applicationWillEnterForeground: () -> NotificationCenter.Notifications
   var applicationWillResignActive: () -> NotificationCenter.Notifications
   var applicationDidEnterBackgroundNotification: () -> NotificationCenter.Notifications
   var applicationWillTerminateNotification: () -> NotificationCenter.Notifications
   var applicationDidReceiveMemoryWarning: () -> NotificationCenter.Notifications
   }
     
  //And in the reducer
  
  return .run { send in
    Task {
            for await _ in self.notifications.applicationDidBecomeActive() {
                    await send(.reloadContact)
                }
         }               
 }

Thanks a lot!

[mbrandonw]

Hi @shannoga, the reason we "erase" the NotificationCenter.Notifications type to an AsyncStream is because Notifications is not constructible. This means we can't construct one for tests, previews, etc. that emit notifications so that we can see how our feature's logic reacts.

If you don't plan on controlling the notifications, then there is no reason to use @Dependency at all. You can just call out to Apple's API directly in an effect in your reducer.

[shannoga]

Thanks for the quick reply.
And what about the Sendable warning? Isn't that going to break in the future?

[mbrandonw]

Can you show exactly where in the code you are getting the warning?

No matter what, all dependencies registered with the library must conform to Sendable, so you should make Notifications be Sendable, which means making all of the closures @Sendable.

[shannoga]

[stephencelis]

@shannoga We just chatted about this and think the constraint is probably too heavy since a lot of async sequences aren't sendable and probably never will be. Here's an alternative we cooked up that you can paste into your project that produces a non-sendable sequence from a sendable closure instead:

extension AsyncStream {
  public init<S: AsyncSequence>(
    bufferingPolicy limit: Continuation.BufferingPolicy = .unbounded,
    @_implicitSelfCapture @_inheritActorContext _ makeUnderlyingSequence: @escaping @Sendable ()
      async -> S
  ) where S.Element == Element {
    self.init(bufferingPolicy: limit) { (continuation: Continuation) in
      let task = Task {
        do {
          for try await element in await makeUnderlyingSequence() {
            continuation.yield(element)
          }
        } catch {}
        continuation.finish()
      }
      continuation.onTermination =
        { _ in
          task.cancel()
        }
        // NB: This explicit cast is needed to work around a compiler bug in Swift 5.5.2
        as @Sendable (Continuation.Termination) -> Void
    }
  }
}

You can then call it with a trailing closure:

AsyncStream {
  await NotificationCenter.default
    .notifications(named: UIApplication.userDidTakeScreenshotNotification)
    .map { _ in }
}

We'll probably roll this change into an update soon, but in case you (or someone else) needs it before then!

[gsl-anthonymerle]

Hi everyone,

We'll probably roll this change into an update soon, but in case you (or someone else) needs it before then!
@stephencelis is it still in your intentions to ship this bit of code ?
I couldn't find an equivalent in the package, and because the warning is now an error in Swift 6 this helper will be of great help 🙏

(Also, I found that I had to add Element: Sendable in the function's where clause because Swift 6's concurrency checker is pretty efficient and knows that the code yield with a non-Sendable element)

Best regards,
Anthony

[shannoga]

I will try this,
Thanks a lot

[shannoga]

Here is my final version if that helps someone. I needed to add support for iOS 14 as Notifications is iOS 15 +.

extension DependencyValues {
    var notifications: Notifications {
        get { self[Notifications.self] }
        set { self[Notifications.self] = newValue }
    }
}

struct Notifications: DependencyKey {
    
    var notification: @Sendable (String, AnyObject?) async -> AsyncStream<Notification>
    var applicationDidFinishLaunching: @Sendable () async -> AsyncStream<Notification>
    var applicationDidBecomeActive: @Sendable () async -> AsyncStream<Notification>
    var applicationWillEnterForeground: @Sendable () async -> AsyncStream<Notification>
    var applicationWillResignActive: @Sendable () async -> AsyncStream<Notification>
    var applicationDidEnterBackgroundNotification: @Sendable () async -> AsyncStream<Notification>
    var applicationWillTerminateNotification: @Sendable () async -> AsyncStream<Notification>
    var applicationDidReceiveMemoryWarning: @Sendable () async -> AsyncStream<Notification>
    
    static var liveValue: Notifications {
        
        @Sendable func buildNotification(named name: Notification.Name, object: AnyObject? = nil) -> AsyncStream<Notification> {
            
            if #available(iOS 15, *) {
                return AsyncStream {
                    NotificationCenter.default
                        .notifications(named: name, object: object)
                        .map { $0 }
                }
            } else {
                
                return AsyncStream { continuation in
                    let cancellable = NotificationCenter.default
                        .publisher(for: name)
                        .sink() { notification in
                            continuation.yield(notification)
                        }
                    
                    continuation.onTermination = { @Sendable _ in
                        cancellable.cancel()
                    }
                }
            }
        }
        
        return .init(
            notification: { name, object in
                let notificationName = Notification.Name(rawValue: name)
                return buildNotification(named: notificationName, object: object)
            }, applicationDidFinishLaunching: {
                return await buildNotification(named: UIApplication.didFinishLaunchingNotification)
            }, applicationDidBecomeActive: {
                return await buildNotification(named: UIApplication.didBecomeActiveNotification)
            }, applicationWillEnterForeground: {
                return await buildNotification(named: UIApplication.willEnterForegroundNotification)
            }, applicationWillResignActive: {
                return await buildNotification(named: UIApplication.willResignActiveNotification)
            }, applicationDidEnterBackgroundNotification: {
                return await buildNotification(named: UIApplication.didEnterBackgroundNotification)
            }, applicationWillTerminateNotification: {
                return await buildNotification(named: UIApplication.willTerminateNotification)
            }, applicationDidReceiveMemoryWarning: {
                return await buildNotification(named: UIApplication.didReceiveMemoryWarningNotification)
            })
    }
}

extension AsyncStream {
    public init<S: AsyncSequence>(
    bufferingPolicy limit: Continuation.BufferingPolicy = .unbounded,
    @_implicitSelfCapture @_inheritActorContext _ makeUnderlyingSequence: @escaping @Sendable ()
    async -> S
    ) where S.Element == Element {
        self.init(bufferingPolicy: limit) { (continuation: Continuation) in
            let task = Task {
                do {
                    for try await element in await makeUnderlyingSequence() {
                        continuation.yield(element)
                    }
                } catch {}
                continuation.finish()
            }
            continuation.onTermination =
            { _ in
                task.cancel()
            }
            // NB: This explicit cast is needed to work around a compiler bug in Swift 5.5.2
            as @Sendable (Continuation.Termination) -> Void
        }
    }
}

@stephencelis
Thanks a lot, your help and support is one more feature in this great library.

[sssuourabh]

@shannoga How you post any custom notification in reducer?
Is it like this - NotificationCenter.default.post(name: "test", object: nil)

[acosmicflamingo]

Really cool! Hmm...I'm actually wondering whether I should adopt this approach in my code. I'm currently trying to test some functionality where the reducer's state changes whenever it receives a NotificationCenter update from an AsyncStream and this looks like something I should adopt. @shannoga have you been able to write tests that utilize this functionality?

I also created a separate discussion about this since my question is more related toward testing than the discussion at hand.

[shannoga]

Yes. I will try to update it here.

[v-slobodianiuk]

For iOS 15+
var appWillEnterForeground: @Sendable () async -> AsyncMapSequence<NotificationCenter.Notifications, Void>

For iOS 18+
var appWillEnterForeground: @Sendable () async -> any AsyncSequence<Void, Never>

Example:

public struct SystemClient {
    public var appWillEnterForeground: @Sendable () async -> AsyncMapSequence<NotificationCenter.Notifications, Void>
}

extension SystemClient: DependencyKey {
    public static let liveValue = Self(
        appWillEnterForeground: {
            NotificationCenter.default
                .notifications(named: UIApplication.willEnterForegroundNotification)
                .map { _ in }
        }
    )
}

public extension DependencyValues {
    var systemClient: SystemClient {
        get {
            self[SystemClient.self]
        }

        set {
            self[SystemClient.self] = newValue
        }
    }
}

[sssuourabh]

Await is missing in
public static let liveValue = Self( appWillEnterForeground: { await NotificationCenter.default.notifications(named: UIApplication.willEnterForegroundNotification) .map { _ in } } )