Integrating external cancellation tokens + Swift concurrency cancellation

[kamcma]

Sometimes dependencies provide their own cancellation tokens.

A simple example I happen to be interested in at the moment is the class function SFSafariViewController.prewarmConnections(to:), to which you pass URLs you may imminently open an SFSafariViewController to, and it returns an SFSafariViewController.PrewarmingToken. You call invalidate() on the token when you are no longer imminently going to present the Safari view controller.

Say I have some host view, in which the user may click a button the present the Safari view controller. My thought is to fire this prewarming effect from an action sent in the View.task(id:priority:_:) modifier on the host view, and thus hook into the task cancellation when the user navigates away from the host view.

I took a shot at writing such a dependency, but it's an odd function that returns Never. I had to use this helper I found in TCA, Task.never(). I also read this interesting thread in the Swift forum about withTaskCancellationHandler, which ends in a slightly weird place because the sample code from the evolution proposal does not actually compile. So I don't feel confident I'm using it correctly.

Has anyone encountered such a pattern when building with concurrency TCA? Is it a weird code smell to write never-returning async functions that exist only to suspend and be cancelled? Have I overlooked some way simpler way to do this? (Often the case.) Thanks in advance for any insight!

import ComposableArchitecture
import Dependencies
import SFSafariServices

extension DependencyValues {
  public var prewarmConnections: @Sendable ([URL]) async throws -> Never {
    get { self[PrewarmConnectionsKey.self] }
    set { self[PrewarmConnectionsKey.self] = newValue }
  }

  public enum PrewarmConnectionsKey: TestDependencyKey {
    public static let testValue: @Sendable ([URL]) async throws -> Never = { _ in
      try await Task.never()
    }
  }
}

extension DependencyValues.PrewarmConnectionsKey: DependencyKey {
  public static let liveValue: @Sendable ([URL]) async throws -> Never = { urls in
    let prewarmingToken = await MainActor.run {
      let prewarmingToken = SFSafariViewController.prewarmConnections(to: urls)
      return UncheckedSendable(prewarmingToken)
    }
    return try await withTaskCancellationHandler {
      try await Task.never()
    } onCancel: {
      prewarmingToken.wrappedValue.invalidate()
    }
  }
}

(A possibly related or not issue is that I am making an assumption about the sendability of the reference-type cancellation token return from SFSafariServices, but whether or not that is valid, my larger question about wrapping cancellation tokens stands.)

[stephencelis]

@kamcma We definitely don't think it's a code smell to use Task.never() in this kind of way 😄 In fact we've used it in similar ways to great effect, some of which may make it into future TCA features.

It's a great way to suspend for as long as you need to, and terminate when some outside event occurs (via cancellation).

In this particular example I'd probably need to think more about alternatives, but it seems clever to me on first look!

[kamcma]

Thanks @stephencelis!

I think it was mentioned that wrapping dependencies (particularly utilizing actors) might be a topic revisited by PF in the future, so I look forward to that. I weirdly find wrapping dependencies—thinking about the fundamental shape of their APIs and correct usage—to be one of the most intellectually stimulating parts of using TCA 😂.

[kamcma]

If anyone comes across this post later, it has since occurred to me that making making my dependency endpoint return an AsyncStream<Never> is perhaps the more straightforward way to do this. Doesn't require a dependency on TCA just for the helper Task.never(), convenient though it is. Still working on mapping my Combine intuitions into new concurrency-native intuitions.

extension DependencyValues.PrewarmConnectionsKey: DependencyKey {
  public static let liveValue: @Sendable ([URL]) async -> AsyncStream<Never> = { urls in
    let prewarmingToken = await SFSafariViewController.prewarmConnections(to: urls)
    return AsyncStream { continuation in
      continuation.onTermination = { _ in
        prewarmingToken.invalidate()
      }
    }
  }
}

[kamcma]

Alright, one final update, I think. The piece of the puzzle I was missing.

If you have a piece of dependency state you want to access across sendable boundaries, such as a cancellation token, but this state is not itself Sendable and you're uncomfortable marking it it @unchecked Sendable, then you can proxy it with something that is Sendable. Say, a UUID. And then you store that state in a dictionary keyed by the sendable and hashable proxy, and synchronize access to it with an actor.

In my case, since SFSafariViewController.prewarmConnections(to:) needs to be called and is going to return me a non-sendable SFSafariViewController.PrewarmingToken on the MainActor anyway, I didn't bother intermediating with my own actor, and just stuck the dictionary on the MainActor as a static. And since [URL] is hashable anyway, I can use that as a key directly. But that's the idea.

I hope this is more obvious to others! But it took me a bit of studying the websocket example in the case studies before the 💡 moment.

extension DependencyValues.PrewarmConnectionsKey: DependencyKey {
  @MainActor
  private static var prewarmingTokens: [[URL]: SFSafariViewController.PrewarmingToken] = [:]

  public static let liveValue: @Sendable ([URL]) async -> AsyncStream<Never> = { @MainActor URLs in
    prewarmingTokens[URLs] = SFSafariViewController.prewarmConnections(to: URLs)
    return AsyncStream { continuation in
      continuation.onTermination = { _ in
        Task { @MainActor in
          prewarmingTokens.removeValue(forKey: URLs)?.invalidate()
        }
      }
    }
  }
}