ExponentialBackoff.swift

//
//  Created by Sean Heber on 8/11/22.
//

import Foundation

enum ExponentialBackoffError : Error {
    case retryLimitExceeded
}

/// Runs the `operation` until it succeeds.
/// Success here is defined as not throwing, so if `operation` throws any errors, this function swallows them, waits a bit, and runs the `operation` again until either we reach the maximum attempts allowed or the task is cancelled.
func retryWithExponentialBackoff<Result>(base: Double = 0.25, maxInterval: Double = 60, maxAttempts: Int? = nil, operation: () async throws -> Result) async throws -> Result {
    var attempt = 0
    
    while maxAttempts == nil || attempt < maxAttempts! {
        try Task.checkCancellation()

        do {
            return try await operation()
        } catch {
            // errors from the operation are ignored!
        }

        // This uses an exponential backoff with jitter (hence the randomness).
        let sleep = base * Double(pow(Double(2), Double(attempt)))
        let seconds = Double.random(in: 0...min(maxInterval, sleep))
        try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
        
        attempt += 1
    }
    
    throw ExponentialBackoffError.retryLimitExceeded
}

For clarity I would rename the onFaliure to shouldRetryOn: (Error, Int) -> Bool = { _,_ in true} it will make it more explicitly a condition/filter like closure