Publisher+PromiseExtension.swift

Publisher+PromiseExtension.swift

extension Publisher {
    func and<T: Publisher>(_ closure: @escaping (Output) -> T) -> AnyPublisher<(Output, T.Output), Failure> where T.Failure == Failure {
        then { output in
            Just(output)
                .setFailureType(to: Failure.self)
                .zip(closure(output))
                .eraseToAnyPublisher()
        }
    }

    func then<T: Publisher>(_ closure: @escaping (Output) -> T) -> AnyPublisher<T.Output, Failure> where T.Failure == Failure {
        flatMap { output in
            closure(output)
        }
        .eraseToAnyPublisher()
    }

    func done(_ closure: @escaping (Output) -> Void, assertIfNotOnMainQueue: Bool = true) -> AnyPublisher<Output, Failure> {
        flatMap { output -> AnyPublisher<Output, Failure> in
            assert(!(assertIfNotOnMainQueue && !Thread.isMainThread),
                   """
done() is not being called on the main thread, this is probably not right. \
If you meant this to happen call with assertIfNotOnMainQueue: false
""")
            closure(output)
            return eraseToAnyPublisher()
        }
        .eraseToAnyPublisher()
    }

    func fail(_ closure: @escaping (Failure) -> Void, assertIfNotOnMainQueue: Bool = true) -> AnyPublisher<Output, Failure> {
        self.catch { error -> AnyPublisher<Output, Failure> in
            assert(!(assertIfNotOnMainQueue && !Thread.isMainThread),
                   """
fail() is not being called on the main thread, this is probably not right. \
If you meant this to happen call with assertIfNotOnMainQueue: false
""")
            closure(error)
            return eraseToAnyPublisher()
        }
        .eraseToAnyPublisher()
    }

    func always(_ closure: @escaping (Result<Output, Failure>) -> Void, assertIfNotOnMainQueue: Bool = true) -> Cancellable {
        return sink { completion in
            switch completion {
            case .finished:
                break
            case let .failure(error):
                assert(!(assertIfNotOnMainQueue && !Thread.isMainThread),
                       """
always() is not being called on the main thread, this is probably not right. \
If you meant this to happen call with assertIfNotOnMainQueue: false
""")
                closure(.failure(error))
            }
        } receiveValue: { output in
            assert(!(assertIfNotOnMainQueue && !Thread.isMainThread),
                   """
always() is not being called on the main thread, this is probably not right. \
If you meant this to happen call with assertIfNotOnMainQueue: false
""")
            closure(.success(output))
        }
    }
}