Naming fixes to Effect.throttle and Effect.debounce.

Author: mluisbrown

Examples/Search/Search/SearchView.swift

@@ -71,7 +71,7 @@ let searchReducer = Reducer<SearchState, SearchAction, SearchEnvironment> {
       .searchLocation(query)
       .observe(on: environment.mainQueue)
       .catchToEffect()
-      .debounce(id: SearchLocationId(), interval: 0.3, scheduler: environment.mainQueue)
+      .debounce(id: SearchLocationId(), for: 0.3, scheduler: environment.mainQueue)
       .map(SearchAction.locationsResponse)
 
   case let .locationWeatherResponse(.failure(locationWeather)):

Examples/Todos/Todos/Todos.swift

@@ -78,7 +78,7 @@ let appReducer = Reducer<AppState, AppAction, AppEnvironment>.combine(
     case .todo(id: _, action: .checkBoxToggled):
       struct TodoCompletionId: Hashable {}
       return Effect(value: .sortCompletedTodos)
-        .debounce(id: TodoCompletionId(), interval: 1, scheduler: environment.mainQueue.animation())
+        .debounce(id: TodoCompletionId(), for: 1, scheduler: environment.mainQueue.animation())
 
     case .todo:
       return .none

Sources/ComposableArchitecture/Effects/Debouncing.swift

@@ -21,13 +21,13 @@ extension Effect {
   ///
   /// - Parameters:
   ///   - id: The effect's identifier.
-  ///   - dueTime: The duration you want to debounce for.
+  ///   - for: The duration you want to debounce for.
   ///   - scheduler: The scheduler you want to deliver the debounced output to.
   ///   - options: Scheduler options that customize the effect's delivery of elements.
   /// - Returns: An effect that publishes events only after a specified time elapses.
   public func debounce(
     id: AnyHashable,
-    interval: TimeInterval,
+    for interval: TimeInterval,
     scheduler: DateScheduler
   ) -> Effect<Value, Error> {
     Effect<Void, Never>.init(value: ())

Sources/ComposableArchitecture/Effects/Throttling.swift

@@ -7,21 +7,17 @@ extension Effect {
   ///
   /// - Parameters:
   ///   - id: The effect's identifier.
-  ///   - interval: The interval at which to find and emit the most recent element, expressed in
+  ///   - for: The interval at which to find and emit the most recent element, expressed in
   ///     the time system of the scheduler.
   ///   - scheduler: The scheduler you want to deliver the throttled output to.
   ///   - latest: A boolean value that indicates whether to publish the most recent element. If
   ///     `false`, the producer emits the first element received during the interval.
   /// - Returns: An effect that emits either the most-recent or first element received during the
   ///   specified interval.
-<<<<<<< ours:Sources/ComposableArchitecture/Internal/Throttling.swift
-  func throttle(
-=======
-  public func throttle<S>(
->>>>>>> theirs:Sources/ComposableArchitecture/Effects/Throttling.swift
+  public func throttle(
     id: AnyHashable,
-    interval: TimeInterval,
-    on scheduler: DateScheduler,
+    for interval: TimeInterval,
+    scheduler: DateScheduler,
     latest: Bool
   ) -> Effect<Value, Error> {
     self.flatMap(.latest) { value -> Effect<Value, Error> in
@@ -31,41 +27,23 @@ extension Effect {
         return Effect(value: value)
       }
 
-<<<<<<< ours:Sources/ComposableArchitecture/Internal/Throttling.swift
+      let value = latest ? value : (throttleValues[id] as! Value? ?? value)
+      throttleValues[id] = value
+
       guard
         scheduler.currentDate.timeIntervalSince1970 - throttleTime.timeIntervalSince1970 < interval
       else {
         throttleTimes[id] = scheduler.currentDate
-=======
-      let value = latest ? value : (throttleValues[id] as! Output? ?? value)
-      throttleValues[id] = value
-
-      guard throttleTime.distance(to: scheduler.now) < interval else {
-        throttleTimes[id] = scheduler.now
->>>>>>> theirs:Sources/ComposableArchitecture/Effects/Throttling.swift
         throttleValues[id] = nil
         return Effect(value: value)
       }
 
-<<<<<<< ours:Sources/ComposableArchitecture/Internal/Throttling.swift
-      let value = latest ? value : (throttleValues[id] as! Value? ?? value)
-      throttleValues[id] = value
-
       return Effect(value: value)
-=======
-      return Just(value)
->>>>>>> theirs:Sources/ComposableArchitecture/Effects/Throttling.swift
         .delay(
           throttleTime.addingTimeInterval(interval).timeIntervalSince1970
             - scheduler.currentDate.timeIntervalSince1970,
           on: scheduler
-        )
-<<<<<<< ours:Sources/ComposableArchitecture/Internal/Throttling.swift
-=======
-        .handleEvents(receiveOutput: { _ in throttleTimes[id] = scheduler.now })
-        .setFailureType(to: Failure.self)
-        .eraseToAnyPublisher()
->>>>>>> theirs:Sources/ComposableArchitecture/Effects/Throttling.swift
+        ).on(value: { _ in throttleTimes[id] = scheduler.currentDate })
     }
     .cancellable(id: id, cancelInFlight: true)
   }

Tests/ComposableArchitectureTests/EffectDebounceTests.swift

@@ -11,7 +11,7 @@ final class EffectDebounceTests: XCTestCase {
       struct CancelToken: Hashable {}
 
       Effect(value: value)
-        .debounce(id: CancelToken(), interval: 1, scheduler: scheduler)
+        .debounce(id: CancelToken(), for: 1, scheduler: scheduler)
         .startWithValues { values.append($0) }
     }
 
@@ -59,7 +59,7 @@ final class EffectDebounceTests: XCTestCase {
         effectRuns += 1
         return Effect(value: value)
       }
-      .debounce(id: CancelToken(), interval: 1, scheduler: scheduler)
+      .debounce(id: CancelToken(), for: 1, scheduler: scheduler)
       .startWithValues { values.append($0) }
     }
 

Tests/ComposableArchitectureTests/EffectThrottleTests.swift

@@ -17,7 +17,7 @@ final class EffectThrottleTests: XCTestCase {
         effectRuns += 1
         return .init(value: value)
       }
-      .throttle(id: CancelToken(), interval: 1, on: scheduler, latest: true)
+      .throttle(id: CancelToken(), for: 1, scheduler: scheduler, latest: true)
       .startWithValues { values.append($0) }
     }
 
@@ -63,7 +63,7 @@ final class EffectThrottleTests: XCTestCase {
         effectRuns += 1
         return .init(value: value)
       }
-      .throttle(id: CancelToken(), interval: 1, on: scheduler, latest: false)
+      .throttle(id: CancelToken(), for: 1, scheduler: scheduler, latest: false)
       .startWithValues { values.append($0) }
     }
 
@@ -109,7 +109,7 @@ final class EffectThrottleTests: XCTestCase {
         effectRuns += 1
         return .init(value: value)
       }
-      .throttle(id: CancelToken(), interval: 1, on: scheduler, latest: true)
+      .throttle(id: CancelToken(), for: 1, scheduler: scheduler, latest: true)
       .startWithValues { values.append($0) }
     }
 
@@ -133,28 +133,26 @@ final class EffectThrottleTests: XCTestCase {
     func runThrottledEffect(value: Int) {
       struct CancelToken: Hashable {}
 
-      Deferred { () -> Just<Int> in
+      Effect.deferred { () -> Effect<Int, Never> in
         effectRuns += 1
-        return Just(value)
+        return .init(value: value)
       }
-      .eraseToEffect()
       .throttle(
-        id: CancelToken(), for: 1, scheduler: scheduler.eraseToAnyScheduler(), latest: false
+        id: CancelToken(), for: 1, scheduler: scheduler, latest: false
       )
-      .sink { values.append($0) }
-      .store(in: &self.cancellables)
+      .startWithValues { values.append($0) }
     }
 
     runThrottledEffect(value: 1)
 
     // A value emits right away.
     XCTAssertEqual(values, [1])
 
-    scheduler.advance(by: 0.5)
+    scheduler.advance(by: .milliseconds(500))
 
     runThrottledEffect(value: 2)
 
-    scheduler.advance(by: 0.5)
+    scheduler.advance(by: .milliseconds(500))
 
     runThrottledEffect(value: 3)