Fix apple#174

Author: FranzBusch

Sources/AsyncAlgorithms/Debounce/DebounceStateMachine.swift

@@ -325,6 +325,15 @@ struct DebounceStateMachine<Base: AsyncSequence, C: Clock> {
             upstreamContinuation: UnsafeContinuation<Void, Error>?,
             clockContinuation: UnsafeContinuation<C.Instant, Error>?
         )
+        /// Indicates that the downstream continuation should be resumed with `nil` and
+        /// the task and the upstream continuation should be cancelled.
+        case resumeContinuationWithElementAndCancelTaskAndUpstreamAndClockContinuation(
+            downstreamContinuation: UnsafeContinuation<Element?, Error>,
+            element: Element,
+            task: Task<Void, Never>,
+            upstreamContinuation: UnsafeContinuation<Void, Error>?,
+            clockContinuation: UnsafeContinuation<C.Instant, Error>?
+        )
         /// Indicates that nothing should be done.
         case none
     }
@@ -372,13 +381,14 @@ struct DebounceStateMachine<Base: AsyncSequence, C: Clock> {
                 clockContinuation: clockContinuation
             )
 
-        case .debouncing(let task, let upstreamContinuation, let downstreamContinuation, _):
+        case .debouncing(let task, let upstreamContinuation, let downstreamContinuation, let currentElement):
             // We are debouncing and the upstream finished. At this point
-            // we can just resume the downstream continuation with nil and cancel everything else
+            // we can just resume the downstream continuation with element and cancel everything else
             self.state = .finished
 
-            return .resumeContinuationWithNilAndCancelTaskAndUpstreamAndClockContinuation(
+            return .resumeContinuationWithElementAndCancelTaskAndUpstreamAndClockContinuation(
                 downstreamContinuation: downstreamContinuation,
+                element: currentElement.element,
                 task: task,
                 upstreamContinuation: upstreamContinuation,
                 clockContinuation: nil

Sources/AsyncAlgorithms/Debounce/DebounceStorage.swift

@@ -119,6 +119,23 @@ final class DebounceStorage<Base: AsyncSequence, C: Clock>: @unchecked Sendable
                                         downstreamContinuation.resume(returning: nil)
 
                                         break loop
+
+                                    case .resumeContinuationWithElementAndCancelTaskAndUpstreamAndClockContinuation(
+                                        let downstreamContinuation,
+                                        let element,
+                                        let task,
+                                        let upstreamContinuation,
+                                        let clockContinuation
+                                    ):
+                                        upstreamContinuation?.resume(throwing: CancellationError())
+                                        clockContinuation?.resume(throwing: CancellationError())
+                                        task.cancel()
+
+                                        downstreamContinuation.resume(returning: element)
+
+                                        break loop
+
+
                                     case .none:
 
                                         break loop

Sources/AsyncAlgorithms/Locking.swift

@@ -87,6 +87,27 @@ internal struct Lock {
   func unlock() {
     Lock.unlock(platformLock)
   }
+
+    /// Acquire the lock for the duration of the given block.
+    ///
+    /// This convenience method should be preferred to `lock` and `unlock` in
+    /// most situations, as it ensures that the lock will be released regardless
+    /// of how `body` exits.
+    ///
+    /// - Parameter body: The block to execute while holding the lock.
+    /// - Returns: The value returned by the block.
+    func withLock<T>(_ body: () throws -> T) rethrows -> T {
+        self.lock()
+        defer {
+            self.unlock()
+        }
+        return try body()
+    }
+
+    // specialise Void return (for performance)
+    func withLockVoid(_ body: () throws -> Void) rethrows -> Void {
+        try self.withLock(body)
+    }
 }
 
 struct ManagedCriticalState<State> {

Tests/AsyncAlgorithmsTests/TestDebounce.swift

@@ -27,7 +27,7 @@ final class TestDebounce: XCTestCase {
     validate {
       "abcd----e---f-g-|"
       $0.inputs[0].debounce(for: .steps(3), clock: $0.clock)
-      "------d----e----|"
+      "------d----e----[g|]"
     }
   }
 
@@ -37,7 +37,7 @@ final class TestDebounce: XCTestCase {
     validate {
       "a|"
       $0.inputs[0].debounce(for: .steps(3), clock: $0.clock)
-      "-|"
+      "-[a|]"
     }
   }