CancellableFuture for Combine framework

CancellableFuture.swift

import Combine

/// Builds `Publisher` with callable promise that can be cancelled.
/// Used in requests and other cancellable tasks.
///
/// Usage:
/// ```
/// CancellableFuture<String, Error> { promise -> AnyCancellable in
///    let request = buildHttpRequest()
///    request.listenToResponse { result in
///        promise(.success(result))
///    }
///
///    return AnyCancellable {
///        request.cancel()
///    }
/// }
/// ```
///
/// - Parameter callable: function that creates `Output`
/// - Returns: deffered `AnyPublisher`
public class CancellableFuture<Output, Failure: Error>: Publisher {
    // MARK: - Aliases

    public typealias Promise = (Result<Output, Failure>) -> Void

    // MARK: - Static

    class CancellableSubscription: Subscription {
        // MARK: - Instance variables

        private let promiseWrapper: (@escaping Promise) -> AnyCancellable
        private let subscriber: AnySubscriber<Output, Failure>

        private var canceller: AnyCancellable?

        // MARK: - Public

        init(
            subscriber: AnySubscriber<Output, Failure>,
            promiseWrapper: @escaping (@escaping Promise) -> AnyCancellable
        ) {
            self.subscriber = subscriber
            self.promiseWrapper = promiseWrapper
        }

        func request(_ demand: Subscribers.Demand) {
            canceller = promiseWrapper { [subscriber] promise in
                switch promise {
                case .failure(let error):
                    subscriber.receive(completion: .failure(error))
                case .success(let output):
                    _ = subscriber.receive(output)
                    subscriber.receive(completion: .finished)
                }
            }
        }

        func cancel() {
            canceller?.cancel()
        }
    }

    // MARK: - Instance variables

    private let promiseWrapper: (@escaping Promise) -> AnyCancellable

    // MARK: - Public

    public init(_ promiseWrapper: @escaping (@escaping Promise) -> AnyCancellable) {
        self.promiseWrapper = promiseWrapper
    }

    public func receive<S>(
        subscriber: S
    ) where S: Subscriber, Failure == S.Failure, Output == S.Input {
        let subscription = CancellableSubscription(
            subscriber: AnySubscriber(subscriber),
            promiseWrapper: promiseWrapper
        )
        subscriber.receive(subscription: subscription)
    }
}