Driver.swift

import Foundation
import Combine

class Driver<Output>: Publisher {
    typealias Output = Output
    typealias Failure = Never

    private let anyPublisher: AnyPublisher<Output, Never>
    private var bag = Set<AnyCancellable>()

    init(_ anyPublisher: AnyPublisher<Output, Never>) {
        self.anyPublisher = anyPublisher
    }

    func receive<S>(subscriber: S) where S : Subscriber, Never == S.Failure, Output == S.Input {
        let subscription = DriverSubscription<S>()
        subscription.target = subscriber
        subscriber.receive(subscription: subscription)

        anyPublisher
            .receive(on: DispatchQueue.main)
            .sink { [subscription] newValue in
                subscription.emit(newValue)
            }
            .store(in: &bag)
    }
}

private extension Driver {
    class DriverSubscription<Target: Subscriber>: Subscription {

        var target: Target?

        func request(_ demand: Subscribers.Demand) {}

        func cancel() {
            target = nil
        }

        func emit<Value>(_ value: Value) where Value == Target.Input {
            _ = target?.receive(value)
        }
    }
}

extension Publisher {
    func asDriver() -> Driver<Output> where Failure == Never {
        Driver(self.eraseToAnyPublisher())
    }
}