Swift Combine publishers vs completion handler and when to cancel

Question

I know in general a publisher is more powerful than a closure, however I want to ask and discuss a specific example:

func getNotificationSettingsPublisher() -> AnyPublisher<UNNotificationSettings, Never> {
   let notificationSettingsFuture = Future<UNNotificationSettings, Never> { (promise) in
      UNUserNotificationCenter.current().getNotificationSettings { (settings) in
         promise(.success(settings))
      }
   }
   return notificationSettingsFuture.eraseToAnyPublisher()
}

I think this is a valid example of a Future publisher and it could be used here instead of using a completion handler. Let's do something with it:

func test() {
    getNotificationSettingsPublisher().sink { (notificationSettings) in
       // Do something here        
    }
}

This works, however it will tell me that the result of sink (AnyCancellable) is unused. So whenever I try to get a value, I need to either store the cancellable or assign it until I get a value.

Is there something like sinkOnce or an auto destroy of cancellables? Sometimes I don't need tasks to the cancelled. I could however do this:

func test() {
   self.cancellable = getNotificationSettingsPublisher().sink { [weak self] (notificationSettings) in
      self?.cancellable?.cancel()
      self?.cancellable = nil
   }
}

So once I receive a value, I cancel the subscription. (I could do the same in the completion closure of sink I guess).

What's the correct way of doing so? Because if I use a closure, it will be called as many times as the function is called, and if it is called only once, then I don't need to cancel anything.

Would you say normal completion handlers could be replaced by Combine and if so, how would you handle receiving one value and then cancelling?

Last but not least, the completion is called, do I still need to cancel the subscription? I at least need to update the cancellable and set it to nil right? I assume storing subscriptions in a set is for long running subscriptions, but what about single value subscriptions?

Thanks

Answer 1

Instead of using the .sink operator, you can use the Sink subscriber directly. That way you don't receive an AnyCancellable that you need to save. When the publisher completes the subscription, Combine cleans everything up.

func test() {
    getNotificationSettingsPublisher()
        .subscribe(Subscribers.Sink(
            receiveCompletion: { _ in },
            receiveValue: ({
                print("value: \($0)")
            })
        ))
}