refactor: renaming

Signed-off-by: Fabrizio Demaria <fabrizio.f.demaria@gmail.com>

Author: fabriziodemaria

Sources/OpenFeature/AsyncUnifiedQueue.swift

@@ -1,26 +1,26 @@
 import Foundation
 
-/// Unified serial async task queue with operation-type-aware coalescing.
-/// - Non-coalescable operations always execute in order
-/// - Consecutive coalescable operations are coalesced (only the last one executes)
+/// Unified serial async task queue with operation-type-aware last-wins semantics.
+/// - Non-last-wins operations always execute in order
+/// - Consecutive last-wins operations: only the last one executes
 /// - Order is always preserved
 internal actor AsyncUnifiedQueue {
     private var currentTask: Task<Void, Never>?
 
     private struct QueuedOperation {
         let operation: () async -> Void
         let continuation: CheckedContinuation<Void, Never>
-        let canCoalesce: Bool
+        let lastWins: Bool
     }
 
     private var queue: [QueuedOperation] = []
 
     /// Runs the given operation serially.
-    /// - If canCoalesce is false: operation always executes
-    /// - If canCoalesce is true: may be skipped if superseded by a later coalescable operation
-    func run(canCoalesce: Bool, operation: @Sendable @escaping () async -> Void) async {
+    /// - If lastWins is false: operation always executes
+    /// - If lastWins is true: may be skipped if superseded by a later last-wins operation
+    func run(lastWins: Bool, operation: @Sendable @escaping () async -> Void) async {
         await withCheckedContinuation { continuation in
-            queue.append(QueuedOperation(operation: operation, continuation: continuation, canCoalesce: canCoalesce))
+            queue.append(QueuedOperation(operation: operation, continuation: continuation, lastWins: lastWins))
 
             if currentTask == nil {
                 processNext()
@@ -36,34 +36,34 @@ internal actor AsyncUnifiedQueue {
 
         // Find the next batch to execute
         // A batch is either:
-        // 1. A single non-coalescable operation, OR
-        // 2. Consecutive coalescable operations (we execute only the last one)
+        // 1. A single non-last-wins operation, OR
+        // 2. Consecutive last-wins operations (we execute only the last one)
 
         let firstOp = queue[0]
 
-        if !firstOp.canCoalesce {
-            // Non-coalescable operation: execute it immediately
+        if !firstOp.lastWins {
+            // Non-last-wins operation: execute it immediately
             let op = queue.removeFirst()
             currentTask = Task { [weak self] in
                 await op.operation()
                 op.continuation.resume()
                 await self?.processNext()
             }
         } else {
-            // Coalescable operation: find all consecutive coalescable ops
-            var coalescableCount = 0
+            // Last-wins operation: find all consecutive last-wins ops
+            var lastWinsCount = 0
             for op in queue {
-                if op.canCoalesce {
-                    coalescableCount += 1
+                if op.lastWins {
+                    lastWinsCount += 1
                 } else {
                     break
                 }
             }
 
-            // Execute only the last one in the coalescable batch
-            let toSkip = Array(queue.prefix(coalescableCount - 1))
-            let toExecute = queue[coalescableCount - 1]
-            queue.removeFirst(coalescableCount)
+            // Execute only the last one in the last-wins batch
+            let toSkip = Array(queue.prefix(lastWinsCount - 1))
+            let toExecute = queue[lastWinsCount - 1]
+            queue.removeFirst(lastWinsCount)
 
             currentTask = Task { [weak self] in
                 await toExecute.operation()

Sources/OpenFeature/OpenFeatureAPI.swift

@@ -6,7 +6,7 @@ import Foundation
 public class OpenFeatureAPI {
     private let eventHandler = EventHandler()
     private let stateQueue = DispatchQueue(label: "com.openfeature.state.queue") // Sync queue to change state atomically
-    private let unifiedQueue: AsyncUnifiedQueue  // Unified queue for all operations with smart coalescing
+    private let unifiedQueue: AsyncUnifiedQueue  // Unified queue for all operations with last-wins semantics
 
     private(set) var providerSubject = CurrentValueSubject<FeatureProvider?, Never>(nil)
     private(set) var evaluationContext: EvaluationContext?
@@ -62,7 +62,7 @@ public class OpenFeatureAPI {
 
     public func clearProvider() {
         Task {
-            await unifiedQueue.run(canCoalesce: false) { [self] in
+            await unifiedQueue.run(lastWins: false) { [self] in
                 stateQueue.sync {
                     self.providerSubject.send(nil)
                     self.providerStatus = .notReady
@@ -156,7 +156,7 @@ public class OpenFeatureAPI {
     }
 
     private func setProviderInternal(provider: FeatureProvider, initialContext: EvaluationContext? = nil) async {
-        await unifiedQueue.run(canCoalesce: false) { [self] in
+        await unifiedQueue.run(lastWins: false) { [self] in
             // Set initial state atomically
             stateQueue.sync {
                 self.providerStatus = .notReady
@@ -193,7 +193,7 @@ public class OpenFeatureAPI {
     }
 
     private func updateContext(evaluationContext: EvaluationContext) async {
-        await unifiedQueue.run(canCoalesce: true) { [self] in
+        await unifiedQueue.run(lastWins: true) { [self] in
             // Get old context and set new context atomically
             let (oldContext, provider) = stateQueue.sync { () -> (EvaluationContext?, FeatureProvider?) in
                 let oldContext = self.evaluationContext