Store.scope/StorePublisher Performance Improvements (#616)

* Scope fix

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* revert

* wip

* wip

* wip

* fix

* wip

* wip

* wip

* wip

* wip

* wip

Co-authored-by: Brandon Williams <[email protected]>

Author: stephencelis

Sources/ComposableArchitecture/Store.swift

@@ -280,17 +280,24 @@ public final class Store<State, Action> {
     state toLocalState: @escaping (State) -> LocalState,
     action fromLocalAction: @escaping (LocalAction) -> Action
   ) -> Store<LocalState, LocalAction> {
+    var isSending = false
     let localStore = Store<LocalState, LocalAction>(
       initialState: toLocalState(self.state.value),
       reducer: .init { localState, localAction, _ in
+        isSending = true
+        defer { isSending = false }
         self.send(fromLocalAction(localAction))
         localState = toLocalState(self.state.value)
         return .none
       },
       environment: ()
     )
     localStore.parentCancellable = self.state
-      .sink { [weak localStore] newValue in localStore?.state.value = toLocalState(newValue) }
+      .dropFirst()
+      .sink { [weak localStore] newValue in
+        guard !isSending else { return }
+        localStore?.state.value = toLocalState(newValue)
+      }
     return localStore
   }
 
@@ -420,22 +427,27 @@ public struct StorePublisher<State>: Publisher {
   public typealias Output = State
   public typealias Failure = Never
 
+  private let isDuplicate: (State, State) -> Bool
   public let upstream: AnyPublisher<State, Never>
 
   public func receive<S>(subscriber: S)
   where S: Subscriber, Failure == S.Failure, Output == S.Input {
-    self.upstream.subscribe(subscriber)
+    self.upstream.removeDuplicates(by: isDuplicate).subscribe(subscriber)
   }
 
-  init<P>(_ upstream: P) where P: Publisher, Failure == P.Failure, Output == P.Output {
+  init<P>(
+    _ upstream: P,
+    removeDuplicates isDuplicate: @escaping (State, State) -> Bool
+  ) where P: Publisher, Failure == P.Failure, Output == P.Output {
     self.upstream = upstream.eraseToAnyPublisher()
+    self.isDuplicate = isDuplicate
   }
 
   /// Returns the resulting publisher of a given key path.
   public subscript<LocalState>(
     dynamicMember keyPath: KeyPath<State, LocalState>
   ) -> StorePublisher<LocalState>
   where LocalState: Equatable {
-    .init(self.upstream.map(keyPath).removeDuplicates())
+    .init(self.upstream.map(keyPath), removeDuplicates: ==)
   }
 }

Sources/ComposableArchitecture/ViewStore.swift

@@ -71,11 +71,13 @@ public final class ViewStore<State, Action>: ObservableObject {
     _ store: Store<State, Action>,
     removeDuplicates isDuplicate: @escaping (State, State) -> Bool
   ) {
-    let publisher = store.state.removeDuplicates(by: isDuplicate)
-    self.publisher = StorePublisher(publisher)
+    self.publisher = StorePublisher(store.state, removeDuplicates: isDuplicate)
     self.state = store.state.value
     self._send = store.send
-    self.viewCancellable = publisher.sink { [weak self] in self?.state = $0 }
+    self.viewCancellable = store.state
+      .dropFirst()
+      .removeDuplicates(by: isDuplicate)
+      .sink { [weak self] in self?.state = $0 }
   }
 
   /// The current state.

Tests/ComposableArchitectureTests/StoreTests.swift

@@ -132,7 +132,7 @@ final class StoreTests: XCTestCase {
         return count
       })
 
-    XCTAssertEqual(numCalls1, 2)
+    XCTAssertEqual(numCalls1, 1)
   }
 
   func testScopeCallCount2() {
@@ -170,33 +170,33 @@ final class StoreTests: XCTestCase {
     _ = ViewStore(store3)
     let viewStore4 = ViewStore(store4)
 
-    XCTAssertEqual(numCalls1, 2)
-    XCTAssertEqual(numCalls2, 2)
-    XCTAssertEqual(numCalls3, 2)
+    XCTAssertEqual(numCalls1, 1)
+    XCTAssertEqual(numCalls2, 1)
+    XCTAssertEqual(numCalls3, 1)
 
     viewStore4.send(())
 
-    XCTAssertEqual(numCalls1, 4)
-    XCTAssertEqual(numCalls2, 5)
-    XCTAssertEqual(numCalls3, 6)
+    XCTAssertEqual(numCalls1, 2)
+    XCTAssertEqual(numCalls2, 2)
+    XCTAssertEqual(numCalls3, 2)
 
     viewStore4.send(())
 
-    XCTAssertEqual(numCalls1, 6)
-    XCTAssertEqual(numCalls2, 8)
-    XCTAssertEqual(numCalls3, 10)
+    XCTAssertEqual(numCalls1, 3)
+    XCTAssertEqual(numCalls2, 3)
+    XCTAssertEqual(numCalls3, 3)
 
     viewStore4.send(())
 
-    XCTAssertEqual(numCalls1, 8)
-    XCTAssertEqual(numCalls2, 11)
-    XCTAssertEqual(numCalls3, 14)
+    XCTAssertEqual(numCalls1, 4)
+    XCTAssertEqual(numCalls2, 4)
+    XCTAssertEqual(numCalls3, 4)
 
     viewStore4.send(())
 
-    XCTAssertEqual(numCalls1, 10)
-    XCTAssertEqual(numCalls2, 14)
-    XCTAssertEqual(numCalls3, 18)
+    XCTAssertEqual(numCalls1, 5)
+    XCTAssertEqual(numCalls2, 5)
+    XCTAssertEqual(numCalls3, 5)
   }
 
   func testSynchronousEffectsSentAfterSinking() {

Tests/ComposableArchitectureTests/ViewStoreTests.swift

@@ -63,17 +63,17 @@ final class ViewStoreTests: XCTestCase {
     XCTAssertEqual(0, equalityChecks)
     XCTAssertEqual(0, subEqualityChecks)
     viewStore4.send(())
-    XCTAssertEqual(42, equalityChecks)
-    XCTAssertEqual(42, subEqualityChecks)
+    XCTAssertEqual(4, equalityChecks)
+    XCTAssertEqual(8, subEqualityChecks)
     viewStore4.send(())
-    XCTAssertEqual(84, equalityChecks)
-    XCTAssertEqual(84, subEqualityChecks)
+    XCTAssertEqual(12, equalityChecks)
+    XCTAssertEqual(20, subEqualityChecks)
     viewStore4.send(())
-    XCTAssertEqual(126, equalityChecks)
-    XCTAssertEqual(126, subEqualityChecks)
+    XCTAssertEqual(20, equalityChecks)
+    XCTAssertEqual(32, subEqualityChecks)
     viewStore4.send(())
-    XCTAssertEqual(168, equalityChecks)
-    XCTAssertEqual(168, subEqualityChecks)
+    XCTAssertEqual(28, equalityChecks)
+    XCTAssertEqual(44, subEqualityChecks)
   }
 }