wip

Author: Ryu0118

Examples/Github-App/Github-App/View/RootView.swift

@@ -5,6 +5,7 @@ import SwiftUI
 struct RootReducer {
     enum ViewAction: Equatable {
         case textChanged
+        case onAppear
     }
 
     enum ReducerAction: Equatable {
@@ -26,6 +27,9 @@ struct RootReducer {
 
     func reduce(into state: StateContainer<RootView>, action: Action) -> SideEffect<Self> {
         switch action {
+        case .onAppear:
+            return fetchRepositories(query: "Swift")
+
         case .textChanged:
             if state.searchText.isEmpty {
                 state.repositories = []
@@ -116,6 +120,9 @@ struct RootView: View {
                 send(.textChanged)
             }
             .alert(target: self, unwrapping: $alertState)
+            .onAppear {
+                send(.onAppear)
+            }
         }
     }
 }

Sources/SimplexArchitecture/SideEffect.swift

@@ -122,6 +122,16 @@ public extension SideEffect {
 }
 
 public extension SideEffect {
+    /// Turns an side effect into one that can be debounced.
+    ///
+    /// debounce is an operator that plays only the last event in a sequence of SideEffects that have been issued for more than a certain time interval.
+    /// To turn an effect into a debounce-able one you must provide an identifier, which is used to determine which in-flight effect should be canceled in order to start a new effect.
+    ///
+    /// - Parameters:
+    ///   - id: The effect's identifier.
+    ///   - duration: The duration you want to debounce for.
+    ///   - clock: A clock conforming to the `Clock` protocol, used to measure the passing of time for the debounce duration.
+    /// - Returns: A debounced version of the effect.
     @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
     @inlinable
     func debounce(

Sources/SimplexArchitecture/Store/Store+send.swift

@@ -199,7 +199,9 @@ extension Store {
             cancellableTasks[id]?.cancel()
             let cancellableTask = Task.withEffectContext {
                 try? await sleep()
-                guard !Task.isCancelled else { return }
+                guard !Task.isCancelled else {
+                    return
+                }
                 await reduce(tasks: runEffect(base, send: send)).wait()
             }
             cancellableTasks.updateValue(cancellableTask, forKey: id)

Tests/SimplexArchitectureTests/ReducerTests.swift

@@ -148,6 +148,18 @@ final class ReducerTests: XCTestCase {
         await testStore.receiveWithoutStateCheck(.decrement)
         await testStore.receiveWithoutStateCheck(.increment)
     }
+
+    func testDebounced() async {
+        let testStore = TestView().testStore(
+            viewState: .init()) {
+                $0.continuousClock = ImmediateClock()
+            }
+
+        await testStore.send(.debounced)
+        await testStore.receive(.increment) {
+            $0.count = 1
+        }
+    }
 }
 
 struct TestDependency: DependencyKey {
@@ -195,6 +207,7 @@ private struct TestReducer {
         case testDependencies
         case runEffectsSerially
         case runEffectsConcurrently
+        case debounced
     }
 
     @Dependency(\.continuousClock) private var clock
@@ -281,6 +294,15 @@ private struct TestReducer {
                     await send(.increment)
                 }
             )
+
+        case .debounced:
+            enum CancelID { case debounce }
+            return .send(.increment)
+                .debounce(
+                    id: CancelID.debounce,
+                    for: .seconds(0.3),
+                    clock: clock
+                )
         }
     }
 }

Tests/SimplexArchitectureTests/StoreTests.swift

@@ -69,13 +69,27 @@ final class StoreTests: XCTestCase {
 
         let sendTasks7 = store.runEffect(.serial(.c3, .c4), send: send)
         XCTAssertEqual(sendTasks7.count, 1)
-        XCTAssertNotNil(sendTasks5.first?.task)
+        XCTAssertNotNil(sendTasks7.first?.task)
 
         let sendTasks8 = store.runEffect(.concurrent(.c3, .c4), send: send)
         XCTAssertEqual(sendTasks8.count, 2)
         for task in sendTasks8.map(\.task) {
             XCTAssertNotNil(task)
         }
+
+        let sendTasks9 = store.runEffect(.serial(.send(.c1), .send(.c2)), send: send)
+        XCTAssertEqual(sendTasks9.count, 1)
+        XCTAssertNotNil(sendTasks9.first?.task)
+
+        let sendTasks10 = store.runEffect(.concurrent(.send(.c1), .send(.c2)), send: send)
+        XCTAssertEqual(sendTasks10.count, 2)
+        for task in sendTasks10.map(\.task) {
+            XCTAssertNotNil(task)
+        }
+
+        let sendTasks11 = store.runEffect(.send(.c1).debounce(id: "test", for: .seconds(0.3), clock: ImmediateClock()), send: send)
+        XCTAssertEqual(sendTasks11.count, 1)
+        XCTAssertNotNil(sendTasks11.first?.task)
     }
 
     func testSendAction() async throws {