Add debounce(id:for:clock:) to SideEffect

Author: Ryu0118

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

@@ -4,32 +4,47 @@ import SwiftUI
 @Reducer
 struct RootReducer {
     enum ViewAction: Equatable {
-        case onSearchButtonTapped
-        case onTextChanged(String)
+        case textChanged
     }
 
     enum ReducerAction: Equatable {
         case fetchRepositoriesResponse(TaskResult<[Repository]>)
         case alert(Alert)
+        case queryChangeDebounced
 
         enum Alert: Equatable {
             case retry
         }
     }
 
+    enum CancelID {
+        case fetchRequest
+    }
+
     @Dependency(\.repositoryClient.fetchRepositories) var fetchRepositories
+    @Dependency(\.continuousClock) var clock
 
     func reduce(into state: StateContainer<RootView>, action: Action) -> SideEffect<Self> {
         switch action {
-        case .onSearchButtonTapped:
-            state.isLoading = true
-            return fetchRepositories(query: state.searchText)
-
-        case let .onTextChanged(text):
-            if text.isEmpty {
+        case .textChanged:
+            if state.searchText.isEmpty {
                 state.repositories = []
+                return .none
+            } else {
+                return .send(.queryChangeDebounced)
+                    .debounce(
+                        id: CancelID.fetchRequest,
+                        for: .seconds(0.3), 
+                        clock: clock
+                    )
             }
-            return .none
+
+        case .queryChangeDebounced:
+            guard !state.searchText.isEmpty else {
+                return .none
+            }
+            state.isLoading = true
+            return fetchRepositories(query: state.searchText)
 
         case let .fetchRepositoriesResponse(.success(repositories)):
             state.isLoading = false
@@ -93,12 +108,12 @@ struct RootView: View {
                     ProgressView()
                 }
             }
-            .searchable(text: $searchText)
-            .onSubmit(of: .search) {
-                send(.onSearchButtonTapped)
-            }
-            .onChange(of: searchText) { _, newValue in
-                send(.onTextChanged(newValue))
+            .searchable(
+                text: $searchText,
+                placement: .navigationBarDrawer
+            )
+            .onChange(of: searchText) { _, _ in
+                send(.textChanged)
             }
             .alert(target: self, unwrapping: $alertState)
         }

Examples/Github-App/Github-AppTests/RootReducerTests.swift

@@ -4,14 +4,14 @@ import XCTest
 
 @MainActor
 final class RootReducerTests: XCTestCase {
-    func testSearchButtonTapped() async {
-        let store = makeStore(
-            repositoryClient: RepositoryClient(
-                fetchRepositories: { _ in [.stub] }
-            )
-        )
+    func testTextChanged() async {
+        let store = RootView().testStore(viewState: .init(searchText: "text")) {
+            $0.repositoryClient.fetchRepositories = { _ in [.stub] }
+            $0.continuousClock = ImmediateClock()
+        }
 
-        await store.send(.onSearchButtonTapped) {
+        await store.send(.textChanged)
+        await store.receive(.queryChangeDebounced) {
             $0.isLoading = true
         }
         await store.receive(.fetchRepositoriesResponse(.success([.stub]))) {
@@ -20,15 +20,15 @@ final class RootReducerTests: XCTestCase {
         }
     }
 
-    func testSearchButtonTappedWithFailure() async {
+    func testTextChangedWithFailure() async {
         let error = CancellationError()
-        let store = makeStore(
-            repositoryClient: RepositoryClient(
-                fetchRepositories: { _ in throw error }
-            )
-        )
+        let store = RootView().testStore(viewState: .init(searchText: "text")) {
+            $0.repositoryClient.fetchRepositories = { _ in throw error }
+            $0.continuousClock = ImmediateClock()
+        }
 
-        await store.send(.onSearchButtonTapped) {
+        await store.send(.textChanged)
+        await store.receive(.queryChangeDebounced) {
             $0.isLoading = true
         }
         await store.receive(.fetchRepositoriesResponse(.failure(error))) {
@@ -48,19 +48,12 @@ final class RootReducerTests: XCTestCase {
         }
     }
 
-    func testTextChanged() async {
+    func testEmptyTextChanged() async {
         let store = RootView().testStore(viewState: .init(repositories: [.stub]))
-        await store.send(.onTextChanged("test"))
-        await store.send(.onTextChanged("")) {
+        await store.send(.textChanged) {
             $0.repositories = []
         }
     }
-
-    func makeStore(repositoryClient: RepositoryClient) -> TestStore<RootReducer> {
-        RootView().testStore(viewState: .init()) {
-            $0.repositoryClient = repositoryClient
-        }
-    }
 }
 
 extension Repository {

Sources/SimplexArchitecture/SideEffect.swift

@@ -18,9 +18,11 @@ public struct SideEffect<Reducer: ReducerProtocol>: Sendable {
         case concurrentAction([Reducer.Action])
         case serialEffect([SideEffect<Reducer>])
         case concurrentEffect([SideEffect<Reducer>])
+        indirect case debounce(base: Self, id: AnyHashable, sleep: () async throws -> Void)
     }
 
     // The kind of side effect.
+    @usableFromInline
     let kind: EffectKind
 
     @usableFromInline
@@ -118,3 +120,28 @@ public extension SideEffect {
         .init(effectKind: .concurrentEffect(effects))
     }
 }
+
+public extension SideEffect {
+    @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
+    @inlinable
+    func debounce(
+        id: some Hashable,
+        for duration: Duration,
+        clock: any Clock<Duration>
+    ) -> Self {
+        switch self.kind {
+        case .none, .debounce:
+            self
+        default:
+            .init(
+                effectKind: .debounce(
+                    base: self.kind,
+                    id: AnyHashable(id),
+                    sleep: {
+                        try await clock.sleep(for: duration)
+                    }
+                )
+            )
+        }
+    }
+}

Sources/SimplexArchitecture/Store/Store+send.swift

@@ -91,7 +91,7 @@ extension Store {
             return .never
         } else {
             let send = _send ?? makeSend(for: container)
-            let tasks = runEffect(sideEffect, send: send)
+            let tasks = runEffect(sideEffect.kind, send: send)
 
             return reduce(tasks: tasks)
         }
@@ -128,10 +128,10 @@ extension Store {
     }
 
     func runEffect(
-        _ sideEffect: borrowing SideEffect<Reducer>,
+        _ sideEffect: SideEffect<Reducer>.EffectKind,
         send: Send<Reducer>
     ) -> [SendTask] {
-        switch sideEffect.kind {
+        switch sideEffect {
         case let .run(priority, operation, `catch`):
             let task = Task.withEffectContext(priority: priority ?? .medium) {
                 do {
@@ -179,7 +179,7 @@ extension Store {
         case let .serialEffect(effects):
             let task = Task.detached {
                 for effect in effects {
-                    await self.reduce(tasks: self.runEffect(effect, send: send)).wait()
+                    await self.reduce(tasks: self.runEffect(effect.kind, send: send)).wait()
                 }
             }
             return [SendTask(task: task)]
@@ -189,12 +189,22 @@ extension Store {
                 partialResult.append(
                     SendTask(
                         task: Task.detached {
-                            await self.reduce(tasks: self.runEffect(effect, send: send)).wait()
+                            await self.reduce(tasks: self.runEffect(effect.kind, send: send)).wait()
                         }
                     )
                 )
             }
 
+        case let .debounce(base, id, sleep):
+            cancellableTasks[id]?.cancel()
+            let cancellableTask =  Task.withEffectContext {
+                try? await sleep()
+                guard !Task.isCancelled else { return }
+                await reduce(tasks: runEffect(base, send: send)).wait()
+            }
+            cancellableTasks.updateValue(cancellableTask, forKey: id)
+            return [SendTask(task: cancellableTask)]
+
         case .none:
             return []
         }

Sources/SimplexArchitecture/Store/Store.swift

@@ -18,6 +18,8 @@ public final class Store<Reducer: ReducerProtocol> {
     // Buffer to store Actions recurrently invoked through SideEffect in a single Action sent from View
     @TestOnly
     var sentFromEffectActions: [ActionTransition<Reducer>] = []
+    // If debounce or cancel is used in SideEffect, the task is stored here
+    var cancellableTasks: [AnyHashable: Task<Void, Never>] = [:]
 
     var _send: Send<Reducer>?
     var initialReducerState: (() -> Reducer.ReducerState)?
@@ -52,6 +54,12 @@ public final class Store<Reducer: ReducerProtocol> {
         self.initialReducerState = initialReducerState
     }
 
+    deinit {
+        cancellableTasks.values.forEach { task in
+            task.cancel()
+        }
+    }
+
     @discardableResult
     @usableFromInline
     func setContainerIfNeeded(

Tests/SimplexArchitectureTests/StoreTests.swift

@@ -241,3 +241,13 @@ private struct TestView: View {
         EmptyView()
     }
 }
+
+extension Store {
+    @_disfavoredOverload
+    func runEffect(
+        _ sideEffect: SideEffect<Reducer>,
+        send: Send<Reducer>
+    ) -> [SendTask] {
+        runEffect(sideEffect.kind, send: send)
+    }
+}