Deferring Side Effect (#550)

* wip

* revert unexpected changes

* fix typo documentation

* fix another typo

* improve api

* api

* add test case

* revert

* rename to deffered

* remove delay keyword entirely

* remove unneccessary

* Update Sources/ComposableArchitecture/Effects/Deferring.swift

Co-authored-by: Stephen Celis <[email protected]>

Author: 2 people

Sources/ComposableArchitecture/Effects/Deferring.swift

@@ -0,0 +1,30 @@
+import Combine
+
+extension Effect {
+  /// Returns an effect that will be executed after given `dueTime`.
+  ///
+  /// ```swift
+  /// case let .textChanged(text):
+  ///   return environment.search(text)
+  ///     .map(Action.searchResponse)
+  ///     .deferred(for: 0.5, scheduler: environment.mainQueue)
+  /// ```
+  ///
+  /// - Parameters:
+  ///   - upstream: the effect you want to defer.
+  ///   - dueTime: The duration you want to defer for.
+  ///   - scheduler: The scheduler you want to deliver the defer output to.
+  ///   - options: Scheduler options that customize the effect's delivery of elements.
+  /// - Returns: An effect that will be executed after `dueTime`
+  public func deferred<S: Scheduler>(
+    for dueTime: S.SchedulerTimeType.Stride,
+    scheduler: S,
+    options: S.SchedulerOptions? = nil
+  ) -> Effect {
+    Just(())
+      .setFailureType(to: Failure.self)
+      .delay(for: dueTime, scheduler: scheduler, options: options)
+      .flatMap { self }
+      .eraseToEffect()
+  }
+}

Tests/ComposableArchitectureTests/EffectDeferredTests.swift

@@ -0,0 +1,83 @@
+import Combine
+import ComposableArchitecture
+import XCTest
+
+final class EffectDeferredTests: XCTestCase {
+  var cancellables: Set<AnyCancellable> = []
+  
+  func testDeferred() {
+    let scheduler = DispatchQueue.test
+    var values: [Int] = []
+    
+    func runDeferredEffect(value: Int) {
+      Just(value)
+        .eraseToEffect()
+        .deferred(for: 1, scheduler: scheduler)
+        .sink { values.append($0) }
+        .store(in: &self.cancellables)
+    }
+    
+    runDeferredEffect(value: 1)
+    
+    // Nothing emits right away.
+    XCTAssertEqual(values, [])
+    
+    // Waiting half the time also emits nothing
+    scheduler.advance(by: 0.5)
+    XCTAssertEqual(values, [])
+    
+    // Run another deferred effect.
+    runDeferredEffect(value: 2)
+    
+    // Waiting half the time emits first deferred effect received.
+    scheduler.advance(by: 0.5)
+    XCTAssertEqual(values, [1])
+    
+    // Run another deferred effect.
+    runDeferredEffect(value: 3)
+    
+    // Waiting half the time emits second deferred effect received.
+    scheduler.advance(by: 0.5)
+    XCTAssertEqual(values, [1, 2])
+    
+    // Waiting the rest of the time emits the final effect value.
+    scheduler.advance(by: 0.5)
+    XCTAssertEqual(values, [1, 2, 3])
+    
+    // Running out the scheduler
+    scheduler.run()
+    XCTAssertEqual(values, [1, 2, 3])
+  }
+  
+  func testDeferredIsLazy() {
+    let scheduler = DispatchQueue.test
+    var values: [Int] = []
+    var effectRuns = 0
+    
+    func runDeferredEffect(value: Int) {
+      Deferred { () -> Just<Int> in
+        effectRuns += 1
+        return Just(value)
+      }
+      .eraseToEffect()
+      .deferred(for: 1, scheduler: scheduler)
+      .sink { values.append($0) }
+      .store(in: &self.cancellables)
+    }
+    
+    runDeferredEffect(value: 1)
+    
+    XCTAssertEqual(values, [])
+    XCTAssertEqual(effectRuns, 0)
+    
+    scheduler.advance(by: 0.5)
+    
+    XCTAssertEqual(values, [])
+    XCTAssertEqual(effectRuns, 0)
+    
+    scheduler.advance(by: 0.5)
+    
+    XCTAssertEqual(values, [1])
+    XCTAssertEqual(effectRuns, 1)
+  }
+}