feat(Produced): Mapping API improvements (#28)

* feat: Produced state mappings

* feat(Produced): Responsibility improvements

* fix: Merge issues

Author: maximkrouk

Sources/ComposableArchitecture/Store.swift

@@ -9,14 +9,14 @@ import ReactiveSwift
 public final class Store<State, Action> {
   @MutableProperty
   private(set) var state: State
-
+  
   private var isSending = false
   private let reducer: (inout State, Action) -> Effect<Action, Never>
   private var synchronousActionsToSend: [Action] = []
   private var bufferedActions: [Action] = []
   internal var effectDisposables: [UUID: Disposable] = [:]
   internal var parentDisposable: Disposable?
-
+  
   /// Initializes a store from an initial state, a reducer, and an environment.
   ///
   /// - Parameters:
@@ -33,7 +33,7 @@ public final class Store<State, Action> {
       reducer: { reducer.run(&$0, $1, environment) }
     )
   }
-
+  
   /// Scopes the store to one that exposes local state and actions.
   ///
   /// This can be useful for deriving new stores to hand to child views in an application. For
@@ -179,7 +179,7 @@ public final class Store<State, Action> {
     }
     return localStore
   }
-
+  
   /// Scopes the store to one that exposes local state.
   ///
   /// - Parameter toLocalState: A function that transforms `State` into `LocalState`.
@@ -189,7 +189,7 @@ public final class Store<State, Action> {
   ) -> Store<LocalState, Action> {
     self.scope(state: toLocalState, action: { $0 })
   }
-
+  
   /// Scopes the store to a producer of stores of more local state and local actions.
   ///
   /// - Parameters:
@@ -201,14 +201,14 @@ public final class Store<State, Action> {
     state toLocalState: @escaping (Effect<State, Never>) -> Effect<LocalState, Never>,
     action fromLocalAction: @escaping (LocalAction) -> Action
   ) -> Effect<Store<LocalState, LocalAction>, Never> {
-
+    
     func extractLocalState(_ state: State) -> LocalState? {
       var localState: LocalState?
       _ = toLocalState(Effect(value: state))
         .startWithValues { localState = $0 }
       return localState
     }
-
+    
     return toLocalState(self.$state.producer)
       .map { localState in
         let localStore = Store<LocalState, LocalAction>(
@@ -219,16 +219,14 @@ public final class Store<State, Action> {
             return .none
           }
         )
-
-        localStore.parentDisposable = self.$state.producer.startWithValues {
-          [weak localStore] state in
+        localStore.parentDisposable = self.$state.producer.startWithValues { [weak localStore] state in
           guard let localStore = localStore else { return }
           localStore.state = extractLocalState(state) ?? localStore.state
         }
         return localStore
       }
   }
-
+  
   /// Scopes the store to a producer of stores of more local state and local actions.
   ///
   /// - Parameter toLocalState: A function that transforms a producer of `State` into a producer
@@ -240,30 +238,29 @@ public final class Store<State, Action> {
   ) -> Effect<Store<LocalState, Action>, Never> {
     self.producerScope(state: toLocalState, action: { $0 })
   }
-
+  
   func send(_ action: Action) {
     if !self.isSending {
       self.synchronousActionsToSend.append(action)
     } else {
       self.bufferedActions.append(action)
       return
     }
-
+    
     while !self.synchronousActionsToSend.isEmpty || !self.bufferedActions.isEmpty {
       let action =
         !self.synchronousActionsToSend.isEmpty
         ? self.synchronousActionsToSend.removeFirst()
         : self.bufferedActions.removeFirst()
-
+      
       self.isSending = true
       let effect = self.reducer(&self.state, action)
       self.isSending = false
-
+      
       var didComplete = false
       let effectID = UUID()
 
       var isProcessingEffects = true
-
       let observer = Signal<Action, Never>.Observer(
         value: { [weak self] action in
           if isProcessingEffects {
@@ -284,34 +281,34 @@ public final class Store<State, Action> {
       )
       let effectDisposable = effect.start(observer)
       isProcessingEffects = false
-
+      
       if !didComplete {
         self.effectDisposables[effectID] = effectDisposable
       } else {
         effectDisposable.dispose()
       }
     }
   }
-
+  
   /// Returns a "stateless" store by erasing state to `Void`.
   public var stateless: Store<Void, Action> {
     self.scope(state: { _ in () })
   }
-
+  
   /// Returns an "actionless" store by erasing action to `Never`.
   public var actionless: Store<State, Never> {
     func absurd<A>(_ never: Never) -> A {}
     return self.scope(state: { $0 }, action: absurd)
   }
-
+  
   private init(
     initialState: State,
     reducer: @escaping (inout State, Action) -> Effect<Action, Never>
   ) {
     self.reducer = reducer
     self.state = initialState
   }
-
+  
   deinit {
     self.parentDisposable?.dispose()
     self.effectDisposables.keys.forEach { id in
@@ -323,24 +320,44 @@ public final class Store<State, Action> {
 /// A producer of store state.
 @dynamicMemberLookup
 public struct Produced<Value>: SignalProducerConvertible {
-  public let producer: Effect<Value, Never>
-
-  init(by upstream: Effect<Value, Never>) {
-    self.producer = upstream
+  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:
-    """
+*, deprecated,
+message:
+"""
 Consider using `Produced<State>` instead, this typealias is added for backward compatibility and will be removed in the next major release.
 """
 )

Sources/ComposableArchitecture/ViewStore.swift

@@ -68,7 +68,7 @@ public final class ViewStore<State, Action> {
     """
   )
   public var publisher: StoreProducer<State> { produced }
-
+  
   internal var viewDisposable: Disposable?
 
   /// Initializes a view store from a store.
@@ -81,11 +81,11 @@ public final class ViewStore<State, Action> {
     _ store: Store<State, Action>,
     removeDuplicates isDuplicate: @escaping (State, State) -> Bool
   ) {
-    let producer = store.$state.producer.skipRepeats(isDuplicate)
-    self.produced = Produced(by: producer)
+    let produced = Produced(by: store.$state.producer, isEqual: isDuplicate)
+    self.produced = produced
     self.state = store.state
     self._send = store.send
-    self.viewDisposable = producer.startWithValues { [weak self] state in
+    self.viewDisposable = produced.producer.startWithValues { [weak self] state in
       self?.state = state
     }
   }
@@ -259,7 +259,7 @@ public final class ViewStore<State, Action> {
       self.binding(send: { _ in action })
     }
   #endif
-
+  
   deinit {
     viewDisposable?.dispose()
   }

Tests/ComposableArchitectureTests/StoreTests.swift

@@ -4,6 +4,37 @@ import XCTest
 @testable import ComposableArchitecture
 
 final class StoreTests: XCTestCase {
+    
+  func testProducedMapping() {
+    struct ChildState: Equatable {
+      var value: Int = 0
+    }
+    struct ParentState: Equatable {
+      var child: ChildState = .init()
+    }
+    
+    let store = Store<ParentState, Void>(
+      initialState: ParentState(),
+      reducer: Reducer { state, _, _ in
+        state.child.value += 1
+        return .none
+      },
+      environment: ()
+    )
+    
+    let viewStore = ViewStore(store)
+    var values: [Int] = []
+    
+    viewStore.produced.child.value.startWithValues { value in
+      values.append(value)
+    }
+    
+    viewStore.send(())
+    viewStore.send(())
+    viewStore.send(())
+    
+    XCTAssertEqual(values, [0, 1, 2, 3])
+  }
 
   func testEffectDisposablesDeinitialization() {
     enum Action {