【Swift/Combine】retryメソッドの使い方！特定のエラー発生で再度実行する方法

func retry(_ retries: Int) -> Publishers.Retry<Self>

let publisher = PassthroughSubject<Int, MyError>()

enum MyError: Error {
    case someError1
    case someError2
}

let subscription = publisher
    .catch { error -> AnyPublisher<Int, MyError> in
        print("エラー発生")
        return Fail<Int, MyError>(error: error).eraseToAnyPublisher()
    }
    .retry(1)
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("完了")
        case .failure(let error):
            print("Error:", error)
        }
    }, receiveValue: { value in
        print("Value:", value)
    })

publisher.send(completion: .failure(.someError1))

エラー発生
エラー発生
Error: someError1

let subscription = publisher
    .retry(1)
    .catch { error -> AnyPublisher<Int, MyError> in
        print("エラー発生")
        return Fail<Int, MyError>(error: error).eraseToAnyPublisher()
    }
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("完了")
        case .failure(let error):
            print("Error:", error)
        }
    }, receiveValue: { value in
        print("Value:", value)
    })

エラー発生
Error: someError1

カスタムオペレーターの実装
extension Publishers {
    struct RetryIf<P: Publisher>: Publisher {
        typealias Output = P.Output
        typealias Failure = P.Failure
        
        let publisher: P
        let times: Int
        let condition: (P.Failure) -> Bool
                
        func receive<S>(subscriber: S) where S : Subscriber, Failure == S.Failure, Output == S.Input {
            guard times > 0 else { return publisher.receive(subscriber: subscriber) }
            
            publisher.catch { (error: P.Failure) -> AnyPublisher<Output, Failure> in
                if condition(error)  {
                    return RetryIf(publisher: publisher, times: times - 1, condition: condition).eraseToAnyPublisher()
                } else {
                    return Fail(error: error).eraseToAnyPublisher()
                }
            }.receive(subscriber: subscriber)
        }
    }
}

extension Publisher {
    func retry(times: Int, if condition: @escaping (Failure) -> Bool) -> Publishers.RetryIf<Self> {
        Publishers.RetryIf(publisher: self, times: times, condition: condition)
    }
}

let subscription = publisher
    .catch { error -> AnyPublisher<Int, MyError> in
        print("エラー発生")
        return Fail<Int, MyError>(error: error).eraseToAnyPublisher()
    }
    .retry(times: 4) { error in
        switch error { 
        case MyError.someError1:
            return true
        default:
            return false
        }
    }
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("完了")
        case .failure(let error):
            print("Error:", error)
        }
    }, receiveValue: { value in
        print("Value:", value)
    })