Convert to ReactiveSwift

Author: mluisbrown

Sources/ComposableArchitecture/Effects/Deferring.swift

@@ -1,4 +1,5 @@
-import Combine
+import Foundation
+import ReactiveSwift
 
 extension Effect {
   /// Returns an effect that will be executed after given `dueTime`.
@@ -16,15 +17,12 @@ extension Effect {
   ///   - 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()
+  public func deferred(
+    for dueTime: TimeInterval,
+    scheduler: DateScheduler
+  ) -> Effect<Value, Error> {
+    SignalProducer<Void, Never>(value: ())
+      .delay(dueTime, on: scheduler)
+      .flatMap(.latest) { self }
   }
 }

Tests/ComposableArchitectureTests/EffectDeferredTests.swift

@@ -1,20 +1,16 @@
-import Combine
 import ComposableArchitecture
+import ReactiveSwift
 import XCTest
 
 final class EffectDeferredTests: XCTestCase {
-  var cancellables: Set<AnyCancellable> = []
-  
   func testDeferred() {
-    let scheduler = DispatchQueue.test
+    let scheduler = TestScheduler()
     var values: [Int] = []
 
     func runDeferredEffect(value: Int) {
-      Just(value)
-        .eraseToEffect()
+      SignalProducer(value: value)
         .deferred(for: 1, scheduler: scheduler)
-        .sink { values.append($0) }
-        .store(in: &self.cancellables)
+        .startWithValues { values.append($0) }
     }
 
     runDeferredEffect(value: 1)
@@ -23,25 +19,25 @@ final class EffectDeferredTests: XCTestCase {
     XCTAssertEqual(values, [])
 
     // Waiting half the time also emits nothing
-    scheduler.advance(by: 0.5)
+    scheduler.advance(by: .milliseconds(500))
     XCTAssertEqual(values, [])
 
     // Run another deferred effect.
     runDeferredEffect(value: 2)
 
     // Waiting half the time emits first deferred effect received.
-    scheduler.advance(by: 0.5)
+    scheduler.advance(by: .milliseconds(500))
     XCTAssertEqual(values, [1])
 
     // Run another deferred effect.
     runDeferredEffect(value: 3)
 
     // Waiting half the time emits second deferred effect received.
-    scheduler.advance(by: 0.5)
+    scheduler.advance(by: .milliseconds(500))
     XCTAssertEqual(values, [1, 2])
 
     // Waiting the rest of the time emits the final effect value.
-    scheduler.advance(by: 0.5)
+    scheduler.advance(by: .milliseconds(500))
     XCTAssertEqual(values, [1, 2, 3])
 
     // Running out the scheduler
@@ -50,32 +46,30 @@ final class EffectDeferredTests: XCTestCase {
   }
 
   func testDeferredIsLazy() {
-    let scheduler = DispatchQueue.test
+    let scheduler = TestScheduler()
     var values: [Int] = []
     var effectRuns = 0
 
     func runDeferredEffect(value: Int) {
-      Deferred { () -> Just<Int> in
+      Effect.deferred { () -> Effect<Int, Never> in
         effectRuns += 1
-        return Just(value)
+        return Effect(value: value)
       }
-      .eraseToEffect()
       .deferred(for: 1, scheduler: scheduler)
-      .sink { values.append($0) }
-      .store(in: &self.cancellables)
+      .startWithValues { values.append($0) }
     }
 
     runDeferredEffect(value: 1)
 
     XCTAssertEqual(values, [])
     XCTAssertEqual(effectRuns, 0)
 
-    scheduler.advance(by: 0.5)
+    scheduler.advance(by: .milliseconds(500))
 
     XCTAssertEqual(values, [])
     XCTAssertEqual(effectRuns, 0)
 
-    scheduler.advance(by: 0.5)
+    scheduler.advance(by: .milliseconds(500))
 
     XCTAssertEqual(values, [1])
     XCTAssertEqual(effectRuns, 1)