Swift 6 mode

.github/workflows/swift.yml

@@ -6,23 +6,24 @@ on:
 
 jobs:
   build:
-    runs-on: macos-13
+    runs-on: macos-14
 
     steps:
-    - uses: maxim-lobanov/setup-xcode@v1
-      with:
-        xcode-version: latest-stable
-    - name: Check XCode Version
+    - uses: actions/checkout@v4
+    - name: List available Xcode versions
+      run: ls /Applications | grep Xcode
+    - name: Set up Xcode version
+      run: sudo xcode-select -s /Applications/Xcode_16.0.app/Contents/Developer
+    - name: Show current version of Xcode
       run: xcodebuild -version
-    - uses: actions/checkout@v3
     - name: Build
       run: xcodebuild -scheme SwiftRetrier build -destination "platform=OS X"
     - name: Run tests
       run: xcodebuild -scheme SwiftRetrier test -destination "platform=OS X"
   lint:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
     - name: SwiftLint
       uses: raphaelbussa/swiftlint-action@main
       with:

Package.swift

@@ -35,5 +35,6 @@ let package = Package(
             dependencies: ["SwiftRetrier"],
             plugins: [] + extraPlugins
         )
-    ]
+    ],
+    swiftLanguageVersions: [.version("6")]
 )

Sources/SwiftRetrier/Core/ConstantDelayPolicy/ConstantDelayRetryPolicy.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-open class ConstantDelayRetryPolicy: RetryPolicy {
+public struct ConstantDelayRetryPolicy: RetryPolicy {
 
     public let delay: TimeInterval
 
@@ -16,7 +16,7 @@ open class ConstantDelayRetryPolicy: RetryPolicy {
         .retry(delay: retryDelay(for: attemptFailure))
     }
 
-    public func freshCopy() -> RetryPolicy {
+    public func policyAfter(attemptFailure: AttemptFailure, delay: TimeInterval) -> any RetryPolicy {
         self
     }
 }

Sources/SwiftRetrier/Core/ExponentialBackoffPolicy/ExponentialBackoffRetryPolicy.swift

@@ -1,8 +1,8 @@
 import Foundation
 
-open class ExponentialBackoffRetryPolicy: RetryPolicy {
+public struct ExponentialBackoffRetryPolicy: RetryPolicy {
 
-    public enum Jitter {
+    public enum Jitter: Sendable {
         case none
         case full
         case decorrelated(growthFactor: Double = ExponentialBackoffConstants.defaultDecorrelatedJitterGrowthFactor)
@@ -11,14 +11,16 @@ open class ExponentialBackoffRetryPolicy: RetryPolicy {
     public let timeSlot: TimeInterval
     public let maxDelay: TimeInterval
     public let jitter: Jitter
-    private var previousDelay: TimeInterval?
+    private let previousDelay: TimeInterval?
 
     public init(timeSlot: TimeInterval = ExponentialBackoffConstants.defaultTimeSlot,
                 maxDelay: TimeInterval = ExponentialBackoffConstants.defaultMaxDelay,
-                jitter: Jitter = ExponentialBackoffConstants.defaultJitter) {
+                jitter: Jitter = ExponentialBackoffConstants.defaultJitter,
+                previousDelay: TimeInterval? = nil) {
         self.timeSlot = timeSlot
         self.maxDelay = maxDelay
         self.jitter = jitter
+        self.previousDelay = previousDelay
     }
 
     public func exponentiationBySquaring<T: BinaryInteger>(_ base: T, _ multiplier: T, _ exponent: T) -> T {
@@ -57,7 +59,6 @@ open class ExponentialBackoffRetryPolicy: RetryPolicy {
         } else {
             delay = fullJitterDelay(attemptIndex: attemptIndex)
         }
-        previousDelay = delay
         return delay
     }
 
@@ -72,15 +73,15 @@ open class ExponentialBackoffRetryPolicy: RetryPolicy {
         }
     }
 
-    open func retryDelay(for attemptFailure: AttemptFailure) -> TimeInterval {
+    public func retryDelay(for attemptFailure: AttemptFailure) -> TimeInterval {
         min(maxDelay, uncappedDelay(attemptIndex: attemptFailure.index))
     }
 
     public func shouldRetry(on attemptFailure: AttemptFailure) -> RetryDecision {
         .retry(delay: retryDelay(for: attemptFailure))
     }
 
-    public func freshCopy() -> RetryPolicy {
-        ExponentialBackoffRetryPolicy(timeSlot: timeSlot, maxDelay: maxDelay, jitter: jitter)
+    public func policyAfter(attemptFailure: AttemptFailure, delay: TimeInterval) -> any RetryPolicy {
+        ExponentialBackoffRetryPolicy(timeSlot: timeSlot, maxDelay: maxDelay, jitter: jitter, previousDelay: delay)
     }
 }

Sources/SwiftRetrier/Core/Model/Job.swift

@@ -1 +1 @@
-public typealias Job<Value> = () async throws -> Value
+public typealias Job<Value> = @Sendable () async throws -> Value

Sources/SwiftRetrier/Core/Model/Policies/AttemptFailure.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-public struct AttemptFailure {
+public struct AttemptFailure: Sendable {
     public let trialStart: Date
     public let index: UInt
     public let error: Error

Sources/SwiftRetrier/Core/Model/Policies/RetryDecision.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-public enum RetryDecision {
+public enum RetryDecision: Sendable {
     case giveUp
     case retry(delay: TimeInterval)
 }

Sources/SwiftRetrier/Core/Model/Policies/RetryPolicy.swift

@@ -1,7 +1,7 @@
 import Foundation
 
-public protocol RetryPolicy {
+public protocol RetryPolicy: Sendable {
     func shouldRetry(on attemptFailure: AttemptFailure) -> RetryDecision
     func retryDelay(for attemptFailure: AttemptFailure) -> TimeInterval
-    func freshCopy() -> RetryPolicy
+    func policyAfter(attemptFailure: AttemptFailure, delay: TimeInterval) -> any RetryPolicy
 }

Sources/SwiftRetrier/Core/Model/Retriers/Retrier.swift

@@ -1,8 +1,8 @@
 import Foundation
 import Combine
 
-public protocol Retrier: Cancellable, AnyObject {
-    associatedtype Output
+public protocol Retrier: Cancellable, AnyObject, Sendable {
+    associatedtype Output: Sendable
 
     func publisher() -> AnyPublisher<RetrierEvent<Output>, Never>
 }

Sources/SwiftRetrier/Core/PolicyBuilding/GiveUpOnPolicyWrapper.swift

@@ -3,9 +3,9 @@ import Foundation
 public struct GiveUpOnPolicyWrapper: RetryPolicy {
 
     private let wrapped: RetryPolicy
-    private let giveUpCriterium: (AttemptFailure) -> Bool
+    private let giveUpCriterium: @Sendable (AttemptFailure) -> Bool
 
-    public init(wrapped: RetryPolicy, giveUpCriterium: @escaping (AttemptFailure) -> Bool) {
+    public init(wrapped: RetryPolicy, giveUpCriterium: @escaping @Sendable (AttemptFailure) -> Bool) {
         self.wrapped = wrapped
         self.giveUpCriterium = giveUpCriterium
     }
@@ -21,7 +21,10 @@ public struct GiveUpOnPolicyWrapper: RetryPolicy {
         return wrapped.shouldRetry(on: attemptFailure)
     }
 
-    public func freshCopy() -> RetryPolicy {
-        GiveUpOnPolicyWrapper(wrapped: wrapped.freshCopy(), giveUpCriterium: giveUpCriterium)
+    public func policyAfter(attemptFailure: AttemptFailure, delay: TimeInterval) -> any RetryPolicy {
+        GiveUpOnPolicyWrapper(
+            wrapped: wrapped.policyAfter(attemptFailure: attemptFailure, delay: delay),
+            giveUpCriterium: giveUpCriterium
+        )
     }
 }

Sources/SwiftRetrier/Core/PolicyBuilding/RetryPolicy+GiveUpOn.swift

@@ -2,7 +2,7 @@ import Foundation
 
 public extension RetryPolicy {
 
-    func giveUp(on giveUpCriterium: @escaping (AttemptFailure) -> Bool) -> RetryPolicy {
+    func giveUp(on giveUpCriterium: @escaping @Sendable (AttemptFailure) -> Bool) -> RetryPolicy {
         GiveUpOnPolicyWrapper(wrapped: self, giveUpCriterium: giveUpCriterium)
     }
 
@@ -17,7 +17,7 @@ public extension RetryPolicy {
         })
     }
 
-    func giveUpOnErrors(matching finalErrorCriterium: @escaping (Error) -> Bool) -> RetryPolicy {
+    func giveUpOnErrors(matching finalErrorCriterium: @escaping @Sendable (Error) -> Bool) -> RetryPolicy {
         GiveUpOnPolicyWrapper(wrapped: self, giveUpCriterium: { finalErrorCriterium($0.error) })
     }
 }

Sources/SwiftRetrier/Core/Retriers/ConditionalRetrier.swift

@@ -20,7 +20,7 @@ import Combine
 ///
 /// If the condition publisher completes and it had not emitted any value or the last value it emitted was `false`
 /// then the retrier emits a completion embedding `RetryError.conditionPublisherCompleted` and finishes.
-public class ConditionalRetrier<Output>: SingleOutputRetrier {
+public class ConditionalRetrier<Output: Sendable>: SingleOutputRetrier, @unchecked Sendable {
 
     private let policy: RetryPolicy
     private let job: Job<Output>

Sources/SwiftRetrier/Core/Retriers/Repeater.swift

@@ -22,7 +22,7 @@ import Combine
 /// ```
 ///
 /// On cancellation, the publisher emits a completion embedding a `CancellationError`then finishes.
-public class Repeater<Output>: Retrier {
+public class Repeater<Output: Sendable>: Retrier, @unchecked Sendable {
 
     private let retrierBuilder: () -> AnySingleOutputRetrier<Output>
     private var retrier: AnySingleOutputRetrier<Output>?

Sources/SwiftRetrier/Core/Retriers/SimpleRetrier.swift

@@ -10,14 +10,14 @@ import Combine
 /// the last attempt error, the publisher emits the attempt failure then a completion embedding  the attempt error.
 /// - **the retrier is canceled:** any awaiting on the `value` property will throw a `CancellationError`, the publisher
 /// emits a completion embedding the same error then finishes.
-public class SimpleRetrier<Output>: SingleOutputRetrier {
+public class SimpleRetrier<Output: Sendable>: SingleOutputRetrier, @unchecked Sendable {
 
     public let trialStart = Date()
     private let subject = PassthroughSubject<RetrierEvent<Output>, Never>()
     private var task: Task<Output, Error>!
 
     public init(policy: RetryPolicy, job: @escaping Job<Output>) {
-        self.task = createTask(policy: policy.freshCopy(), job: job)
+        self.task = createTask(policy: policy, job: job)
     }
 
     @MainActor
@@ -49,6 +49,7 @@ public class SimpleRetrier<Output>: SingleOutputRetrier {
             // Ensure we don't start before any ongoing business on main actor is finished
             await MainActor.run {}
             do {
+                var policy = policy
                 var attemptIndex: UInt = 0
                 while true {
                     try Task.checkCancellation()
@@ -60,7 +61,7 @@ public class SimpleRetrier<Output>: SingleOutputRetrier {
                         let attemptFailure = AttemptFailure(trialStart: trialStart, index: attemptIndex, error: error)
                         await sendAttemptFailure(attemptFailure)
                         try Task.checkCancellation()
-                        let retryDecision = await MainActor.run { [attemptIndex] in
+                        let retryDecision = await MainActor.run { [policy, attemptIndex] in
                             policy.shouldRetry(on: AttemptFailure(trialStart: trialStart,
                                                                   index: attemptIndex,
                                                                   error: error))
@@ -70,6 +71,7 @@ public class SimpleRetrier<Output>: SingleOutputRetrier {
                             throw error
                         case .retry(delay: let delay):
                             try await Task.sleep(nanoseconds: nanoseconds(delay))
+                            policy = policy.policyAfter(attemptFailure: attemptFailure, delay: delay)
                             attemptIndex += 1
                         }
                     }

Sources/SwiftRetrier/DSL/ColdRepeater.swift

@@ -9,7 +9,7 @@ public struct ColdRepeater {
 
 public extension ColdRepeater {
 
-    func giveUp(on giveUpCriterium: @escaping (AttemptFailure) -> Bool) -> ColdRepeater {
+    func giveUp(on giveUpCriterium: @escaping @Sendable (AttemptFailure) -> Bool) -> ColdRepeater {
         let policy = policy.giveUp(on: giveUpCriterium)
         return ColdRepeater(policy: policy, repeatDelay: repeatDelay, conditionPublisher: conditionPublisher)
     }
@@ -24,7 +24,7 @@ public extension ColdRepeater {
         return ColdRepeater(policy: policy, repeatDelay: repeatDelay, conditionPublisher: conditionPublisher)
     }
 
-    func giveUpOnErrors(matching finalErrorCriterium: @escaping (Error) -> Bool) -> ColdRepeater {
+    func giveUpOnErrors(matching finalErrorCriterium: @escaping @Sendable (Error) -> Bool) -> ColdRepeater {
         let policy = policy.giveUpOnErrors(matching: finalErrorCriterium)
         return ColdRepeater(policy: policy, repeatDelay: repeatDelay, conditionPublisher: conditionPublisher)
     }

Sources/SwiftRetrier/DSL/ColdRetrier.swift

@@ -8,7 +8,7 @@ public struct ColdRetrier {
 
 public extension ColdRetrier {
 
-    func giveUp(on giveUpCriterium: @escaping (AttemptFailure) -> Bool) -> ColdRetrier {
+    func giveUp(on giveUpCriterium: @escaping @Sendable (AttemptFailure) -> Bool) -> ColdRetrier {
         let policy = policy.giveUp(on: giveUpCriterium)
         return ColdRetrier(policy: policy, conditionPublisher: conditionPublisher)
     }
@@ -23,7 +23,7 @@ public extension ColdRetrier {
         return ColdRetrier(policy: policy, conditionPublisher: conditionPublisher)
     }
 
-    func giveUpOnErrors(matching finalErrorCriterium: @escaping (Error) -> Bool) -> ColdRetrier {
+    func giveUpOnErrors(matching finalErrorCriterium: @escaping @Sendable (Error) -> Bool) -> ColdRetrier {
         let policy = policy.giveUpOnErrors(matching: finalErrorCriterium)
         return ColdRetrier(policy: policy, conditionPublisher: conditionPublisher)
     }
@@ -40,7 +40,7 @@ public extension ColdRetrier {
     }
 
     @discardableResult
-    func execute<Output>(_ job: @escaping Job<Output>) -> AnySingleOutputRetrier<Output> {
+    func execute<Output: Sendable>(_ job: @escaping Job<Output>) -> AnySingleOutputRetrier<Output> {
         if let conditionPublisher {
             return ConditionalRetrier(policy: policy, conditionPublisher: conditionPublisher, job: job)
                 .eraseToAnySingleOutputRetrier()
@@ -49,7 +49,7 @@ public extension ColdRetrier {
     }
 
     @discardableResult
-    func callAsFunction<Output>(_ job: @escaping Job<Output>) -> AnySingleOutputRetrier<Output> {
+    func callAsFunction<Output: Sendable>(_ job: @escaping Job<Output>) -> AnySingleOutputRetrier<Output> {
         execute(job)
     }
 }

Sources/SwiftRetrier/TypeErasing/AnyRetrier.swift

@@ -1,7 +1,7 @@
 import Foundation
 import Combine
 
-public class AnyRetrier<Output>: Retrier {
+public class AnyRetrier<Output: Sendable>: Retrier, @unchecked Sendable {
 
     public let publisherBlock: () -> AnyPublisher<RetrierEvent<Output>, Never>
     private let cancelBlock: () -> Void

Sources/SwiftRetrier/TypeErasing/AnySingleOutputRetrier.swift

@@ -1,9 +1,9 @@
 import Foundation
 import Combine
 
-public class AnySingleOutputRetrier<Value>: AnyRetrier<Value>, SingleOutputRetrier {
+public class AnySingleOutputRetrier<Value: Sendable>: AnyRetrier<Value>, SingleOutputRetrier, @unchecked Sendable {
 
-    private let outputBlock: () async throws -> Output
+    private let outputBlock: @Sendable () async throws -> Output
 
     public init<R>(_ retrier: R) where R: SingleOutputRetrier, R.Output == Value {
         self.outputBlock = { try await retrier.value }

Sources/SwiftRetrier/Util/OnMain.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-func onMain(_ block: @escaping () -> Void) {
+func onMain(_ block: @escaping @Sendable () -> Void) {
     if Thread.isMainThread {
         block()
     } else {

Tests/SwiftRetrierTests/Retriers/ConditionalRetrierTests.swift

@@ -82,6 +82,7 @@ class ConditionalRetrierSpecificTests: XCTestCase {
         try await taskWait()
     }
 
+    @MainActor
     func test_execution_when_condition_true() {
         let condition = Just(true)
             .eraseToAnyPublisher()
@@ -123,20 +124,20 @@ class ConditionalRetrierSpecificTests: XCTestCase {
         cancellable.cancel()
     }
 
+    @MainActor
     func test_attempt_on_failure_propagated_during_second_trial() {
         var failedOnce = false
         var jobExecutionCount = 0
-        let job = {
+        let expectationOwnErrorPropagated = expectation(description: "Attempt own error propagated")
+
+        let retrier = buildRetrier(trueFalseTruePublisher(), { @MainActor in
             jobExecutionCount += 1
             try await taskWait()
             if !failedOnce {
                 failedOnce = true
                 throw defaultError
             }
-        }
-        let expectationOwnErrorPropagated = expectation(description: "Attempt own error propagated")
-
-        let retrier = buildRetrier(trueFalseTruePublisher(), job)
+        })
         let cancellable = retrier.publisher()
             .sink(receiveCompletion: { _ in },
                   receiveValue: {