Make ReactiveSwift versions performance improvements to Store and ViewStore

Author: mluisbrown

Examples/CaseStudies/SwiftUICaseStudiesTests/02-Effects-CancellationTests.swift

@@ -35,7 +35,7 @@ class EffectsCancellationTests: XCTestCase {
       initialState: .init(),
       reducer: effectsCancellationReducer,
       environment: .init(
-        fact: .init(fetch: { _ in Fail(error: FactClient.Error()).eraseToEffect() }),
+        fact: .init(fetch: { _ in Effect(error: FactClient.Error()) }),
         mainQueue: ImmediateScheduler()
       )
     )

Sources/ComposableArchitecture/Internal/Deprecations.swift

@@ -3,8 +3,7 @@ import CasePaths
 
 import SwiftUI
 
-// NB: Deprecated after 0.20.0:
-
+// NB: Deprecated after 0.21.0:
 extension Reducer {
   @available(*, deprecated, message: "Use the 'IdentifiedArray'-based version, instead")
   public func forEach<GlobalState, GlobalAction, GlobalEnvironment>(
@@ -62,6 +61,7 @@ extension Reducer {
   }
 }
 
+@available(iOS 13, macOS 10.15, macCatalyst 13, tvOS 13, watchOS 6, *)
 extension ForEachStore {
   @available(*, deprecated, message: "Use the 'IdentifiedArray'-based version, instead")
   public init<EachContent>(
@@ -76,7 +76,7 @@ extension ForEachStore {
       [ID], (Data.Index, EachAction), ForEach<[(offset: Int, element: ID)], ID, EachContent>
     >
   {
-    let data = store.state.value
+    let data = store.$state.value
     self.data = data
     self.content = {
       WithViewStore(store.scope(state: { $0.map { $0[keyPath: id] } })) { viewStore in

Sources/ComposableArchitecture/Store.swift

@@ -293,12 +293,14 @@ public final class Store<State, Action> {
       },
       environment: ()
     )
-    localStore.parentCancellable = self.state
-      .dropFirst()
-      .sink { [weak localStore] newValue in
+
+    localStore.parentDisposable = self.$state.producer
+      .skip(first: 1)
+      .startWithValues { [weak localStore] newValue in
         guard !isSending else { return }
-        localStore?.state.value = toLocalState(newValue)
-    }
+        localStore?.$state.value = toLocalState(newValue)
+      }
+    
     return localStore
   }
 
@@ -364,13 +366,13 @@ public final class Store<State, Action> {
   }
 
   func send(_ action: Action) {
-      self.bufferedActions.append(action)
+    self.bufferedActions.append(action)
     guard !self.isSending else { return }
 
-      self.isSending = true
-    var currentState = self.state.value
+    self.isSending = true
+    var currentState = self.$state.value
     defer {
-      self.state.value = currentState
+      self.$state.value = currentState
       self.isSending = false
     }
 
@@ -380,18 +382,25 @@ public final class Store<State, Action> {
 
       var didComplete = false
       let uuid = UUID()
-      let effectCancellable = effect.sink(
-        receiveCompletion: { [weak self] _ in
+
+      let observer = Signal<Action, Never>.Observer(
+        value: { [weak self] action in
+          self?.send(action)
+        },
+        completed: { [weak self] in
           didComplete = true
-          self?.effectCancellables[uuid] = nil
+          self?.effectDisposables.removeValue(forKey: uuid)?.dispose()
         },
-        receiveValue: { [weak self] action in
-            self?.send(action)
-          }
+        interrupted: { [weak self] in
+          didComplete = true
+          self?.effectDisposables.removeValue(forKey: uuid)?.dispose()
+        }
       )
 
+      let effectDisposable = effect.start(observer)
+
       if !didComplete {
-        self.effectDisposables[effectID] = effectDisposable
+        self.effectDisposables[uuid] = effectDisposable
       } else {
         effectDisposable.dispose()
       }
@@ -413,52 +422,6 @@ public final class Store<State, Action> {
     self.parentDisposable?.dispose()
     self.effectDisposables.keys.forEach { id in
       self.effectDisposables.removeValue(forKey: id)?.dispose()
-}
-  }
-}
-
-/// A producer of store state.
-@dynamicMemberLookup
-public struct Produced<Value>: SignalProducerConvertible {
-  private let _producer: Effect<Value, Never>
-  private let comparator: (Value, Value) -> Bool
-
-  public var producer: Effect<Value, Never> {
-    _producer.skipRepeats(comparator)
-  }
-
-  init(
-    by upstream: Effect<Value, Never>,
-    isEqual: @escaping (Value, Value) -> Bool
-  ) {
-    self._producer = upstream
-    self.comparator = isEqual
-  }
-
-  init(by upstream: Effect<Value, Never>) where Value: Equatable {
-    self.init(by: upstream, isEqual: ==)
-  }
-
-  /// Returns the resulting producer of a given key path.
-  public subscript<LocalValue>(
-    dynamicMember keyPath: KeyPath<Value, LocalValue>
-  ) -> Effect<LocalValue, Never> where LocalValue: Equatable {
-    self.producer.map(keyPath).skipRepeats()
-  }
-
-  /// Returns the resulting producer of a given key path.
-  public subscript<LocalValue>(
-    dynamicMember keyPath: KeyPath<Value, LocalValue>
-  ) -> Produced<LocalValue> where LocalValue: Equatable {
-    Produced<LocalValue>(by: self.producer.map(keyPath).skipRepeats())
+    }
   }
 }
-
-@available(
-  *, deprecated,
-  message:
-    """
-Consider using `Produced<State>` instead, this typealias is added for backward compatibility and will be removed in the next major release.
-"""
-)
-public typealias StoreProducer<State> = Produced<State>

Sources/ComposableArchitecture/ViewStore.swift

@@ -57,31 +57,14 @@ import SwiftUI
 /// made.
 @dynamicMemberLookup
 public final class ViewStore<State, Action> {
-  /// A producer of state.
-  public let produced: Produced<State>
-
-  @available(
-    *, deprecated,
-    message:
-      """
-    Consider using `.produced` instead, this property exists for backwards compatibility and will be removed in the next major release.
-    """
-  )
-  public var producer: StoreProducer<State> { produced }
-
-  @available(
-    *, deprecated,
-    message:
-      """
-    Consider using `.produced` instead, this property exists for backwards compatibility and will be removed in the next major release.
-    """
-  )
-  public var publisher: StoreProducer<State> { produced }
-  internal var viewDisposable: Disposable?
+  #if canImport(Combine)
+    @available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+    public private(set) lazy var objectWillChange = ObservableObjectPublisher()
+  #endif
 
   private let _send: (Action) -> Void
-  private let _state: CurrentValueSubject<State, Never>
-  private var viewCancellable: AnyCancellable?
+  fileprivate let _state: MutableProperty<State>
+  private var viewDisposable: Disposable?
 
   /// Initializes a view store from a store.
   ///
@@ -93,34 +76,31 @@ public final class ViewStore<State, Action> {
     _ store: Store<State, Action>,
     removeDuplicates isDuplicate: @escaping (State, State) -> Bool
   ) {
-    let produced = Produced(by: store.$state.producer, isEqual: isDuplicate)
-    self.produced = produced
-    self.state = store.state
+    self._state = MutableProperty(store.$state.value)
     self._send = store.send
-    self.viewDisposable = produced.producer.startWithValues { [weak self] state in
-      self?.state = state
-    }
 
-    self.publisher = StorePublisher(self._state)
-    self.viewCancellable = store.state
-      .removeDuplicates(by: isDuplicate)
-      .sink { [weak self] in
+    self.viewDisposable = store.$state.producer
+      .skipRepeats(isDuplicate)
+      .startWithValues { [weak self] in
         guard let self = self else { return }
-      #if canImport(Combine)
-        if #available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *) {
-      self.objectWillChange.send()
-        self._state.send($0)
-    }
-      #endif
-    }
+        #if canImport(Combine)
+          if #available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *) {
+            self.objectWillChange.send()
+            self._state.value = $0
+          }
+        #endif
+      }
   }
 
-  #if canImport(Combine)
-    @available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
-    public lazy var objectWillChange = ObservableObjectPublisher()
-  #endif
+  /// A producer of state.
+  public var produced: StoreProducer<State> {
+    StoreProducer(viewStore: self)
+  }
 
-  let _send: (Action) -> Void
+  /// The current state.
+  public var state: State {
+    self._state.value
+  }
 
   /// Returns the resulting value of a given key path.
   public subscript<LocalState>(dynamicMember keyPath: KeyPath<State, LocalState>) -> LocalState {
@@ -303,3 +283,42 @@ extension ViewStore where State == Void {
   extension ViewStore: ObservableObject {
   }
 #endif
+
+@dynamicMemberLookup
+public struct StoreProducer<State>: SignalProducerConvertible {
+  public let upstream: Effect<State, Never>
+  public let viewStore: Any
+
+  public var producer: Effect<State, Never> {
+    upstream
+  }
+
+  fileprivate init<Action>(viewStore: ViewStore<State, Action>) {
+    self.viewStore = viewStore
+    self.upstream = viewStore._state.producer
+  }
+
+  private init(
+    upstream: Effect<State, Never>,
+    viewStore: Any
+  ) {
+    self.upstream = upstream
+    self.viewStore = viewStore
+  }
+
+  /// Returns the resulting `StoreProducer` of a given key path.
+  public subscript<LocalState>(
+    dynamicMember keyPath: KeyPath<State, LocalState>
+  ) -> StoreProducer<LocalState>
+    where LocalState: Equatable
+  {
+    .init(upstream: self.upstream.map(keyPath).skipRepeats(), viewStore: self.viewStore)
+  }
+
+  /// Returns the resulting `SignalProducer` of a given key path.
+  public subscript<LocalValue>(
+    dynamicMember keyPath: KeyPath<Value, LocalValue>
+  ) -> Effect<LocalValue, Never> where LocalValue: Equatable {
+    self.upstream.map(keyPath).skipRepeats()
+  }
+}

Tests/ComposableArchitectureTests/ViewStoreTests.swift

@@ -1,8 +1,14 @@
+#if canImport(Combine)
+import Combine
+#endif
 import ComposableArchitecture
 import ReactiveSwift
 import XCTest
 
+
 final class ViewStoreTests: XCTestCase {
+  var cancellables: Set<AnyCancellable> = []
+
   override func setUp() {
     super.setUp()
     equalityChecks = 0
@@ -84,9 +90,8 @@ final class ViewStoreTests: XCTestCase {
 
     var results: [Int] = []
 
-    viewStore.publisher
-      .sink { _ in results.append(viewStore.state) }
-      .store(in: &self.cancellables)
+    viewStore.produced.producer
+      .startWithValues { _ in results.append(viewStore.state) }
 
     viewStore.send(())
     viewStore.send(())
@@ -95,6 +100,7 @@ final class ViewStoreTests: XCTestCase {
     XCTAssertEqual([0, 1, 2, 3], results)
   }
 
+  #if canImport(Combine)
   func testWillSet() {
     let reducer = Reducer<Int, Void, Void> { count, _, _ in
       count += 1
@@ -116,6 +122,7 @@ final class ViewStoreTests: XCTestCase {
 
     XCTAssertEqual([0, 1, 2], results)
   }
+  #endif
 }
 
 private struct State: Equatable {