feat: add Swift Duration support for retry strategies

Author: ns-vasilev

README.md

@@ -99,21 +99,21 @@ Typhoon provides three powerful retry strategies to handle different failure sce
 
 ```swift
 /// A retry strategy with a constant number of attempts and fixed duration between retries.
-case constant(retry: UInt, duration: DispatchTimeInterval)
+case constant(retry: UInt, dispatchDuration: DispatchTimeInterval)
 
 /// A retry strategy with a linearly increasing delay.
-case linear(retry: UInt, duration: DispatchTimeInterval)
+case linear(retry: UInt, dispatchDuration: DispatchTimeInterval)
 
 /// A retry strategy with a Fibonacci-based delay progression.
-case fibonacci(retry: UInt, duration: DispatchTimeInterval)
+case fibonacci(retry: UInt, dispatchDuration: DispatchTimeInterval)
 
 /// A retry strategy with exponential increase in duration between retries and added jitter.
 case exponential(
     retry: UInt, 
     jitterFactor: Double = 0.1, 
     maxInterval: DispatchTimeInterval? = .seconds(60), 
     multiplier: Double = 2.0, 
-    duration: DispatchTimeInterval
+    dispatchDuration: DispatchTimeInterval
 )
 
 /// A custom retry strategy defined by a user-provided delay calculator.
@@ -129,7 +129,7 @@ import Typhoon
 
 // Retry up to 5 times with 2 seconds between each attempt
 let service = RetryPolicyService(
-    strategy: .constant(retry: 4, duration: .seconds(2))
+    strategy: .constant(retry: 4, dispatchDuration: .seconds(2))
 )
 
 do {
@@ -157,7 +157,7 @@ import Typhoon
 
 // Retry up to 4 times with linearly increasing delays
 let service = RetryPolicyService(
-    strategy: .linear(retry: 3, duration: .seconds(1))
+    strategy: .linear(retry: 3, dispatchDuration: .seconds(1))
 )
 ```
 
@@ -175,7 +175,7 @@ Delays follow the Fibonacci sequence — grows faster than linear but slower tha
 import Typhoon
 
 let service = RetryPolicyService(
-    strategy: .fibonacci(retry: 5, duration: .seconds(1))
+    strategy: .fibonacci(retry: 5, dispatchDuration: .seconds(1))
 )
 ```
 
@@ -200,7 +200,7 @@ let service = RetryPolicyService(
         retry: 3,
         jitterFactor: 0,
         multiplier: 2.0,
-        duration: .seconds(1)
+        dispatchDuration: .seconds(1)
     )
 )
 
@@ -233,7 +233,7 @@ let service = RetryPolicyService(
         jitterFactor: 0.2,      // Add ±20% randomization
         maxInterval: .seconds(30),         // Cap at 30 seconds
         multiplier: 2.0,
-        duration: .seconds(1)
+        dispatchDuration: .seconds(1)
     )
 )
 
@@ -280,10 +280,10 @@ import Typhoon
 let service = RetryPolicyService(
     strategy: .chain([
         // Phase 1: 3 quick attempts with constant delay
-        .init(retries: 3, strategy: ConstantDelayStrategy(duration: .milliseconds(100))),
+        .init(retries: 3, strategy: ConstantDelayStrategy(dispatchDuration: .milliseconds(100))),
         // Phase 2: 3 slower attempts with exponential backoff
         .init(retries: 3, strategy: ExponentialDelayStrategy(
-            duration: .seconds(1),
+            dispatchDuration: .seconds(1),
             multiplier: 2.0,
             jitterFactor: 0.1,
             maxInterval: .seconds(60)
@@ -325,7 +325,7 @@ import Typhoon
 
 class APIClient {
     private let retryService = RetryPolicyService(
-        strategy: .exponential(retry: 3, duration: .milliseconds(500))
+        strategy: .exponential(retry: 3, dispatchDuration: .milliseconds(500))
     )
 
     func fetchUser(id: String) async throws -> User {
@@ -350,7 +350,7 @@ class DatabaseManager {
             retry: 5,
             jitterFactor: 0.15,
             maxInterval: .seconds(60),
-            duration: .seconds(1)
+            dispatchDuration: .seconds(1)
         )
     )
 
@@ -369,7 +369,7 @@ import Typhoon
 
 class FileService {
     private let retryService = RetryPolicyService(
-        strategy: .constant(retry: 3, duration: .milliseconds(100))
+        strategy: .constant(retry: 3, dispatchDuration: .milliseconds(100))
     )
 
     func writeFile(data: Data, to path: String) async throws {
@@ -390,7 +390,7 @@ class PaymentService {
         strategy: .exponential(
             retry: 4,
             multiplier: 1.5,
-            duration: .seconds(2)
+            dispatchDuration: .seconds(2)
         )
     )
 

Sources/Typhoon/Classes/Extensions/DispatchTimeInterval+Double.swift

@@ -6,34 +6,32 @@
 import Foundation
 
 extension DispatchTimeInterval {
-    /// Converts a `DispatchTimeInterval` value into seconds represented as `Double`.
+    /// Converts a `DispatchTimeInterval` value into nanoseconds represented as `UInt64`.
     ///
-    /// This computed property normalizes all supported `DispatchTimeInterval` cases
-    /// (`seconds`, `milliseconds`, `microseconds`, `nanoseconds`) into a single
-    /// unit — **seconds** — which simplifies time calculations and conversions.
-    ///
-    /// For example:
-    /// - `.seconds(2)` → `2.0`
-    /// - `.milliseconds(500)` → `0.5`
-    /// - `.microseconds(1_000)` → `0.001`
-    /// - `.nanoseconds(1_000_000_000)` → `1.0`
-    ///
-    /// - Returns: The interval expressed in seconds as `Double`,
+    /// - Returns: The interval expressed in nanoseconds,
     ///   or `nil` if the interval represents `.never` or an unknown case.
-    var double: Double? {
+    var nanoseconds: UInt64? {
         switch self {
         case let .seconds(value):
-            return Double(value)
+            return UInt64(value) * 1_000_000_000
         case let .milliseconds(value):
-            return Double(value) * 1e-3
+            return UInt64(value) * 1_000_000
         case let .microseconds(value):
-            return Double(value) * 1e-6
+            return UInt64(value) * 1000
         case let .nanoseconds(value):
-            return Double(value) * 1e-9
+            return UInt64(value)
         case .never:
             return nil
         @unknown default:
             return nil
         }
     }
+
+    @available(iOS 16, macOS 13, tvOS 16, watchOS 9, *)
+    static func from(_ duration: Duration) -> DispatchTimeInterval {
+        let seconds = duration.components.seconds
+        let nanos = duration.components.attoseconds / 1_000_000_000
+        let totalNanos = Int(seconds) * 1_000_000_000 + Int(nanos)
+        return .nanoseconds(totalNanos)
+    }
 }

Sources/Typhoon/Classes/Extensions/Double+Nanosec.swift

@@ -94,7 +94,9 @@ extension RetryPolicyService: IRetryPolicyService {
 
         var iterator = RetrySequence(strategy: effectiveStrategy).makeIterator()
 
-        let deadline = maxTotalDuration?.double.map { Date().addingTimeInterval($0) }
+        let deadline = maxTotalDuration?.nanoseconds.map {
+            Date().addingTimeInterval(TimeInterval($0) / 1_000_000_000)
+        }
 
         while true {
             if let deadline, Date() > deadline {

Sources/Typhoon/Classes/Extensions/Double+SafeUInt64.swift

@@ -20,7 +20,7 @@ struct ConstantDelayStrategy: IRetryDelayStrategy {
     /// - Parameter retries: The current retry attempt index (ignored).
     /// - Returns: The delay in nanoseconds.
     func delay(forRetry _: UInt) -> UInt64? {
-        guard let seconds = duration.double else { return .zero }
-        return (seconds * .nanosec).safeUInt64
+        guard let nanos = duration.nanoseconds else { return .zero }
+        return nanos
     }
 }

Sources/Typhoon/Classes/RetryPolicyService/RetryPolicyService.swift

@@ -31,6 +31,20 @@ struct ExponentialDelayStrategy: IRetryDelayStrategy {
     /// If specified, the computed delay will never exceed this value.
     let maxInterval: DispatchTimeInterval?
 
+    // MARK: Initialization
+
+    init(
+        duration: DispatchTimeInterval,
+        multiplier: Double = 2.0,
+        jitterFactor: Double = 0.1,
+        maxInterval: DispatchTimeInterval? = .seconds(60)
+    ) {
+        self.duration = duration
+        self.multiplier = multiplier
+        self.jitterFactor = jitterFactor
+        self.maxInterval = maxInterval
+    }
+
     // MARK: - IRetryDelayStrategy
 
     /// Calculates the delay for a given retry attempt using
@@ -39,22 +53,21 @@ struct ExponentialDelayStrategy: IRetryDelayStrategy {
     /// - Parameter retries: The current retry attempt index (starting at `0`).
     /// - Returns: The delay in nanoseconds, or `nil` if it cannot be computed.
     func delay(forRetry retries: UInt) -> UInt64? {
-        guard let seconds = duration.double else { return .zero }
+        guard let baseNanos = duration.nanoseconds else { return .zero }
 
-        let maxDelayNanos = maxInterval.flatMap(\.double)
-            .map { min($0 * .nanosec, Double(UInt64.max)) } ?? Double(UInt64.max)
+        let maxDelayNanos = maxInterval?.nanoseconds.map { UInt64($0) } ?? UInt64.max
 
-        let base = seconds * .nanosec * pow(multiplier, Double(retries))
+        let base = Double(baseNanos) * pow(multiplier, Double(retries))
 
-        guard base < maxDelayNanos, base < Double(UInt64.max) else {
-            return maxDelayNanos.safeUInt64
+        guard base < Double(maxDelayNanos) else {
+            return maxDelayNanos
         }
 
         let jitterRange = base * jitterFactor
         let jittered = Double.random(
-            in: max(0, base - jitterRange) ... min(base + jitterRange, maxDelayNanos)
+            in: max(0, base - jitterRange) ... min(base + jitterRange, Double(maxDelayNanos))
         )
 
-        return min(jittered, maxDelayNanos).safeUInt64
+        return UInt64(jittered)
     }
 }

Sources/Typhoon/Classes/RetrySequence/Strategies/ConstantDelayStrategy.swift

@@ -26,20 +26,16 @@ struct FibonacciDelayStrategy: IRetryDelayStrategy {
     /// - Parameter retries: The current retry attempt index (starting from `0`).
     /// - Returns: The delay in nanoseconds.
     func delay(forRetry retries: UInt) -> UInt64? {
-        guard let seconds = duration.double else { return .zero }
-
-        let fib = fibonacci(retries + 1)
-        let delay = seconds * Double(fib)
-
-        return (delay * .nanosec).safeUInt64
+        guard let nanos = duration.nanoseconds else { return .zero }
+        return nanos * fibonacci(retries + 1)
     }
 
     // MARK: - Private
 
     /// Returns the Fibonacci number for a given index.
     ///
     /// Uses an iterative approach to avoid recursion overhead.
-    private func fibonacci(_ n: UInt) -> UInt {
+    private func fibonacci(_ n: UInt) -> UInt64 {
         guard n > 1 else { return 1 }
 
         var previous: UInt = 1
@@ -51,6 +47,6 @@ struct FibonacciDelayStrategy: IRetryDelayStrategy {
             current = next
         }
 
-        return current
+        return UInt64(current)
     }
 }

Sources/Typhoon/Classes/RetrySequence/Strategies/ExponentialDelayStrategy.swift

@@ -26,8 +26,7 @@ struct LinearDelayStrategy: IRetryDelayStrategy {
     /// The formula used:
     /// `baseDuration * (retries + 1)`
     func delay(forRetry retries: UInt) -> UInt64? {
-        guard let seconds = duration.double else { return .zero }
-        let delay = seconds * Double(retries + 1)
-        return (delay * .nanosec).safeUInt64
+        guard let nanos = duration.nanoseconds else { return .zero }
+        return nanos * UInt64(retries + 1)
     }
 }