Promise is non-sendable type

Using Swift
, ,
1

Hey guys,

Enabling StrictConcurrency check raise a warning on our Future extension:

extension Future where Failure == Error, Output: Sendable {

    convenience public init(_ asyncFunction: @escaping @Sendable () async throws -> Output) {
        self.init { promise in
            Task {
                do {
                    let result = try await asyncFunction()
                    promise(.success(result))
                } catch {
                    promise(.failure(error))
                }
            }
        }
    }
}

The warning is: Capture of 'promise' with non-sendable type '(Result<Output, any Error>) -> Void' in a @Sendable closure

I'm trying to understand the reason behind. I've read here that

closure must not close over non-Sendable

But why promise is non-Sendable? Result is enum with only Sendable associated values (both Output and Failure)

Looks like I'm still missing key point of @Sendable

2 Likes
2

Hmmmmmm looks like the promise closure isn't marked Sendable.

1 Like
3

Just to elaborate a bit on @AlexanderM's answer here, the possible sendability of a closure expression can depend on state that is not reflected in the parameter-and-return-type signature of the function type. An arbitrary function value of type (Result<some Sendable, some Sendable & Error>) -> Void may be sendable, but without visibility into the definition of the function itself, we can't know for sure. So your use of promise can't just assume that "sendable parameters and sendable return value means sendable," the author of the API providing the promise parameter needs to explicitly mark the function type @Sendable in order for us to rely on it. The fact that it hasn't been marked as @Sendable may be an oversight, or there may be some fundamental implementation reason that promise cannot be sent across isolation domains.

8 Likes
4

add this code to suppress the warning

#if swift(>=6)
    nonisolated(unsafe) let promise = promise
#endif
5

Hello @longvudai. The code mentioned does not suppress the warning anymore. Actually, the warning has changed to Task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode. Is there any another option to fix it?

2 Likes
6

This solution still works: create an unchecked sendable class to wrap the promise:

2 Likes
7

You could use this instead of a Combine Future:

public struct SwiftConcurrencyPublisher<Output: Sendable, Failure: Sendable & Error> : Publisher {
    private let subject: Publishers.HandleEvents<PassthroughSubject<Output, Failure>>

    public init(body: @Sendable @escaping () async -> Result<Output, Failure>) {
        let subject = PassthroughSubject<Output, Failure>()
        let task = Task {
            switch await body() {
            case .success(let success):
                subject.send(success)
                subject.send(completion: .finished)
            case .failure(let failure):
                subject.send(completion: .failure(failure))
            }
        }
        self.subject = subject.handleEvents(receiveCancel: { task.cancel() })
    }

    public func receive<S>(subscriber: S) where S : Subscriber, Failure == S.Failure, Output == S.Input {
        subject.receive(subscriber: subscriber)
    }
}